io-event 1.19.1 → 1.19.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba7c5ec2b2a68b1d615e75f33a081973b1f6c28122128e21e014dd5a348118b1
-  data.tar.gz: 78435a88a40c5b6458a13887cc709fcfc386c6ed7268b382fc7f976e422aa9c5
+  metadata.gz: f9b4e34ef8c8e421b9fe40c1e0556a1317b3233f0746f3c8c613c26bc962a2db
+  data.tar.gz: 8c4839836a933969612713d34031d2a88e8bac969061b64ad1d188db4f56e4db
 SHA512:
-  metadata.gz: b72b4d8e4f03515215af878ffe81c7bacf34be736bf8bc642d3e12e21d78c39eed7e1ae78ebb68786cddeae07042588a202b29f7a382352ed72fa08b1673cf88
-  data.tar.gz: 780583a7ef578f08f3e9c6fdec3547ea1140de80b514c934d3f3bd56d95eeb776a07f5cd5fc6fea2c65708a7730401c172bf981dc2d4e086325123e4cb6e0ae4
+  metadata.gz: 75d55f360c232dbbb88c9794db98cd3c4e685652f7e407b1f411c2296991a6a31b947f5448e91a44daed431d562859e3f3d45640ecc99ae0936b65edbcb48183
+  data.tar.gz: 8f47bb334168fc983d765e39c53ccc6a19501204c15ae68d72bbeb3d11f0459b6a255c2ea944061ac494c8696c28d992bb3b241c6685ba3c6aaa2fc8ef5c98a1

data/ext/extconf.rb

@@ -51,6 +51,7 @@ have_header("sys/eventfd.h")
 $srcs << "io/event/interrupt.c"
 
 have_func("rb_io_descriptor")
+have_func("rb_process_status_for")
 have_func("&rb_process_status_wait")
 have_func("rb_fiber_current")
 have_func("&rb_fiber_raise")

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

@@ -41,11 +41,6 @@ struct IO_Event_Selector_EPoll
 	int descriptor;
 	pid_t owner;
 	
-	// Flag indicating whether the selector is currently blocked in a system call.
-	// Set to 1 when blocked in epoll_wait() without GVL, 0 otherwise.
-	// Used by wakeup() to determine if an interrupt signal is needed.
-	int blocked;
-	
 	struct timespec idle_duration;
 	
 	struct IO_Event_Interrupt interrupt;
@@ -320,8 +315,6 @@ VALUE IO_Event_Selector_EPoll_allocate(VALUE self) {
 	IO_Event_Selector_initialize(&selector->backend, self, Qnil);
 	selector->descriptor = -1;
 	selector->owner = 0;
-	selector->blocked = 0;
-	
 	selector->descriptors.element_initialize = IO_Event_Selector_EPoll_Descriptor_initialize;
 	selector->descriptors.element_free = IO_Event_Selector_EPoll_Descriptor_free;
 	IO_Event_Array_initialize(&selector->descriptors, IO_EVENT_ARRAY_DEFAULT_COUNT, sizeof(struct IO_Event_Selector_EPoll_Descriptor));
@@ -846,14 +839,6 @@ int select_blocking_allowed(struct timespec * timespec) {
 	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;
 }
 
@@ -918,13 +903,7 @@ void * select_internal(void *_arguments) {
 static
 int select_internal_without_gvl(struct select_arguments *arguments) {
 	arguments->result = -1;
-	arguments->selector->blocked = 1;
-#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;
+	IO_Event_Selector_blocking_operation(&arguments->selector->backend, select_internal, (void *)arguments, RUBY_UBF_IO, 0);
 	
 	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.
@@ -1089,7 +1068,7 @@ VALUE IO_Event_Selector_EPoll_wakeup(VALUE self) {
 	TypedData_Get_Struct(self, struct IO_Event_Selector_EPoll, &IO_Event_Selector_EPoll_Type, selector);
 	
 	// If we are blocking, we can schedule a nop event to wake up the selector:
-	if (selector->blocked) {
+	if (selector->backend.blocked) {
 		IO_Event_Interrupt_signal(&selector->interrupt);
 		
 		return Qtrue;

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

@@ -50,11 +50,6 @@ struct IO_Event_Selector_KQueue
 	int descriptor;
 	pid_t owner;
 	
-	// Flag indicating whether the selector is currently blocked in a system call.
-	// Set to 1 when blocked in kevent() without GVL, 0 otherwise.
-	// Used by wakeup() to determine if an interrupt signal is needed.
-	int blocked;
-	
 	struct timespec idle_duration;
 	
 #ifdef IO_EVENT_SELECTOR_KQUEUE_USE_INTERRUPT
@@ -299,8 +294,6 @@ VALUE IO_Event_Selector_KQueue_allocate(VALUE self) {
 	IO_Event_Selector_initialize(&selector->backend, self, Qnil);
 	selector->descriptor = -1;
 	selector->owner = 0;
-	selector->blocked = 0;
-	
 	selector->descriptors.element_initialize = IO_Event_Selector_KQueue_Descriptor_initialize;
 	selector->descriptors.element_free = IO_Event_Selector_KQueue_Descriptor_free;
 	
@@ -850,14 +843,6 @@ int select_blocking_allowed(struct timespec * timespec) {
 	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;
 }
 
@@ -886,14 +871,7 @@ void * select_internal(void *_arguments) {
 static
 int select_internal_without_gvl(struct select_arguments *arguments) {
 	arguments->result = -1;
-	arguments->selector->blocked = 1;
-	
-#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;
+	IO_Event_Selector_blocking_operation(&arguments->selector->backend, select_internal, (void *)arguments, RUBY_UBF_IO, 0);
 	
 	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.
@@ -1069,7 +1047,7 @@ VALUE IO_Event_Selector_KQueue_wakeup(VALUE self) {
 	struct IO_Event_Selector_KQueue *selector = NULL;
 	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
-	if (selector->blocked) {
+	if (selector->backend.blocked) {
 #ifdef IO_EVENT_SELECTOR_KQUEUE_USE_INTERRUPT
 		IO_Event_Interrupt_signal(&selector->interrupt);
 #else

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

@@ -8,7 +8,59 @@
 
 static const int DEBUG = 0;
 
-ID IO_Event_Selector_pending_interrupt_p_id;
+#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;
@@ -89,7 +141,14 @@ VALUE IO_Event_Selector_process_wait(rb_pid_t pid, int flags) {
 }
 
 void Init_IO_Event_Selector(VALUE IO_Event_Selector) {
-	IO_Event_Selector_pending_interrupt_p_id = rb_intern("pending_interrupt?");
+#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);
@@ -114,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,11 +40,11 @@ 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));
-}
+// 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)
@@ -90,6 +90,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;

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

@@ -42,10 +42,6 @@ struct IO_Event_Selector_URing
 	struct io_uring ring;
 	pid_t owner;
 	
-	// Flag indicating whether the selector is currently blocked in a system call.
-	// Set to 1 when blocked in io_uring_wait_cqe_timeout() without GVL, 0 otherwise.
-	int blocked;
-	
 	// Interrupt used to wake the selector from another thread without touching the ring's SQ.
 	// This allows IORING_SETUP_SINGLE_ISSUER: only the owner thread ever submits SQEs.
 	// Uses eventfd on Linux, pipe fallback elsewhere.
@@ -254,7 +250,6 @@ VALUE IO_Event_Selector_URing_allocate(VALUE self) {
 	selector->ring.ring_fd = -1;
 	selector->owner = 0;
 	
-	selector->blocked = 0;
 	selector->interrupt.descriptor = -1;
 	selector->wakeup_registered = 0;
 	
@@ -546,6 +541,29 @@ struct process_wait_arguments {
 #endif
 };
 
+#if defined(IO_EVENT_SELECTOR_URING_USE_WAITID) && defined(HAVE_RB_PROCESS_STATUS_FOR)
+static inline int process_wait_status_exited(int exit_status) {
+	return (exit_status & 0xff) << 8;
+}
+
+static inline int process_wait_status_signaled(int term_signal) {
+	return term_signal & 0x7f;
+}
+
+static inline int process_wait_status_from_siginfo(const siginfo_t *siginfo) {
+	switch (siginfo->si_code) {
+		case CLD_EXITED:
+			return process_wait_status_exited(siginfo->si_status);
+		case CLD_KILLED:
+			return process_wait_status_signaled(siginfo->si_status);
+		case CLD_DUMPED:
+			return process_wait_status_signaled(siginfo->si_status) | 0x80;
+		default:
+			return 0;
+	}
+}
+#endif
+
 static
 VALUE process_wait_transfer(VALUE _arguments) {
 	struct process_wait_arguments *arguments = (struct process_wait_arguments *)_arguments;
@@ -559,11 +577,20 @@ VALUE process_wait_transfer(VALUE _arguments) {
 	
 	if (result < 0) {
 		// The `waitid` failed (e.g. `ECHILD` when there are no children). Reproduce the failure as a `Process::Status` carrying the error, rather than raising, so callers like `Process.waitall` / `Process.detach` (which expect `waitpid` to report the error, not raise) behave correctly:
+#ifdef HAVE_RB_PROCESS_STATUS_FOR
+		return rb_process_status_for(-1, 0, -result);
+#else
 		return IO_Event_Selector_process_status_reap(arguments->pid, arguments->flags);
+#endif
 	}
 	
+#ifdef HAVE_RB_PROCESS_STATUS_FOR
+	// The `waitid` operation already reaped the child. Convert the `siginfo_t` result directly into the Ruby process status value:
+	return rb_process_status_for(arguments->siginfo.si_pid, process_wait_status_from_siginfo(&arguments->siginfo), 0);
+#else
 	// 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);
+#endif
 #else
 	if (arguments->waiting->result) {
 		return IO_Event_Selector_process_status_reap(arguments->pid, arguments->flags);
@@ -632,8 +659,13 @@ VALUE IO_Event_Selector_URing_process_wait(VALUE self, VALUE fiber, VALUE _pid,
 	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);
+#ifdef HAVE_RB_PROCESS_STATUS_FOR
+	// Reap the child directly; the completion contains enough information to construct the Ruby process status value:
+	io_uring_prep_waitid(sqe, idtype, id, &process_wait_arguments.siginfo, WEXITED, 0);
+#else
 	// `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);
+#endif
 #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);
@@ -1210,14 +1242,6 @@ int select_blocking_allowed(struct __kernel_timespec *timespec) {
 	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;
 }
 
@@ -1258,13 +1282,7 @@ int select_internal_without_gvl(struct select_arguments *arguments) {
 	io_uring_submit_flush(selector);
 	
 	arguments->result = -EINTR;
-	selector->blocked = 1;
-#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;
+	IO_Event_Selector_blocking_operation(&selector->backend, select_internal, (void *)arguments, RUBY_UBF_IO, 0);
 	
 	if (arguments->result == -ETIME) {
 		return 0;
@@ -1418,7 +1436,7 @@ VALUE IO_Event_Selector_URing_wakeup(VALUE self) {
 	
 	// Wake the selector by signalling the interrupt. This is safe from any thread
 	// and never touches the ring's SQ, which is required for IORING_SETUP_SINGLE_ISSUER.
-	if (selector->blocked) {
+	if (selector->backend.blocked) {
 		IO_Event_Interrupt_signal(&selector->interrupt);
 		return Qtrue;
 	}

data/lib/io/event/version.rb

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

data/readme.md

@@ -18,6 +18,14 @@ 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.3
+
+  - Prevent `URing`, `EPoll`, and `KQueue` from entering a native wait when a signal exception becomes pending during the GVL transition. On Ruby versions without `RB_NOGVL_PENDING_INTR_FAIL`, the fallback now refreshes pending-interrupt state immediately before releasing the GVL while preserving the caller's exception-delivery timing.
+
+### v1.19.2
+
+  - Use `rb_process_status_for` when available to construct `URing` `process_wait` results directly from `waitid`, avoiding the extra reap syscall previously needed to build a `Process::Status`.
+
 ### v1.19.1
 
   - Fix `Process.waitall` / `Process.detach` under the `URing` selector: when `io_uring`'s `waitid` reported an error (e.g. `ECHILD` when there are no more children), the `process_wait` hook raised instead of returning the error as a `Process::Status`, so callers that expect `waitpid` to *report* "no more children" rather than raise would fail.
@@ -51,20 +59,6 @@ Please see the [project releases](https://socketry.github.io/io-event/releases/i
 
   - Ensure the pure Ruby `Select` selector returns `false`, not `nil`, when `io_wait` resumes without any ready events.
 
-### v1.16.0
-
-  - Use `eventfd` for `URing` cross-thread wakeup, and enable `IORING_SETUP_SINGLE_ISSUER`, `IORING_SETUP_DEFER_TASKRUN`, and `IORING_SETUP_TASKRUN_FLAG`. The waking thread now signals via `eventfd` rather than submitting a `NOP` SQE, which unlocks the single-issuer optimisation, defers task work to the application thread, and lets `select()` skip the `io_uring_get_events()` syscall when no task work is pending.
-  - Add support for the `io_close` fiber-scheduler hook (Ruby 4.0+). The `URing` selector performs the close asynchronously via the ring; the `Debug::Selector` and `TestScheduler` wrappers forward to the underlying selector when supported.
-  - Improve `WorkerPool` GC compaction support and add proper write barriers, fixing potential use-after-free under compacting GC.
-  - Keep blocked scheduler fibers alive during GC by registering them as roots in `TestScheduler#block`, preventing premature collection and the resulting use-after-free crash on resume.
-  - Use Ruby's `xmalloc` / `xcalloc` / `xrealloc2` / `xfree` for all internal selector allocations (the per-fiber ready-queue entries in `IO_Event_Selector_ready_push`, and both the backing array and per-element allocations in `IO_Event_Array`). Previously a raw `malloc` paired with a debug-build-only `assert(...)` would silently dereference `NULL` and crash in release builds under memory pressure; the Ruby allocators trigger a GC sweep on pressure and raise `NoMemoryError` / `RangeError` on real failure, so the `-1` return-code paths through `IO_Event_Array_initialize` / `_resize` / `_lookup` and their callers in `epoll.c` / `kqueue.c` / `uring.c` are removed in favour of straight exception propagation.
-  - Correctly handle short `io_uring_submit()` results in the `URing` selector. `io_uring_submit()` returns the number of SQEs actually accepted by the kernel and can be short (SQE prep errors, `ENOMEM`, transient `EAGAIN`); the old accounting reset `pending = 0` on any success and silently lost track of unsubmitted SQEs.
-  - Enable `IORING_SETUP_SUBMIT_ALL` (kernel 5.18+) on the `URing` selector so the kernel keeps processing the rest of an SQE batch past individual errors, reducing the frequency of short submits in practice.
-
-### v1.15.1
-
-  - Simplify closed-IO handling in the `Select` selector: rely on Ruby 4's `rb_thread_io_close_interrupt` to wake fibers waiting on a descriptor that's been closed, removing a custom error-recovery path that could mis-attribute `IOError` / `Errno::EBADF` to the wrong waiter.
-
 ## Contributing
 
 We welcome contributions to this project.

data/releases.md

@@ -1,5 +1,13 @@
 # Releases
 
+## v1.19.3
+
+  - Prevent `URing`, `EPoll`, and `KQueue` from entering a native wait when a signal exception becomes pending during the GVL transition. On Ruby versions without `RB_NOGVL_PENDING_INTR_FAIL`, the fallback now refreshes pending-interrupt state immediately before releasing the GVL while preserving the caller's exception-delivery timing.
+
+## v1.19.2
+
+  - Use `rb_process_status_for` when available to construct `URing` `process_wait` results directly from `waitid`, avoiding the extra reap syscall previously needed to build a `Process::Status`.
+
 ## v1.19.1
 
   - Fix `Process.waitall` / `Process.detach` under the `URing` selector: when `io_uring`'s `waitid` reported an error (e.g. `ECHILD` when there are no more children), the `process_wait` hook raised instead of returning the error as a `Process::Status`, so callers that expect `waitpid` to *report* "no more children" rather than raise would fail.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: io-event
 version: !ruby/object:Gem::Version
-  version: 1.19.1
+  version: 1.19.3
 platform: ruby
 authors:
 - Samuel Williams