io-event 1.19.5 → 1.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f7b5b3a617c2f1ef060c072fc860927172b31a8e7e574cc3607f8107326b57bf
-  data.tar.gz: '078687c1ee12579d38d9c5d85f8ad4a49827872567ed48f6835098a8081a6929'
+  metadata.gz: 648484dee2c6698568b24073b4fcf90a32629dcfa2119c450df16cae77f52c49
+  data.tar.gz: 895241950306f5dbc0f1c0b31f6981ec78096c6f90160c018a56dccc6102b799
 SHA512:
-  metadata.gz: '063501649153028126c8b1087d60c8c089aeb03f536ca86e3f5be2a494d891ab1bfca0b08fc796f5d050a8d28dab68c1ffda6fcf2f6e3ea4b20c4ea0310ae8c3'
-  data.tar.gz: cd0df567da5d936491da4c454106ae0c80e4b5a0368bc2ce2ddf02642dd5e313aec14e34d74d3b700be46d9f15f9e76413dae7a8397716afcc08e24a8280b1d9
+  metadata.gz: ff589133ec2d19d400c0c80daf0dc1cbf448005d26ca2c2df1d893c08371387cc12d37e8d1133379b17ed599cbe947197e0765e59c9c30c603802794283d9226
+  data.tar.gz: ec3c7a5d210053cf1e66d22eb4673c208184a044cb3b55404f34d645fcca0267711fe36ee12b7e8a7ef360d5ff6ed70a3da5ad0d64765406ec52ea2295119c40

data/context/getting-started.md

@@ -33,21 +33,21 @@ input, output = IO.pipe
 
 writer = Fiber.new do
 	puts "[writer] Writing data"
-
+	
 	output.write("Hello World")
 	output.close
 end
 
 reader = Fiber.new do
 	puts "[reader] No data available, waiting for input"
-
+	
 	# Suspend this Fiber until the input becomes readable.
 	selector.io_wait(
 		Fiber.current,
 		input,
 		IO::READABLE
 	)
-
+	
 	# Execution resumes here once the selector detects the event.
 	puts "[reader] Received: #{input.read.inspect}"
 end

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

@@ -593,9 +593,11 @@ VALUE IO_Event_Selector_EPoll_io_wait(VALUE self, VALUE fiber, VALUE io, VALUE e
 #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;
 	
@@ -605,14 +607,20 @@ struct io_read_arguments {
 	void *base;
 	size_t size;
 	
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 	// The minimum number of bytes requested by the caller.
 	size_t length;
+#endif
 };
 
 static
 VALUE io_read_loop(VALUE _arguments) {
 	struct io_read_arguments *arguments = (struct io_read_arguments *)_arguments;
 	
+#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 total = 0;
 	
@@ -635,6 +643,7 @@ VALUE io_read_loop(VALUE _arguments) {
 	}
 	
 	return rb_fiber_scheduler_io_result(total, 0);
+#endif
 }
 
 static
@@ -646,14 +655,27 @@ VALUE io_read_ensure(VALUE _arguments) {
 	return Qnil;
 }
 
-VALUE IO_Event_Selector_EPoll_io_read(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _length, VALUE _offset) {
-	size_t offset = NUM2SIZET(_offset);
-	size_t length = NUM2SIZET(_length);
-	
+VALUE IO_Event_Selector_EPoll_io_read(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _first, VALUE _second) {
 	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);
+	
 	if (offset > size) {
 		return rb_fiber_scheduler_io_result(-1, EINVAL);
 	} else if (offset == size) {
@@ -662,19 +684,24 @@ VALUE IO_Event_Selector_EPoll_io_read(VALUE self, VALUE fiber, VALUE io, VALUE b
 	
 	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,
 		.base = base,
 		.size = size,
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 		.length = length,
+#endif
 	};
 	
 	RB_OBJ_WRITTEN(self, Qundef, fiber);
@@ -682,6 +709,7 @@ VALUE IO_Event_Selector_EPoll_io_read(VALUE self, VALUE fiber, VALUE io, VALUE b
 	return rb_ensure(io_read_loop, (VALUE)&io_read_arguments, io_read_ensure, (VALUE)&io_read_arguments);
 }
 
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 VALUE IO_Event_Selector_EPoll_io_read_compatible(int argc, VALUE *argv, VALUE self)
 {
 	rb_check_arity(argc, 4, 5);
@@ -694,11 +722,14 @@ VALUE IO_Event_Selector_EPoll_io_read_compatible(int argc, VALUE *argv, VALUE se
 	
 	return IO_Event_Selector_EPoll_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;
 	
@@ -708,14 +739,20 @@ struct io_write_arguments {
 	const void *base;
 	size_t size;
 	
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 	// The minimum number of bytes requested by the caller.
 	size_t length;
+#endif
 };
 
 static
 VALUE io_write_loop(VALUE _arguments) {
 	struct io_write_arguments *arguments = (struct io_write_arguments *)_arguments;
 	
+#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 total = 0;
 	
@@ -738,6 +775,7 @@ VALUE io_write_loop(VALUE _arguments) {
 	}
 	
 	return rb_fiber_scheduler_io_result(total, 0);
+#endif
 };
 
 static
@@ -749,14 +787,27 @@ VALUE io_write_ensure(VALUE _arguments) {
 	return Qnil;
 };
 
-VALUE IO_Event_Selector_EPoll_io_write(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _length, VALUE _offset) {
-	size_t length = NUM2SIZET(_length);
-	size_t offset = NUM2SIZET(_offset);
-	
+VALUE IO_Event_Selector_EPoll_io_write(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _first, VALUE _second) {
 	const void *base;
 	size_t size;
 	rb_io_buffer_get_bytes_for_reading(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 = (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!");
 	}
@@ -769,19 +820,24 @@ VALUE IO_Event_Selector_EPoll_io_write(VALUE self, VALUE fiber, VALUE io, VALUE
 	
 	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,
 		.base = base,
 		.size = size,
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 		.length = length,
+#endif
 	};
 	
 	RB_OBJ_WRITTEN(self, Qundef, fiber);
@@ -789,6 +845,7 @@ VALUE IO_Event_Selector_EPoll_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
 VALUE IO_Event_Selector_EPoll_io_write_compatible(int argc, VALUE *argv, VALUE self)
 {
 	rb_check_arity(argc, 4, 5);
@@ -801,6 +858,7 @@ VALUE IO_Event_Selector_EPoll_io_write_compatible(int argc, VALUE *argv, VALUE s
 	
 	return IO_Event_Selector_EPoll_io_write(self, argv[0], argv[1], argv[2], argv[3], _offset);
 }
+#endif
 
 #endif
 
@@ -1123,13 +1181,14 @@ void Init_IO_Event_Selector_EPoll(VALUE IO_Event_Selector) {
 	rb_define_method(IO_Event_Selector_EPoll, "io_wait", IO_Event_Selector_EPoll_io_wait, 3);
 	
 #ifdef HAVE_RUBY_IO_BUFFER_H
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	rb_define_method(IO_Event_Selector_EPoll, "io_read", IO_Event_Selector_EPoll_io_read, 5);
+	rb_define_method(IO_Event_Selector_EPoll, "io_write", IO_Event_Selector_EPoll_io_write, 5);
+#else
 	rb_define_method(IO_Event_Selector_EPoll, "io_read", IO_Event_Selector_EPoll_io_read_compatible, -1);
 	rb_define_method(IO_Event_Selector_EPoll, "io_write", IO_Event_Selector_EPoll_io_write_compatible, -1);
 #endif
-	
-	// Once compatibility isn't a concern, we can do this:
-	// rb_define_method(IO_Event_Selector_EPoll, "io_read", IO_Event_Selector_EPoll_io_read, 5);
-	// rb_define_method(IO_Event_Selector_EPoll, "io_write", IO_Event_Selector_EPoll_io_write, 5);
+#endif
 	
 	rb_define_method(IO_Event_Selector_EPoll, "process_wait", IO_Event_Selector_EPoll_process_wait, 3);
 }

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

@@ -582,9 +582,11 @@ 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;
 	
@@ -594,14 +596,20 @@ struct io_read_arguments {
 	void *base;
 	size_t size;
 	
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 	// The minimum number of bytes requested by the caller.
 	size_t length;
+#endif
 };
 
 static
 VALUE io_read_loop(VALUE _arguments) {
 	struct io_read_arguments *arguments = (struct io_read_arguments *)_arguments;
 	
+#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 total = 0;
 	
@@ -631,6 +639,7 @@ VALUE io_read_loop(VALUE _arguments) {
 	
 	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
@@ -642,17 +651,30 @@ 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);
 	
-	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 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);
+	
 	if (offset > size) {
 		return rb_fiber_scheduler_io_result(-1, EINVAL);
 	} else if (offset == size) {
@@ -661,19 +683,24 @@ VALUE IO_Event_Selector_KQueue_io_read(VALUE self, VALUE fiber, VALUE io, VALUE
 	
 	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,
 		.base = base,
 		.size = size,
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 		.length = length,
+#endif
 	};
 	
 	RB_OBJ_WRITTEN(self, Qundef, fiber);
@@ -681,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);
@@ -693,11 +721,14 @@ 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;
 	
@@ -707,14 +738,20 @@ struct io_write_arguments {
 	const void *base;
 	size_t size;
 	
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 	// The minimum number of bytes requested by the caller.
 	size_t length;
+#endif
 };
 
 static
 VALUE io_write_loop(VALUE _arguments) {
 	struct io_write_arguments *arguments = (struct io_write_arguments *)_arguments;
 	
+#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 total = 0;
 	
@@ -744,6 +781,7 @@ VALUE io_write_loop(VALUE _arguments) {
 	
 	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
@@ -755,17 +793,30 @@ 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);
 	
-	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 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!");
 	}
@@ -778,19 +829,24 @@ VALUE IO_Event_Selector_KQueue_io_write(VALUE self, VALUE fiber, VALUE io, VALUE
 	
 	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,
 		.base = base,
 		.size = size,
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 		.length = length,
+#endif
 	};
 	
 	RB_OBJ_WRITTEN(self, Qundef, fiber);
@@ -798,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);
@@ -810,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
 
@@ -1125,8 +1183,13 @@ void Init_IO_Event_Selector_KQueue(VALUE IO_Event_Selector) {
 	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);

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

@@ -40,6 +40,10 @@ static inline int IO_Event_try_again(int error) {
 	return error == EAGAIN || error == EWOULDBLOCK;
 }
 
+static inline int IO_Event_Selector_valid_buffer_range(size_t size, size_t offset, size_t length) {
+	return offset <= size && length <= size - offset;
+}
+
 // Enter a blocking region without the GVL. On Rubies without
 // `RB_NOGVL_PENDING_INTR_FAIL`, refresh pending-interrupt state immediately
 // before releasing the GVL so a signal cannot be stranded in the queue.

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

@@ -81,8 +81,26 @@ struct IO_Event_Selector_URing_Completion
 	struct IO_Event_List list;
 	
 	struct IO_Event_Selector_URing_Waiting *waiting;
+	bool cancellation_pending;
 };
 
+// Cancellation completions use the low bit to distinguish them from the
+// completion of the operation being cancelled. Completion records are aligned,
+// so the low bit is otherwise always clear.
+#define IO_EVENT_SELECTOR_URING_CANCELLATION_TAG ((uint64_t)1)
+
+static inline uint64_t
+IO_Event_Selector_URing_Completion_cancellation_data(struct IO_Event_Selector_URing_Completion *completion)
+{
+	return ((uint64_t)(uintptr_t)completion) | IO_EVENT_SELECTOR_URING_CANCELLATION_TAG;
+}
+
+static inline struct IO_Event_Selector_URing_Completion *
+IO_Event_Selector_URing_Completion_from_cancellation_data(uint64_t data)
+{
+	return (struct IO_Event_Selector_URing_Completion *)(uintptr_t)(data & ~IO_EVENT_SELECTOR_URING_CANCELLATION_TAG);
+}
+
 static
 void IO_Event_Selector_URing_Completion_mark(void *_completion)
 {
@@ -188,6 +206,9 @@ struct IO_Event_Selector_URing_Completion * IO_Event_Selector_URing_Completion_a
 	
 	if (DEBUG_COMPLETION) fprintf(stderr, "IO_Event_Selector_URing_Completion_acquire(%p, limit=%ld)\n", (void*)completion, selector->completions.limit);
 	
+	assert(completion->waiting == NULL);
+	assert(!completion->cancellation_pending);
+	
 	waiting->completion = completion;
 	completion->waiting = waiting;
 	
@@ -206,14 +227,41 @@ void IO_Event_Selector_URing_Completion_cancel(struct IO_Event_Selector_URing_Co
 }
 
 inline static
-void IO_Event_Selector_URing_Completion_release(struct IO_Event_Selector_URing *selector, struct IO_Event_Selector_URing_Completion *completion)
+void IO_Event_Selector_URing_Completion_recycle(struct IO_Event_Selector_URing *selector, struct IO_Event_Selector_URing_Completion *completion)
 {
-	if (DEBUG_COMPLETION) fprintf(stderr, "IO_Event_Selector_URing_Completion_release(%p)\n", (void*)completion);
+	assert(completion->waiting == NULL);
+	assert(!completion->cancellation_pending);
 	
-	IO_Event_Selector_URing_Completion_cancel(completion);
 	IO_Event_List_prepend(&selector->free_list, &completion->list);
 }
 
+inline static
+void IO_Event_Selector_URing_Completion_complete(struct IO_Event_Selector_URing *selector, struct IO_Event_Selector_URing_Completion *completion)
+{
+	if (DEBUG_COMPLETION) fprintf(stderr, "IO_Event_Selector_URing_Completion_complete(%p)\n", (void*)completion);
+	
+	IO_Event_Selector_URing_Completion_cancel(completion);
+	
+	// A cancellation SQE still refers to this completion record. Keep it out of
+	// the free list until that CQE has also been observed, avoiding ABA reuse.
+	if (!completion->cancellation_pending) {
+		IO_Event_Selector_URing_Completion_recycle(selector, completion);
+	}
+}
+
+inline static
+void IO_Event_Selector_URing_Completion_cancellation_complete(struct IO_Event_Selector_URing *selector, struct IO_Event_Selector_URing_Completion *completion)
+{
+	if (DEBUG_COMPLETION) fprintf(stderr, "IO_Event_Selector_URing_Completion_cancellation_complete(%p)\n", (void*)completion);
+	
+	assert(completion->cancellation_pending);
+	completion->cancellation_pending = false;
+	
+	if (completion->waiting == NULL) {
+		IO_Event_Selector_URing_Completion_recycle(selector, completion);
+	}
+}
+
 inline static
 void IO_Event_Selector_URing_Waiting_cancel(struct IO_Event_Selector_URing_Waiting *waiting)
 {
@@ -234,6 +282,8 @@ void IO_Event_Selector_URing_Completion_initialize(void *element)
 	struct IO_Event_Selector_URing_Completion *completion = element;
 	IO_Event_List_initialize(&completion->list);
 	completion->list.type = &IO_Event_Selector_URing_Completion_Type;
+	completion->waiting = NULL;
+	completion->cancellation_pending = false;
 }
 
 void IO_Event_Selector_URing_Completion_free(void *element)
@@ -500,6 +550,36 @@ struct io_uring_sqe * io_get_sqe(struct IO_Event_Selector_URing *selector) {
 	return sqe;
 }
 
+static
+void IO_Event_Selector_URing_Completion_cancel_async(struct IO_Event_Selector_URing *selector, struct IO_Event_Selector_URing_Completion *completion)
+{
+	if (completion->cancellation_pending) return;
+	
+	completion->cancellation_pending = true;
+	
+	struct io_uring_sqe *sqe = io_get_sqe(selector);
+	io_uring_prep_cancel(sqe, completion, 0);
+	io_uring_sqe_set_data64(sqe, IO_Event_Selector_URing_Completion_cancellation_data(completion));
+	io_uring_submit_pending(selector);
+}
+
+static
+void IO_Event_Selector_URing_Waiting_cancel_and_wait(struct IO_Event_Selector_URing *selector, struct IO_Event_Selector_URing_Waiting *waiting)
+{
+	if (waiting->completion) {
+		IO_Event_Selector_URing_Completion_cancel_async(selector, waiting->completion);
+		
+		// The kernel may still be reading from or writing to the supplied buffer.
+		// Keep the C frame, buffer lock and completion record alive until the
+		// original operation CQE confirms that it can no longer access memory.
+		while (waiting->completion) {
+			IO_Event_Selector_loop_yield(&selector->backend);
+		}
+	}
+	
+	IO_Event_Selector_URing_Waiting_cancel(waiting);
+}
+
 #pragma mark - Process.wait
 
 #ifdef IO_EVENT_SELECTOR_URING_USE_WAITID
@@ -604,6 +684,10 @@ static
 VALUE process_wait_ensure(VALUE _arguments) {
 	struct process_wait_arguments *arguments = (struct process_wait_arguments *)_arguments;
 	
+	if (arguments->waiting->completion) {
+		IO_Event_Selector_URing_Completion_cancel_async(arguments->selector, arguments->waiting->completion);
+	}
+	
 #ifndef IO_EVENT_SELECTOR_URING_USE_WAITID
 	close(arguments->descriptor);
 #endif
@@ -714,13 +798,8 @@ static
 VALUE io_wait_ensure(VALUE _arguments) {
 	struct io_wait_arguments *arguments = (struct io_wait_arguments *)_arguments;
 	
-	// If the operation is still in progress, cancel it:
 	if (arguments->waiting->completion) {
-		if (DEBUG) fprintf(stderr, "io_wait_ensure:io_uring_prep_cancel(waiting=%p, completion=%p)\n", (void*)arguments->waiting, (void*)arguments->waiting->completion);
-		struct io_uring_sqe *sqe = io_get_sqe(arguments->selector);
-		io_uring_prep_cancel(sqe, (void*)arguments->waiting->completion, 0);
-		io_uring_sqe_set_data(sqe, NULL);
-		io_uring_submit_now(arguments->selector);
+		IO_Event_Selector_URing_Completion_cancel_async(arguments->selector, arguments->waiting->completion);
 	}
 	
 	IO_Event_Selector_URing_Waiting_cancel(arguments->waiting);
@@ -824,7 +903,7 @@ io_read_submit(VALUE _arguments)
 	struct io_uring_sqe *sqe = io_get_sqe(selector);
 	io_uring_prep_read(sqe, arguments->descriptor, arguments->buffer, arguments->length, arguments->offset);
 	io_uring_sqe_set_data(sqe, arguments->waiting->completion);
-	io_uring_submit_now(selector);
+	io_uring_submit_pending(selector);
 	
 	IO_Event_Selector_loop_yield(&selector->backend);
 	
@@ -837,16 +916,7 @@ io_read_ensure(VALUE _arguments)
 	struct io_read_arguments *arguments = (struct io_read_arguments *)_arguments;
 	struct IO_Event_Selector_URing *selector = arguments->selector;
 	
-	// If the operation is still in progress, cancel it:
-	if (arguments->waiting->completion) {
-		if (DEBUG) fprintf(stderr, "io_read_ensure:io_uring_prep_cancel(waiting=%p, completion=%p)\n", (void*)arguments->waiting, (void*)arguments->waiting->completion);
-		struct io_uring_sqe *sqe = io_get_sqe(selector);
-		io_uring_prep_cancel(sqe, (void*)arguments->waiting->completion, 0);
-		io_uring_sqe_set_data(sqe, NULL);
-		io_uring_submit_now(selector);
-	}
-	
-	IO_Event_Selector_URing_Waiting_cancel(arguments->waiting);
+	IO_Event_Selector_URing_Waiting_cancel_and_wait(selector, arguments->waiting);
 	
 	return Qnil;
 }
@@ -876,16 +946,86 @@ io_read(struct IO_Event_Selector_URing *selector, VALUE fiber, int descriptor, c
 	);
 }
 
-VALUE IO_Event_Selector_URing_io_read(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _length, VALUE _offset) {
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+struct io_read_locked_arguments {
+	struct IO_Event_Selector_URing *selector;
+	VALUE fiber;
+	VALUE io;
+	off_t from;
+	size_t offset;
+	size_t length;
+	bool positional;
+};
+
+static VALUE
+io_read_locked(void *base, size_t size, VALUE _arguments)
+{
+	struct io_read_locked_arguments *arguments = (struct io_read_locked_arguments *)_arguments;
+	
+	if (!IO_Event_Selector_valid_buffer_range(size, arguments->offset, arguments->length)) {
+		return rb_fiber_scheduler_io_result(-1, EINVAL);
+	} else if (arguments->length == 0) {
+		return rb_fiber_scheduler_io_result(0, 0);
+	}
+	
+	int descriptor = IO_Event_Selector_io_descriptor(arguments->io);
+	char *buffer = (char*)base + arguments->offset;
+	
+	// Avoid the submission and suspension overhead when the operation can
+	// complete immediately. The descriptor must be non-blocking for this
+	// optimistic syscall; if it would block, restore its original mode and
+	// submit the operation to io_uring instead.
+	int flags = IO_Event_Selector_nonblock_set(descriptor);
+	ssize_t result;
+	
+	if (arguments->positional) {
+		result = pread(descriptor, buffer, arguments->length, arguments->from);
+	} else {
+		result = read(descriptor, buffer, arguments->length);
+	}
+	
+	int error = errno;
+	IO_Event_Selector_nonblock_restore(descriptor, flags);
+	
+	if (result >= 0) {
+		return rb_fiber_scheduler_io_result(result, 0);
+	} else if (!IO_Event_try_again(error)) {
+		return rb_fiber_scheduler_io_result(-1, error);
+	}
+	
+	off_t from = arguments->positional ? arguments->from : io_seekable(descriptor);
+	
+	int completion = io_read(arguments->selector, arguments->fiber, descriptor, buffer, arguments->length, from);
+	if (completion < 0) {
+		return rb_fiber_scheduler_io_result(-1, -completion);
+	}
+	
+	return rb_fiber_scheduler_io_result(completion, 0);
+}
+#endif
+
+VALUE IO_Event_Selector_URing_io_read(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _first, VALUE _second) {
 	struct IO_Event_Selector_URing *selector = NULL;
 	TypedData_Get_Struct(self, struct IO_Event_Selector_URing, &IO_Event_Selector_URing_Type, selector);
 	
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	struct io_read_locked_arguments arguments = {
+		.selector = selector,
+		.fiber = fiber,
+		.io = io,
+		.offset = NUM2SIZET(_first),
+		.length = NUM2SIZET(_second),
+		.positional = false,
+	};
+	
+	return rb_io_buffer_locked_for_writing(buffer, io_read_locked, (VALUE)&arguments);
+#else
 	void *base;
 	size_t size;
 	rb_io_buffer_get_bytes_for_writing(buffer, &base, &size);
 	
-	size_t length = NUM2SIZET(_length);
-	size_t offset = NUM2SIZET(_offset);
+	size_t length = NUM2SIZET(_first);
+	size_t offset = NUM2SIZET(_second);
 	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.
@@ -894,10 +1034,10 @@ VALUE IO_Event_Selector_URing_io_read(VALUE self, VALUE fiber, VALUE io, VALUE b
 	} else if (offset == size) {
 		return rb_fiber_scheduler_io_result(0, 0);
 	}
+#endif
 	
 	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?
@@ -933,8 +1073,10 @@ VALUE IO_Event_Selector_URing_io_read(VALUE self, VALUE fiber, VALUE io, VALUE b
 	}
 	
 	return rb_fiber_scheduler_io_result(total, 0);
+#endif
 }
 
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 static VALUE IO_Event_Selector_URing_io_read_compatible(int argc, VALUE *argv, VALUE self)
 {
 	rb_check_arity(argc, 4, 5);
@@ -947,19 +1089,32 @@ static VALUE IO_Event_Selector_URing_io_read_compatible(int argc, VALUE *argv, V
 	
 	return IO_Event_Selector_URing_io_read(self, argv[0], argv[1], argv[2], argv[3], _offset);
 }
+#endif
 
-VALUE IO_Event_Selector_URing_io_pread(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _from, VALUE _length, VALUE _offset) {
+VALUE IO_Event_Selector_URing_io_pread(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _from, VALUE _first, VALUE _second) {
 	struct IO_Event_Selector_URing *selector = NULL;
 	TypedData_Get_Struct(self, struct IO_Event_Selector_URing, &IO_Event_Selector_URing_Type, selector);
 	
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	struct io_read_locked_arguments arguments = {
+		.selector = selector,
+		.fiber = fiber,
+		.io = io,
+		.from = NUM2OFFT(_from),
+		.offset = NUM2SIZET(_first),
+		.length = NUM2SIZET(_second),
+		.positional = true,
+	};
+	
+	return rb_io_buffer_locked_for_writing(buffer, io_read_locked, (VALUE)&arguments);
+#else
 	void *base;
 	size_t size;
 	rb_io_buffer_get_bytes_for_writing(buffer, &base, &size);
 	
-	size_t length = NUM2SIZET(_length);
-	size_t offset = NUM2SIZET(_offset);
+	size_t length = NUM2SIZET(_first);
+	size_t offset = NUM2SIZET(_second);
 	size_t total = 0;
-	off_t from = NUM2OFFT(_from);
 	
 	// 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) {
@@ -967,9 +1122,9 @@ VALUE IO_Event_Selector_URing_io_pread(VALUE self, VALUE fiber, VALUE io, VALUE
 	} else if (offset == size) {
 		return rb_fiber_scheduler_io_result(0, 0);
 	}
-	
+#endif
+	off_t from = NUM2OFFT(_from);
 	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);
@@ -992,6 +1147,7 @@ VALUE IO_Event_Selector_URing_io_pread(VALUE self, VALUE fiber, VALUE io, VALUE
 	}
 	
 	return rb_fiber_scheduler_io_result(total, 0);
+#endif
 }
 
 #pragma mark - IO#write
@@ -1029,16 +1185,7 @@ io_write_ensure(VALUE _argument)
 	struct io_write_arguments *arguments = (struct io_write_arguments*)_argument;
 	struct IO_Event_Selector_URing *selector = arguments->selector;
 	
-	// If the operation is still in progress, cancel it:
-	if (arguments->waiting->completion) {
-		if (DEBUG) fprintf(stderr, "io_write_ensure:io_uring_prep_cancel(waiting=%p, completion=%p)\n", (void*)arguments->waiting, (void*)arguments->waiting->completion);
-		struct io_uring_sqe *sqe = io_get_sqe(selector);
-		io_uring_prep_cancel(sqe, (void*)arguments->waiting->completion, 0);
-		io_uring_sqe_set_data(sqe, NULL);
-		io_uring_submit_now(selector);
-	}
-	
-	IO_Event_Selector_URing_Waiting_cancel(arguments->waiting);
+	IO_Event_Selector_URing_Waiting_cancel_and_wait(selector, arguments->waiting);
 	
 	return Qnil;
 }
@@ -1068,16 +1215,86 @@ io_write(struct IO_Event_Selector_URing *selector, VALUE fiber, int descriptor,
 	);
 }
 
-VALUE IO_Event_Selector_URing_io_write(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _length, VALUE _offset) {
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+struct io_write_locked_arguments {
+	struct IO_Event_Selector_URing *selector;
+	VALUE fiber;
+	VALUE io;
+	off_t from;
+	size_t offset;
+	size_t length;
+	bool positional;
+};
+
+static VALUE
+io_write_locked(const void *base, size_t size, VALUE _arguments)
+{
+	struct io_write_locked_arguments *arguments = (struct io_write_locked_arguments *)_arguments;
+	
+	if (!IO_Event_Selector_valid_buffer_range(size, arguments->offset, arguments->length)) {
+		return rb_fiber_scheduler_io_result(-1, EINVAL);
+	} else if (arguments->length == 0) {
+		return rb_fiber_scheduler_io_result(0, 0);
+	}
+	
+	int descriptor = IO_Event_Selector_io_descriptor(arguments->io);
+	const char *buffer = (const char*)base + arguments->offset;
+	
+	// Avoid the submission and suspension overhead when the operation can
+	// complete immediately. The descriptor must be non-blocking for this
+	// optimistic syscall; if it would block, restore its original mode and
+	// submit the operation to io_uring instead.
+	int flags = IO_Event_Selector_nonblock_set(descriptor);
+	ssize_t result;
+	
+	if (arguments->positional) {
+		result = pwrite(descriptor, buffer, arguments->length, arguments->from);
+	} else {
+		result = write(descriptor, buffer, arguments->length);
+	}
+	
+	int error = errno;
+	IO_Event_Selector_nonblock_restore(descriptor, flags);
+	
+	if (result >= 0) {
+		return rb_fiber_scheduler_io_result(result, 0);
+	} else if (!IO_Event_try_again(error)) {
+		return rb_fiber_scheduler_io_result(-1, error);
+	}
+	
+	off_t from = arguments->positional ? arguments->from : io_seekable(descriptor);
+	
+	int completion = io_write(arguments->selector, arguments->fiber, descriptor, (char*)buffer, arguments->length, from);
+	if (completion < 0) {
+		return rb_fiber_scheduler_io_result(-1, -completion);
+	}
+	
+	return rb_fiber_scheduler_io_result(completion, 0);
+}
+#endif
+
+VALUE IO_Event_Selector_URing_io_write(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _first, VALUE _second) {
 	struct IO_Event_Selector_URing *selector = NULL;
 	TypedData_Get_Struct(self, struct IO_Event_Selector_URing, &IO_Event_Selector_URing_Type, selector);
 	
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	struct io_write_locked_arguments arguments = {
+		.selector = selector,
+		.fiber = fiber,
+		.io = io,
+		.offset = NUM2SIZET(_first),
+		.length = NUM2SIZET(_second),
+		.positional = false,
+	};
+	
+	return rb_io_buffer_locked_for_reading(buffer, io_write_locked, (VALUE)&arguments);
+#else
 	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);
+	size_t length = NUM2SIZET(_first);
+	size_t offset = NUM2SIZET(_second);
 	size_t total = 0;
 	
 	if (length > size) {
@@ -1090,10 +1307,10 @@ VALUE IO_Event_Selector_URing_io_write(VALUE self, VALUE fiber, VALUE io, VALUE
 	} else if (offset == size) {
 		return rb_fiber_scheduler_io_result(0, 0);
 	}
+#endif
 	
 	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);
@@ -1115,8 +1332,10 @@ VALUE IO_Event_Selector_URing_io_write(VALUE self, VALUE fiber, VALUE io, VALUE
 	}
 	
 	return rb_fiber_scheduler_io_result(total, 0);
+#endif
 }
 
+#if RUBY_FIBER_SCHEDULER_VERSION < 4
 static VALUE IO_Event_Selector_URing_io_write_compatible(int argc, VALUE *argv, VALUE self)
 {
 	rb_check_arity(argc, 4, 5);
@@ -1129,19 +1348,32 @@ static VALUE IO_Event_Selector_URing_io_write_compatible(int argc, VALUE *argv,
 	
 	return IO_Event_Selector_URing_io_write(self, argv[0], argv[1], argv[2], argv[3], _offset);
 }
+#endif
 
-VALUE IO_Event_Selector_URing_io_pwrite(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _from, VALUE _length, VALUE _offset) {
+VALUE IO_Event_Selector_URing_io_pwrite(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _from, VALUE _first, VALUE _second) {
 	struct IO_Event_Selector_URing *selector = NULL;
 	TypedData_Get_Struct(self, struct IO_Event_Selector_URing, &IO_Event_Selector_URing_Type, selector);
 	
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	struct io_write_locked_arguments arguments = {
+		.selector = selector,
+		.fiber = fiber,
+		.io = io,
+		.from = NUM2OFFT(_from),
+		.offset = NUM2SIZET(_first),
+		.length = NUM2SIZET(_second),
+		.positional = true,
+	};
+	
+	return rb_io_buffer_locked_for_reading(buffer, io_write_locked, (VALUE)&arguments);
+#else
 	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);
+	size_t length = NUM2SIZET(_first);
+	size_t offset = NUM2SIZET(_second);
 	size_t total = 0;
-	off_t from = NUM2OFFT(_from);
 	
 	if (length > size) {
 		rb_raise(rb_eRuntimeError, "Length exceeds size of buffer!");
@@ -1153,9 +1385,9 @@ VALUE IO_Event_Selector_URing_io_pwrite(VALUE self, VALUE fiber, VALUE io, VALUE
 	} else if (offset == size) {
 		return rb_fiber_scheduler_io_result(0, 0);
 	}
-	
+#endif
+	off_t from = NUM2OFFT(_from);
 	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);
@@ -1178,6 +1410,7 @@ VALUE IO_Event_Selector_URing_io_pwrite(VALUE self, VALUE fiber, VALUE io, VALUE
 	}
 	
 	return rb_fiber_scheduler_io_result(total, 0);
+#endif
 }
 
 #endif
@@ -1329,6 +1562,13 @@ unsigned select_process_completions(struct IO_Event_Selector_URing *selector) {
 			continue;
 		}
 		
+		if (cqe->user_data & IO_EVENT_SELECTOR_URING_CANCELLATION_TAG) {
+			struct IO_Event_Selector_URing_Completion *completion = IO_Event_Selector_URing_Completion_from_cancellation_data(cqe->user_data);
+			IO_Event_Selector_URing_Completion_cancellation_complete(selector, completion);
+			io_uring_cq_advance(ring, 1);
+			continue;
+		}
+		
 		struct IO_Event_Selector_URing_Completion *completion = (void*)cqe->user_data;
 		struct IO_Event_Selector_URing_Waiting *waiting = completion->waiting;
 		
@@ -1343,13 +1583,11 @@ unsigned select_process_completions(struct IO_Event_Selector_URing *selector) {
 		
 		VALUE fiber = 0;
 		if (waiting && waiting->fiber) {
-			assert(waiting->result != -ECANCELED);
-			
 			fiber = waiting->fiber;
 		}
 
 		// This marks the waiting operation as "complete":
-		IO_Event_Selector_URing_Completion_release(selector, completion);
+		IO_Event_Selector_URing_Completion_complete(selector, completion);
 		
 		if (fiber) {
 			IO_Event_Selector_loop_resume(&selector->backend, fiber, 0, NULL);
@@ -1511,8 +1749,13 @@ void Init_IO_Event_Selector_URing(VALUE IO_Event_Selector) {
 	rb_define_method(IO_Event_Selector_URing, "io_wait", IO_Event_Selector_URing_io_wait, 3);
 	
 #ifdef HAVE_RUBY_IO_BUFFER_H
+#if RUBY_FIBER_SCHEDULER_VERSION >= 4
+	rb_define_method(IO_Event_Selector_URing, "io_read", IO_Event_Selector_URing_io_read, 5);
+	rb_define_method(IO_Event_Selector_URing, "io_write", IO_Event_Selector_URing_io_write, 5);
+#else
 	rb_define_method(IO_Event_Selector_URing, "io_read", IO_Event_Selector_URing_io_read_compatible, -1);
 	rb_define_method(IO_Event_Selector_URing, "io_write", IO_Event_Selector_URing_io_write_compatible, -1);
+#endif
 	rb_define_method(IO_Event_Selector_URing, "io_pread", IO_Event_Selector_URing_io_pread, 6);
 	rb_define_method(IO_Event_Selector_URing, "io_pwrite", IO_Event_Selector_URing_io_pwrite, 6);
 #endif

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

@@ -177,15 +177,15 @@ module IO::Event
 			end
 			
 			# Read from the given IO, forwarded to the underlying selector.
-			def io_read(fiber, io, buffer, length, offset = 0)
-				log("Reading from IO #{io.inspect} with buffer #{buffer}; length #{length} offset #{offset}")
-				@selector.io_read(fiber, io, buffer, length, offset)
+			def io_read(fiber, io, buffer, *arguments)
+				log("Reading from IO #{io.inspect} with buffer #{buffer}; arguments #{arguments.inspect}")
+				@selector.io_read(fiber, io, buffer, *arguments)
 			end
 			
 			# Write to the given IO, forwarded to the underlying selector.
-			def io_write(fiber, io, buffer, length, offset = 0)
-				log("Writing to IO #{io.inspect} with buffer #{buffer}; length #{length} offset #{offset}")
-				@selector.io_write(fiber, io, buffer, length, offset)
+			def io_write(fiber, io, buffer, *arguments)
+				log("Writing to IO #{io.inspect} with buffer #{buffer}; arguments #{arguments.inspect}")
+				@selector.io_write(fiber, io, buffer, *arguments)
 			end
 			
 			# Forward the given method to the underlying selector.

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

@@ -197,78 +197,112 @@ module IO::Event
 				errno == EAGAIN or errno == EWOULDBLOCK
 			end
 			
-			# Read from the given IO to the buffer.
-			#
-			# @parameter length [Integer] The minimum number of bytes to read.
-			# @parameter offset [Integer] The offset into the buffer to read to.
-			def io_read(fiber, io, buffer, length, offset = 0)
-				# 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
+			if defined?(IO::Buffer::VERSION) && IO::Buffer::VERSION >= 3
+				# Read at most `length` bytes from the given IO to the buffer in one operation.
+				#
+				# @parameter offset [Integer] The offset into the buffer to read to.
+				# @parameter length [Integer] The maximum number of bytes to read.
+				def io_read(fiber, io, buffer, offset, length)
+					if offset > buffer.size || length > buffer.size - offset
+						return -Errno::EINVAL::Errno
+					elsif length == 0
+						return 0
+					end
+					
+					Selector.nonblock(io) do
+						return Fiber.blocking{buffer.read(io, offset, length)}
+					end
 				end
 				
-				total = 0
-				
-				Selector.nonblock(io) do
-					while true
-						result = Fiber.blocking{buffer.read(io, 0, offset)}
-						
-						if result < 0
-							if length > 0 and again?(result)
-								self.io_wait(fiber, io, IO::READABLE)
+				# Write at most `length` bytes to the given IO from the buffer in one operation.
+				#
+				# @parameter offset [Integer] The offset into the buffer to write from.
+				# @parameter length [Integer] The maximum number of bytes to write.
+				def io_write(fiber, io, buffer, offset, length)
+					if offset > buffer.size || length > buffer.size - offset
+						return -Errno::EINVAL::Errno
+					elsif length == 0
+						return 0
+					end
+					
+					Selector.nonblock(io) do
+						return Fiber.blocking{buffer.write(io, offset, length)}
+					end
+				end
+			else
+				# Read from the given IO to the buffer.
+				#
+				# @parameter length [Integer] The minimum number of bytes to read.
+				# @parameter offset [Integer] The offset into the buffer to read to.
+				def io_read(fiber, io, buffer, length, offset = 0)
+					# 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
+					
+					Selector.nonblock(io) do
+						while true
+							result = Fiber.blocking{buffer.read(io, 0, offset)}
+							
+							if result < 0
+								if length > 0 and again?(result)
+									self.io_wait(fiber, io, IO::READABLE)
+								else
+									return result
+								end
+							elsif result == 0
+								break
 							else
-								return result
+								total += result
+								break if total >= length
+								offset += result
 							end
-						elsif result == 0
-							break
-						else
-							total += result
-							break if total >= length
-							offset += result
 						end
 					end
+					
+					return total
 				end
 				
-				return total
-			end
-			
-			# Write to the given IO from the buffer.
-			#
-			# @parameter length [Integer] The minimum number of bytes to write.
-			# @parameter offset [Integer] The offset into the buffer to write from.
-			def io_write(fiber, io, buffer, length, offset = 0)
-				# 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
-				
-				Selector.nonblock(io) do
-					while true
-						result = Fiber.blocking{buffer.write(io, 0, offset)}
-						
-						if result < 0
-							if length > 0 and again?(result)
-								self.io_wait(fiber, io, IO::WRITABLE)
+				# Write to the given IO from the buffer.
+				#
+				# @parameter length [Integer] The minimum number of bytes to write.
+				# @parameter offset [Integer] The offset into the buffer to write from.
+				def io_write(fiber, io, buffer, length, offset = 0)
+					# 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
+					
+					Selector.nonblock(io) do
+						while true
+							result = Fiber.blocking{buffer.write(io, 0, offset)}
+							
+							if result < 0
+								if length > 0 and again?(result)
+									self.io_wait(fiber, io, IO::WRITABLE)
+								else
+									return result
+								end
+							elsif result == 0
+								break result
 							else
-								return result
+								total += result
+								break if total >= length
+								offset += result
 							end
-						elsif result == 0
-							break result
-						else
-							total += result
-							break if total >= length
-							offset += result
 						end
 					end
+					
+					return total
 				end
-				
-				return total
 			end
 			
 			# Wait for a process to change state.

data/lib/io/event/version.rb

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

data/readme.md

@@ -18,6 +18,10 @@ 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.20.0
+
+  - Add compatibility with Ruby 4.1's fiber scheduler interface version 4. Buffered IO operations now use `(offset, length)`, perform a single transfer of at most `length` bytes, return short transfers directly, and report `-EAGAIN` without waiting. Earlier Ruby versions retain the existing minimum-progress behavior.
+
 ### v1.19.5
 
   - Preserve the original exception or non-local control flow when `IO::Event::WorkerPool` cancellation interrupts a blocked fiber, while still cancelling and draining the in-flight blocking operation before returning control to Ruby.
@@ -55,10 +59,6 @@ Please see the [project releases](https://socketry.github.io/io-event/releases/i
 
   - Correctly implement `Interrupt#signal` so that it is robust enough to be called by `Scheduler#unblock`.
 
-### v1.16.3
-
-  - Handle `IOError` raised while shutting down the pure Ruby interrupt pipe, so `IO::Event::Interrupt#close` does not leak expected shutdown errors from the interrupt fiber.
-
 ## Contributing
 
 We welcome contributions to this project.

data/releases.md

@@ -1,5 +1,9 @@
 # Releases
 
+## v1.20.0
+
+  - Add compatibility with Ruby 4.1's fiber scheduler interface version 4. Buffered IO operations now use `(offset, length)`, perform a single transfer of at most `length` bytes, return short transfers directly, and report `-EAGAIN` without waiting. Earlier Ruby versions retain the existing minimum-progress behavior.
+
 ## v1.19.5
 
   - Preserve the original exception or non-local control flow when `IO::Event::WorkerPool` cancellation interrupts a blocked fiber, while still cancelling and draining the in-flight blocking operation before returning control to Ruby.

metadata

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