Use IO_Event_Interrupt for wakeup instead of bespoke eventfd.

Replace the hand-rolled wakeup_fd/eventfd code with struct IO_Event_Interrupt,
which already provides open/close/signal/clear with an eventfd on Linux and
a pipe fallback on other platforms. The logic is identical; this just removes
the duplication.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: samuel-williams-shopify

ext/io/event/selector/uring.c

@@ -10,7 +10,8 @@
 #include <poll.h>
 #include <stdint.h>
 #include <time.h>
-#include <sys/eventfd.h>
+
+#include "../interrupt.h"
 
 #include "pidfd.c"
 
@@ -36,15 +37,16 @@ struct IO_Event_Selector_URing
 	// Set to 1 when blocked in io_uring_wait_cqe_timeout() without GVL, 0 otherwise.
 	int blocked;
 
-	// eventfd used to wake the selector from another thread without touching the ring's SQ.
+	// Interrupt used to wake the selector from another thread without touching the ring's SQ.
 	// This allows IORING_SETUP_SINGLE_ISSUER: only the owner thread ever submits SQEs.
-	int wakeup_fd;
+	// Uses eventfd on Linux, pipe fallback elsewhere.
+	struct IO_Event_Interrupt interrupt;
 
-	// Whether an async read on wakeup_fd is currently pending in the ring.
+	// Whether an async read on interrupt is currently pending in the ring.
 	// The read is re-submitted before each blocking wait when not registered.
 	int wakeup_registered;
 
-	// Buffer for the pending async read on wakeup_fd.
+	// Buffer for the pending async read on the interrupt descriptor.
 	// Must remain valid for the lifetime of the in-flight SQE.
 	uint64_t wakeup_value;
 
@@ -113,9 +115,9 @@ void IO_Event_Selector_URing_Type_compact(void *_selector)
 static
 void close_internal(struct IO_Event_Selector_URing *selector)
 {
-	if (selector->wakeup_fd >= 0) {
-		close(selector->wakeup_fd);
-		selector->wakeup_fd = -1;
+	if (selector->interrupt.descriptor >= 0) {
+		IO_Event_Interrupt_close(&selector->interrupt);
+		selector->interrupt.descriptor = -1;
 		selector->wakeup_registered = 0;
 	}
 
@@ -238,7 +240,7 @@ VALUE IO_Event_Selector_URing_allocate(VALUE self) {
 
 	selector->pending = 0;
 	selector->blocked = 0;
-	selector->wakeup_fd = -1;
+	selector->interrupt.descriptor = -1;
 	selector->wakeup_registered = 0;
 
 	IO_Event_List_initialize(&selector->free_list);
@@ -282,16 +284,15 @@ VALUE IO_Event_Selector_URing_initialize(VALUE self, VALUE loop) {
 
 	rb_update_max_fd(selector->ring.ring_fd);
 
-	// eventfd for cross-thread wakeup: another thread writes to this fd; the owner
-	// thread registers a one-shot poll_add before each blocking wait so the ring
-	// wakes up without the waking thread ever touching the SQ.
-	selector->wakeup_fd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
-	if (selector->wakeup_fd < 0) {
+	// Interrupt for cross-thread wakeup: another thread calls signal(); the owner
+	// thread submits an async read before each blocking wait so the ring wakes up
+	// without the waking thread ever touching the SQ.
+	IO_Event_Interrupt_open(&selector->interrupt);
+	if (selector->interrupt.descriptor < 0) {
 		io_uring_queue_exit(&selector->ring);
 		selector->ring.ring_fd = -1;
-		rb_sys_fail("IO_Event_Selector_URing_initialize:eventfd");
+		rb_sys_fail("IO_Event_Selector_URing_initialize:IO_Event_Interrupt_open");
 	}
-	rb_update_max_fd(selector->wakeup_fd);
 
 	return self;
 }
@@ -1126,8 +1127,8 @@ int select_internal_without_gvl(struct select_arguments *arguments) {
 	// The address of wakeup_fd serves as a unique sentinel in user_data.
 	if (!selector->wakeup_registered) {
 		struct io_uring_sqe *sqe = io_get_sqe(selector);
-		io_uring_prep_read(sqe, selector->wakeup_fd, &selector->wakeup_value, sizeof(selector->wakeup_value), 0);
-		io_uring_sqe_set_data(sqe, &selector->wakeup_fd);
+		io_uring_prep_read(sqe, IO_Event_Interrupt_descriptor(&selector->interrupt), &selector->wakeup_value, sizeof(selector->wakeup_value), 0);
+		io_uring_sqe_set_data(sqe, &selector->interrupt);
 		selector->wakeup_registered = 1;
 		selector->pending += 1;
 	}
@@ -1175,10 +1176,9 @@ unsigned select_process_completions(struct IO_Event_Selector_URing *selector) {
 			continue;
 		}
 
-		// Wakeup eventfd read completion — the read already consumed the counter,
-		// no separate drain needed. Clear the flag so the next blocking wait
-		// re-submits the read.
-		if (cqe->user_data == (uint64_t)(uintptr_t)&selector->wakeup_fd) {
+		// Interrupt read completion — the read already consumed the counter.
+		// Clear the flag so the next blocking wait re-submits the read.
+		if (cqe->user_data == (uint64_t)(uintptr_t)&selector->interrupt) {
 			selector->wakeup_registered = 0;
 			io_uring_cq_advance(ring, 1);
 			continue;
@@ -1269,18 +1269,10 @@ VALUE IO_Event_Selector_URing_wakeup(VALUE self) {
 	struct IO_Event_Selector_URing *selector = NULL;
 	TypedData_Get_Struct(self, struct IO_Event_Selector_URing, &IO_Event_Selector_URing_Type, selector);
 
-	// Wake the selector by writing to the eventfd. This is safe from any thread
+	// Wake the selector by signalling the interrupt. This is safe from any thread
 	// and never touches the ring's SQ, which is required for IORING_SETUP_SINGLE_ISSUER.
 	if (selector->blocked) {
-		uint64_t value = 1;
-		int result = write(selector->wakeup_fd, &value, sizeof(value));
-		
-		// EAGAIN means the eventfd counter is already at its maximum (UINT64_MAX - 1),
-		// i.e. a wakeup is already pending — that's fine.
-		if (result < 0 && errno != EAGAIN) {
-			rb_sys_fail("IO_Event_Selector_URing_wakeup:write");
-		}
-		
+		IO_Event_Interrupt_signal(&selector->interrupt);
 		return Qtrue;
 	}