Use eventfd for wakeup and enable IORING_SETUP_SINGLE_ISSUER.

Replace the NOP-SQE wakeup strategy with an eventfd: the owner thread
registers a one-shot poll_add on the eventfd before each blocking wait,
and wakeup() writes to the fd from any thread without touching the ring's
SQ.  This satisfies IORING_SETUP_SINGLE_ISSUER (kernel 6.0+, guarded by

Also install liburing-dev in the benchmark workflow so the benchmark
actually exercises the URing backend.

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

Author: samuel-williams-shopify

ext/io/event/selector/uring.c

@@ -10,6 +10,7 @@
 #include <poll.h>
 #include <stdint.h>
 #include <time.h>
+#include <sys/eventfd.h>
 
 #include "pidfd.c"
 
@@ -33,9 +34,12 @@ struct IO_Event_Selector_URing
 
 	// 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.
-	// Used by wakeup() to determine if an interrupt signal is needed.
 	int blocked;
 
+	// eventfd 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;
+	
 	struct timespec idle_duration;
 
 	struct IO_Event_Array completions;
@@ -101,6 +105,11 @@ 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->ring.ring_fd >= 0) {
 		io_uring_queue_exit(&selector->ring);
 		selector->ring.ring_fd = -1;
@@ -220,6 +229,7 @@ VALUE IO_Event_Selector_URing_allocate(VALUE self) {
 
 	selector->pending = 0;
 	selector->blocked = 0;
+	selector->wakeup_fd = -1;
 
 	IO_Event_List_initialize(&selector->free_list);
 
@@ -240,14 +250,33 @@ VALUE IO_Event_Selector_URing_initialize(VALUE self, VALUE loop) {
 	TypedData_Get_Struct(self, struct IO_Event_Selector_URing, &IO_Event_Selector_URing_Type, selector);
 
 	IO_Event_Selector_initialize(&selector->backend, self, loop);
-	int result = io_uring_queue_init(URING_ENTRIES, &selector->ring, 0);
+	
+	unsigned int flags = 0;
+	// IORING_SETUP_SINGLE_ISSUER (kernel 6.0+): only the owner thread submits SQEs.
+	// Safe here because wakeup() uses eventfd (no ring access from other threads).
+#ifdef IORING_SETUP_SINGLE_ISSUER
+	flags |= IORING_SETUP_SINGLE_ISSUER;
+#endif
+	
+	int result = io_uring_queue_init(URING_ENTRIES, &selector->ring, flags);
 
 	if (result < 0) {
 		rb_syserr_fail(-result, "IO_Event_Selector_URing_initialize:io_uring_queue_init");
 	}
 
 	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) {
+		io_uring_queue_exit(&selector->ring);
+		selector->ring.ring_fd = -1;
+		rb_sys_fail("IO_Event_Selector_URing_initialize:eventfd");
+	}
+	rb_update_max_fd(selector->wakeup_fd);
+	
 	return self;
 }
 
@@ -1073,11 +1102,25 @@ void * select_internal(void *_arguments) {
 
 static
 int select_internal_without_gvl(struct select_arguments *arguments) {
-	io_uring_submit_flush(arguments->selector);
+	struct IO_Event_Selector_URing *selector = arguments->selector;
 
-	arguments->selector->blocked = 1;
+	// Register a one-shot poll on the wakeup eventfd before releasing the GVL.
+	// This allows wakeup() to signal us by writing to the fd from any thread
+	// without touching the ring's SQ (required for IORING_SETUP_SINGLE_ISSUER).
+	struct io_uring_sqe *sqe = io_get_sqe(selector);
+	io_uring_prep_poll_add(sqe, selector->wakeup_fd, POLLIN);
+	io_uring_sqe_set_data(sqe, NULL);
+	selector->pending += 1;
+	
+	io_uring_submit_flush(selector);
+	
+	selector->blocked = 1;
 	rb_thread_call_without_gvl(select_internal, (void *)arguments, RUBY_UBF_IO, 0);
-	arguments->selector->blocked = 0;
+	selector->blocked = 0;
+	
+	// Drain the wakeup eventfd so the next poll_add doesn't fire immediately.
+	uint64_t value;
+	while (read(selector->wakeup_fd, &value, sizeof(value)) > 0) {}
 
 	if (arguments->result == -ETIME) {
 		arguments->result = 0;
@@ -1201,25 +1244,18 @@ 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);
 
-	// If we are blocking, we can schedule a nop event to wake up the selector:
+	// Wake the selector by writing to the eventfd. This is safe from any thread
+	// and never touches the ring's SQ, which is required for IORING_SETUP_SINGLE_ISSUER.
 	if (selector->blocked) {
-		struct io_uring_sqe *sqe = NULL;
+		uint64_t value = 1;
+		int result = write(selector->wakeup_fd, &value, sizeof(value));
 
-		while (true) {
-			sqe = io_uring_get_sqe(&selector->ring);
-			if (sqe) break;
-			
-			rb_thread_schedule();
-			
-			// It's possible we became unblocked already, so we can assume the selector has already cycled at least once:
-			if (!selector->blocked) return Qfalse;
+		// 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_uring_prep_nop(sqe);
-		// If you don't set this line, the SQE will eventually be recycled and have valid user selector which can cause odd behaviour:
-		io_uring_sqe_set_data(sqe, NULL);
-		io_uring_submit(&selector->ring);
-		
 		return Qtrue;
 	}
 
@@ -1230,7 +1266,13 @@ VALUE IO_Event_Selector_URing_wakeup(VALUE self) {
 
 static int IO_Event_Selector_URing_supported_p(void) {
 	struct io_uring ring;
-	int result = io_uring_queue_init(32, &ring, 0);
+	
+	unsigned int flags = 0;
+#ifdef IORING_SETUP_SINGLE_ISSUER
+	flags |= IORING_SETUP_SINGLE_ISSUER;
+#endif
+	
+	int result = io_uring_queue_init(32, &ring, flags);
 
 	if (result < 0) {
 		rb_warn("io_uring_queue_init() was available at compile time but failed at run time: %s\n", strerror(-result));