io-event 1.22.0 → 1.22.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f41abe7e66f2a71d150116a4da4196a07fd247140c64c2850e130cf430da1f3
-  data.tar.gz: 1722ecdf3d215d95fb8019686ae6c00790529a14df9513666867719a2841262d
+  metadata.gz: a02e2dca1e03b9cb6e7a23525af5e35bac78cb0d3661ff0d219d4f5f115baac3
+  data.tar.gz: aaaf14ed6534424afca5f46cf867c3b5d9e323a12328e58c0c28ab0e7578e06c
 SHA512:
-  metadata.gz: a7bd80686939ad0e4df60f7113ea0825de36e82eace8a734f19ea6fc3134b1f9853ba9c797c8d7275839d8ea916f0b6f7d8f7b3587ad1477ce81b1f96d1ff0f0
-  data.tar.gz: 2add34ba036026c83dc395bf8b727b999c3a6df5c2f387da71ce26110d8ed1fe34d8c6ad04cb328aa3419c6b3ec64e71349f06a570f0d7d79bc4dd7127d8b407
+  metadata.gz: cd3db9299b34ec8e6143b1fb303da42002ec263cfd90987d5ec693889ab03edc8b3deeee7137596ae17e327e2efa42a89fbc6d89e70c718121ed5780900362fc
+  data.tar.gz: f0821c42ff1a0f135a11e59700229236b6d64a408a4dde1c18c9ee637b775c2701d9df877656070d3c312829f3b46c7679129d928839825fb70dd60fc434f6a5

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

@@ -437,7 +437,7 @@ VALUE IO_Event_Selector_EPoll_ready_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->backend.ready ? Qtrue : Qfalse;
+	return IO_Event_Selector_ready_p(&selector->backend) ? Qtrue : Qfalse;
 }
 
 struct process_wait_arguments {
@@ -1101,7 +1101,7 @@ VALUE IO_Event_Selector_EPoll_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 && !result && !selector->backend.ready) {
+	if (!ready && !result && !IO_Event_Selector_ready_p(&selector->backend)) {
 		arguments.timeout = make_timeout(duration, &arguments.storage);
 		
 		if (select_blocking_allowed(arguments.timeout)) {

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

@@ -425,7 +425,7 @@ VALUE IO_Event_Selector_KQueue_ready_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->backend.ready ? Qtrue : Qfalse;
+	return IO_Event_Selector_ready_p(&selector->backend) ? Qtrue : Qfalse;
 }
 
 struct process_wait_arguments {
@@ -1080,7 +1080,7 @@ 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 && !result && !selector->backend.ready) {
+	if (!ready && !result && !IO_Event_Selector_ready_p(&selector->backend)) {
 		arguments.timeout = make_timeout(duration, &arguments.storage);
 		
 		if (select_blocking_allowed(arguments.timeout)) {

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

@@ -354,27 +354,71 @@ void IO_Event_Selector_ready_pop(struct IO_Event_Selector *backend, struct IO_Ev
 	IO_Event_Selector_loop_resume(backend, fiber, 0, NULL);
 }
 
-int IO_Event_Selector_ready_flush(struct IO_Event_Selector *backend)
+// State shared by the rb_ensure body and cleanup callbacks. Each flush owns a distinct placeholder on its C stack, including when flushes are nested.
+struct ready_flush_arguments {
+	struct IO_Event_Selector *backend;
+	struct IO_Event_Selector_Queue placeholder;
+	int count;
+};
+
+// rb_ensure requires VALUE(VALUE) callbacks. IO_Event_Selector_ready_flush wraps this loop and returns the count stored in the shared arguments.
+static VALUE IO_Event_Selector_ready_flush_begin(VALUE _arguments)
 {
-	int count = 0;
+	struct ready_flush_arguments *arguments = (struct ready_flush_arguments *)_arguments;
+	struct IO_Event_Selector *backend = arguments->backend;
 	
-	// During iteration of the queue, the same item may be re-queued. If we don't handle this correctly, we may end up in an infinite loop. So, to avoid this situation, we keep note of the current head of the queue and break the loop if we reach the same item again.
-	
-	// Get the current tail and head of the queue:
-	struct IO_Event_Selector_Queue *waiting = backend->waiting;
-	if (DEBUG) fprintf(stderr, "IO_Event_Selector_ready_flush waiting = %p\n", waiting);
+	// rb_ensure has installed cleanup before entering this callback. Link the placeholder before any operation that can raise or yield.
+	//
+	// Saving the last existing entry is unsafe: another fiber can remove it. Counting entries instead can let newly queued work replace removed entries. This placeholder stays linked until its owning flush finishes, preserving:
+	//   existing entries -> placeholder -> newly queued entries
+	queue_push(backend, &arguments->placeholder);
 	
-	// Process from head to tail in order:
-	// During this, more items may be appended to tail.
 	while (backend->ready) {
-		if (DEBUG) fprintf(stderr, "backend->ready = %p\n", backend->ready);
 		struct IO_Event_Selector_Queue *ready = backend->ready;
 		
-		count += 1;
-		IO_Event_Selector_ready_pop(backend, ready);
+		// Each flush stops at its own placeholder. Entries beyond an outer placeholder may already have been queued when this flush started. Skip other placeholders without unlinking them: their owners still need them as boundaries and will remove them in their ensure callbacks.
+		while (ready && ready != &arguments->placeholder && (ready->flags & IO_EVENT_SELECTOR_QUEUE_PLACEHOLDER)) {
+			ready = ready->head;
+		}
 		
-		if (ready == waiting) break;
+		if (!ready || ready == &arguments->placeholder) break;
+		
+		// Resuming a fiber can unlink other entries, so read backend->ready again on the next iteration instead of retaining a neighbour pointer.
+		arguments->count += 1;
+		IO_Event_Selector_ready_pop(backend, ready);
 	}
 	
-	return count;
+	return Qnil;
+}
+
+static VALUE IO_Event_Selector_ready_flush_ensure(VALUE _arguments)
+{
+	struct ready_flush_arguments *arguments = (struct ready_flush_arguments *)_arguments;
+	
+	// Only the owning flush removes this placeholder, exactly once. Unlinking it reconnects its neighbours without removing any other placeholders.
+	queue_pop(arguments->backend, &arguments->placeholder);
+	
+	return Qnil;
+}
+
+int IO_Event_Selector_ready_flush(struct IO_Event_Selector *backend)
+{
+	if (!backend->ready) return 0;
+	
+	struct ready_flush_arguments arguments = {
+		.backend = backend,
+		.placeholder = {
+			.head = NULL,
+			.tail = NULL,
+			.flags = IO_EVENT_SELECTOR_QUEUE_PLACEHOLDER,
+			// Queue marking and compaction visit every node, including this one.
+			.fiber = Qnil,
+		},
+		.count = 0,
+	};
+	
+	// Always unlink the placeholder on normal return or exception, before the arguments leave scope, so the queue cannot retain a pointer into this stack.
+	rb_ensure(IO_Event_Selector_ready_flush_begin, (VALUE)&arguments, IO_Event_Selector_ready_flush_ensure, (VALUE)&arguments);
+	
+	return arguments.count;
 }

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

@@ -77,6 +77,8 @@ void IO_Event_Selector_nonblock_restore(int file_descriptor, int flags);
 enum IO_Event_Selector_Queue_Flags {
 	IO_EVENT_SELECTOR_QUEUE_FIBER = 1,
 	IO_EVENT_SELECTOR_QUEUE_INTERNAL = 2,
+	// A stack-allocated flush boundary; never dispatched or freed as a fiber entry.
+	IO_EVENT_SELECTOR_QUEUE_PLACEHOLDER = 4,
 };
 
 struct IO_Event_Selector_Queue {
@@ -107,6 +109,18 @@ struct IO_Event_Selector {
 
 void IO_Event_Selector_initialize(struct IO_Event_Selector *backend, VALUE self, VALUE loop);
 
+// Whether the queue contains any entries other than flush placeholders.
+static inline
+int IO_Event_Selector_ready_p(struct IO_Event_Selector *backend) {
+	struct IO_Event_Selector_Queue *ready = backend->ready;
+	// Nested flushes can leave several adjacent placeholders at the front. Look past them for real entries, including work deferred to the next flush.
+	while (ready && (ready->flags & IO_EVENT_SELECTOR_QUEUE_PLACEHOLDER)) {
+		ready = ready->head;
+	}
+	
+	return ready != NULL;
+}
+
 static inline
 void IO_Event_Selector_mark(struct IO_Event_Selector *backend) {
 	rb_gc_mark_movable(backend->self);

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

@@ -463,7 +463,7 @@ VALUE IO_Event_Selector_URing_ready_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->backend.ready ? Qtrue : Qfalse;
+	return IO_Event_Selector_ready_p(&selector->backend) ? Qtrue : Qfalse;
 }
 
 #pragma mark - Submission Queue
@@ -1677,7 +1677,7 @@ VALUE IO_Event_Selector_URing_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 && !completed && !selector->backend.ready) {
+	if (!ready && !completed && !IO_Event_Selector_ready_p(&selector->backend)) {
 		// We might need to wait for events:
 		struct select_arguments arguments = {
 			.selector = selector,
@@ -1687,7 +1687,7 @@ VALUE IO_Event_Selector_URing_select(VALUE self, VALUE duration) {
 		
 		arguments.timeout = make_timeout(duration, &arguments.storage);
 		
-		if (!selector->backend.ready && select_blocking_allowed(arguments.timeout)) {
+		if (!IO_Event_Selector_ready_p(&selector->backend) && select_blocking_allowed(arguments.timeout)) {
 			struct timespec start_time;
 			IO_Event_Time_current(&start_time);
 			

data/lib/io/event/version.rb

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

data/readme.md

@@ -18,6 +18,11 @@ 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.22.1
+
+  - Fix an infinite loop in the ready queue flush when a queued fiber is resumed out of band, e.g. by a stale `unblock` racing a timeout, while another fiber re-queues itself on every iteration.
+  - Preserve each ready queue flush's boundary with its own placeholder so newly queued fibers are deferred even when earlier entries are removed. Nested native flushes skip other placeholders, processing work queued before their own boundary. Native selectors ignore placeholders when checking readiness and remove them if a fiber raises.
+
 ### v1.22.0
 
   - Reject non-finite timer times (`NaN` and positive or negative infinity), preventing invalid heap ordering and permanently retained timer handles.
@@ -56,10 +61,6 @@ Please see the [project releases](https://socketry.github.io/io-event/releases/i
   - Use `io_uring_prep_waitid` for `process_wait` in the `URing` selector (Linux 6.7+), waiting for child exit directly in the ring instead of polling on a `pidfd`. The child is reaped via `rb_process_status_wait` (using `WEXITED | WNOWAIT`) to construct a correct `Process::Status`, and `process_wait(-1, ...)` / `process_wait(0, ...)` are now supported.
   - Support waiting for any child or a process group (`pid <= 0`) on all selectors. The `EPoll` (`pidfd_open`) and `KQueue` (`EVFILT_PROC`) selectors can only watch a specific process, so these cases now fall back to a blocking wait on a dedicated thread; joining it is fiber-scheduler aware, so the reactor keeps running.
 
-### v1.18.0
-
-  - **Fixed**: Avoid entering a blocking native selector wait when an interrupt is already pending for the current thread.
-
 ## Contributing
 
 We welcome contributions to this project.

data/releases.md

@@ -1,5 +1,10 @@
 # Releases
 
+## v1.22.1
+
+  - Fix an infinite loop in the ready queue flush when a queued fiber is resumed out of band, e.g. by a stale `unblock` racing a timeout, while another fiber re-queues itself on every iteration.
+  - Preserve each ready queue flush's boundary with its own placeholder so newly queued fibers are deferred even when earlier entries are removed. Nested native flushes skip other placeholders, processing work queued before their own boundary. Native selectors ignore placeholders when checking readiness and remove them if a fiber raises.
+
 ## v1.22.0
 
   - Reject non-finite timer times (`NaN` and positive or negative infinity), preventing invalid heap ordering and permanently retained timer handles.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: io-event
 version: !ruby/object:Gem::Version
-  version: 1.22.0
+  version: 1.22.1
 platform: ruby
 authors:
 - Samuel Williams
@@ -124,7 +124,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
 summary: An event loop.
 test_files: []