io-event 1.17.0 → 1.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be6f12aa408dcf76d86fbac8ae598d4a6313b65275357d611eeae9dc2fd1fe75
-  data.tar.gz: facad52118ca469a78fa08187f14265fc98b577b1e703d76e66c83fc733a3b21
+  metadata.gz: f4e37070c965d89037b3fac95c4b5de378273050ee28eb397a954c5fce84a6ae
+  data.tar.gz: 7571ee0edd25008cafe5cc9a81488969d5d269ec1e53793fa7cca393bbfd754c
 SHA512:
-  metadata.gz: a32f4bf15f0377d88912e799f87898787ee817e24c2b3638dca609d54ebc9ef3c97258732545be36fb90ef0a26455c210047872f686736d5fae2d6fbf8495aef
-  data.tar.gz: 931c9b8ee443cc311a8d8823dde3128f109e8cdc739fdc421bf959c5ebfb8fea9a17a17fdc2020a65b0b970eafa91d4cba7fa6ff483165b2c4fca862061ca93c
+  metadata.gz: 22cb0db38d55f3710fc36469c2f2e1162fd69c69c228a9be2c4310f83dbc5304c8cb4194fc7fe2ca4b4316f906ff17341bcceeb24ed1cf9ebe70cd076bb05ca2
+  data.tar.gz: d7e4a07d6acf309898b3df66e8e6b2b21f09af99a7f21ac03f30c68ad32024a1766320159f350c450df18aa46c911951c87c6f38abd06c55c9635f7eb1c86831

data/ext/extconf.rb

@@ -6,6 +6,7 @@
 # Copyright, 2023, by Math Ieu.
 # Copyright, 2025, by Stanislav (Stas) Katkov.
 # Copyright, 2026, by Stan Hu.
+# Copyright, 2026, by Sharon Rosner.
 
 return if RUBY_DESCRIPTION =~ /jruby/
 
@@ -32,9 +33,7 @@ have_func("rb_ext_ractor_safe")
 have_func("&rb_fiber_transfer")
 
 if have_library("uring") and have_header("liburing.h")
-	# We might want to consider using this in the future:
-	# have_func("io_uring_submit_and_wait_timeout", "liburing.h")
-	
+	have_func("io_uring_prep_waitid", "liburing.h")
 	$srcs << "io/event/selector/uring.c"
 end
 

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

@@ -462,7 +462,7 @@ VALUE process_wait_transfer(VALUE _arguments) {
 	IO_Event_Selector_loop_yield(&arguments->selector->backend);
 	
 	if (arguments->waiting->ready) {
-		return IO_Event_Selector_process_status_wait(arguments->pid, arguments->flags);
+		return IO_Event_Selector_process_status_reap(arguments->pid, arguments->flags);
 	} else {
 		return Qfalse;
 	}
@@ -488,6 +488,11 @@ VALUE IO_Event_Selector_EPoll_process_wait(VALUE self, VALUE fiber, VALUE _pid,
 	pid_t pid = NUM2PIDT(_pid);
 	int flags = NUM2INT(_flags);
 	
+	// `pidfd_open` can only refer to a specific process, so waiting for any child or a process group (pid <= 0) is delegated to the threaded fallback:
+	if (pid <= 0) {
+		return IO_Event_Selector_process_wait(pid, flags);
+	}
+	
 	int descriptor = pidfd_open(pid, 0);
 	
 	if (descriptor == -1) {
@@ -497,7 +502,7 @@ VALUE IO_Event_Selector_EPoll_process_wait(VALUE self, VALUE fiber, VALUE _pid,
 	rb_update_max_fd(descriptor);
 	
 	// `pidfd_open` (above) may be edge triggered, so we need to check if the process is already exited, and if so, return immediately, otherwise we will block indefinitely.
-	VALUE status = IO_Event_Selector_process_status_wait(pid, flags);
+	VALUE status = IO_Event_Selector_process_status_reap(pid, flags);
 	if (status != Qnil) {
 		close(descriptor);
 		return status;
@@ -830,14 +835,33 @@ struct timespec * make_timeout(VALUE duration, struct timespec * storage) {
 }
 
 static
-int timeout_nonblocking(struct timespec * timespec) {
+int timeout_is_nonblocking(struct timespec * timespec) {
 	return timespec && timespec->tv_sec == 0 && timespec->tv_nsec == 0;
 }
 
+// Return true when it is safe and useful to enter the blocking selector wait.
+static
+int select_blocking_allowed(struct timespec * timespec) {
+	// A `0` timeout is already a poll. The selector has already performed the immediate poll previously, so there is no useful blocking wait to enter here.
+	if (timeout_is_nonblocking(timespec)) {
+		return 0;
+	}
+	
+#ifndef RB_NOGVL_PENDING_INTERRUPT_FAIL
+	// On Rubies without `RB_NOGVL_PENDING_INTERRUPT_FAIL`, `rb_thread_call_without_gvl2` can enter an indefinite native wait even if a masked interrupt is already pending for this thread. This is the last safe point to avoid that wait: we still hold the GVL, so the pending interrupt queue cannot change concurrently before we decide whether to enter the blocking path.
+	if (IO_Event_Selector_pending_interrupt()) {
+		return 0;
+	}
+#endif
+	
+	return 1;
+}
+
 struct select_arguments {
 	struct IO_Event_Selector_EPoll *selector;
 	
 	int count;
+	int result;
 	struct epoll_event events[EPOLL_MAX_EVENTS];
 	
 	struct timespec * timeout;
@@ -851,7 +875,7 @@ static int make_timeout_ms(struct timespec * timeout) {
 		return -1;
 	}
 	
-	if (timeout_nonblocking(timeout)) {
+	if (timeout_is_nonblocking(timeout)) {
 		return 0;
 	}
 	
@@ -872,13 +896,13 @@ void * select_internal(void *_arguments) {
 	struct select_arguments * arguments = (struct select_arguments *)_arguments;
 	
 #if defined(HAVE_EPOLL_PWAIT2)
-	arguments->count = epoll_pwait2(arguments->selector->descriptor, arguments->events, EPOLL_MAX_EVENTS, arguments->timeout, NULL);
+	arguments->result = epoll_pwait2(arguments->selector->descriptor, arguments->events, arguments->count, arguments->timeout, NULL);
 	
 	// Comment out the above line and enable the below lines to test ENOSYS code path.
-	// arguments->count = -1;
+	// arguments->result = -1;
 	// errno = ENOSYS;
 	
-	if (!enosys_error(arguments->count)) {
+	if (!enosys_error(arguments->result)) {
 		return NULL;
 	}
 	else {
@@ -886,37 +910,47 @@ void * select_internal(void *_arguments) {
 	}
 #endif
 	
-	arguments->count = epoll_wait(arguments->selector->descriptor, arguments->events, EPOLL_MAX_EVENTS, make_timeout_ms(arguments->timeout));
+	arguments->result = epoll_wait(arguments->selector->descriptor, arguments->events, arguments->count, make_timeout_ms(arguments->timeout));
 	
 	return NULL;
 }
 
 static
-void select_internal_without_gvl(struct select_arguments *arguments) {
+int select_internal_without_gvl(struct select_arguments *arguments) {
+	arguments->result = -1;
 	arguments->selector->blocked = 1;
-	rb_thread_call_without_gvl(select_internal, (void *)arguments, RUBY_UBF_IO, 0);
+#ifdef RB_NOGVL_PENDING_INTERRUPT_FAIL
+	rb_nogvl(select_internal, (void *)arguments, RUBY_UBF_IO, 0, RB_NOGVL_INTR_FAIL | RB_NOGVL_PENDING_INTERRUPT_FAIL);
+#else
+	rb_thread_call_without_gvl2(select_internal, (void *)arguments, RUBY_UBF_IO, 0);
+#endif
 	arguments->selector->blocked = 0;
 	
-	if (arguments->count == -1) {
-		if (errno != EINTR) {
+	if (arguments->result == -1) {
+		// If Ruby skips the native callback, the result sentinel can remain `-1`; `errno` may be `0` or `EINTR` depending on the Ruby implementation. Both cases mean the blocking wait did not produce any events.
+		if (errno != EINTR && errno != 0) {
 			rb_sys_fail("select_internal_without_gvl:epoll_wait");
 		} else {
-			arguments->count = 0;
+			return 0;
 		}
 	}
+	
+	return arguments->result;
 }
 
 static
-void select_internal_with_gvl(struct select_arguments *arguments) {
+int select_internal_with_gvl(struct select_arguments *arguments) {
 	select_internal((void *)arguments);
 	
-	if (arguments->count == -1) {
+	if (arguments->result == -1) {
 		if (errno != EINTR) {
 			rb_sys_fail("select_internal_with_gvl:epoll_wait");
 		} else {
-			arguments->count = 0;
+			return 0;
 		}
 	}
+	
+	return arguments->result;
 }
 
 static
@@ -972,7 +1006,7 @@ VALUE select_handle_events(VALUE _arguments)
 	struct select_arguments *arguments = (struct select_arguments *)_arguments;
 	struct IO_Event_Selector_EPoll *selector = arguments->selector;
 	
-	for (int i = 0; i < arguments->count; i += 1) {
+	for (int i = 0; i < arguments->result; i += 1) {
 		const struct epoll_event *event = &arguments->events[i];
 		if (DEBUG) fprintf(stderr, "-> fd=%d events=%d\n", event->data.fd, event->events);
 		
@@ -983,7 +1017,7 @@ VALUE select_handle_events(VALUE _arguments)
 		}
 	}
 	
-	return INT2NUM(arguments->count);
+	return INT2NUM(arguments->result);
 }
 
 static
@@ -1008,6 +1042,8 @@ VALUE IO_Event_Selector_EPoll_select(VALUE self, VALUE duration) {
 	
 	struct select_arguments arguments = {
 		.selector = selector,
+		.count = EPOLL_MAX_EVENTS,
+		.result = 0,
 		.storage = {
 			.tv_sec = 0,
 			.tv_nsec = 0
@@ -1018,22 +1054,22 @@ VALUE IO_Event_Selector_EPoll_select(VALUE self, VALUE duration) {
 	arguments.timeout = &arguments.storage;
 
 	// Process any currently pending events:
-	select_internal_with_gvl(&arguments);
+	int result = select_internal_with_gvl(&arguments);
 	
 	// If we:
 	// 1. Didn't process any ready fibers, and
 	// 2. Didn't process any events from non-blocking select (above), and
 	// 3. There are no items in the ready list,
 	// then we can perform a blocking select.
-	if (!ready && !arguments.count && !selector->backend.ready) {
+	if (!ready && !result && !selector->backend.ready) {
 		arguments.timeout = make_timeout(duration, &arguments.storage);
 		
-		if (!timeout_nonblocking(arguments.timeout)) {
+		if (select_blocking_allowed(arguments.timeout)) {
 			struct timespec start_time;
 			IO_Event_Time_current(&start_time);
 			
 			// Wait for events to occur:
-			select_internal_without_gvl(&arguments);
+			result = select_internal_without_gvl(&arguments);
 			
 			struct timespec end_time;
 			IO_Event_Time_current(&end_time);
@@ -1041,7 +1077,7 @@ VALUE IO_Event_Selector_EPoll_select(VALUE self, VALUE duration) {
 		}
 	}
 	
-	if (arguments.count) {
+	if (result) {
 		return rb_ensure(select_handle_events, (VALUE)&arguments, select_handle_events_ensure, (VALUE)&arguments);
 	} else {
 		return RB_INT2NUM(0);

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

@@ -469,7 +469,7 @@ VALUE process_wait_transfer(VALUE _arguments) {
 	
 	if (arguments->waiting->ready) {
 		process_prewait(arguments->pid);
-		return IO_Event_Selector_process_status_wait(arguments->pid, arguments->flags);
+		return IO_Event_Selector_process_status_reap(arguments->pid, arguments->flags);
 	} else {
 		return Qfalse;
 	}
@@ -493,6 +493,11 @@ VALUE IO_Event_Selector_KQueue_process_wait(VALUE self, VALUE fiber, VALUE _pid,
 	pid_t pid = NUM2PIDT(_pid);
 	int flags = NUM2INT(_flags);
 	
+	// `EVFILT_PROC` can only refer to a specific process, so waiting for any child or a process group (pid <= 0) is delegated to the threaded fallback:
+	if (pid <= 0) {
+		return IO_Event_Selector_process_wait(pid, flags);
+	}
+	
 	struct IO_Event_Selector_KQueue_Waiting waiting = {
 		.list = {.type = &IO_Event_Selector_KQueue_process_wait_list_type},
 		.fiber = fiber,
@@ -514,7 +519,7 @@ VALUE IO_Event_Selector_KQueue_process_wait(VALUE self, VALUE fiber, VALUE _pid,
 		if (errno == ESRCH) {
 			process_prewait(pid);
 			
-			return IO_Event_Selector_process_status_wait(pid, flags);
+			return IO_Event_Selector_process_status_reap(pid, flags);
 		}
 		
 		rb_sys_fail("IO_Event_Selector_KQueue_process_wait:IO_Event_Selector_KQueue_Waiting_register");
@@ -838,15 +843,29 @@ struct timespec * make_timeout(VALUE duration, struct timespec * storage) {
 	return storage;
 }
 
+// Return true when it is safe and useful to enter the blocking selector wait.
 static
-int timeout_nonblocking(struct timespec * timespec) {
-	return timespec && timespec->tv_sec == 0 && timespec->tv_nsec == 0;
+int select_blocking_allowed(struct timespec * timespec) {
+	// A `0` timeout is already a poll. The selector has already performed the immediate poll previously, so there is no useful blocking wait to enter here.
+	if (timespec && timespec->tv_sec == 0 && timespec->tv_nsec == 0) {
+		return 0;
+	}
+	
+#ifndef RB_NOGVL_PENDING_INTERRUPT_FAIL
+	// On Rubies without `RB_NOGVL_PENDING_INTERRUPT_FAIL`, `rb_thread_call_without_gvl2` can enter an indefinite native wait even if a masked interrupt is already pending for this thread. This is the last safe point to avoid that wait: we still hold the GVL, so the pending interrupt queue cannot change concurrently before we decide whether to enter the blocking path.
+	if (IO_Event_Selector_pending_interrupt()) {
+		return 0;
+	}
+#endif
+	
+	return 1;
 }
 
 struct select_arguments {
 	struct IO_Event_Selector_KQueue *selector;
 	
 	int count;
+	int result;
 	struct kevent events[KQUEUE_MAX_EVENTS];
 	
 	struct timespec storage;
@@ -859,38 +878,48 @@ static
 void * select_internal(void *_arguments) {
 	struct select_arguments * arguments = (struct select_arguments *)_arguments;
 	
-	arguments->count = kevent(arguments->selector->descriptor, NULL, 0, arguments->events, arguments->count, arguments->timeout);
+	arguments->result = kevent(arguments->selector->descriptor, NULL, 0, arguments->events, arguments->count, arguments->timeout);
 	
 	return NULL;
 }
 
 static
-void select_internal_without_gvl(struct select_arguments *arguments) {
+int select_internal_without_gvl(struct select_arguments *arguments) {
+	arguments->result = -1;
 	arguments->selector->blocked = 1;
 	
-	rb_thread_call_without_gvl(select_internal, (void *)arguments, RUBY_UBF_IO, 0);
+#ifdef RB_NOGVL_PENDING_INTERRUPT_FAIL
+	rb_nogvl(select_internal, (void *)arguments, RUBY_UBF_IO, 0, RB_NOGVL_INTR_FAIL | RB_NOGVL_PENDING_INTERRUPT_FAIL);
+#else
+	rb_thread_call_without_gvl2(select_internal, (void *)arguments, RUBY_UBF_IO, 0);
+#endif
 	arguments->selector->blocked = 0;
 	
-	if (arguments->count == -1) {
-		if (errno != EINTR) {
+	if (arguments->result == -1) {
+		// If Ruby skips the native callback, the result sentinel can remain `-1`; `errno` may be `0` or `EINTR` depending on the Ruby implementation. Both cases mean the blocking wait did not produce any events.
+		if (errno != EINTR && errno != 0) {
 			rb_sys_fail("select_internal_without_gvl:kevent");
 		} else {
-			arguments->count = 0;
+			return 0;
 		}
 	}
+	
+	return arguments->result;
 }
 
 static
-void select_internal_with_gvl(struct select_arguments *arguments) {
+int select_internal_with_gvl(struct select_arguments *arguments) {
 	select_internal((void *)arguments);
 	
-	if (arguments->count == -1) {
+	if (arguments->result == -1) {
 		if (errno != EINTR) {
 			rb_sys_fail("select_internal_with_gvl:kevent");
 		} else {
-			arguments->count = 0;
+			return 0;
 		}
 	}
+	
+	return arguments->result;
 }
 
 static
@@ -944,14 +973,14 @@ VALUE select_handle_events(VALUE _arguments)
 	struct select_arguments *arguments = (struct select_arguments *)_arguments;
 	struct IO_Event_Selector_KQueue *selector = arguments->selector;
 	
-	for (int i = 0; i < arguments->count; i += 1) {
+	for (int i = 0; i < arguments->result; i += 1) {
 		if (arguments->events[i].udata) {
 			struct IO_Event_Selector_KQueue_Descriptor *kqueue_descriptor = arguments->events[i].udata;
 			kqueue_descriptor->ready_events |= events_from_kevent_filter(arguments->events[i].filter);
 		}
 	}
 	
-	for (int i = 0; i < arguments->count; i += 1) {
+	for (int i = 0; i < arguments->result; i += 1) {
 		if (arguments->events[i].udata) {
 			struct IO_Event_Selector_KQueue_Descriptor *kqueue_descriptor = arguments->events[i].udata;
 			IO_Event_Selector_KQueue_handle(selector, arguments->events[i].ident, kqueue_descriptor, &arguments->saved);
@@ -962,7 +991,7 @@ VALUE select_handle_events(VALUE _arguments)
 		}
 	}
 	
-	return RB_INT2NUM(arguments->count);
+	return RB_INT2NUM(arguments->result);
 }
 
 static
@@ -987,6 +1016,7 @@ VALUE IO_Event_Selector_KQueue_select(VALUE self, VALUE duration) {
 	struct select_arguments arguments = {
 		.selector = selector,
 		.count = KQUEUE_MAX_EVENTS,
+		.result = 0,
 		.storage = {
 			.tv_sec = 0,
 			.tv_nsec = 0
@@ -997,14 +1027,14 @@ VALUE IO_Event_Selector_KQueue_select(VALUE self, VALUE duration) {
 	arguments.timeout = &arguments.storage;
 	
 	// We break this implementation into two parts.
-	// (1) count = kevent(..., timeout = 0)
-	// (2) without gvl: kevent(..., timeout = 0) if count == 0 and timeout != 0
+	// (1) result = kevent(..., timeout = 0)
+	// (2) without gvl: kevent(..., timeout = 0) if result == 0 and timeout != 0
 	// This allows us to avoid releasing and reacquiring the GVL.
 	// Non-comprehensive testing shows this gives a 1.5x speedup.
 	
 	// First do the syscall with no timeout to get any immediately available events:
 	if (DEBUG) fprintf(stderr, "\r\nselect_internal_with_gvl timeout=" IO_EVENT_TIME_PRINTF_TIMESPEC "\r\n", IO_EVENT_TIME_PRINTF_TIMESPEC_ARGUMENTS(arguments.storage));
-	select_internal_with_gvl(&arguments);
+	int result = select_internal_with_gvl(&arguments);
 	if (DEBUG) fprintf(stderr, "\r\nselect_internal_with_gvl done\r\n");
 	
 	// If we:
@@ -1012,17 +1042,15 @@ VALUE IO_Event_Selector_KQueue_select(VALUE self, VALUE duration) {
 	// 2. Didn't process any events from non-blocking select (above), and
 	// 3. There are no items in the ready list,
 	// then we can perform a blocking select.
-	if (!ready && !arguments.count && !selector->backend.ready) {
+	if (!ready && !result && !selector->backend.ready) {
 		arguments.timeout = make_timeout(duration, &arguments.storage);
 		
-		if (!timeout_nonblocking(arguments.timeout)) {
-			arguments.count = KQUEUE_MAX_EVENTS;
-			
+		if (select_blocking_allowed(arguments.timeout)) {
 			struct timespec start_time;
 			IO_Event_Time_current(&start_time);
 			
 			if (DEBUG) fprintf(stderr, "IO_Event_Selector_KQueue_select timeout=" IO_EVENT_TIME_PRINTF_TIMESPEC "\n", IO_EVENT_TIME_PRINTF_TIMESPEC_ARGUMENTS(arguments.storage));
-			select_internal_without_gvl(&arguments);
+			result = select_internal_without_gvl(&arguments);
 			
 			struct timespec end_time;
 			IO_Event_Time_current(&end_time);
@@ -1030,7 +1058,7 @@ VALUE IO_Event_Selector_KQueue_select(VALUE self, VALUE duration) {
 		}
 	}
 	
-	if (arguments.count) {
+	if (result) {
 		return rb_ensure(select_handle_events, (VALUE)&arguments, select_handle_events_ensure, (VALUE)&arguments);
 	} else {
 		return RB_INT2NUM(0);

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

@@ -8,6 +8,8 @@
 
 static const int DEBUG = 0;
 
+ID IO_Event_Selector_pending_interrupt_p_id;
+
 #ifndef HAVE_RB_IO_DESCRIPTOR
 static ID id_fileno;
 
@@ -22,7 +24,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 +80,21 @@ 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) {
+	IO_Event_Selector_pending_interrupt_p_id = rb_intern("pending_interrupt?");
+	
+	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

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

@@ -40,19 +40,33 @@ static inline int IO_Event_try_again(int error) {
 	return error == EAGAIN || error == EWOULDBLOCK;
 }
 
+extern ID IO_Event_Selector_pending_interrupt_p_id;
+
+static inline int IO_Event_Selector_pending_interrupt(void) {
+	return RTEST(rb_funcall(rb_cThread, IO_Event_Selector_pending_interrupt_p_id, 0));
+}
+
 #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);
 

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

@@ -15,10 +15,17 @@
 
 #include "../interrupt.h"
 
-#include "pidfd.c"
-
 #include <linux/version.h>
 
+// `io_uring` support for `IORING_OP_WAITID` was introduced in Linux 6.7. When available, we use it to wait for process exit directly in the ring, instead of polling on a pidfd.
+#if defined(HAVE_IO_URING_PREP_WAITID) && (LINUX_VERSION_CODE >= KERNEL_VERSION(6,7,0))
+#define IO_EVENT_SELECTOR_URING_USE_WAITID
+#endif
+
+#ifndef IO_EVENT_SELECTOR_URING_USE_WAITID
+#include "pidfd.c"
+#endif
+
 enum {
 	DEBUG = 0,
 	DEBUG_COMPLETION = 0,
@@ -500,13 +507,43 @@ struct io_uring_sqe * io_get_sqe(struct IO_Event_Selector_URing *selector) {
 
 #pragma mark - Process.wait
 
+#ifdef IO_EVENT_SELECTOR_URING_USE_WAITID
+// Translate a Ruby/`waitpid`-style pid into the `waitid(2)` idtype and id, mirroring the semantics of `waitpid(2)`:
+//
+//   pid == -1  -> any child                                  (P_ALL)
+//   pid ==  0  -> any child in the caller's process group    (P_PGID, id 0; Linux >= 5.4)
+//   pid <  -1  -> any child in process group |pid|           (P_PGID)
+//   pid >   0  -> the specific child                         (P_PID)
+//
+static inline idtype_t process_waitid_type(pid_t pid, id_t *id) {
+	if (pid == -1) {
+		*id = 0;
+		return P_ALL;
+	} else if (pid == 0) {
+		*id = 0;
+		return P_PGID;
+	} else if (pid < -1) {
+		*id = (id_t)(-pid);
+		return P_PGID;
+	} else {
+		*id = (id_t)pid;
+		return P_PID;
+	}
+}
+#endif
+
 struct process_wait_arguments {
 	struct IO_Event_Selector_URing *selector;
 	struct IO_Event_Selector_URing_Waiting *waiting;
 	
 	pid_t pid;
 	int flags;
+	
+#ifdef IO_EVENT_SELECTOR_URING_USE_WAITID
+	siginfo_t siginfo;
+#else
 	int descriptor;
+#endif
 };
 
 static
@@ -515,18 +552,32 @@ VALUE process_wait_transfer(VALUE _arguments) {
 	
 	IO_Event_Selector_loop_yield(&arguments->selector->backend);
 	
+#ifdef IO_EVENT_SELECTOR_URING_USE_WAITID
+	int32_t result = arguments->waiting->result;
+	if (result < 0) {
+		rb_syserr_fail(-result, "IO_Event_Selector_URing_process_wait:io_uring_prep_waitid");
+	}
+	
+	if (DEBUG) fprintf(stderr, "waitid result=%d pid=%d code=%d status=%d\n", result, arguments->siginfo.si_pid, arguments->siginfo.si_code, arguments->siginfo.si_status);
+	
+	// We waited with `WNOWAIT`, so the child has not been reaped yet. `si_pid` tells us exactly which child changed state (important when waiting for any child, e.g. pid -1). Reap it to obtain a correct `Process::Status`:
+	return IO_Event_Selector_process_status_reap(arguments->siginfo.si_pid, arguments->flags);
+#else
 	if (arguments->waiting->result) {
-		return IO_Event_Selector_process_status_wait(arguments->pid, arguments->flags);
+		return IO_Event_Selector_process_status_reap(arguments->pid, arguments->flags);
 	} else {
 		return Qfalse;
 	}
+#endif
 }
 
 static
 VALUE process_wait_ensure(VALUE _arguments) {
 	struct process_wait_arguments *arguments = (struct process_wait_arguments *)_arguments;
 	
+#ifndef IO_EVENT_SELECTOR_URING_USE_WAITID
 	close(arguments->descriptor);
+#endif
 	
 	IO_Event_Selector_URing_Waiting_cancel(arguments->waiting);
 	
@@ -540,11 +591,18 @@ VALUE IO_Event_Selector_URing_process_wait(VALUE self, VALUE fiber, VALUE _pid,
 	pid_t pid = NUM2PIDT(_pid);
 	int flags = NUM2INT(_flags);
 	
+#ifndef IO_EVENT_SELECTOR_URING_USE_WAITID
+	// `pidfd_open` can only refer to a specific process, so waiting for any child or a process group (pid <= 0) is delegated to the threaded fallback:
+	if (pid <= 0) {
+		return IO_Event_Selector_process_wait(pid, flags);
+	}
+	
 	int descriptor = pidfd_open(pid, 0);
 	if (descriptor < 0) {
 		rb_syserr_fail(errno, "IO_Event_Selector_URing_process_wait:pidfd_open");
 	}
 	rb_update_max_fd(descriptor);
+#endif
 	
 	struct IO_Event_Selector_URing_Waiting waiting = {
 		.fiber = fiber,
@@ -559,12 +617,25 @@ VALUE IO_Event_Selector_URing_process_wait(VALUE self, VALUE fiber, VALUE _pid,
 		.waiting = &waiting,
 		.pid = pid,
 		.flags = flags,
+#ifdef IO_EVENT_SELECTOR_URING_USE_WAITID
+		.siginfo = {0},
+#else
 		.descriptor = descriptor,
+#endif
 	};
 	
-	if (DEBUG) fprintf(stderr, "IO_Event_Selector_URing_process_wait:io_uring_prep_poll_add(%p)\n", (void*)fiber);
 	struct io_uring_sqe *sqe = io_get_sqe(selector);
+	
+#ifdef IO_EVENT_SELECTOR_URING_USE_WAITID
+	id_t id;
+	idtype_t idtype = process_waitid_type(pid, &id);
+	if (DEBUG) fprintf(stderr, "IO_Event_Selector_URing_process_wait:io_uring_prep_waitid(fiber=%p, idtype=%d, id=%d, flags=%d)\n", (void*)fiber, idtype, (int)id, flags);
+	// `WNOWAIT` leaves the child in a waitable state so we can reap it with `rb_process_status_wait` afterwards and build a correct `Process::Status`:
+	io_uring_prep_waitid(sqe, idtype, id, &process_wait_arguments.siginfo, WEXITED | WNOWAIT, 0);
+#else
+	if (DEBUG) fprintf(stderr, "IO_Event_Selector_URing_process_wait:io_uring_prep_poll_add(%p)\n", (void*)fiber);
 	io_uring_prep_poll_add(sqe, descriptor, POLLIN|POLLHUP|POLLERR);
+#endif
 	io_uring_sqe_set_data(sqe, completion);
 	io_uring_submit_pending(selector);
 	
@@ -1130,9 +1201,22 @@ struct __kernel_timespec * make_timeout(VALUE duration, struct __kernel_timespec
 	return storage;
 }
 
+// Return true when it is safe and useful to enter the blocking selector wait.
 static
-int timeout_nonblocking(struct __kernel_timespec *timespec) {
-	return timespec && timespec->tv_sec == 0 && timespec->tv_nsec == 0;
+int select_blocking_allowed(struct __kernel_timespec *timespec) {
+	// A `0` timeout is already a poll. The selector has already performed the immediate poll previously, so there is no useful blocking wait to enter here.
+	if (timespec && timespec->tv_sec == 0 && timespec->tv_nsec == 0) {
+		return 0;
+	}
+	
+#ifndef RB_NOGVL_PENDING_INTERRUPT_FAIL
+	// On Rubies without `RB_NOGVL_PENDING_INTERRUPT_FAIL`, `rb_thread_call_without_gvl2` can enter an indefinite native wait even if a masked interrupt is already pending for this thread. This is the last safe point to avoid that wait: we still hold the GVL, so the pending interrupt queue cannot change concurrently before we decide whether to enter the blocking path.
+	if (IO_Event_Selector_pending_interrupt()) {
+		return 0;
+	}
+#endif
+	
+	return 1;
 }
 
 struct select_arguments {
@@ -1171,22 +1255,27 @@ int select_internal_without_gvl(struct select_arguments *arguments) {
 	
 	io_uring_submit_flush(selector);
 	
+	arguments->result = -EINTR;
 	selector->blocked = 1;
-	rb_thread_call_without_gvl(select_internal, (void *)arguments, RUBY_UBF_IO, 0);
+#ifdef RB_NOGVL_PENDING_INTERRUPT_FAIL
+	rb_nogvl(select_internal, (void *)arguments, RUBY_UBF_IO, 0, RB_NOGVL_INTR_FAIL | RB_NOGVL_PENDING_INTERRUPT_FAIL);
+#else
+	rb_thread_call_without_gvl2(select_internal, (void *)arguments, RUBY_UBF_IO, 0);
+#endif
 	selector->blocked = 0;
 	
 	if (arguments->result == -ETIME) {
-		arguments->result = 0;
+		return 0;
 	} else if (arguments->result == -EINTR) {
-		arguments->result = 0;
+		return 0;
 	} else if (arguments->result < 0) {
 		rb_syserr_fail(-arguments->result, "select_internal_without_gvl:io_uring_wait_cqe_timeout");
 	} else {
 		// At least 1 event is waiting:
-		arguments->result = 1;
+		return 1;
 	}
 	
-	return arguments->result;
+	return 0;
 }
 
 static inline
@@ -1283,28 +1372,29 @@ VALUE IO_Event_Selector_URing_select(VALUE self, VALUE duration) {
 	
 	int ready = IO_Event_Selector_ready_flush(&selector->backend);
 	
-	int result = select_process_completions(selector);
+	int completed = select_process_completions(selector);
 	
 	// If we:
 	// 1. Didn't process any ready fibers, and
 	// 2. Didn't process any events from non-blocking select (above), and
 	// 3. There are no items in the ready list,
 	// then we can perform a blocking select.
-	if (!ready && !result && !selector->backend.ready) {
+	if (!ready && !completed && !selector->backend.ready) {
 		// We might need to wait for events:
 		struct select_arguments arguments = {
 			.selector = selector,
+			.result = 0,
 			.timeout = NULL,
 		};
 		
 		arguments.timeout = make_timeout(duration, &arguments.storage);
 		
-		if (!selector->backend.ready && !timeout_nonblocking(arguments.timeout)) {
+		if (!selector->backend.ready && select_blocking_allowed(arguments.timeout)) {
 			struct timespec start_time;
 			IO_Event_Time_current(&start_time);
 			
 			// This is a blocking operation, we wait for events:
-			result = select_internal_without_gvl(&arguments);
+			int result = select_internal_without_gvl(&arguments);
 			
 			struct timespec end_time;
 			IO_Event_Time_current(&end_time);
@@ -1312,12 +1402,12 @@ VALUE IO_Event_Selector_URing_select(VALUE self, VALUE duration) {
 			
 			// After waiting/flushing the SQ, check if there are any completions:
 			if (result > 0) {
-				result = select_process_completions(selector);
+				completed = select_process_completions(selector);
 			}
 		}
 	}
 	
-	return RB_INT2NUM(result);
+	return RB_INT2NUM(completed);
 }
 
 VALUE IO_Event_Selector_URing_wakeup(VALUE self) {

data/lib/io/event/interrupt.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2021-2024, by Samuel Williams.
+# Copyright, 2021-2026, by Samuel Williams.
 
 module IO::Event
 	# A thread safe synchronisation primative.

data/lib/io/event/selector/select.rb

@@ -278,9 +278,7 @@ module IO::Event
 			# @parameter flags [Integer] Flags to pass to Process::Status.wait.
 			# @returns [Process::Status] The status of the waited process.
 			def process_wait(fiber, pid, flags)
-				Thread.new do
-					Process::Status.wait(pid, flags)
-				end.value
+				Selector.process_wait(pid, flags)
 			end
 			
 			private def pop_ready

data/lib/io/event/selector.rb

@@ -40,5 +40,23 @@ module IO::Event
 			
 			return selector
 		end
+		
+		# Wait for a process to change state, for the cases a selector cannot represent natively (e.g. `pid <= 0`: any child, or a process group). The native selectors integrate process waiting with the event loop using per-process primitives (`pidfd_open`, `EVFILT_PROC`) which can only refer to a single, specific process, and delegate here otherwise.
+		#
+		# The wait is performed on a separate thread, which has no fiber scheduler and therefore blocks. Joining it via `Thread#value` is fiber-scheduler aware, so the calling fiber yields to the event loop and the reactor keeps running other fibers.
+		#
+		# @parameter pid [Integer] The process ID (or process group) to wait for.
+		# @parameter flags [Integer] Flags to pass to `Process::Status.wait`.
+		# @returns [Process::Status] The status of the waited process.
+		def self.process_wait(pid, flags)
+			thread = ::Thread.new do
+				::Process::Status.wait(pid, flags)
+			end
+			
+			thread.value
+		ensure
+			# If the calling fiber was interrupted before the wait completed, don't leave the thread running:
+			thread&.kill
+		end
 	end
 end

data/lib/io/event/version.rb

@@ -7,6 +7,6 @@
 class IO
 	# @namespace
 	module Event
-		VERSION = "1.17.0"
+		VERSION = "1.19.0"
 	end
 end

data/license.md

@@ -19,6 +19,7 @@ Copyright, 2026, by John Hawthorn.
 Copyright, 2026, by Italo Brandão.  
 Copyright, 2026, by Fletcher Dares.  
 Copyright, 2026, by Tavian Barnes.  
+Copyright, 2026, by Sharon Rosner.  
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/readme.md

@@ -18,6 +18,15 @@ Please see the [project documentation](https://socketry.github.io/io-event/) for
 
 Please see the [project releases](https://socketry.github.io/io-event/releases/index) for all releases.
 
+### v1.19.0
+
+  - Use `io_uring_prep_waitid` for `process_wait` in the `URing` selector (Linux 6.7+), waiting for child exit directly in the ring instead of polling on a `pidfd`. The child is reaped via `rb_process_status_wait` (using `WEXITED | WNOWAIT`) to construct a correct `Process::Status`, and `process_wait(-1, ...)` / `process_wait(0, ...)` are now supported.
+  - Support waiting for any child or a process group (`pid <= 0`) on all selectors. The `EPoll` (`pidfd_open`) and `KQueue` (`EVFILT_PROC`) selectors can only watch a specific process, so these cases now fall back to a blocking wait on a dedicated thread; joining it is fiber-scheduler aware, so the reactor keeps running.
+
+### v1.18.0
+
+  - **Fixed**: Avoid entering a blocking native selector wait when an interrupt is already pending for the current thread.
+
 ### v1.17.0
 
   - Report inherited selector objects as closed after fork, and avoid closing descriptors they no longer own.
@@ -56,14 +65,6 @@ Please see the [project releases](https://socketry.github.io/io-event/releases/i
 
   - Add bounds checks, in the unlikely event of a user providing an invalid offset that exceeds the buffer size. This prevents potential memory corruption and ensures safe operation when using buffered IO methods.
 
-### v1.14.4
-
-  - Allow `epoll_pwait2` to be disabled via `--disable-epoll_pwait2`.
-
-### v1.14.3
-
-  - Fix several implementation bugs that could cause deadlocks on blocking writes.
-
 ## Contributing
 
 We welcome contributions to this project.

data/releases.md

@@ -1,5 +1,14 @@
 # Releases
 
+## v1.19.0
+
+  - Use `io_uring_prep_waitid` for `process_wait` in the `URing` selector (Linux 6.7+), waiting for child exit directly in the ring instead of polling on a `pidfd`. The child is reaped via `rb_process_status_wait` (using `WEXITED | WNOWAIT`) to construct a correct `Process::Status`, and `process_wait(-1, ...)` / `process_wait(0, ...)` are now supported.
+  - Support waiting for any child or a process group (`pid <= 0`) on all selectors. The `EPoll` (`pidfd_open`) and `KQueue` (`EVFILT_PROC`) selectors can only watch a specific process, so these cases now fall back to a blocking wait on a dedicated thread; joining it is fiber-scheduler aware, so the reactor keeps running.
+
+## v1.18.0
+
+  - **Fixed**: Avoid entering a blocking native selector wait when an interrupt is already pending for the current thread.
+
 ## v1.17.0
 
   - Report inherited selector objects as closed after fork, and avoid closing descriptors they no longer own.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: io-event
 version: !ruby/object:Gem::Version
-  version: 1.17.0
+  version: 1.19.0
 platform: ruby
 authors:
 - Samuel Williams
@@ -20,6 +20,7 @@ authors:
 - John Hawthorn
 - Luke Gruber
 - Pavel Rosický
+- Sharon Rosner
 - Stan Hu
 - Stanislav (Stas) Katkov
 - William T. Nelson