Mark work queue items through pool mark fn; remove rb_gc_register_address

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

Author: samuel-williams-shopify

ext/io/event/worker_pool.c

@@ -102,6 +102,28 @@ static void worker_pool_mark(void *ptr)
 		rb_gc_mark(worker->thread);  // thread objects are currently pinned anyway
 		worker = next;
 	}
+	
+	// Mark all VALUES in queued work items. While work is executing, the work
+	// struct is on the C stack of worker_pool_call (the blocked fiber), so the
+	// conservative scanner already covers it. But while it is waiting in the
+	// queue we need to mark from here to keep blocking_operation_value alive
+	// across any GC that might run during that window.
+	//
+	// We use trylock rather than lock: if a worker thread is currently
+	// dequeuing (which it does while holding the mutex but without the GVL),
+	// we skip this cycle.  The work will still be on the blocked fiber's
+	// C stack and the conservative scan will keep the VALUEs alive.
+	if (pthread_mutex_trylock(&pool->mutex) == 0) {
+		struct IO_Event_WorkerPool_Work *work = pool->work_queue;
+		while (work) {
+			rb_gc_mark(work->blocking_operation_value);
+			rb_gc_mark(work->scheduler);
+			rb_gc_mark(work->blocker);
+			rb_gc_mark(work->fiber);
+			work = work->next;
+		}
+		pthread_mutex_unlock(&pool->mutex);
+	}
 }
 
 // Size functions for Ruby GC
@@ -342,11 +364,9 @@ static VALUE worker_pool_call(VALUE self, VALUE _blocking_operation) {
 	}
 
 	// 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.
+	// blocking_operation_value is marked by worker_pool_mark while the item
+	// sits in the queue. Once dequeued and executing, the work struct lives on
+	// the blocked fiber's C stack so the conservative scanner covers it.
 	struct IO_Event_WorkerPool_Work work = {
 		.blocking_operation = blocking_operation,
 		.blocking_operation_value = _blocking_operation,
@@ -356,10 +376,6 @@ static VALUE worker_pool_call(VALUE self, VALUE _blocking_operation) {
 		.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);
@@ -394,12 +410,6 @@ 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) {
 		if (DEBUG) fprintf(stderr, "[worker_pool] exception path: blocking_operation=%p state_tag=%d\n",
 			(void*)blocking_operation, state);