io-event 1.16.2 → 1.21.1

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,11 +48,7 @@ struct IO_Event_Selector_KQueue
 {
 	struct IO_Event_Selector backend;
 	int descriptor;
-	
-	// 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;
+	pid_t owner;
 	
 	struct timespec idle_duration;
 	
@@ -132,7 +129,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,8 +293,7 @@ VALUE IO_Event_Selector_KQueue_allocate(VALUE self) {
 	
 	IO_Event_Selector_initialize(&selector->backend, self, Qnil);
 	selector->descriptor = -1;
-	selector->blocked = 0;
-	
+	selector->owner = 0;
 	selector->descriptors.element_initialize = IO_Event_Selector_KQueue_Descriptor_initialize;
 	selector->descriptors.element_free = IO_Event_Selector_KQueue_Descriptor_free;
 	
@@ -331,6 +334,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 +369,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;
@@ -455,7 +462,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;
 	}
@@ -479,6 +486,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,
@@ -500,7 +512,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");
@@ -570,48 +582,49 @@ VALUE IO_Event_Selector_KQueue_io_wait(VALUE self, VALUE fiber, VALUE io, VALUE
 #ifdef HAVE_RUBY_IO_BUFFER_H
 
 struct io_read_arguments {
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 	VALUE self;
 	VALUE fiber;
 	VALUE io;
+#endif
 	
 	int flags;
 	
 	int descriptor;
 	
-	VALUE buffer;
+	// The remaining writable buffer region after applying the requested offset.
+	void *base;
+	size_t size;
+	
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
+	// The minimum number of bytes requested by the caller.
 	size_t length;
-	size_t offset;
+#endif
 };
 
 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);
-	
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	ssize_t result = read(arguments->descriptor, arguments->base, arguments->size);
+	return rb_fiber_scheduler_io_result(result, errno);
+#else
 	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,12 +635,11 @@ 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);
+#endif
 }
 
 static
@@ -639,25 +651,56 @@ VALUE io_read_ensure(VALUE _arguments) {
 	return Qnil;
 }
 
-VALUE IO_Event_Selector_KQueue_io_read(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _length, VALUE _offset) {
+VALUE IO_Event_Selector_KQueue_io_read(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _first, VALUE _second) {
 	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);
+	void *base;
+	size_t size;
+	rb_io_buffer_get_bytes_for_writing(buffer, &base, &size);
+	
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	size_t offset = NUM2SIZET(_first);
+	size_t length = NUM2SIZET(_second);
+	
+	if (!IO_Event_Selector_valid_buffer_range(size, offset, length)) {
+		return rb_fiber_scheduler_io_result(-1, EINVAL);
+	} else if (length == 0) {
+		return rb_fiber_scheduler_io_result(0, 0);
+	}
+	
+	base = (char*)base + offset;
+	size = length;
+#else
+	size_t length = NUM2SIZET(_first);
+	size_t offset = NUM2SIZET(_second);
 	
-	size_t length = NUM2SIZET(_length);
-	size_t offset = NUM2SIZET(_offset);
+	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;
+#endif
+	
+	int descriptor = IO_Event_Selector_io_descriptor(io);
 	
 	struct io_read_arguments io_read_arguments = {
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 		.self = self,
 		.fiber = fiber,
 		.io = io,
+#endif
 		
 		.flags = IO_Event_Selector_nonblock_set(descriptor),
 		.descriptor = descriptor,
-		.buffer = buffer,
+		.base = base,
+		.size = size,
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 		.length = length,
-		.offset = offset,
+#endif
 	};
 	
 	RB_OBJ_WRITTEN(self, Qundef, fiber);
@@ -665,6 +708,7 @@ VALUE IO_Event_Selector_KQueue_io_read(VALUE self, VALUE fiber, VALUE io, VALUE
 	return rb_ensure(io_read_loop, (VALUE)&io_read_arguments, io_read_ensure, (VALUE)&io_read_arguments);
 }
 
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 static VALUE IO_Event_Selector_KQueue_io_read_compatible(int argc, VALUE *argv, VALUE self)
 {
 	rb_check_arity(argc, 4, 5);
@@ -677,54 +721,52 @@ static VALUE IO_Event_Selector_KQueue_io_read_compatible(int argc, VALUE *argv,
 	
 	return IO_Event_Selector_KQueue_io_read(self, argv[0], argv[1], argv[2], argv[3], _offset);
 }
+#endif
 
 struct io_write_arguments {
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 	VALUE self;
 	VALUE fiber;
 	VALUE io;
+#endif
 	
 	int flags;
 	
 	int descriptor;
 	
-	VALUE buffer;
+	// The remaining readable buffer region after applying the requested offset.
+	const void *base;
+	size_t size;
+	
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
+	// The minimum number of bytes requested by the caller.
 	size_t length;
-	size_t offset;
+#endif
 };
 
 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);
-	
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	ssize_t result = write(arguments->descriptor, arguments->base, arguments->size);
+	return rb_fiber_scheduler_io_result(result, errno);
+#else
 	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,12 +777,11 @@ 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);
+#endif
 };
 
 static
@@ -752,25 +793,60 @@ VALUE io_write_ensure(VALUE _arguments) {
 	return Qnil;
 };
 
-VALUE IO_Event_Selector_KQueue_io_write(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _length, VALUE _offset) {
+VALUE IO_Event_Selector_KQueue_io_write(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _first, VALUE _second) {
 	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);
+	const void *base;
+	size_t size;
+	rb_io_buffer_get_bytes_for_reading(buffer, &base, &size);
 	
-	size_t length = NUM2SIZET(_length);
-	size_t offset = NUM2SIZET(_offset);
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	size_t offset = NUM2SIZET(_first);
+	size_t length = NUM2SIZET(_second);
+	
+	if (!IO_Event_Selector_valid_buffer_range(size, offset, length)) {
+		return rb_fiber_scheduler_io_result(-1, EINVAL);
+	} else if (length == 0) {
+		return rb_fiber_scheduler_io_result(0, 0);
+	}
+	
+	base = (const char*)base + offset;
+	size = length;
+#else
+	size_t length = NUM2SIZET(_first);
+	size_t offset = NUM2SIZET(_second);
+	
+	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;
+#endif
+	
+	int descriptor = IO_Event_Selector_io_descriptor(io);
 	
 	struct io_write_arguments io_write_arguments = {
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 		.self = self,
 		.fiber = fiber,
 		.io = io,
+#endif
 		
 		.flags = IO_Event_Selector_nonblock_set(descriptor),
 		.descriptor = descriptor,
-		.buffer = buffer,
+		.base = base,
+		.size = size,
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 		.length = length,
-		.offset = offset,
+#endif
 	};
 	
 	RB_OBJ_WRITTEN(self, Qundef, fiber);
@@ -778,6 +854,7 @@ VALUE IO_Event_Selector_KQueue_io_write(VALUE self, VALUE fiber, VALUE io, VALUE
 	return rb_ensure(io_write_loop, (VALUE)&io_write_arguments, io_write_ensure, (VALUE)&io_write_arguments);
 }
 
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 static VALUE IO_Event_Selector_KQueue_io_write_compatible(int argc, VALUE *argv, VALUE self)
 {
 	rb_check_arity(argc, 4, 5);
@@ -790,6 +867,7 @@ static VALUE IO_Event_Selector_KQueue_io_write_compatible(int argc, VALUE *argv,
 	
 	return IO_Event_Selector_KQueue_io_write(self, argv[0], argv[1], argv[2], argv[3], _offset);
 }
+#endif
 
 #endif
 
@@ -816,15 +894,22 @@ 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;
+	}
+	return 1;
 }
 
 struct select_arguments {
 	struct IO_Event_Selector_KQueue *selector;
 	
 	int count;
+	int result;
+	int error;
 	struct kevent events[KQUEUE_MAX_EVENTS];
 	
 	struct timespec storage;
@@ -837,38 +922,42 @@ 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);
+	arguments->error = errno;
 	
 	return NULL;
 }
 
 static
-void select_internal_without_gvl(struct select_arguments *arguments) {
-	arguments->selector->blocked = 1;
-	
-	rb_thread_call_without_gvl(select_internal, (void *)arguments, RUBY_UBF_IO, 0);
-	arguments->selector->blocked = 0;
-	
-	if (arguments->count == -1) {
-		if (errno != EINTR) {
-			rb_sys_fail("select_internal_without_gvl:kevent");
+int select_internal_without_gvl(struct select_arguments *arguments) {
+	arguments->result = -1;
+	arguments->error = EINTR;
+	IO_Event_Selector_blocking_operation(&arguments->selector->backend, select_internal, (void *)arguments, RUBY_UBF_IO, 0);
+	
+	if (arguments->result == -1) {
+		if (arguments->error != EINTR) {
+			rb_syserr_fail(arguments->error, "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 (errno != EINTR) {
-			rb_sys_fail("select_internal_with_gvl:kevent");
+	if (arguments->result == -1) {
+		if (arguments->error != EINTR) {
+			rb_syserr_fail(arguments->error, "select_internal_with_gvl:kevent");
 		} else {
-			arguments->count = 0;
+			return 0;
 		}
 	}
+	
+	return arguments->result;
 }
 
 static
@@ -922,14 +1011,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 +1029,7 @@ VALUE select_handle_events(VALUE _arguments)
 		}
 	}
 	
-	return RB_INT2NUM(arguments->count);
+	return RB_INT2NUM(arguments->result);
 }
 
 static
@@ -965,6 +1054,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 +1065,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 +1080,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 +1096,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);
@@ -1019,7 +1107,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
@@ -1090,12 +1178,18 @@ 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);
 	
 #ifdef HAVE_RUBY_IO_BUFFER_H
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	rb_define_method(IO_Event_Selector_KQueue, "io_read", IO_Event_Selector_KQueue_io_read, 5);
+	rb_define_method(IO_Event_Selector_KQueue, "io_write", IO_Event_Selector_KQueue_io_write, 5);
+#else
 	rb_define_method(IO_Event_Selector_KQueue, "io_read", IO_Event_Selector_KQueue_io_read_compatible, -1);
 	rb_define_method(IO_Event_Selector_KQueue, "io_write", IO_Event_Selector_KQueue_io_write_compatible, -1);
+#endif
 #endif
 	
 	rb_define_method(IO_Event_Selector_KQueue, "process_wait", IO_Event_Selector_KQueue_process_wait, 3);