io-event 1.6.5 → 1.7.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 53b1f32affa83ac713eaaf8fba4b9a1c9d2f25421908759dde9b5adec11c498f
-  data.tar.gz: 6504222eab182d55f2b56ef91c4de9f301f509a69fff17f286c03f0ef0315786
+  metadata.gz: ab271a1de3eb0f5d21b0b7c92cafcc226e5ca218e7b87ebaa80f93a54fd7b945
+  data.tar.gz: fa6227d0b4218b277903fb1c6f1889e51bcfb7e8d8f83086edc30a336a065eff
 SHA512:
-  metadata.gz: ac5f863272fb2a532d1adbe16e2960f78dd6f4ce52891e391f301d40bb28ad74e2775348d55610f1f308f7a69b0b362e93f794b44fe94b4ec6e91331a2e851d5
-  data.tar.gz: 042a1a3ba4ec1a3e438d823b9d9348eeebc86be2464030744a9a01ff50654aeeb229fb79729083d3f1bdb2feb968dcee8ec320d33de7083196eb1afd887c5ef6
+  metadata.gz: d5afc83ef6364791d86b14bdf130d68fda3a7a1c720349dce6bb2140a2ee9f69015e542dbf5c724a0daa338e5f13c87f1dee566e8a36a1b0847ce5e86e1fa92b
+  data.tar.gz: 7d09237e5141123bf251fe686e25fca7d8391a7c25fe331e8882d7e43bf87ff9c5e89bc5c5f90d0731705b923eade10c4667344ad06d04a08544bb9a944baa28

data/ext/extconf.rb

@@ -2,21 +2,23 @@
 # frozen_string_literal: true
 
 # Released under the MIT License.
-# Copyright, 2021-2023, by Samuel Williams.
+# Copyright, 2021-2024, by Samuel Williams.
 # Copyright, 2023, by Math Ieu.
 
 return if RUBY_DESCRIPTION =~ /jruby/
 
-require 'mkmf'
+require "mkmf"
 
 gem_name = File.basename(__dir__)
-extension_name = 'IO_Event'
+extension_name = "IO_Event"
 
 # dir_config(extension_name)
 
 $CFLAGS << " -Wall -Wno-unknown-pragmas -std=c99"
 
-if ENV.key?('RUBY_DEBUG')
+if ENV.key?("RUBY_DEBUG")
+	$stderr.puts "Enabling debug mode..."
+	
 	$CFLAGS << " -DRUBY_DEBUG -O0"
 end
 
@@ -24,24 +26,27 @@ $srcs = ["io/event/event.c", "io/event/selector/selector.c"]
 $VPATH << "$(srcdir)/io/event"
 $VPATH << "$(srcdir)/io/event/selector"
 
-have_func('rb_ext_ractor_safe')
-have_func('&rb_fiber_transfer')
+have_func("rb_ext_ractor_safe")
+have_func("&rb_fiber_transfer")
 
-if have_library('uring') and have_header('liburing.h')
+if have_library("uring") and have_header("liburing.h")
+	# We might want to consider using this in the future:
+	# have_func("io_uring_submit_and_wait_timeout", "liburing.h")
+	
 	$srcs << "io/event/selector/uring.c"
 end
 
-if have_header('sys/epoll.h')
+if have_header("sys/epoll.h")
 	$srcs << "io/event/selector/epoll.c"
 end
 
-if have_header('sys/event.h')
+if have_header("sys/event.h")
 	$srcs << "io/event/selector/kqueue.c"
 end
 
-have_header('sys/wait.h')
+have_header("sys/wait.h")
 
-have_header('sys/eventfd.h')
+have_header("sys/eventfd.h")
 $srcs << "io/event/interrupt.c"
 
 have_func("rb_io_descriptor")
@@ -50,7 +55,15 @@ have_func("rb_fiber_current")
 have_func("&rb_fiber_raise")
 have_func("epoll_pwait2")
 
-have_header('ruby/io/buffer.h')
+have_header("ruby/io/buffer.h")
+
+if ENV.key?("RUBY_SANITIZE")
+	$stderr.puts "Enabling sanitizers..."
+	
+	# Add address and undefined behaviour sanitizers:
+	$CFLAGS << " -fsanitize=address -fsanitize=undefined -fno-omit-frame-pointer"
+	$LDFLAGS << " -fsanitize=address -fsanitize=undefined"
+end
 
 create_header
 

data/ext/io/event/event.c

@@ -21,20 +21,14 @@
 #include "event.h"
 #include "selector/selector.h"
 
-VALUE IO_Event = Qnil;
-VALUE IO_Event_Selector = Qnil;
-
 void Init_IO_Event(void)
 {
 #ifdef HAVE_RB_EXT_RACTOR_SAFE
 	rb_ext_ractor_safe(true);
 #endif
 	
-	IO_Event = rb_define_module_under(rb_cIO, "Event");
-	rb_gc_register_mark_object(IO_Event);
-	
-	IO_Event_Selector = rb_define_module_under(IO_Event, "Selector");
-	rb_gc_register_mark_object(IO_Event_Selector);
+	VALUE IO_Event = rb_define_module_under(rb_cIO, "Event");
+	VALUE IO_Event_Selector = rb_define_module_under(IO_Event, "Selector");
 	
 	Init_IO_Event_Selector(IO_Event_Selector);
 	

data/ext/io/event/interrupt.c

@@ -25,6 +25,13 @@
 
 #include "selector/selector.h"
 
+#ifdef HAVE_RUBY_WIN32_H
+#include <ruby/win32.h>
+#if !defined(HAVE_PIPE) && !defined(pipe)
+#define pipe(p)	rb_w32_pipe(p)
+#endif
+#endif
+
 #ifdef HAVE_SYS_EVENTFD_H
 #include <sys/eventfd.h>
 

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

@@ -8,6 +8,9 @@
 #include <errno.h>
 #include <assert.h>
 
+static const size_t IO_EVENT_ARRAY_MAXIMUM_COUNT = SIZE_MAX / sizeof(void*);
+static const size_t IO_EVENT_ARRAY_DEFAULT_COUNT = 128;
+
 struct IO_Event_Array {
 	// The array of pointers to elements:
 	void **base;
@@ -25,18 +28,27 @@ struct IO_Event_Array {
 	void (*element_free)(void*);
 };
 
-inline static void IO_Event_Array_allocate(struct IO_Event_Array *array, size_t count, size_t element_size)
+inline static int IO_Event_Array_allocate(struct IO_Event_Array *array, size_t count, size_t element_size)
 {
+	array->limit = 0;
+	array->element_size = element_size;
+	
 	if (count) {
 		array->base = (void**)calloc(count, sizeof(void*));
+		
+		if (array->base == NULL) {
+			return -1;
+		}
+		
 		array->count = count;
+		
+		return 1;
 	} else {
 		array->base = NULL;
 		array->count = 0;
+		
+		return 0;
 	}
-	
-	array->limit = 0;
-	array->element_size = element_size;
 }
 
 inline static size_t IO_Event_Array_memory_size(const struct IO_Event_Array *array)
@@ -47,31 +59,51 @@ inline static size_t IO_Event_Array_memory_size(const struct IO_Event_Array *arr
 
 inline static void IO_Event_Array_free(struct IO_Event_Array *array)
 {
-	for (size_t i = 0; i < array->limit; i += 1) {
-		void *element = array->base[i];
-		if (element) {
-			array->element_free(element);
-			free(element);
+	if (array->base) {
+		void **base = array->base;
+		size_t limit = array->limit;
+		
+		array->base = NULL;
+		array->count = 0;
+		array->limit = 0;
+		
+		for (size_t i = 0; i < limit; i += 1) {
+			void *element = base[i];
+			if (element) {
+				array->element_free(element);
+				
+				free(element);
+			}
 		}
+		
+		free(base);
 	}
-	
-	if (array->base)
-		free(array->base);
-	
-	array->base = NULL;
-	array->count = 0;
-	array->limit = 0;
 }
 
 inline static int IO_Event_Array_resize(struct IO_Event_Array *array, size_t count)
 {
 	if (count <= array->count) {
+		// Already big enough:
 		return 0;
 	}
 	
-	// Compute the next multiple (ideally a power of 2):
+	if (count > IO_EVENT_ARRAY_MAXIMUM_COUNT) {
+		errno = ENOMEM;
+		return -1;
+	}
+	
 	size_t new_count = array->count;
-	while (new_count < count) {
+	
+	// If the array is empty, we need to set the initial size:
+	if (new_count == 0) new_count = IO_EVENT_ARRAY_DEFAULT_COUNT;
+	else while (new_count < count) {
+		// Ensure we don't overflow:
+		if (new_count > (IO_EVENT_ARRAY_MAXIMUM_COUNT / 2)) {
+			new_count = IO_EVENT_ARRAY_MAXIMUM_COUNT;
+			break;
+		}
+		
+		// Compute the next multiple (ideally a power of 2):
 		new_count *= 2;
 	}
 	
@@ -87,6 +119,7 @@ inline static int IO_Event_Array_resize(struct IO_Event_Array *array, size_t cou
 	array->base = (void**)new_base;
 	array->count = new_count;
 	
+	// Resizing sucessful:
 	return 1;
 }
 
@@ -107,6 +140,7 @@ inline static void* IO_Event_Array_lookup(struct IO_Event_Array *array, size_t i
 	// Allocate the element if it doesn't exist:
 	if (*element == NULL) {
 		*element = malloc(array->element_size);
+		assert(*element);
 		
 		if (array->element_initialize) {
 			array->element_initialize(*element);

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

@@ -34,8 +34,6 @@ enum {
 	DEBUG = 0,
 };
 
-static VALUE IO_Event_Selector_EPoll = Qnil;
-
 enum {EPOLL_MAX_EVENTS = 64};
 
 // This represents an actual fiber waiting for a specific event.
@@ -184,7 +182,7 @@ static const rb_data_type_t IO_Event_Selector_EPoll_Type = {
 		.dsize = IO_Event_Selector_EPoll_Type_size,
 	},
 	.data = NULL,
-	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
 inline static
@@ -243,7 +241,7 @@ int IO_Event_Selector_EPoll_Descriptor_update(struct IO_Event_Selector_EPoll *se
 	} else {
 		// The IO has changed, we need to reset the state:
 		epoll_descriptor->registered_events = 0;
-		epoll_descriptor->io = io;
+		RB_OBJ_WRITE(selector->backend.self, &epoll_descriptor->io, io);
 	}
 	
 	if (epoll_descriptor->waiting_events == 0) {
@@ -253,7 +251,7 @@ int IO_Event_Selector_EPoll_Descriptor_update(struct IO_Event_Selector_EPoll *se
 			epoll_descriptor->registered_events = 0;
 		}
 		
-		epoll_descriptor->io = 0;
+		RB_OBJ_WRITE(selector->backend.self, &epoll_descriptor->io, 0);
 		
 		return 0;
 	}
@@ -333,13 +331,16 @@ VALUE IO_Event_Selector_EPoll_allocate(VALUE self) {
 	struct IO_Event_Selector_EPoll *selector = NULL;
 	VALUE instance = TypedData_Make_Struct(self, struct IO_Event_Selector_EPoll, &IO_Event_Selector_EPoll_Type, selector);
 	
-	IO_Event_Selector_initialize(&selector->backend, Qnil);
+	IO_Event_Selector_initialize(&selector->backend, self, Qnil);
 	selector->descriptor = -1;
 	selector->blocked = 0;
 	
 	selector->descriptors.element_initialize = IO_Event_Selector_EPoll_Descriptor_initialize;
 	selector->descriptors.element_free = IO_Event_Selector_EPoll_Descriptor_free;
-	IO_Event_Array_allocate(&selector->descriptors, 1024, sizeof(struct IO_Event_Selector_EPoll_Descriptor));
+	int result = IO_Event_Array_allocate(&selector->descriptors, IO_EVENT_ARRAY_DEFAULT_COUNT, sizeof(struct IO_Event_Selector_EPoll_Descriptor));
+	if (result < 0) {
+		rb_sys_fail("IO_Event_Selector_EPoll_allocate:IO_Event_Array_allocate");
+	}
 	
 	return instance;
 }
@@ -363,7 +364,7 @@ VALUE IO_Event_Selector_EPoll_initialize(VALUE self, VALUE loop) {
 	struct IO_Event_Selector_EPoll *selector = NULL;
 	TypedData_Get_Struct(self, struct IO_Event_Selector_EPoll, &IO_Event_Selector_EPoll_Type, selector);
 	
-	IO_Event_Selector_initialize(&selector->backend, loop);
+	IO_Event_Selector_initialize(&selector->backend, self, loop);
 	int result = epoll_create1(EPOLL_CLOEXEC);
 	
 	if (result == -1) {
@@ -503,13 +504,22 @@ VALUE IO_Event_Selector_EPoll_process_wait(VALUE self, VALUE fiber, VALUE _pid,
 	
 	rb_update_max_fd(descriptor);
 	
+	// `pidfd_open` (above) may be edge triggered, so we need to check if the process is already exited, and if so, return immediately, otherwise we will block indefinitely.
+	VALUE status = IO_Event_Selector_process_status_wait(pid, flags);
+	if (status != Qnil) {
+		close(descriptor);
+		return status;
+	}
+	
 	struct IO_Event_Selector_EPoll_Waiting waiting = {
 		.list = {.type = &IO_Event_Selector_EPoll_process_wait_list_type},
 		.fiber = fiber,
 		.events = IO_EVENT_READABLE,
 	};
 	
-	int result = IO_Event_Selector_EPoll_Waiting_register(selector, 0, descriptor, &waiting);
+	RB_OBJ_WRITTEN(self, Qundef, fiber);
+	
+	int result = IO_Event_Selector_EPoll_Waiting_register(selector, _pid, descriptor, &waiting);
 	
 	if (result == -1) {
 		close(descriptor);
@@ -568,6 +578,8 @@ VALUE IO_Event_Selector_EPoll_io_wait(VALUE self, VALUE fiber, VALUE io, VALUE e
 		.events = RB_NUM2INT(events),
 	};
 	
+	RB_OBJ_WRITTEN(self, Qundef, fiber);
+	
 	int result = IO_Event_Selector_EPoll_Waiting_register(selector, io, descriptor, &waiting);
 	
 	if (result == -1) {
@@ -666,6 +678,8 @@ VALUE IO_Event_Selector_EPoll_io_read(VALUE self, VALUE fiber, VALUE io, VALUE b
 		.offset = offset,
 	};
 	
+	RB_OBJ_WRITTEN(self, Qundef, fiber);
+	
 	return rb_ensure(io_read_loop, (VALUE)&io_read_arguments, io_read_ensure, (VALUE)&io_read_arguments);
 }
 
@@ -762,6 +776,8 @@ VALUE IO_Event_Selector_EPoll_io_write(VALUE self, VALUE fiber, VALUE io, VALUE
 		.offset = offset,
 	};
 	
+	RB_OBJ_WRITTEN(self, Qundef, fiber);
+	
 	return rb_ensure(io_write_loop, (VALUE)&io_write_arguments, io_write_ensure, (VALUE)&io_write_arguments);
 }
 
@@ -1037,8 +1053,7 @@ VALUE IO_Event_Selector_EPoll_wakeup(VALUE self) {
 }
 
 void Init_IO_Event_Selector_EPoll(VALUE IO_Event_Selector) {
-	IO_Event_Selector_EPoll = rb_define_class_under(IO_Event_Selector, "EPoll", rb_cObject);
-	rb_gc_register_mark_object(IO_Event_Selector_EPoll);
+	VALUE IO_Event_Selector_EPoll = rb_define_class_under(IO_Event_Selector, "EPoll", rb_cObject);
 	
 	rb_define_alloc_func(IO_Event_Selector_EPoll, IO_Event_Selector_EPoll_allocate);
 	rb_define_method(IO_Event_Selector_EPoll, "initialize", IO_Event_Selector_EPoll_initialize, 1);

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

@@ -43,8 +43,6 @@ enum {
 #define IO_EVENT_SELECTOR_KQUEUE_USE_INTERRUPT
 #endif
 
-static VALUE IO_Event_Selector_KQueue = Qnil;
-
 enum {KQUEUE_MAX_EVENTS = 64};
 
 // This represents an actual fiber waiting for a specific event.
@@ -183,7 +181,7 @@ static const rb_data_type_t IO_Event_Selector_KQueue_Type = {
 		.dsize = IO_Event_Selector_KQueue_Type_size,
 	},
 	.data = NULL,
-	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
+	.flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED,
 };
 
 inline static
@@ -307,13 +305,17 @@ VALUE IO_Event_Selector_KQueue_allocate(VALUE self) {
 	struct IO_Event_Selector_KQueue *selector = NULL;
 	VALUE instance = TypedData_Make_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
-	IO_Event_Selector_initialize(&selector->backend, Qnil);
+	IO_Event_Selector_initialize(&selector->backend, self, Qnil);
 	selector->descriptor = -1;
 	selector->blocked = 0;
 	
 	selector->descriptors.element_initialize = IO_Event_Selector_KQueue_Descriptor_initialize;
 	selector->descriptors.element_free = IO_Event_Selector_KQueue_Descriptor_free;
-	IO_Event_Array_allocate(&selector->descriptors, 1024, sizeof(struct IO_Event_Selector_KQueue_Descriptor));
+	
+	int result = IO_Event_Array_allocate(&selector->descriptors, IO_EVENT_ARRAY_DEFAULT_COUNT, sizeof(struct IO_Event_Selector_KQueue_Descriptor));
+	if (result < 0) {
+		rb_sys_fail("IO_Event_Selector_KQueue_allocate:IO_Event_Array_allocate");
+	}
 	
 	return instance;
 }
@@ -340,7 +342,7 @@ VALUE IO_Event_Selector_KQueue_initialize(VALUE self, VALUE loop) {
 	struct IO_Event_Selector_KQueue *selector = NULL;
 	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
-	IO_Event_Selector_initialize(&selector->backend, loop);
+	IO_Event_Selector_initialize(&selector->backend, self, loop);
 	int result = kqueue();
 	
 	if (result == -1) {
@@ -459,6 +461,7 @@ void process_prewait(pid_t pid) {
 		result = waitid(P_PID, pid, &info, WEXITED | WNOWAIT);
 		// This can sometimes get interrupted by SIGCHLD.
 	} while (result == -1 && errno == EINTR);
+	
 	if (result == -1) {
 		rb_sys_fail("process_prewait:waitid");
 	}
@@ -503,6 +506,8 @@ VALUE IO_Event_Selector_KQueue_process_wait(VALUE self, VALUE fiber, VALUE _pid,
 		.events = IO_EVENT_EXIT,
 	};
 	
+	RB_OBJ_WRITTEN(self, Qundef, fiber);
+	
 	struct process_wait_arguments process_wait_arguments = {
 		.selector = selector,
 		.waiting = &waiting,
@@ -566,6 +571,8 @@ VALUE IO_Event_Selector_KQueue_io_wait(VALUE self, VALUE fiber, VALUE io, VALUE
 		.events = RB_NUM2INT(events),
 	};
 	
+	RB_OBJ_WRITTEN(self, Qundef, fiber);
+	
 	int result = IO_Event_Selector_KQueue_Waiting_register(selector, descriptor, &waiting);
 	if (result == -1) {
 		rb_sys_fail("IO_Event_Selector_KQueue_io_wait:IO_Event_Selector_KQueue_Waiting_register");
@@ -669,6 +676,8 @@ VALUE IO_Event_Selector_KQueue_io_read(VALUE self, VALUE fiber, VALUE io, VALUE
 		.offset = offset,
 	};
 	
+	RB_OBJ_WRITTEN(self, Qundef, fiber);
+	
 	return rb_ensure(io_read_loop, (VALUE)&io_read_arguments, io_read_ensure, (VALUE)&io_read_arguments);
 }
 
@@ -775,6 +784,8 @@ VALUE IO_Event_Selector_KQueue_io_write(VALUE self, VALUE fiber, VALUE io, VALUE
 		.offset = offset,
 	};
 	
+	RB_OBJ_WRITTEN(self, Qundef, fiber);
+	
 	return rb_ensure(io_write_loop, (VALUE)&io_write_arguments, io_write_ensure, (VALUE)&io_write_arguments);
 }
 
@@ -981,7 +992,7 @@ VALUE IO_Event_Selector_KQueue_select(VALUE self, VALUE duration) {
 	// Non-comprehensive testing shows this gives a 1.5x speedup.
 	
 	// First do the syscall with no timeout to get any immediately available events:
-	if (DEBUG) fprintf(stderr, "\r\nselect_internal_with_gvl timeout=" PRINTF_TIMESPEC "\r\n", PRINTF_TIMESPEC_ARGS(arguments.storage));
+	if (DEBUG) fprintf(stderr, "\r\nselect_internal_with_gvl timeout=" IO_EVENT_PRINTF_TIMESPEC "\r\n", IO_EVENT_PRINTF_TIMESPEC_ARGUMENTS(arguments.storage));
 	select_internal_with_gvl(&arguments);
 	if (DEBUG) fprintf(stderr, "\r\nselect_internal_with_gvl done\r\n");
 	
@@ -999,7 +1010,7 @@ VALUE IO_Event_Selector_KQueue_select(VALUE self, VALUE duration) {
 			struct timespec start_time;
 			IO_Event_Selector_current_time(&start_time);
 			
-			if (DEBUG) fprintf(stderr, "IO_Event_Selector_KQueue_select timeout=" PRINTF_TIMESPEC "\n", PRINTF_TIMESPEC_ARGS(arguments.storage));
+			if (DEBUG) fprintf(stderr, "IO_Event_Selector_KQueue_select timeout=" IO_EVENT_PRINTF_TIMESPEC "\n", IO_EVENT_PRINTF_TIMESPEC_ARGUMENTS(arguments.storage));
 			select_internal_without_gvl(&arguments);
 			
 			struct timespec end_time;
@@ -1052,8 +1063,7 @@ VALUE IO_Event_Selector_KQueue_wakeup(VALUE self) {
 }
 
 void Init_IO_Event_Selector_KQueue(VALUE IO_Event_Selector) {
-	IO_Event_Selector_KQueue = rb_define_class_under(IO_Event_Selector, "KQueue", rb_cObject);
-	rb_gc_register_mark_object(IO_Event_Selector_KQueue);
+	VALUE IO_Event_Selector_KQueue = rb_define_class_under(IO_Event_Selector, "KQueue", rb_cObject);
 	
 	rb_define_alloc_func(IO_Event_Selector_KQueue, IO_Event_Selector_KQueue_allocate);
 	rb_define_method(IO_Event_Selector_KQueue, "initialize", IO_Event_Selector_KQueue_initialize, 1);

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

@@ -38,6 +38,7 @@ inline static void IO_Event_List_append(struct IO_Event_List *list, struct IO_Ev
 	head->tail = node;
 }
 
+// Prepend an item to the beginning of the list.
 inline static void IO_Event_List_prepend(struct IO_Event_List *list, struct IO_Event_List *node)
 {
 	assert(node->head == NULL);
@@ -64,6 +65,7 @@ inline static void IO_Event_List_pop(struct IO_Event_List *node)
 	node->head = node->tail = NULL;
 }
 
+// Remove an item from the list, if it is in a list.
 inline static void IO_Event_List_free(struct IO_Event_List *node)
 {
 	if (node->head && node->tail) {
@@ -71,11 +73,27 @@ inline static void IO_Event_List_free(struct IO_Event_List *node)
 	}
 }
 
-inline static int IO_Event_List_empty(struct IO_Event_List *list)
+// Calculate the memory size of the list nodes.
+inline static size_t IO_Event_List_memory_size(const struct IO_Event_List *list)
+{
+	size_t memsize = 0;
+
+	const struct IO_Event_List *node = list->tail;
+	while (node != list) {
+		memsize += sizeof(struct IO_Event_List);
+		node = node->tail;
+	}
+
+	return memsize;
+}
+
+// Return true if the list is empty.
+inline static int IO_Event_List_empty(const struct IO_Event_List *list)
 {
 	return list->head == list->tail;
 }
 
+// Enumerate all items in the list, assuming the list will not be modified during iteration.
 inline static void IO_Event_List_immutable_each(struct IO_Event_List *list, void (*callback)(struct IO_Event_List *node))
 {
 	struct IO_Event_List *node = list->tail;

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

@@ -172,24 +172,35 @@ static void queue_pop(struct IO_Event_Selector *backend, struct IO_Event_Selecto
 	if (waiting->head) {
 		waiting->head->tail = waiting->tail;
 	} else {
+		// We must have been at the head of the queue:
 		backend->waiting = waiting->tail;
 	}
 	
 	if (waiting->tail) {
 		waiting->tail->head = waiting->head;
 	} else {
+		// We must have been at the tail of the queue:
 		backend->ready = waiting->head;
 	}
+	
+	waiting->head = NULL;
+	waiting->tail = NULL;
 }
 
 static void queue_push(struct IO_Event_Selector *backend, struct IO_Event_Selector_Queue *waiting) {
+	assert(waiting->head == NULL);
+	assert(waiting->tail == NULL);
+	
 	if (backend->waiting) {
+		// If there was an item in the queue already, we shift it along:
 		backend->waiting->head = waiting;
 		waiting->tail = backend->waiting;
 	} else {
+		// If the queue was empty, we update the tail too:
 		backend->ready = waiting;
 	}
 	
+	// We always push to the front/head:
 	backend->waiting = waiting;
 }
 
@@ -222,6 +233,8 @@ VALUE IO_Event_Selector_resume(struct IO_Event_Selector *backend, int argc, VALU
 		.fiber = rb_fiber_current()
 	};
 	
+	RB_OBJ_WRITTEN(backend->self, Qundef, waiting.fiber);
+	
 	queue_push(backend, &waiting);
 	
 	struct wait_and_transfer_arguments arguments = {
@@ -255,6 +268,8 @@ VALUE IO_Event_Selector_raise(struct IO_Event_Selector *backend, int argc, VALUE
 		.fiber = rb_fiber_current()
 	};
 	
+	RB_OBJ_WRITTEN(backend->self, Qundef, waiting.fiber);
+	
 	queue_push(backend, &waiting);
 	
 	struct wait_and_transfer_arguments arguments = {
@@ -270,11 +285,13 @@ VALUE IO_Event_Selector_raise(struct IO_Event_Selector *backend, int argc, VALUE
 void IO_Event_Selector_queue_push(struct IO_Event_Selector *backend, VALUE fiber)
 {
 	struct IO_Event_Selector_Queue *waiting = malloc(sizeof(struct IO_Event_Selector_Queue));
+	assert(waiting);
 	
 	waiting->head = NULL;
 	waiting->tail = NULL;
 	waiting->flags = IO_EVENT_SELECTOR_QUEUE_INTERNAL;
-	waiting->fiber = fiber;
+	
+	RB_OBJ_WRITE(backend->self, &waiting->fiber, fiber);
 	
 	queue_push(backend, waiting);
 }
@@ -283,9 +300,10 @@ static inline
 void IO_Event_Selector_queue_pop(struct IO_Event_Selector *backend, struct IO_Event_Selector_Queue *ready)
 {
 	if (DEBUG) fprintf(stderr, "IO_Event_Selector_queue_pop -> %p\n", (void*)ready->fiber);
+	
 	if (ready->flags & IO_EVENT_SELECTOR_QUEUE_FIBER) {
 		IO_Event_Selector_fiber_transfer(ready->fiber, 0, NULL);
-	} else {
+	} else if (ready->flags & IO_EVENT_SELECTOR_QUEUE_INTERNAL) {
 		VALUE fiber = ready->fiber;
 		queue_pop(backend, ready);
 		free(ready);
@@ -293,6 +311,8 @@ void IO_Event_Selector_queue_pop(struct IO_Event_Selector *backend, struct IO_Ev
 		if (RTEST(rb_funcall(fiber, id_alive_p, 0))) {
 			rb_funcall(fiber, id_transfer, 0);
 		}
+	} else {
+		rb_raise(rb_eRuntimeError, "Unknown queue type!");
 	}
 }
 
@@ -300,6 +320,8 @@ int IO_Event_Selector_queue_flush(struct IO_Event_Selector *backend)
 {
 	int count = 0;
 	
+	// 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_queue_flush waiting = %p\n", waiting);

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

@@ -95,27 +95,29 @@ struct IO_Event_Selector_Queue {
 };
 
 struct IO_Event_Selector {
+	VALUE self;
 	VALUE loop;
 	
-	struct IO_Event_Selector_Queue *free;
-	
-	// Append to waiting.
+	// Append to waiting (front/head of queue).
 	struct IO_Event_Selector_Queue *waiting;
-	// Process from ready.
+	// Process from ready (back/tail of queue).
 	struct IO_Event_Selector_Queue *ready;
 };
 
 static inline
-void IO_Event_Selector_initialize(struct IO_Event_Selector *backend, VALUE loop) {
-	backend->loop = loop;
+void IO_Event_Selector_initialize(struct IO_Event_Selector *backend, VALUE self, VALUE loop) {
+	RB_OBJ_WRITE(self, &backend->self, self);
+	RB_OBJ_WRITE(self, &backend->loop, loop);
 	backend->waiting = NULL;
 	backend->ready = NULL;
 }
 
 static inline
 void IO_Event_Selector_mark(struct IO_Event_Selector *backend) {
+	rb_gc_mark_movable(backend->self);
 	rb_gc_mark_movable(backend->loop);
 	
+	// Walk backwards through the ready queue:
 	struct IO_Event_Selector_Queue *ready = backend->ready;
 	while (ready) {
 		rb_gc_mark_movable(ready->fiber);
@@ -125,6 +127,7 @@ void IO_Event_Selector_mark(struct IO_Event_Selector *backend) {
 
 static inline
 void IO_Event_Selector_compact(struct IO_Event_Selector *backend) {
+	backend->self = rb_gc_location(backend->self);
 	backend->loop = rb_gc_location(backend->loop);
 	
 	struct IO_Event_Selector_Queue *ready = backend->ready;
@@ -149,5 +152,5 @@ int IO_Event_Selector_queue_flush(struct IO_Event_Selector *backend);
 void IO_Event_Selector_elapsed_time(struct timespec* start, struct timespec* stop, struct timespec *duration);
 void IO_Event_Selector_current_time(struct timespec *time);
 
-#define PRINTF_TIMESPEC "%lld.%.9ld"
-#define PRINTF_TIMESPEC_ARGS(ts) (long long)((ts).tv_sec), (ts).tv_nsec
+#define IO_EVENT_PRINTF_TIMESPEC "%lld.%.9ld"
+#define IO_EVENT_PRINTF_TIMESPEC_ARGUMENTS(ts) (long long)((ts).tv_sec), (ts).tv_nsec