io-event 1.2.2 → 1.3.3

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

@@ -20,11 +20,17 @@
 
 #include "kqueue.h"
 #include "selector.h"
+#include "list.h"
+#include "array.h"
 
 #include <sys/event.h>
 #include <sys/ioctl.h>
 #include <time.h>
 #include <errno.h>
+#include <sys/wait.h>
+#include <signal.h>
+
+#include "../interrupt.h"
 
 enum {
 	DEBUG = 0,
@@ -33,49 +39,144 @@ enum {
 	DEBUG_IO_WAIT = 0
 };
 
+#ifndef EVFILT_USER
+#define IO_EVENT_SELECTOR_KQUEUE_USE_INTERRUPT
+#endif
+
 static VALUE IO_Event_Selector_KQueue = Qnil;
 
 enum {KQUEUE_MAX_EVENTS = 64};
 
-struct IO_Event_Selector_KQueue {
+// This represents an actual fiber waiting for a specific event.
+struct IO_Event_Selector_KQueue_Waiting
+{
+	struct IO_Event_List list;
+	
+	// The events the fiber is waiting for.
+	enum IO_Event events;
+	
+	// The events that are currently ready.
+	enum IO_Event ready;
+	
+	// The fiber value itself.
+	VALUE fiber;
+};
+
+struct IO_Event_Selector_KQueue
+{
 	struct IO_Event_Selector backend;
 	int descriptor;
-	
 	int blocked;
+	
+#ifdef IO_EVENT_SELECTOR_KQUEUE_USE_INTERRUPT
+	struct IO_Event_Interrupt interrupt;
+#endif
+	struct IO_Event_Array descriptors;
+};
+
+// This represents zero or more fibers waiting for a specific descriptor.
+struct IO_Event_Selector_KQueue_Descriptor
+{
+	struct IO_Event_List list;
+	
+	// The union of all events we are waiting for:
+	enum IO_Event waiting_events;
+	
+	// The union of events we are registered for:
+	enum IO_Event registered_events;
+	
+	// The events that are currently ready:
+	enum IO_Event ready_events;
 };
 
-void IO_Event_Selector_KQueue_Type_mark(void *_data)
+static
+void IO_Event_Selector_KQueue_Waiting_mark(struct IO_Event_List *_waiting)
+{
+	struct IO_Event_Selector_KQueue_Waiting *waiting = (void*)_waiting;
+	
+	if (waiting->fiber) {
+		rb_gc_mark_movable(waiting->fiber);
+	}
+}
+
+static
+void IO_Event_Selector_KQueue_Descriptor_mark(void *_descriptor)
+{
+	struct IO_Event_Selector_KQueue_Descriptor *descriptor = _descriptor;
+	
+	IO_Event_List_immutable_each(&descriptor->list, IO_Event_Selector_KQueue_Waiting_mark);
+}
+
+static
+void IO_Event_Selector_KQueue_Type_mark(void *_selector)
+{
+	struct IO_Event_Selector_KQueue *selector = _selector;
+	IO_Event_Selector_mark(&selector->backend);
+	IO_Event_Array_each(&selector->descriptors, IO_Event_Selector_KQueue_Descriptor_mark);
+}
+
+static
+void IO_Event_Selector_KQueue_Waiting_compact(struct IO_Event_List *_waiting)
+{
+	struct IO_Event_Selector_KQueue_Waiting *waiting = (void*)_waiting;
+	
+	if (waiting->fiber) {
+		waiting->fiber = rb_gc_location(waiting->fiber);
+	}
+}
+
+static
+void IO_Event_Selector_KQueue_Descriptor_compact(void *_descriptor)
+{
+	struct IO_Event_Selector_KQueue_Descriptor *descriptor = _descriptor;
+	
+	IO_Event_List_immutable_each(&descriptor->list, IO_Event_Selector_KQueue_Waiting_compact);
+}
+
+static
+void IO_Event_Selector_KQueue_Type_compact(void *_selector)
 {
-	struct IO_Event_Selector_KQueue *data = _data;
-	IO_Event_Selector_mark(&data->backend);
+	struct IO_Event_Selector_KQueue *selector = _selector;
+	IO_Event_Selector_compact(&selector->backend);
+	IO_Event_Array_each(&selector->descriptors, IO_Event_Selector_KQueue_Descriptor_compact);
 }
 
 static
-void close_internal(struct IO_Event_Selector_KQueue *data) {
-	if (data->descriptor >= 0) {
-		close(data->descriptor);
-		data->descriptor = -1;
+void close_internal(struct IO_Event_Selector_KQueue *selector)
+{
+	if (selector->descriptor >= 0) {
+		close(selector->descriptor);
+		selector->descriptor = -1;
 	}
 }
 
-void IO_Event_Selector_KQueue_Type_free(void *_data)
+static
+void IO_Event_Selector_KQueue_Type_free(void *_selector)
 {
-	struct IO_Event_Selector_KQueue *data = _data;
+	struct IO_Event_Selector_KQueue *selector = _selector;
+	
+	close_internal(selector);
 	
-	close_internal(data);
+	IO_Event_Array_free(&selector->descriptors);
 	
-	free(data);
+	free(selector);
 }
 
-size_t IO_Event_Selector_KQueue_Type_size(const void *data)
+static
+size_t IO_Event_Selector_KQueue_Type_size(const void *_selector)
 {
-	return sizeof(struct IO_Event_Selector_KQueue);
+	const struct IO_Event_Selector_KQueue *selector = _selector;
+	
+	return sizeof(struct IO_Event_Selector_KQueue)
+		+ IO_Event_Array_memory_size(&selector->descriptors)
+	;
 }
 
 static const rb_data_type_t IO_Event_Selector_KQueue_Type = {
 	.wrap_struct_name = "IO_Event::Backend::KQueue",
 	.function = {
 		.dmark = IO_Event_Selector_KQueue_Type_mark,
+		.dcompact = IO_Event_Selector_KQueue_Type_compact,
 		.dfree = IO_Event_Selector_KQueue_Type_free,
 		.dsize = IO_Event_Selector_KQueue_Type_size,
 	},
@@ -83,301 +184,390 @@ static const rb_data_type_t IO_Event_Selector_KQueue_Type = {
 	.flags = RUBY_TYPED_FREE_IMMEDIATELY,
 };
 
+inline static
+struct IO_Event_Selector_KQueue_Descriptor * IO_Event_Selector_KQueue_Descriptor_lookup(struct IO_Event_Selector_KQueue *selector, uintptr_t descriptor)
+{
+	struct IO_Event_Selector_KQueue_Descriptor *kqueue_descriptor = IO_Event_Array_lookup(&selector->descriptors, descriptor);
+	
+	if (!kqueue_descriptor) {
+		rb_sys_fail("IO_Event_Selector_KQueue_Descriptor_lookup:IO_Event_Array_lookup");
+	}
+	
+	return kqueue_descriptor;
+}
+
+inline static
+enum IO_Event events_from_kevent_filter(int filter)
+{
+	switch (filter) {
+		case EVFILT_READ:
+			return IO_EVENT_READABLE;
+		case EVFILT_WRITE:
+			return IO_EVENT_WRITABLE;
+		case EVFILT_PROC:
+			return IO_EVENT_EXIT;
+		default:
+			return 0;
+	}
+}
+
+inline static
+int IO_Event_Selector_KQueue_Descriptor_update(struct IO_Event_Selector_KQueue *selector, uintptr_t identifier, struct IO_Event_Selector_KQueue_Descriptor *kqueue_descriptor)
+{
+	int count = 0;
+	struct kevent kevents[3] = {0};
+	
+	if (kqueue_descriptor->waiting_events & IO_EVENT_READABLE) {
+		kevents[count].ident = identifier;
+		kevents[count].filter = EVFILT_READ;
+		kevents[count].flags = EV_ADD | EV_ONESHOT;
+		kevents[count].udata = (void *)kqueue_descriptor;
+// #ifdef EV_OOBAND
+// 		if (events & IO_EVENT_PRIORITY) {
+// 			kevents[count].flags |= EV_OOBAND;
+// 		}
+// #endif
+		count++;
+	}
+	
+	if (kqueue_descriptor->waiting_events & IO_EVENT_WRITABLE) {
+		kevents[count].ident = identifier;
+		kevents[count].filter = EVFILT_WRITE;
+		kevents[count].flags = EV_ADD | EV_ONESHOT;
+		kevents[count].udata = (void *)kqueue_descriptor;
+		count++;
+	}
+	
+	if (kqueue_descriptor->waiting_events & IO_EVENT_EXIT) {
+		kevents[count].ident = identifier;
+		kevents[count].filter = EVFILT_PROC;
+		kevents[count].flags = EV_ADD | EV_ONESHOT;
+		kevents[count].fflags = NOTE_EXIT;
+		kevents[count].udata = (void *)kqueue_descriptor;
+		count++;
+	}
+	
+	if (count == 0) {
+		return 0;
+	}
+	
+	int result = kevent(selector->descriptor, kevents, count, NULL, 0, NULL);
+	
+	if (result == -1) {
+		return result;
+	}
+	
+	kqueue_descriptor->registered_events = kqueue_descriptor->waiting_events;
+	
+	return result;
+}
+
+inline static
+int IO_Event_Selector_KQueue_Waiting_register(struct IO_Event_Selector_KQueue *selector, uintptr_t identifier, struct IO_Event_Selector_KQueue_Waiting *waiting)
+{
+	struct IO_Event_Selector_KQueue_Descriptor *kqueue_descriptor = IO_Event_Selector_KQueue_Descriptor_lookup(selector, identifier);
+	
+	// We are waiting for these events:
+	kqueue_descriptor->waiting_events |= waiting->events;
+	
+	int result = IO_Event_Selector_KQueue_Descriptor_update(selector, identifier, kqueue_descriptor);
+	if (result == -1) return -1;
+	
+	IO_Event_List_prepend(&kqueue_descriptor->list, &waiting->list);
+	
+	return result;
+}
+
+inline static
+void IO_Event_Selector_KQueue_Waiting_cancel(struct IO_Event_Selector_KQueue_Waiting *waiting)
+{
+	IO_Event_List_pop(&waiting->list);
+	waiting->fiber = 0;
+}
+
+void IO_Event_Selector_KQueue_Descriptor_initialize(void *element)
+{
+	struct IO_Event_Selector_KQueue_Descriptor *kqueue_descriptor = element;
+	IO_Event_List_initialize(&kqueue_descriptor->list);
+	kqueue_descriptor->waiting_events = 0;
+	kqueue_descriptor->registered_events = 0;
+	kqueue_descriptor->ready_events = 0;
+}
+
+void IO_Event_Selector_KQueue_Descriptor_free(void *element)
+{
+	struct IO_Event_Selector_KQueue_Descriptor *kqueue_descriptor = element;
+	
+	IO_Event_List_free(&kqueue_descriptor->list);
+}
+
 VALUE IO_Event_Selector_KQueue_allocate(VALUE self) {
-	struct IO_Event_Selector_KQueue *data = NULL;
-	VALUE instance = TypedData_Make_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, data);
+	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);
+	selector->descriptor = -1;
+	selector->blocked = 0;
 	
-	IO_Event_Selector_initialize(&data->backend, Qnil);
-	data->descriptor = -1;
-	data->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));
 	
 	return instance;
 }
 
+#ifdef IO_EVENT_SELECTOR_KQUEUE_USE_INTERRUPT
+void IO_Event_Interrupt_add(struct IO_Event_Interrupt *interrupt, struct IO_Event_Selector_KQueue *selector) {
+	int descriptor = IO_Event_Interrupt_descriptor(interrupt);
+	
+	struct kevent kev = {
+		.filter = EVFILT_READ,
+		.ident = descriptor,
+		.flags = EV_ADD | EV_CLEAR,
+	};
+	
+	int result = kevent(selector->descriptor, &kev, 1, NULL, 0, NULL);
+	
+	if (result == -1) {
+		rb_sys_fail("IO_Event_Interrupt_add:kevent");
+	}
+}
+#endif
+
 VALUE IO_Event_Selector_KQueue_initialize(VALUE self, VALUE loop) {
-	struct IO_Event_Selector_KQueue *data = NULL;
-	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, data);
+	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(&data->backend, loop);
+	IO_Event_Selector_initialize(&selector->backend, loop);
 	int result = kqueue();
 	
 	if (result == -1) {
 		rb_sys_fail("IO_Event_Selector_KQueue_initialize:kqueue");
 	} else {
+		// Make sure the descriptor is closed on exec.
 		ioctl(result, FIOCLEX);
-		data->descriptor = result;
 		
-		rb_update_max_fd(data->descriptor);
+		selector->descriptor = result;
+		
+		rb_update_max_fd(selector->descriptor);
 	}
 	
+#ifdef IO_EVENT_SELECTOR_KQUEUE_USE_INTERRUPT
+	IO_Event_Interrupt_open(&selector->interrupt);
+	IO_Event_Interrupt_add(&selector->interrupt, selector);
+#endif
+	
 	return self;
 }
 
 VALUE IO_Event_Selector_KQueue_loop(VALUE self) {
-	struct IO_Event_Selector_KQueue *data = NULL;
-	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, data);
+	struct IO_Event_Selector_KQueue *selector = NULL;
+	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
-	return data->backend.loop;
+	return selector->backend.loop;
 }
 
 VALUE IO_Event_Selector_KQueue_close(VALUE self) {
-	struct IO_Event_Selector_KQueue *data = NULL;
-	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, data);
+	struct IO_Event_Selector_KQueue *selector = NULL;
+	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
+	
+	close_internal(selector);
 	
-	close_internal(data);
+#ifdef IO_EVENT_SELECTOR_KQUEUE_USE_INTERRUPT
+	IO_Event_Interrupt_close(&selector->interrupt);
+#endif
 	
 	return Qnil;
 }
 
 VALUE IO_Event_Selector_KQueue_transfer(VALUE self)
 {
-	struct IO_Event_Selector_KQueue *data = NULL;
-	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, data);
+	struct IO_Event_Selector_KQueue *selector = NULL;
+	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
-	return IO_Event_Selector_fiber_transfer(data->backend.loop, 0, NULL);
+	return IO_Event_Selector_fiber_transfer(selector->backend.loop, 0, NULL);
 }
 
 VALUE IO_Event_Selector_KQueue_resume(int argc, VALUE *argv, VALUE self)
 {
-	struct IO_Event_Selector_KQueue *data = NULL;
-	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, data);
+	struct IO_Event_Selector_KQueue *selector = NULL;
+	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
-	return IO_Event_Selector_resume(&data->backend, argc, argv);
+	return IO_Event_Selector_resume(&selector->backend, argc, argv);
 }
 
 VALUE IO_Event_Selector_KQueue_yield(VALUE self)
 {
-	struct IO_Event_Selector_KQueue *data = NULL;
-	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, data);
+	struct IO_Event_Selector_KQueue *selector = NULL;
+	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
-	return IO_Event_Selector_yield(&data->backend);
+	return IO_Event_Selector_yield(&selector->backend);
 }
 
 VALUE IO_Event_Selector_KQueue_push(VALUE self, VALUE fiber)
 {
-	struct IO_Event_Selector_KQueue *data = NULL;
-	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, data);
+	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_queue_push(&data->backend, fiber);
+	IO_Event_Selector_queue_push(&selector->backend, fiber);
 	
 	return Qnil;
 }
 
 VALUE IO_Event_Selector_KQueue_raise(int argc, VALUE *argv, VALUE self)
 {
-	struct IO_Event_Selector_KQueue *data = NULL;
-	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, data);
+	struct IO_Event_Selector_KQueue *selector = NULL;
+	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
-	return IO_Event_Selector_raise(&data->backend, argc, argv);
+	return IO_Event_Selector_raise(&selector->backend, argc, argv);
 }
 
 VALUE IO_Event_Selector_KQueue_ready_p(VALUE self) {
-	struct IO_Event_Selector_KQueue *data = NULL;
-	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, data);
+	struct IO_Event_Selector_KQueue *selector = NULL;
+	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
-	return data->backend.ready ? Qtrue : Qfalse;
+	return selector->backend.ready ? Qtrue : Qfalse;
 }
 
 struct process_wait_arguments {
-	struct IO_Event_Selector_KQueue *data;
+	struct IO_Event_Selector_KQueue *selector;
+	struct IO_Event_Selector_KQueue_Waiting *waiting;
 	pid_t pid;
 	int flags;
 };
 
 static
-int process_add_filters(int descriptor, int ident, VALUE fiber) {
-	struct kevent event = {0};
-	
-	event.ident = ident;
-	event.filter = EVFILT_PROC;
-	event.flags = EV_ADD | EV_ENABLE | EV_ONESHOT | EV_UDATA_SPECIFIC;
-	event.fflags = NOTE_EXIT;
-	event.udata = (void*)fiber;
-	
-	int result = kevent(descriptor, &event, 1, NULL, 0, NULL);
-	
+void process_prewait(pid_t pid) {
+#if defined(WNOWAIT)
+	// FreeBSD seems to have an issue where kevent() can return an EVFILT_PROC/NOTE_EXIT event for a process even though a wait with WNOHANG on it immediately after will not return it (but it does after a small delay). Similarly, OpenBSD/NetBSD seem to sometimes fail the kevent() call with ESRCH (indicating the process has already terminated) even though a WNOHANG may not return it immediately after.
+	// To deal with this, do a hanging WNOWAIT wait on the process to make sure it is "terminated enough" for future WNOHANG waits to return it.
+	// Using waitid() for this because OpenBSD only supports WNOWAIT with waitid().
+	int result;
+	do {
+		siginfo_t info;
+		result = waitid(P_PID, pid, &info, WEXITED | WNOWAIT);
+		// This can sometimes get interrupted by SIGCHLD.
+	} while (result == -1 && errno == EINTR);
 	if (result == -1) {
-		// No such process - the process has probably already terminated:
-		if (errno == ESRCH) {
-			return 0;
-		}
-		
-		rb_sys_fail("process_add_filters:kevent");
+		rb_sys_fail("process_prewait:waitid");
 	}
-	
-	return 1;
-}
-
-static
-void process_remove_filters(int descriptor, int ident) {
-	struct kevent event = {0};
-	
-	event.ident = ident;
-	event.filter = EVFILT_PROC;
-	event.flags = EV_DELETE | EV_UDATA_SPECIFIC;
-	event.fflags = NOTE_EXIT;
-	
-	// Ignore the result.
-	kevent(descriptor, &event, 1, NULL, 0, NULL);
+#endif
 }
 
 static
 VALUE process_wait_transfer(VALUE _arguments) {
 	struct process_wait_arguments *arguments = (struct process_wait_arguments *)_arguments;
 	
-	IO_Event_Selector_fiber_transfer(arguments->data->backend.loop, 0, NULL);
+	IO_Event_Selector_fiber_transfer(arguments->selector->backend.loop, 0, NULL);
 	
-	return IO_Event_Selector_process_status_wait(arguments->pid);
+	if (arguments->waiting->ready) {
+		process_prewait(arguments->pid);
+		return IO_Event_Selector_process_status_wait(arguments->pid, arguments->flags);
+	} else {
+		return Qfalse;
+	}
 }
 
 static
-VALUE process_wait_rescue(VALUE _arguments, VALUE exception) {
+VALUE process_wait_ensure(VALUE _arguments) {
 	struct process_wait_arguments *arguments = (struct process_wait_arguments *)_arguments;
 	
-	process_remove_filters(arguments->data->descriptor, arguments->pid);
+	IO_Event_Selector_KQueue_Waiting_cancel(arguments->waiting);
 	
-	rb_exc_raise(exception);
+	return Qnil;
 }
 
-VALUE IO_Event_Selector_KQueue_process_wait(VALUE self, VALUE fiber, VALUE pid, VALUE flags) {
-	struct IO_Event_Selector_KQueue *data = NULL;
-	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, data);
-	
-	struct process_wait_arguments process_wait_arguments = {
-		.data = data,
-		.pid = NUM2PIDT(pid),
-		.flags = RB_NUM2INT(flags),
-	};
-	
-	VALUE result = Qnil;
-	
-	// This loop should not be needed but I have seen a race condition between NOTE_EXIT and `waitpid`, thus the result would be (unexpectedly) nil. So we put this in a loop to retry if the race condition shows up:
-	while (NIL_P(result)) {
-		int waiting = process_add_filters(data->descriptor, process_wait_arguments.pid, fiber);
-	
-		if (waiting) {
-			result = rb_rescue(process_wait_transfer, (VALUE)&process_wait_arguments, process_wait_rescue, (VALUE)&process_wait_arguments);
-		} else {
-			result = IO_Event_Selector_process_status_wait(process_wait_arguments.pid);
-		}
-	}
-	
-	return result;
-}
+struct IO_Event_List_Type IO_Event_Selector_KQueue_process_wait_list_type = {};
 
-static
-int io_add_filters(int descriptor, int ident, int events, VALUE fiber) {
-	int count = 0;
-	struct kevent kevents[2] = {0};
+VALUE IO_Event_Selector_KQueue_process_wait(VALUE self, VALUE fiber, VALUE _pid, VALUE _flags) {
+	struct IO_Event_Selector_KQueue *selector = NULL;
+	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
-	if (events & IO_EVENT_READABLE) {
-		kevents[count].ident = ident;
-		kevents[count].filter = EVFILT_READ;
-		kevents[count].flags = EV_ADD | EV_ENABLE | EV_ONESHOT | EV_UDATA_SPECIFIC;
-		kevents[count].udata = (void*)fiber;
-		
-// #ifdef EV_OOBAND
-// 		if (events & PRIORITY) {
-// 			kevents[count].flags |= EV_OOBAND;
-// 		}
-// #endif
-		
-		count++;
-	}
+	pid_t pid = NUM2PIDT(_pid);
+	int flags = NUM2INT(_flags);
 	
-	if (events & IO_EVENT_WRITABLE) {
-		kevents[count].ident = ident;
-		kevents[count].filter = EVFILT_WRITE;
-		kevents[count].flags = EV_ADD | EV_ENABLE | EV_ONESHOT | EV_UDATA_SPECIFIC;
-		kevents[count].udata = (void*)fiber;
-		count++;
-	}
+	struct IO_Event_Selector_KQueue_Waiting waiting = {
+		.list = {.type = &IO_Event_Selector_KQueue_process_wait_list_type},
+		.fiber = fiber,
+		.events = IO_EVENT_EXIT,
+	};
 	
-	int result = kevent(descriptor, kevents, count, NULL, 0, NULL);
+	struct process_wait_arguments process_wait_arguments = {
+		.selector = selector,
+		.waiting = &waiting,
+		.pid = pid,
+		.flags = flags,
+	};
 	
+	int result = IO_Event_Selector_KQueue_Waiting_register(selector, pid, &waiting);
 	if (result == -1) {
-		rb_sys_fail("io_add_filters:kevent");
-	}
-	
-	return events;
-}
-
-static
-void io_remove_filters(int descriptor, int ident, int events) {
-	int count = 0;
-	struct kevent kevents[2] = {0};
-	
-	if (events & IO_EVENT_READABLE) {
-		kevents[count].ident = ident;
-		kevents[count].filter = EVFILT_READ;
-		kevents[count].flags = EV_DELETE | EV_UDATA_SPECIFIC;
+		// OpenBSD/NetBSD return ESRCH when attempting to register an EVFILT_PROC event for a zombie process.
+		if (errno == ESRCH) {
+			process_prewait(pid);
+			
+			return IO_Event_Selector_process_status_wait(pid, flags);
+		}
 		
-		count++;
-	}
-	
-	if (events & IO_EVENT_WRITABLE) {
-		kevents[count].ident = ident;
-		kevents[count].filter = EVFILT_WRITE;
-		kevents[count].flags = EV_DELETE | EV_UDATA_SPECIFIC;
-		count++;
+		rb_sys_fail("IO_Event_Selector_KQueue_process_wait:IO_Event_Selector_KQueue_Waiting_register");
 	}
 	
-	// Ignore the result.
-	kevent(descriptor, kevents, count, NULL, 0, NULL);
+	return rb_ensure(process_wait_transfer, (VALUE)&process_wait_arguments, process_wait_ensure, (VALUE)&process_wait_arguments);
 }
 
 struct io_wait_arguments {
-	struct IO_Event_Selector_KQueue *data;
-	int events;
-	int descriptor;
+	struct IO_Event_Selector_KQueue *selector;
+	struct IO_Event_Selector_KQueue_Waiting *waiting;
 };
 
 static
-VALUE io_wait_rescue(VALUE _arguments, VALUE exception) {
+VALUE io_wait_ensure(VALUE _arguments) {
 	struct io_wait_arguments *arguments = (struct io_wait_arguments *)_arguments;
 	
-	io_remove_filters(arguments->data->descriptor, arguments->descriptor, arguments->events);
+	IO_Event_Selector_KQueue_Waiting_cancel(arguments->waiting);
 	
-	rb_exc_raise(exception);
-}
-
-static inline
-int events_from_kqueue_filter(int filter) {
-	if (filter == EVFILT_READ) return IO_EVENT_READABLE;
-	if (filter == EVFILT_WRITE) return IO_EVENT_WRITABLE;
-	
-	return 0;
+	return Qnil;
 }
 
 static
 VALUE io_wait_transfer(VALUE _arguments) {
 	struct io_wait_arguments *arguments = (struct io_wait_arguments *)_arguments;
 	
-	VALUE result = IO_Event_Selector_fiber_transfer(arguments->data->backend.loop, 0, NULL);
+	IO_Event_Selector_fiber_transfer(arguments->selector->backend.loop, 0, NULL);
 	
-	// If the fiber is being cancelled, it might be resumed with nil:
-	if (!RTEST(result)) {
+	if (arguments->waiting->ready) {
+		return RB_INT2NUM(arguments->waiting->ready);
+	} else {
 		return Qfalse;
 	}
-	
-	return INT2NUM(events_from_kqueue_filter(RB_NUM2INT(result)));
 }
 
+struct IO_Event_List_Type IO_Event_Selector_KQueue_io_wait_list_type = {};
+
 VALUE IO_Event_Selector_KQueue_io_wait(VALUE self, VALUE fiber, VALUE io, VALUE events) {
-	struct IO_Event_Selector_KQueue *data = NULL;
-	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, data);
+	struct IO_Event_Selector_KQueue *selector = NULL;
+	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
 	int descriptor = IO_Event_Selector_io_descriptor(io);
 	
+	struct IO_Event_Selector_KQueue_Waiting waiting = {
+		.list = {.type = &IO_Event_Selector_KQueue_io_wait_list_type},
+		.fiber = fiber,
+		.events = RB_NUM2INT(events),
+	};
+	
+	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");
+	}
+	
 	struct io_wait_arguments io_wait_arguments = {
-		.events = io_add_filters(data->descriptor, descriptor, RB_NUM2INT(events), fiber),
-		.data = data,
-		.descriptor = descriptor,
+		.selector = selector,
+		.waiting = &waiting,
 	};
 	
 	if (DEBUG_IO_WAIT) fprintf(stderr, "IO_Event_Selector_KQueue_io_wait descriptor=%d\n", descriptor);
 	
-	return rb_rescue(io_wait_transfer, (VALUE)&io_wait_arguments, io_wait_rescue, (VALUE)&io_wait_arguments);
+	return rb_ensure(io_wait_transfer, (VALUE)&io_wait_arguments, io_wait_ensure, (VALUE)&io_wait_arguments);
 }
 
 #ifdef HAVE_RUBY_IO_BUFFER_H
@@ -406,16 +596,18 @@ VALUE io_read_loop(VALUE _arguments) {
 	
 	size_t length = arguments->length;
 	size_t offset = arguments->offset;
+	size_t total = 0;
 	
 	if (DEBUG_IO_READ) fprintf(stderr, "io_read_loop(fd=%d, length=%zu)\n", arguments->descriptor, length);
 	
-	while (true) {
-		size_t maximum_size = size - offset;
+	size_t maximum_size = size - offset;
+	while (maximum_size) {
 		if (DEBUG_IO_READ) fprintf(stderr, "read(%d, +%ld, %ld)\n", arguments->descriptor, offset, maximum_size);
 		ssize_t result = read(arguments->descriptor, (char*)base+offset, maximum_size);
 		if (DEBUG_IO_READ) fprintf(stderr, "read(%d, +%ld, %ld) -> %zd\n", arguments->descriptor, offset, maximum_size, result);
 		
 		if (result > 0) {
+			total += result;
 			offset += result;
 			if ((size_t)result >= length) break;
 			length -= result;
@@ -428,10 +620,12 @@ VALUE io_read_loop(VALUE _arguments) {
 			if (DEBUG_IO_READ) fprintf(stderr, "io_read_loop(fd=%d, length=%zu) -> errno=%d\n", arguments->descriptor, length, errno);
 			return rb_fiber_scheduler_io_result(-1, errno);
 		}
+		
+		maximum_size = size - offset;
 	}
 	
 	if (DEBUG_IO_READ) fprintf(stderr, "io_read_loop(fd=%d, length=%zu) -> %zu\n", arguments->descriptor, length, offset);
-	return rb_fiber_scheduler_io_result(offset, 0);
+	return rb_fiber_scheduler_io_result(total, 0);
 }
 
 static
@@ -444,8 +638,8 @@ VALUE io_read_ensure(VALUE _arguments) {
 }
 
 VALUE IO_Event_Selector_KQueue_io_read(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _length, VALUE _offset) {
-	struct IO_Event_Selector_KQueue *data = NULL;
-	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, data);
+	struct IO_Event_Selector_KQueue *selector = NULL;
+	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
 	int descriptor = IO_Event_Selector_io_descriptor(io);
 	
@@ -504,6 +698,7 @@ VALUE io_write_loop(VALUE _arguments) {
 	
 	size_t length = arguments->length;
 	size_t offset = arguments->offset;
+	size_t total = 0;
 	
 	if (length > size) {
 		rb_raise(rb_eRuntimeError, "Length exceeds size of buffer!");
@@ -511,13 +706,14 @@ VALUE io_write_loop(VALUE _arguments) {
 	
 	if (DEBUG_IO_WRITE) fprintf(stderr, "io_write_loop(fd=%d, length=%zu)\n", arguments->descriptor, length);
 	
-	while (true) {
-		size_t maximum_size = size - offset;
+	size_t maximum_size = size - offset;
+	while (maximum_size) {
 		if (DEBUG_IO_WRITE) fprintf(stderr, "write(%d, +%ld, %ld, length=%zu)\n", arguments->descriptor, offset, maximum_size, length);
 		ssize_t result = write(arguments->descriptor, (char*)base+offset, maximum_size);
 		if (DEBUG_IO_WRITE) fprintf(stderr, "write(%d, +%ld, %ld) -> %zd\n", arguments->descriptor, offset, maximum_size, result);
 		
 		if (result > 0) {
+			total += result;
 			offset += result;
 			if ((size_t)result >= length) break;
 			length -= result;
@@ -530,10 +726,12 @@ VALUE io_write_loop(VALUE _arguments) {
 			if (DEBUG_IO_WRITE) fprintf(stderr, "io_write_loop(fd=%d, length=%zu) -> errno=%d\n", arguments->descriptor, length, errno);
 			return rb_fiber_scheduler_io_result(-1, errno);
 		}
+		
+		maximum_size = size - offset;
 	}
 	
 	if (DEBUG_IO_READ) fprintf(stderr, "io_write_loop(fd=%d, length=%zu) -> %zu\n", arguments->descriptor, length, offset);
-	return rb_fiber_scheduler_io_result(offset, 0);
+	return rb_fiber_scheduler_io_result(total, 0);
 };
 
 static
@@ -546,8 +744,8 @@ VALUE io_write_ensure(VALUE _arguments) {
 };
 
 VALUE IO_Event_Selector_KQueue_io_write(VALUE self, VALUE fiber, VALUE io, VALUE buffer, VALUE _length, VALUE _offset) {
-	struct IO_Event_Selector_KQueue *data = NULL;
-	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, data);
+	struct IO_Event_Selector_KQueue *selector = NULL;
+	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
 	int descriptor = IO_Event_Selector_io_descriptor(io);
 	
@@ -616,30 +814,32 @@ int timeout_nonblocking(struct timespec * timespec) {
 }
 
 struct select_arguments {
-	struct IO_Event_Selector_KQueue *data;
+	struct IO_Event_Selector_KQueue *selector;
 	
 	int count;
 	struct kevent events[KQUEUE_MAX_EVENTS];
 	
 	struct timespec storage;
 	struct timespec *timeout;
+	
+	struct IO_Event_List saved;
 };
 
 static
 void * select_internal(void *_arguments) {
 	struct select_arguments * arguments = (struct select_arguments *)_arguments;
 	
-	arguments->count = kevent(arguments->data->descriptor, NULL, 0, arguments->events, arguments->count, arguments->timeout);
+	arguments->count = kevent(arguments->selector->descriptor, NULL, 0, arguments->events, arguments->count, arguments->timeout);
 	
 	return NULL;
 }
 
 static
 void select_internal_without_gvl(struct select_arguments *arguments) {
-	arguments->data->blocked = 1;
+	arguments->selector->blocked = 1;
 	
 	rb_thread_call_without_gvl(select_internal, (void *)arguments, RUBY_UBF_IO, 0);
-	arguments->data->blocked = 0;
+	arguments->selector->blocked = 0;
 	
 	if (arguments->count == -1) {
 		if (errno != EINTR) {
@@ -663,19 +863,102 @@ void select_internal_with_gvl(struct select_arguments *arguments) {
 	}
 }
 
+static
+int IO_Event_Selector_KQueue_handle(struct IO_Event_Selector_KQueue *selector, uintptr_t identifier, struct IO_Event_Selector_KQueue_Descriptor *kqueue_descriptor, struct IO_Event_List *saved)
+{
+	// This is the mask of all events that occured for the given descriptor:
+	enum IO_Event ready_events = kqueue_descriptor->ready_events;
+	
+	if (ready_events) {
+		kqueue_descriptor->ready_events = 0;
+		// Since we use one-shot semantics, we need to re-arm the events that are ready if needed:
+		kqueue_descriptor->registered_events &= ~ready_events;
+	} else {
+		return 0;
+	}
+	
+	struct IO_Event_List *list = &kqueue_descriptor->list;
+	struct IO_Event_List *node = list->tail;
+	
+	// Reset the events back to 0 so that we can re-arm if necessary:
+	kqueue_descriptor->waiting_events = 0;
+	
+	// It's possible (but unlikely) that the address of list will changing during iteration.
+	while (node != list) {
+		struct IO_Event_Selector_KQueue_Waiting *waiting = (struct IO_Event_Selector_KQueue_Waiting *)node;
+		
+		enum IO_Event matching_events = waiting->events & ready_events;
+		
+		if (DEBUG) fprintf(stderr, "IO_Event_Selector_KQueue_handle: identifier=%lu, ready_events=%d, matching_events=%d\n", identifier, ready_events, matching_events);
+		
+		if (matching_events) {
+			IO_Event_List_append(node, saved);
+			
+			waiting->ready = matching_events;
+			IO_Event_Selector_fiber_transfer(waiting->fiber, 0, NULL);
+			
+			node = saved->tail;
+			IO_Event_List_pop(saved);
+		} else {
+			kqueue_descriptor->waiting_events |= waiting->events;
+			node = node->tail;
+		}
+	}
+	
+	return IO_Event_Selector_KQueue_Descriptor_update(selector, identifier, kqueue_descriptor);
+}
+
+static
+VALUE select_handle_events(VALUE _arguments)
+{
+	struct select_arguments *arguments = (struct select_arguments *)_arguments;
+	struct IO_Event_Selector_KQueue *selector = arguments->selector;
+	
+	for (int i = 0; i < arguments->count; i += 1) {
+		if (arguments->events[i].udata) {
+			struct IO_Event_Selector_KQueue_Descriptor *kqueue_descriptor = arguments->events[i].udata;
+			kqueue_descriptor->ready_events |= events_from_kevent_filter(arguments->events[i].filter);
+		}
+	}
+	
+	for (int i = 0; i < arguments->count; i += 1) {
+		if (arguments->events[i].udata) {
+			struct IO_Event_Selector_KQueue_Descriptor *kqueue_descriptor = arguments->events[i].udata;
+			IO_Event_Selector_KQueue_handle(selector, arguments->events[i].ident, kqueue_descriptor, &arguments->saved);
+		} else {
+#ifdef IO_EVENT_SELECTOR_KQUEUE_USE_INTERRUPT
+			IO_Event_Interrupt_clear(&selector->interrupt);
+#endif
+		}
+	}
+	
+	return RB_INT2NUM(arguments->count);
+}
+
+static
+VALUE select_handle_events_ensure(VALUE _arguments)
+{
+	struct select_arguments *arguments = (struct select_arguments *)_arguments;
+	
+	IO_Event_List_free(&arguments->saved);
+	
+	return Qnil;
+}
+
 VALUE IO_Event_Selector_KQueue_select(VALUE self, VALUE duration) {
-	struct IO_Event_Selector_KQueue *data = NULL;
-	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, data);
+	struct IO_Event_Selector_KQueue *selector = NULL;
+	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
-	int ready = IO_Event_Selector_queue_flush(&data->backend);
+	int ready = IO_Event_Selector_queue_flush(&selector->backend);
 	
 	struct select_arguments arguments = {
-		.data = data,
+		.selector = selector,
 		.count = KQUEUE_MAX_EVENTS,
 		.storage = {
 			.tv_sec = 0,
 			.tv_nsec = 0
-		}
+		},
+		.saved = {},
 	};
 	
 	arguments.timeout = &arguments.storage;
@@ -696,7 +979,7 @@ VALUE IO_Event_Selector_KQueue_select(VALUE self, VALUE duration) {
 	// 2. Didn't process any events from non-blocking select (above), and
 	// 3. There are no items in the ready list,
 	// then we can perform a blocking select.
-	if (!ready && !arguments.count && !data->backend.ready) {
+	if (!ready && !arguments.count && !selector->backend.ready) {
 		arguments.timeout = make_timeout(duration, &arguments.storage);
 		
 		if (!timeout_nonblocking(arguments.timeout)) {
@@ -707,34 +990,42 @@ VALUE IO_Event_Selector_KQueue_select(VALUE self, VALUE duration) {
 		}
 	}
 	
-	for (int i = 0; i < arguments.count; i += 1) {
-		if (arguments.events[i].udata) {
-			VALUE fiber = (VALUE)arguments.events[i].udata;
-			VALUE result = INT2NUM(arguments.events[i].filter);
-			
-			IO_Event_Selector_fiber_transfer(fiber, 1, &result);
-		}
+	if (arguments.count) {
+		return rb_ensure(select_handle_events, (VALUE)&arguments, select_handle_events_ensure, (VALUE)&arguments);
+	} else {
+		return RB_INT2NUM(0);
 	}
-	
-	return INT2NUM(arguments.count);
 }
 
 VALUE IO_Event_Selector_KQueue_wakeup(VALUE self) {
-	struct IO_Event_Selector_KQueue *data = NULL;
-	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, data);
+	struct IO_Event_Selector_KQueue *selector = NULL;
+	TypedData_Get_Struct(self, struct IO_Event_Selector_KQueue, &IO_Event_Selector_KQueue_Type, selector);
 	
-	if (data->blocked) {
+	if (selector->blocked) {
+#ifdef IO_EVENT_SELECTOR_KQUEUE_USE_INTERRUPT
+		IO_Event_Interrupt_signal(&selector->interrupt);
+#else
 		struct kevent trigger = {0};
 		
 		trigger.filter = EVFILT_USER;
-		trigger.flags = EV_ADD | EV_CLEAR | EV_UDATA_SPECIFIC;
+		trigger.flags = EV_ADD | EV_CLEAR;
+		
+		int result = kevent(selector->descriptor, &trigger, 1, NULL, 0, NULL);
+		
+		if (result == -1) {
+			rb_sys_fail("IO_Event_Selector_KQueue_wakeup:kevent");
+		}
+		
+		// FreeBSD apparently only works if the NOTE_TRIGGER is done as a separate call.
+		trigger.flags = 0;
 		trigger.fflags = NOTE_TRIGGER;
 		
-		int result = kevent(data->descriptor, &trigger, 1, NULL, 0, NULL);
+		result = kevent(selector->descriptor, &trigger, 1, NULL, 0, NULL);
 		
 		if (result == -1) {
 			rb_sys_fail("IO_Event_Selector_KQueue_wakeup:kevent");
 		}
+#endif
 		
 		return Qtrue;
 	}