Fix: keep blocking_operation_value as explicit GC root for worker lifetime

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

Author: samuel-williams-shopify

ext/io/event/worker_pool.c

@@ -15,7 +15,7 @@
 #include <string.h>
 
 enum {
-	DEBUG = 0,
+	DEBUG = 1,
 };
 
 static VALUE IO_Event_WorkerPool;
@@ -37,7 +37,12 @@ struct IO_Event_WorkerPool_Worker {
 
 // Work item structure
 struct IO_Event_WorkerPool_Work {
+	// The raw C pointer is used by the worker thread (no GVL required).
+	// blocking_operation_value is the Ruby VALUE that owns this pointer —
+	// it must stay alive for the full lifetime of the operation so that
+	// the embedded state struct the worker writes into is not freed by GC.
 	rb_fiber_scheduler_blocking_operation_t *blocking_operation;
+	VALUE blocking_operation_value;
 
 	bool completed;
 
@@ -147,7 +152,7 @@ static void worker_unblock_func(void *_worker) {
 
 	// If there's a currently executing blocking operation, cancel it
 	if (worker->current_blocking_operation) {
-		fprintf(stderr, "[worker_pool] unblock: cancelling blocking_operation=%p\n",
+		if (DEBUG) fprintf(stderr, "worker_unblock_func: cancelling blocking_operation=%p\n",
 			(void*)worker->current_blocking_operation);
 		rb_fiber_scheduler_blocking_operation_cancel(worker->current_blocking_operation);
 	}
@@ -179,7 +184,7 @@ static void *worker_wait_and_execute(void *_worker) {
 
 		// Execute work WITHOUT GVL (this is the whole point!)
 		if (work) {
-			fprintf(stderr, "[worker_pool] execute: blocking_operation=%p\n",
+			if (DEBUG) fprintf(stderr, "worker_wait_and_execute: blocking_operation=%p\n",
 				(void*)work->blocking_operation);
 			worker->current_blocking_operation = work->blocking_operation;
 			rb_fiber_scheduler_blocking_operation_execute(work->blocking_operation);
@@ -336,15 +341,25 @@ static VALUE worker_pool_call(VALUE self, VALUE _blocking_operation) {
 		rb_raise(rb_eArgError, "Invalid blocking operation!");
 	}
 
-	// Create work item
+	// Create work item.
+	// Keep blocking_operation_value as an explicit GC root: the raw C pointer
+	// is used by the worker thread without the GVL, and if an exception causes
+	// the caller's Ruby frames to be unwound, nothing else will keep the VALUE
+	// alive — which would allow GC to free the embedded state the worker is
+	// still writing into.
 	struct IO_Event_WorkerPool_Work work = {
 		.blocking_operation = blocking_operation,
+		.blocking_operation_value = _blocking_operation,
 		.completed = false,
 		.scheduler = scheduler,
 		.blocker = self,
 		.fiber = fiber,
 		.next = NULL
 	};
+	rb_gc_register_address(&work.blocking_operation_value);
+	rb_gc_register_address(&work.scheduler);
+	rb_gc_register_address(&work.blocker);
+	rb_gc_register_address(&work.fiber);
 
 	// Enqueue work:
 	pthread_mutex_lock(&pool->mutex);
@@ -379,11 +394,14 @@ static VALUE worker_pool_call(VALUE self, VALUE _blocking_operation) {
 
 	if (DEBUG) fprintf(stderr, "<- worker_pool_call:work completed=%d, state=%d\n", work.completed, state);
 
+	// Unregister GC roots before returning or re-raising.
+	rb_gc_unregister_address(&work.blocking_operation_value);
+	rb_gc_unregister_address(&work.scheduler);
+	rb_gc_unregister_address(&work.blocker);
+	rb_gc_unregister_address(&work.fiber);
+
 	if (state) {
-		// Exception path: cleanup in rb_fiber_scheduler_blocking_operation_wait is
-		// bypassed (operation->state becomes a dangling pointer to our caller's stack).
-		// Log the blocking_operation so we can correlate with any later cancel calls.
-		fprintf(stderr, "[worker_pool] exception path: blocking_operation=%p state_tag=%d\n",
+		if (DEBUG) fprintf(stderr, "[worker_pool] exception path: blocking_operation=%p state_tag=%d\n",
 			(void*)blocking_operation, state);
 		rb_jump_tag(state);
 	} else {