io-event 1.16.4 → 1.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 83f9faed054855a0c3a50ab469f315c1345a8af43641ab6c5630d648763fc55d
-  data.tar.gz: 78114e047cd897ed0192c262d099a93baea21d0c30ddb70cd57e4efc73a40889
+  metadata.gz: 7ad9ab9326ef0bb4d637833e5d9705940a7d150c0e42154ee4642fbf6f4b4b49
+  data.tar.gz: bb1274afaa893df427b3eb422aa5c198da08493126e8b5f3ee2daac375f1ebda
 SHA512:
-  metadata.gz: 7cea5251f1c5b93b0235e2aa6aa69c65913e13de847a535eee21343060f744b2a810eb901b15b82bbb3c9979d60a620d4d89dfba349473ab6836e9c420985b9d
-  data.tar.gz: c8752f8a0bc9da0ca37ae420364a564c68ad4cb6020124f767677a854c7d81639e9e6daa46040d8fc575e02a7231ff5409d72833b8eb15ec72684b063b5d92d2
+  metadata.gz: 543bdb171056e37849b7042c0d822e7421908bbd006227be92b1b2c5c12d7988c8201ce02316c9f0aa32df9746f4a6d88345c8eb9f38f9c5018f4adbaeca27b9
+  data.tar.gz: 65b3f2b61cf38b3c66cb2d0e9299ece198e546d0e30676f8bbd616fdccb043b47f032f0e8fd00bb5bf14bdef471f5ebb1c4769e8de86654900916fc8952c2be7

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

@@ -9,6 +9,7 @@
 #include <sys/epoll.h>
 #include <time.h>
 #include <errno.h>
+#include <unistd.h>
 
 #include "pidfd.c"
 #include "../interrupt.h"
@@ -38,6 +39,7 @@ struct IO_Event_Selector_EPoll
 {
 	struct IO_Event_Selector backend;
 	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.
@@ -131,10 +133,12 @@ static
 void close_internal(struct IO_Event_Selector_EPoll *selector)
 {
 	if (selector->descriptor >= 0) {
-		close(selector->descriptor);
-		selector->descriptor = -1;
+		if (selector->owner == getpid()) {
+			close(selector->descriptor);
+			IO_Event_Interrupt_close(&selector->interrupt);
+		}
 		
-		IO_Event_Interrupt_close(&selector->interrupt);
+		selector->descriptor = -1;
 	}
 }
 
@@ -315,6 +319,7 @@ 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;
@@ -350,6 +355,7 @@ VALUE IO_Event_Selector_EPoll_initialize(VALUE self, VALUE loop) {
 		rb_sys_fail("IO_Event_Selector_EPoll_initialize:epoll_create");
 	} else {
 		selector->descriptor = result;
+		selector->owner = getpid();
 		
 		rb_update_max_fd(selector->descriptor);
 	}
@@ -385,6 +391,13 @@ VALUE IO_Event_Selector_EPoll_close(VALUE self) {
 	return Qnil;
 }
 
+VALUE IO_Event_Selector_EPoll_closed_p(VALUE self) {
+	struct IO_Event_Selector_EPoll *selector = NULL;
+	TypedData_Get_Struct(self, struct IO_Event_Selector_EPoll, &IO_Event_Selector_EPoll_Type, selector);
+	
+	return selector->descriptor < 0 || selector->owner != getpid() ? Qtrue : Qfalse;
+}
+
 VALUE IO_Event_Selector_EPoll_transfer(VALUE self)
 {
 	struct IO_Event_Selector_EPoll *selector = NULL;
@@ -590,36 +603,29 @@ struct io_read_arguments {
 	
 	int descriptor;
 	
-	VALUE buffer;
+	// The remaining writable buffer region after applying the requested offset.
+	void *base;
+	size_t size;
+	
+	// The minimum number of bytes requested by the caller.
 	size_t length;
-	size_t offset;
 };
 
 static
 VALUE io_read_loop(VALUE _arguments) {
 	struct io_read_arguments *arguments = (struct io_read_arguments *)_arguments;
 	
-	void *base;
-	size_t size;
-	rb_io_buffer_get_bytes_for_writing(arguments->buffer, &base, &size);
-	
 	size_t length = arguments->length;
-	size_t offset = arguments->offset;
 	size_t total = 0;
 	
-	// Ensure offset is within the bounds of the buffer to avoid size_t underflow and out-of-bounds pointer arithmetic on (char *)base + offset.
-	if (offset > size) {
-		return rb_fiber_scheduler_io_result(-1, EINVAL);
-	}
-	
-	size_t maximum_size = size - offset;
+	size_t maximum_size = arguments->size;
 	while (maximum_size) {
-		ssize_t result = read(arguments->descriptor, (char*)base+offset, maximum_size);
+		ssize_t result = read(arguments->descriptor, (char*)arguments->base+total, maximum_size);
 		
 		if (result > 0) {
 			total += result;
-			offset += result;
 			if ((size_t)result >= length) break;
+			maximum_size -= result;
 			length -= result;
 		} else if (result == 0) {
 			break;
@@ -628,8 +634,6 @@ VALUE io_read_loop(VALUE _arguments) {
 		} else {
 			return rb_fiber_scheduler_io_result(-1, errno);
 		}
-		
-		maximum_size = size - offset;
 	}
 	
 	return rb_fiber_scheduler_io_result(total, 0);
@@ -645,11 +649,24 @@ VALUE io_read_ensure(VALUE _arguments) {
 }
 
 VALUE IO_Event_Selector_EPoll_io_read(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _length, VALUE _offset) {
-	int descriptor = IO_Event_Selector_io_descriptor(io);
-	
 	size_t offset = NUM2SIZET(_offset);
 	size_t length = NUM2SIZET(_length);
 	
+	void *base;
+	size_t size;
+	rb_io_buffer_get_bytes_for_writing(buffer, &base, &size);
+	
+	if (offset > size) {
+		return rb_fiber_scheduler_io_result(-1, EINVAL);
+	} else if (offset == size) {
+		return rb_fiber_scheduler_io_result(0, 0);
+	}
+	
+	base = (char*)base + offset;
+	size -= offset;
+	
+	int descriptor = IO_Event_Selector_io_descriptor(io);
+	
 	struct io_read_arguments io_read_arguments = {
 		.self = self,
 		.fiber = fiber,
@@ -657,9 +674,9 @@ VALUE IO_Event_Selector_EPoll_io_read(VALUE self, VALUE fiber, VALUE io, VALUE b
 		
 		.flags = IO_Event_Selector_nonblock_set(descriptor),
 		.descriptor = descriptor,
-		.buffer = buffer,
+		.base = base,
+		.size = size,
 		.length = length,
-		.offset = offset,
 	};
 	
 	RB_OBJ_WRITTEN(self, Qundef, fiber);
@@ -689,40 +706,29 @@ struct io_write_arguments {
 	
 	int descriptor;
 	
-	VALUE buffer;
+	// The remaining readable buffer region after applying the requested offset.
+	const void *base;
+	size_t size;
+	
+	// The minimum number of bytes requested by the caller.
 	size_t length;
-	size_t offset;
 };
 
 static
 VALUE io_write_loop(VALUE _arguments) {
 	struct io_write_arguments *arguments = (struct io_write_arguments *)_arguments;
 	
-	const void *base;
-	size_t size;
-	rb_io_buffer_get_bytes_for_reading(arguments->buffer, &base, &size);
-	
 	size_t length = arguments->length;
-	size_t offset = arguments->offset;
 	size_t total = 0;
 	
-	if (length > size) {
-		rb_raise(rb_eRuntimeError, "Length exceeds size of buffer!");
-	}
-	
-	// Ensure offset is within the bounds of the buffer to avoid size_t underflow and out-of-bounds pointer arithmetic on (char *)base + offset.
-	if (offset > size) {
-		return rb_fiber_scheduler_io_result(-1, EINVAL);
-	}
-	
-	size_t maximum_size = size - offset;
+	size_t maximum_size = arguments->size;
 	while (maximum_size) {
-		ssize_t result = write(arguments->descriptor, (char*)base+offset, maximum_size);
+		ssize_t result = write(arguments->descriptor, (char*)arguments->base+total, maximum_size);
 		
 		if (result > 0) {
 			total += result;
-			offset += result;
 			if ((size_t)result >= length) break;
+			maximum_size -= result;
 			length -= result;
 		} else if (result == 0) {
 			break;
@@ -731,8 +737,6 @@ VALUE io_write_loop(VALUE _arguments) {
 		} else {
 			return rb_fiber_scheduler_io_result(-1, errno);
 		}
-		
-		maximum_size = size - offset;
 	}
 	
 	return rb_fiber_scheduler_io_result(total, 0);
@@ -748,11 +752,28 @@ VALUE io_write_ensure(VALUE _arguments) {
 };
 
 VALUE IO_Event_Selector_EPoll_io_write(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _length, VALUE _offset) {
-	int descriptor = IO_Event_Selector_io_descriptor(io);
-	
 	size_t length = NUM2SIZET(_length);
 	size_t offset = NUM2SIZET(_offset);
 	
+	const void *base;
+	size_t size;
+	rb_io_buffer_get_bytes_for_reading(buffer, &base, &size);
+	
+	if (length > size) {
+		rb_raise(rb_eRuntimeError, "Length exceeds size of buffer!");
+	}
+	
+	if (offset > size) {
+		return rb_fiber_scheduler_io_result(-1, EINVAL);
+	} else if (offset == size) {
+		return rb_fiber_scheduler_io_result(0, 0);
+	}
+	
+	base = (const char*)base + offset;
+	size -= offset;
+	
+	int descriptor = IO_Event_Selector_io_descriptor(io);
+	
 	struct io_write_arguments io_write_arguments = {
 		.self = self,
 		.fiber = fiber,
@@ -760,9 +781,9 @@ VALUE IO_Event_Selector_EPoll_io_write(VALUE self, VALUE fiber, VALUE io, VALUE
 		
 		.flags = IO_Event_Selector_nonblock_set(descriptor),
 		.descriptor = descriptor,
-		.buffer = buffer,
+		.base = base,
+		.size = size,
 		.length = length,
-		.offset = offset,
 	};
 	
 	RB_OBJ_WRITTEN(self, Qundef, fiber);
@@ -809,14 +830,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;
@@ -830,7 +870,7 @@ static int make_timeout_ms(struct timespec * timeout) {
 		return -1;
 	}
 	
-	if (timeout_nonblocking(timeout)) {
+	if (timeout_is_nonblocking(timeout)) {
 		return 0;
 	}
 	
@@ -851,13 +891,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 {
@@ -865,37 +905,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
@@ -951,7 +1001,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);
 		
@@ -962,7 +1012,7 @@ VALUE select_handle_events(VALUE _arguments)
 		}
 	}
 	
-	return INT2NUM(arguments->count);
+	return INT2NUM(arguments->result);
 }
 
 static
@@ -987,6 +1037,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
@@ -997,22 +1049,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);
@@ -1020,7 +1072,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);
@@ -1079,6 +1131,7 @@ void Init_IO_Event_Selector_EPoll(VALUE IO_Event_Selector) {
 	rb_define_method(IO_Event_Selector_EPoll, "select", IO_Event_Selector_EPoll_select, 1);
 	rb_define_method(IO_Event_Selector_EPoll, "wakeup", IO_Event_Selector_EPoll_wakeup, 0);
 	rb_define_method(IO_Event_Selector_EPoll, "close", IO_Event_Selector_EPoll_close, 0);
+	rb_define_method(IO_Event_Selector_EPoll, "closed?", IO_Event_Selector_EPoll_closed_p, 0);
 	
 	rb_define_method(IO_Event_Selector_EPoll, "io_wait", IO_Event_Selector_EPoll_io_wait, 3);
 	

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

@@ -12,6 +12,7 @@
 #include <errno.h>
 #include <sys/wait.h>
 #include <signal.h>
+#include <unistd.h>
 
 #include "../interrupt.h"
 
@@ -47,6 +48,7 @@ struct IO_Event_Selector_KQueue
 {
 	struct IO_Event_Selector backend;
 	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.
@@ -132,7 +134,14 @@ static
 void close_internal(struct IO_Event_Selector_KQueue *selector)
 {
 	if (selector->descriptor >= 0) {
-		close(selector->descriptor);
+		if (selector->owner == getpid()) {
+			close(selector->descriptor);
+			
+#ifdef IO_EVENT_SELECTOR_KQUEUE_USE_INTERRUPT
+			IO_Event_Interrupt_close(&selector->interrupt);
+#endif
+		}
+		
 		selector->descriptor = -1;
 	}
 }
@@ -289,6 +298,7 @@ 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;
@@ -331,6 +341,7 @@ VALUE IO_Event_Selector_KQueue_initialize(VALUE self, VALUE loop) {
 		ioctl(result, FIOCLEX);
 		
 		selector->descriptor = result;
+		selector->owner = getpid();
 		
 		rb_update_max_fd(selector->descriptor);
 	}
@@ -365,13 +376,16 @@ VALUE IO_Event_Selector_KQueue_close(VALUE self) {
 	
 	close_internal(selector);
 	
-#ifdef IO_EVENT_SELECTOR_KQUEUE_USE_INTERRUPT
-	IO_Event_Interrupt_close(&selector->interrupt);
-#endif
-	
 	return Qnil;
 }
 
+VALUE IO_Event_Selector_KQueue_closed_p(VALUE self) {
+	struct IO_Event_Selector_KQueue *selector = NULL;
+	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
+	
+	return selector->descriptor < 0 || selector->owner != getpid() ? Qtrue : Qfalse;
+}
+
 VALUE IO_Event_Selector_KQueue_transfer(VALUE self)
 {
 	struct IO_Event_Selector_KQueue *selector = NULL;
@@ -578,40 +592,33 @@ struct io_read_arguments {
 	
 	int descriptor;
 	
-	VALUE buffer;
+	// The remaining writable buffer region after applying the requested offset.
+	void *base;
+	size_t size;
+	
+	// The minimum number of bytes requested by the caller.
 	size_t length;
-	size_t offset;
 };
 
 static
 VALUE io_read_loop(VALUE _arguments) {
 	struct io_read_arguments *arguments = (struct io_read_arguments *)_arguments;
 	
-	void *base;
-	size_t size;
-	rb_io_buffer_get_bytes_for_writing(arguments->buffer, &base, &size);
-	
 	size_t length = arguments->length;
-	size_t offset = arguments->offset;
 	size_t total = 0;
 	
 	if (DEBUG_IO_READ) fprintf(stderr, "io_read_loop(fd=%d, length=%zu)\n", arguments->descriptor, length);
 	
-	// Ensure offset is within the bounds of the buffer to avoid size_t underflow and out-of-bounds pointer arithmetic on (char *)base + offset.
-	if (offset > size) {
-		return rb_fiber_scheduler_io_result(-1, EINVAL);
-	}
-	
-	size_t maximum_size = size - offset;
+	size_t maximum_size = arguments->size;
 	while (maximum_size) {
-		if (DEBUG_IO_READ) fprintf(stderr, "read(%d, +%ld, %ld)\n", arguments->descriptor, offset, maximum_size);
-		ssize_t result = read(arguments->descriptor, (char*)base+offset, maximum_size);
-		if (DEBUG_IO_READ) fprintf(stderr, "read(%d, +%ld, %ld) -> %zd\n", arguments->descriptor, offset, maximum_size, result);
+		if (DEBUG_IO_READ) fprintf(stderr, "read(%d, +%ld, %ld)\n", arguments->descriptor, total, maximum_size);
+		ssize_t result = read(arguments->descriptor, (char*)arguments->base+total, maximum_size);
+		if (DEBUG_IO_READ) fprintf(stderr, "read(%d, +%ld, %ld) -> %zd\n", arguments->descriptor, total, maximum_size, result);
 		
 		if (result > 0) {
 			total += result;
-			offset += result;
 			if ((size_t)result >= length) break;
+			maximum_size -= result;
 			length -= result;
 		} else if (result == 0) {
 			break;
@@ -622,11 +629,9 @@ VALUE io_read_loop(VALUE _arguments) {
 			if (DEBUG_IO_READ) fprintf(stderr, "io_read_loop(fd=%d, length=%zu) -> errno=%d\n", arguments->descriptor, length, errno);
 			return rb_fiber_scheduler_io_result(-1, errno);
 		}
-		
-		maximum_size = size - offset;
 	}
 	
-	if (DEBUG_IO_READ) fprintf(stderr, "io_read_loop(fd=%d, length=%zu) -> %zu\n", arguments->descriptor, length, offset);
+	if (DEBUG_IO_READ) fprintf(stderr, "io_read_loop(fd=%d, length=%zu) -> %zu\n", arguments->descriptor, length, total);
 	return rb_fiber_scheduler_io_result(total, 0);
 }
 
@@ -643,11 +648,24 @@ VALUE IO_Event_Selector_KQueue_io_read(VALUE self, VALUE fiber, VALUE io, VALUE
 	struct IO_Event_Selector_KQueue *selector = NULL;
 	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
-	int descriptor = IO_Event_Selector_io_descriptor(io);
-	
 	size_t length = NUM2SIZET(_length);
 	size_t offset = NUM2SIZET(_offset);
 	
+	void *base;
+	size_t size;
+	rb_io_buffer_get_bytes_for_writing(buffer, &base, &size);
+	
+	if (offset > size) {
+		return rb_fiber_scheduler_io_result(-1, EINVAL);
+	} else if (offset == size) {
+		return rb_fiber_scheduler_io_result(0, 0);
+	}
+	
+	base = (char*)base + offset;
+	size -= offset;
+	
+	int descriptor = IO_Event_Selector_io_descriptor(io);
+	
 	struct io_read_arguments io_read_arguments = {
 		.self = self,
 		.fiber = fiber,
@@ -655,9 +673,9 @@ VALUE IO_Event_Selector_KQueue_io_read(VALUE self, VALUE fiber, VALUE io, VALUE
 		
 		.flags = IO_Event_Selector_nonblock_set(descriptor),
 		.descriptor = descriptor,
-		.buffer = buffer,
+		.base = base,
+		.size = size,
 		.length = length,
-		.offset = offset,
 	};
 	
 	RB_OBJ_WRITTEN(self, Qundef, fiber);
@@ -687,44 +705,33 @@ struct io_write_arguments {
 	
 	int descriptor;
 	
-	VALUE buffer;
+	// The remaining readable buffer region after applying the requested offset.
+	const void *base;
+	size_t size;
+	
+	// The minimum number of bytes requested by the caller.
 	size_t length;
-	size_t offset;
 };
 
 static
 VALUE io_write_loop(VALUE _arguments) {
 	struct io_write_arguments *arguments = (struct io_write_arguments *)_arguments;
 	
-	const void *base;
-	size_t size;
-	rb_io_buffer_get_bytes_for_reading(arguments->buffer, &base, &size);
-	
 	size_t length = arguments->length;
-	size_t offset = arguments->offset;
 	size_t total = 0;
 	
-	if (length > size) {
-		rb_raise(rb_eRuntimeError, "Length exceeds size of buffer!");
-	}
-	
 	if (DEBUG_IO_WRITE) fprintf(stderr, "io_write_loop(fd=%d, length=%zu)\n", arguments->descriptor, length);
 	
-	// Ensure offset is within the bounds of the buffer to avoid size_t underflow and out-of-bounds pointer arithmetic on (char *)base + offset.
-	if (offset > size) {
-		return rb_fiber_scheduler_io_result(-1, EINVAL);
-	}
-	
-	size_t maximum_size = size - offset;
+	size_t maximum_size = arguments->size;
 	while (maximum_size) {
-		if (DEBUG_IO_WRITE) fprintf(stderr, "write(%d, +%ld, %ld, length=%zu)\n", arguments->descriptor, offset, maximum_size, length);
-		ssize_t result = write(arguments->descriptor, (char*)base+offset, maximum_size);
-		if (DEBUG_IO_WRITE) fprintf(stderr, "write(%d, +%ld, %ld) -> %zd\n", arguments->descriptor, offset, maximum_size, result);
+		if (DEBUG_IO_WRITE) fprintf(stderr, "write(%d, +%ld, %ld, length=%zu)\n", arguments->descriptor, total, maximum_size, length);
+		ssize_t result = write(arguments->descriptor, (char*)arguments->base+total, maximum_size);
+		if (DEBUG_IO_WRITE) fprintf(stderr, "write(%d, +%ld, %ld) -> %zd\n", arguments->descriptor, total, maximum_size, result);
 		
 		if (result > 0) {
 			total += result;
-			offset += result;
 			if ((size_t)result >= length) break;
+			maximum_size -= result;
 			length -= result;
 		} else if (result == 0) {
 			break;
@@ -735,11 +742,9 @@ VALUE io_write_loop(VALUE _arguments) {
 			if (DEBUG_IO_WRITE) fprintf(stderr, "io_write_loop(fd=%d, length=%zu) -> errno=%d\n", arguments->descriptor, length, errno);
 			return rb_fiber_scheduler_io_result(-1, errno);
 		}
-		
-		maximum_size = size - offset;
 	}
 	
-	if (DEBUG_IO_WRITE) fprintf(stderr, "io_write_loop(fd=%d, length=%zu) -> %zu\n", arguments->descriptor, length, offset);
+	if (DEBUG_IO_WRITE) fprintf(stderr, "io_write_loop(fd=%d, length=%zu) -> %zu\n", arguments->descriptor, length, total);
 	return rb_fiber_scheduler_io_result(total, 0);
 };
 
@@ -756,11 +761,28 @@ VALUE IO_Event_Selector_KQueue_io_write(VALUE self, VALUE fiber, VALUE io, VALUE
 	struct IO_Event_Selector_KQueue *selector = NULL;
 	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
-	int descriptor = IO_Event_Selector_io_descriptor(io);
-	
 	size_t length = NUM2SIZET(_length);
 	size_t offset = NUM2SIZET(_offset);
 	
+	const void *base;
+	size_t size;
+	rb_io_buffer_get_bytes_for_reading(buffer, &base, &size);
+	
+	if (length > size) {
+		rb_raise(rb_eRuntimeError, "Length exceeds size of buffer!");
+	}
+	
+	if (offset > size) {
+		return rb_fiber_scheduler_io_result(-1, EINVAL);
+	} else if (offset == size) {
+		return rb_fiber_scheduler_io_result(0, 0);
+	}
+	
+	base = (const char*)base + offset;
+	size -= offset;
+	
+	int descriptor = IO_Event_Selector_io_descriptor(io);
+	
 	struct io_write_arguments io_write_arguments = {
 		.self = self,
 		.fiber = fiber,
@@ -768,9 +790,9 @@ VALUE IO_Event_Selector_KQueue_io_write(VALUE self, VALUE fiber, VALUE io, VALUE
 		
 		.flags = IO_Event_Selector_nonblock_set(descriptor),
 		.descriptor = descriptor,
-		.buffer = buffer,
+		.base = base,
+		.size = size,
 		.length = length,
-		.offset = offset,
 	};
 	
 	RB_OBJ_WRITTEN(self, Qundef, fiber);
@@ -816,15 +838,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;
@@ -837,38 +873,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
@@ -922,14 +968,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);
@@ -940,7 +986,7 @@ VALUE select_handle_events(VALUE _arguments)
 		}
 	}
 	
-	return RB_INT2NUM(arguments->count);
+	return RB_INT2NUM(arguments->result);
 }
 
 static
@@ -965,6 +1011,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
@@ -975,14 +1022,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:
@@ -990,17 +1037,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);
@@ -1008,7 +1053,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);
@@ -1090,6 +1135,7 @@ void Init_IO_Event_Selector_KQueue(VALUE IO_Event_Selector) {
 	rb_define_method(IO_Event_Selector_KQueue, "select", IO_Event_Selector_KQueue_select, 1);
 	rb_define_method(IO_Event_Selector_KQueue, "wakeup", IO_Event_Selector_KQueue_wakeup, 0);
 	rb_define_method(IO_Event_Selector_KQueue, "close", IO_Event_Selector_KQueue_close, 0);
+	rb_define_method(IO_Event_Selector_KQueue, "closed?", IO_Event_Selector_KQueue_closed_p, 0);
 	
 	rb_define_method(IO_Event_Selector_KQueue, "io_wait", IO_Event_Selector_KQueue_io_wait, 3);
 	

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;
 
@@ -79,6 +81,8 @@ static VALUE IO_Event_Selector_nonblock(VALUE class, VALUE io)
 }
 
 void Init_IO_Event_Selector(VALUE IO_Event_Selector) {
+	IO_Event_Selector_pending_interrupt_p_id = rb_intern("pending_interrupt?");
+	
 #ifndef HAVE_RB_IO_DESCRIPTOR
 	id_fileno = rb_intern("fileno");
 #endif

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

@@ -40,6 +40,12 @@ 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

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

@@ -11,6 +11,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include <time.h>
+#include <unistd.h>
 
 #include "../interrupt.h"
 
@@ -32,6 +33,7 @@ struct IO_Event_Selector_URing
 {
 	struct IO_Event_Selector backend;
 	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.
@@ -115,14 +117,20 @@ void IO_Event_Selector_URing_Type_compact(void *_selector)
 static
 void close_internal(struct IO_Event_Selector_URing *selector)
 {
-	if (selector->interrupt.descriptor >= 0) {
-		IO_Event_Interrupt_close(&selector->interrupt);
+	if (selector->owner == getpid()) {
+		if (selector->interrupt.descriptor >= 0) {
+			IO_Event_Interrupt_close(&selector->interrupt);
+			selector->interrupt.descriptor = -1;
+			selector->wakeup_registered = 0;
+		}
+		
+		if (selector->ring.ring_fd >= 0) {
+			io_uring_queue_exit(&selector->ring);
+			selector->ring.ring_fd = -1;
+		}
+	} else {
 		selector->interrupt.descriptor = -1;
 		selector->wakeup_registered = 0;
-	}
-	
-	if (selector->ring.ring_fd >= 0) {
-		io_uring_queue_exit(&selector->ring);
 		selector->ring.ring_fd = -1;
 	}
 }
@@ -237,6 +245,7 @@ VALUE IO_Event_Selector_URing_allocate(VALUE self) {
 	
 	IO_Event_Selector_initialize(&selector->backend, self, Qnil);
 	selector->ring.ring_fd = -1;
+	selector->owner = 0;
 	
 	selector->blocked = 0;
 	selector->interrupt.descriptor = -1;
@@ -299,6 +308,8 @@ VALUE IO_Event_Selector_URing_initialize(VALUE self, VALUE loop) {
 		rb_syserr_fail(-result, "IO_Event_Selector_URing_initialize:io_uring_queue_init");
 	}
 	
+	selector->owner = getpid();
+	
 	rb_update_max_fd(selector->ring.ring_fd);
 	
 	// Interrupt for cross-thread wakeup: another thread calls signal(); the owner
@@ -339,6 +350,13 @@ VALUE IO_Event_Selector_URing_close(VALUE self) {
 	return Qnil;
 }
 
+VALUE IO_Event_Selector_URing_closed_p(VALUE self) {
+	struct IO_Event_Selector_URing *selector = NULL;
+	TypedData_Get_Struct(self, struct IO_Event_Selector_URing, &IO_Event_Selector_URing_Type, selector);
+	
+	return selector->ring.ring_fd < 0 || selector->owner != getpid() ? Qtrue : Qfalse;
+}
+
 VALUE IO_Event_Selector_URing_transfer(VALUE self)
 {
 	struct IO_Event_Selector_URing *selector = NULL;
@@ -757,8 +775,6 @@ VALUE IO_Event_Selector_URing_io_read(VALUE self, VALUE fiber, VALUE io, VALUE b
 	struct IO_Event_Selector_URing *selector = NULL;
 	TypedData_Get_Struct(self, struct IO_Event_Selector_URing, &IO_Event_Selector_URing_Type, selector);
 	
-	int descriptor = IO_Event_Selector_io_descriptor(io);
-	
 	void *base;
 	size_t size;
 	rb_io_buffer_get_bytes_for_writing(buffer, &base, &size);
@@ -766,13 +782,17 @@ VALUE IO_Event_Selector_URing_io_read(VALUE self, VALUE fiber, VALUE io, VALUE b
 	size_t length = NUM2SIZET(_length);
 	size_t offset = NUM2SIZET(_offset);
 	size_t total = 0;
-	off_t from = io_seekable(descriptor);
 	
 	// Ensure offset is within the bounds of the buffer to avoid size_t underflow and out-of-bounds pointer arithmetic on (char *)base + offset.
 	if (offset > size) {
 		return rb_fiber_scheduler_io_result(-1, EINVAL);
+	} else if (offset == size) {
+		return rb_fiber_scheduler_io_result(0, 0);
 	}
 	
+	int descriptor = IO_Event_Selector_io_descriptor(io);
+	off_t from = io_seekable(descriptor);
+	
 	size_t maximum_size = size - offset;
 	
 	// Are we performing a non-blocking read?
@@ -827,8 +847,6 @@ VALUE IO_Event_Selector_URing_io_pread(VALUE self, VALUE fiber, VALUE io, VALUE
 	struct IO_Event_Selector_URing *selector = NULL;
 	TypedData_Get_Struct(self, struct IO_Event_Selector_URing, &IO_Event_Selector_URing_Type, selector);
 	
-	int descriptor = IO_Event_Selector_io_descriptor(io);
-	
 	void *base;
 	size_t size;
 	rb_io_buffer_get_bytes_for_writing(buffer, &base, &size);
@@ -841,8 +859,12 @@ VALUE IO_Event_Selector_URing_io_pread(VALUE self, VALUE fiber, VALUE io, VALUE
 	// Ensure offset is within the bounds of the buffer to avoid size_t underflow and out-of-bounds pointer arithmetic on (char *)base + offset.
 	if (offset > size) {
 		return rb_fiber_scheduler_io_result(-1, EINVAL);
+	} else if (offset == size) {
+		return rb_fiber_scheduler_io_result(0, 0);
 	}
 	
+	int descriptor = IO_Event_Selector_io_descriptor(io);
+	
 	size_t maximum_size = size - offset;
 	while (maximum_size) {
 		int result = io_read(selector, fiber, descriptor, (char*)base+offset, maximum_size, from);
@@ -945,8 +967,6 @@ VALUE IO_Event_Selector_URing_io_write(VALUE self, VALUE fiber, VALUE io, VALUE
 	struct IO_Event_Selector_URing *selector = NULL;
 	TypedData_Get_Struct(self, struct IO_Event_Selector_URing, &IO_Event_Selector_URing_Type, selector);
 	
-	int descriptor = IO_Event_Selector_io_descriptor(io);
-	
 	const void *base;
 	size_t size;
 	rb_io_buffer_get_bytes_for_reading(buffer, &base, &size);
@@ -954,7 +974,6 @@ VALUE IO_Event_Selector_URing_io_write(VALUE self, VALUE fiber, VALUE io, VALUE
 	size_t length = NUM2SIZET(_length);
 	size_t offset = NUM2SIZET(_offset);
 	size_t total = 0;
-	off_t from = io_seekable(descriptor);
 	
 	if (length > size) {
 		rb_raise(rb_eRuntimeError, "Length exceeds size of buffer!");
@@ -963,8 +982,13 @@ VALUE IO_Event_Selector_URing_io_write(VALUE self, VALUE fiber, VALUE io, VALUE
 	// Ensure offset is within the bounds of the buffer to avoid size_t underflow and out-of-bounds pointer arithmetic on (char *)base + offset.
 	if (offset > size) {
 		return rb_fiber_scheduler_io_result(-1, EINVAL);
+	} else if (offset == size) {
+		return rb_fiber_scheduler_io_result(0, 0);
 	}
-
+	
+	int descriptor = IO_Event_Selector_io_descriptor(io);
+	off_t from = io_seekable(descriptor);
+	
 	size_t maximum_size = size - offset;
 	while (maximum_size) {
 		int result = io_write(selector, fiber, descriptor, (char*)base+offset, maximum_size, from);
@@ -1005,8 +1029,6 @@ VALUE IO_Event_Selector_URing_io_pwrite(VALUE self, VALUE fiber, VALUE io, VALUE
 	struct IO_Event_Selector_URing *selector = NULL;
 	TypedData_Get_Struct(self, struct IO_Event_Selector_URing, &IO_Event_Selector_URing_Type, selector);
 	
-	int descriptor = IO_Event_Selector_io_descriptor(io);
-	
 	const void *base;
 	size_t size;
 	rb_io_buffer_get_bytes_for_reading(buffer, &base, &size);
@@ -1023,8 +1045,12 @@ VALUE IO_Event_Selector_URing_io_pwrite(VALUE self, VALUE fiber, VALUE io, VALUE
 	// Ensure offset is within the bounds of the buffer to avoid size_t underflow and out-of-bounds pointer arithmetic on (char *)base + offset.
 	if (offset > size) {
 		return rb_fiber_scheduler_io_result(-1, EINVAL);
+	} else if (offset == size) {
+		return rb_fiber_scheduler_io_result(0, 0);
 	}
-
+	
+	int descriptor = IO_Event_Selector_io_descriptor(io);
+	
 	size_t maximum_size = size - offset;
 	while (maximum_size) {
 		int result = io_write(selector, fiber, descriptor, (char*)base+offset, maximum_size, from);
@@ -1104,9 +1130,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 {
@@ -1145,22 +1184,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
@@ -1257,28 +1301,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);
@@ -1286,12 +1331,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) {
@@ -1370,6 +1415,7 @@ void Init_IO_Event_Selector_URing(VALUE IO_Event_Selector) {
 	rb_define_method(IO_Event_Selector_URing, "select", IO_Event_Selector_URing_select, 1);
 	rb_define_method(IO_Event_Selector_URing, "wakeup", IO_Event_Selector_URing_wakeup, 0);
 	rb_define_method(IO_Event_Selector_URing, "close", IO_Event_Selector_URing_close, 0);
+	rb_define_method(IO_Event_Selector_URing, "closed?", IO_Event_Selector_URing_closed_p, 0);
 	
 	rb_define_method(IO_Event_Selector_URing, "io_wait", IO_Event_Selector_URing_io_wait, 3);
 	

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

@@ -111,6 +111,11 @@ module IO::Event
 				@log&.flush
 			end
 			
+			# @returns [Boolean] Whether the wrapped selector is closed.
+			def closed?
+				@selector.nil? || @selector.closed?
+			end
+			
 			# Transfer from the calling fiber to the selector.
 			def transfer
 				log("Transfering to event loop")

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

@@ -13,6 +13,7 @@ module IO::Event
 			# Initialize the selector with the given event loop fiber.
 			def initialize(loop)
 				@loop = loop
+				@owner = Process.pid
 				
 				@waiting = Hash.new.compare_by_identity
 				
@@ -52,6 +53,11 @@ module IO::Event
 				@waiting = nil
 			end
 			
+			# @returns [Boolean] Whether the selector is closed or belongs to a different process.
+			def closed?
+				@loop.nil? || @owner != Process.pid
+			end
+			
 			# An optional reference to a fiber which can be cleared before it is resumed.
 			Optional = Struct.new(:fiber) do
 				# Transfer control to the fiber if it is still available.
@@ -199,6 +205,8 @@ module IO::Event
 				# Ensure offset is within the bounds of the buffer to avoid ArgumentError
 				if offset > buffer.size
 					return -Errno::EINVAL::Errno
+				elsif offset == buffer.size
+					return 0
 				end
 				
 				total = 0
@@ -234,6 +242,8 @@ module IO::Event
 				# Ensure offset is within the bounds of the buffer to avoid ArgumentError
 				if offset > buffer.size
 					return -Errno::EINVAL::Errno
+				elsif offset == buffer.size
+					return 0
 				end
 				
 				total = 0

data/lib/io/event/version.rb

@@ -7,6 +7,6 @@
 class IO
 	# @namespace
 	module Event
-		VERSION = "1.16.4"
+		VERSION = "1.18.0"
 	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.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.
+
 ### v1.16.4
 
   - Correctly implement `Interrupt#signal` so that it is robust enough to be called by `Scheduler#unblock`.
@@ -56,14 +64,6 @@ Please see the [project releases](https://socketry.github.io/io-event/releases/i
 
   - Allow `epoll_pwait2` to be disabled via `--disable-epoll_pwait2`.
 
-### v1.14.3
-
-  - Fix several implementation bugs that could cause deadlocks on blocking writes.
-
-### v1.14.0
-
-  - [Enhanced `IO::Event::PriorityHeap` with deletion and bulk insertion methods](https://socketry.github.io/io-event/releases/index#enhanced-io::event::priorityheap-with-deletion-and-bulk-insertion-methods)
-
 ## Contributing
 
 We welcome contributions to this project.

data/releases.md

@@ -1,5 +1,13 @@
 # Releases
 
+## 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.
+
 ## v1.16.4
 
   - Correctly implement `Interrupt#signal` so that it is robust enough to be called by `Scheduler#unblock`.

metadata

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