sleepy_penguin 3.1.0 → 3.1.0.26.g7181

data/.gitignore

@@ -3,6 +3,7 @@
 *.log
 *.so
 *.rbc
+/.rbx
 /.config
 /InstalledFiles
 /doc

data/.wrongdoc.yml

@@ -2,3 +2,5 @@
 cgit_url: http://bogomips.org/sleepy_penguin.git
 git_url: git://bogomips.org/sleepy_penguin.git
 rdoc_url: http://bogomips.org/sleepy_penguin/
+private_email: sleepy.penguin@bogomips.org
+public_email: sleepy.penguin@librelist.org

data/LICENSE

@@ -14,5 +14,4 @@ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser
 General Public License for more details.
 
 You should have received a copy of the GNU Lesser General Public License
-along with this library; if not, write to the Free Software
-Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301
+along with this library; if not, see http://www.gnu.org/licenses/

data/README

@@ -6,14 +6,15 @@ timerfd, inotify, and epoll interfaces are provided.
 
 == Features
 
-* Thread-safe blocking operations under both Ruby 1.8 and 1.9.
+* Thread-safe blocking operations for all versions of Ruby
 
 * IO-like objects are backwards-compatible with IO.select.
 
 * Epoll interface is fork-safe and GC-safe
 
-* Unlike portable event frameworks, the Linux-only Epoll interface
-  allows using edge-triggered I/O for possibly improved performance
+* Unlike portable event frameworks, the Linux-only epoll interfaces
+  allow using edge-triggered or one-shot notifications for possibly
+  improved performance
 
 * Fully-documented and user-friendly API
 

data/ext/sleepy_penguin/epoll.c

@@ -1,22 +1,13 @@
 #include "sleepy_penguin.h"
 #include <sys/epoll.h>
-#include <pthread.h>
+#include <unistd.h>
 #include <time.h>
 #include "missing_epoll.h"
-#ifdef HAVE_RUBY_ST_H
-#  include <ruby/st.h>
-#else
-#  include <st.h>
-#endif
 #include "missing_rb_thread_fd_close.h"
 #include "missing_rb_update_max_fd.h"
-#define EP_RECREATE (-2)
 
-static pthread_key_t epoll_key;
-static st_table *active;
-static const int step = 64; /* unlikely to grow unless you're huge */
-static VALUE cEpoll_IO;
 static ID id_for_fd;
+static VALUE cEpoll;
 
 static uint64_t now_ms(void)
 {
@@ -47,27 +38,38 @@ static VALUE unpack_event_data(struct epoll_event *event)
 # endif
 #endif
 
-struct rb_epoll {
-	int fd;
-	VALUE io;
-	VALUE marks;
-	VALUE flag_cache;
-	int flags;
-};
-
 struct ep_per_thread {
-	struct rb_epoll *ep;
+	VALUE io;
+	int fd;
 	int timeout;
 	int maxevents;
 	int capa;
 	struct epoll_event events[FLEX_ARRAY];
 };
 
-static struct ep_per_thread *ept_get(int maxevents)
+/* this will raise if the IO is closed */
+static int ep_fd_check(struct ep_per_thread *ept)
 {
-	struct ep_per_thread *ept = pthread_getspecific(epoll_key);
-	int err;
+	int save_errno = errno;
+
+	ept->fd = rb_sp_fileno(ept->io);
+	errno = save_errno;
+
+	return 1;
+}
+
+static struct ep_per_thread *ept_get(VALUE self, int maxevents)
+{
+	static __thread struct ep_per_thread *ept;
 	size_t size;
+	int err;
+	void *ptr;
+
+	/* error check here to prevent OOM from posix_memalign */
+	if (maxevents <= 0) {
+		errno = EINVAL;
+		rb_sys_fail("epoll_wait maxevents <= 0");
+	}
 
 	if (ept && ept->capa >= maxevents)
 		goto out;
@@ -76,264 +78,76 @@ static struct ep_per_thread *ept_get(int maxevents)
 	       sizeof(struct epoll_event) * maxevents;
 
 	free(ept); /* free(NULL) is POSIX and works on glibc */
-	ept = malloc(size);
-	if (ept == NULL)
-		rb_memerror();
-	err = pthread_setspecific(epoll_key, ept);
-	if (err != 0) {
+	err = posix_memalign(&ptr, rb_sp_l1_cache_line_size, size);
+	if (err) {
 		errno = err;
-		rb_sys_fail("pthread_setspecific");
+		rb_memerror();
 	}
+	ept = ptr;
 	ept->capa = maxevents;
 out:
 	ept->maxevents = maxevents;
+	ept->io = self;
+	ept->fd = rb_sp_fileno(ept->io);
 
 	return ept;
 }
 
-static struct rb_epoll *ep_get(VALUE self)
-{
-	struct rb_epoll *ep;
-
-	Data_Get_Struct(self, struct rb_epoll, ep);
-
-	return ep;
-}
-
-static void gcmark(void *ptr)
-{
-	struct rb_epoll *ep = ptr;
-
-	rb_gc_mark(ep->io);
-	rb_gc_mark(ep->marks);
-	rb_gc_mark(ep->flag_cache);
-}
-
-static void gcfree(void *ptr)
-{
-	struct rb_epoll *ep = ptr;
-
-	if (ep->fd >= 0) {
-		st_data_t key = ep->fd;
-		st_delete(active, &key, NULL);
-	}
-	if (NIL_P(ep->io) && ep->fd >= 0) {
-		/* can't raise during GC, and close() never fails in Linux */
-		(void)close(ep->fd);
-		errno = 0;
-	}
-	/* let GC take care of the underlying IO object if there is one */
-
-	xfree(ep);
-}
-
-static VALUE alloc(VALUE klass)
-{
-	struct rb_epoll *ep;
-	VALUE self;
-
-	self = Data_Make_Struct(klass, struct rb_epoll, gcmark, gcfree, ep);
-	ep->fd = -1;
-	ep->io = Qnil;
-	ep->marks = Qnil;
-	ep->flag_cache = Qnil;
-	ep->flags = 0;
-
-	return self;
-}
-
-static void my_epoll_create(struct rb_epoll *ep)
-{
-	ep->fd = epoll_create1(ep->flags);
-
-	if (ep->fd == -1) {
-		if (errno == EMFILE || errno == ENFILE || errno == ENOMEM) {
-			rb_gc();
-			ep->fd = epoll_create1(ep->flags);
-		}
-		if (ep->fd == -1)
-			rb_sys_fail("epoll_create1");
-	}
-	rb_update_max_fd(ep->fd);
-	st_insert(active, (st_data_t)ep->fd, (st_data_t)ep);
-	ep->marks = rb_ary_new();
-	ep->flag_cache = rb_ary_new();
-}
-
-static int ep_fd_check(struct rb_epoll *ep)
-{
-	if (ep->fd == -1)
-		rb_raise(rb_eIOError, "closed epoll descriptor");
-	return 1;
-}
-
-static void ep_check(struct rb_epoll *ep)
-{
-	if (ep->fd == EP_RECREATE)
-		my_epoll_create(ep);
-	ep_fd_check(ep);
-	assert(TYPE(ep->marks) == T_ARRAY && "marks not initialized");
-	assert(TYPE(ep->flag_cache) == T_ARRAY && "flag_cache not initialized");
-}
-
 /*
  * call-seq:
- *	SleepyPenguin::Epoll.new([flags])	-> Epoll object
+ *	SleepyPenguin::Epoll::IO.new(flags)	-> Epoll::IO object
  *
- * Creates a new Epoll object with an optional +flags+ argument.
- * +flags+ may currently be +:CLOEXEC+ or +0+ (or +nil+).
+ * Creates a new Epoll::IO object with the given +flags+ argument.
+ * +flags+ may currently be +CLOEXEC+ or +0+.
  */
-static VALUE init(int argc, VALUE *argv, VALUE self)
+static VALUE s_new(VALUE klass, VALUE _flags)
 {
-	struct rb_epoll *ep = ep_get(self);
-	VALUE fl;
+	int default_flags = RB_SP_CLOEXEC(EPOLL_CLOEXEC);
+	int flags = rb_sp_get_flags(klass, _flags, default_flags);
+	int fd = epoll_create1(flags);
+	VALUE rv;
 
-	rb_scan_args(argc, argv, "01", &fl);
-	ep->flags = rb_sp_get_flags(self, fl);
-	my_epoll_create(ep);
-
-	return self;
-}
-
-static VALUE ctl(VALUE self, VALUE io, VALUE flags, int op)
-{
-	struct epoll_event event;
-	struct rb_epoll *ep = ep_get(self);
-	int fd = rb_sp_fileno(io);
-	int rv;
-
-	ep_check(ep);
-	event.events = rb_sp_get_uflags(self, flags);
-	pack_event_data(&event, io);
-
-	rv = epoll_ctl(ep->fd, op, fd, &event);
-	if (rv == -1) {
-		if (errno == ENOMEM) {
+	if (fd < 0) {
+		if (errno == EMFILE || errno == ENFILE || errno == ENOMEM) {
 			rb_gc();
-			rv = epoll_ctl(ep->fd, op, fd, &event);
+			fd = epoll_create1(flags);
 		}
-		if (rv == -1)
-			rb_sys_fail("epoll_ctl");
-	}
-	switch (op) {
-	case EPOLL_CTL_ADD:
-		rb_ary_store(ep->marks, fd, io);
-		/* fall-through */
-	case EPOLL_CTL_MOD:
-		flags = UINT2NUM(event.events);
-		rb_ary_store(ep->flag_cache, fd, flags);
-		break;
-	case EPOLL_CTL_DEL:
-		rb_ary_store(ep->marks, fd, Qnil);
-		rb_ary_store(ep->flag_cache, fd, Qnil);
+		if (fd < 0)
+			rb_sys_fail("epoll_create1");
 	}
 
-	return INT2NUM(rv);
+	rv = INT2FIX(fd);
+	return rb_call_super(1, &rv);
 }
 
 /*
  * call-seq:
- *	ep.set(io, flags)	-> 0
- *
- * Used to avoid exceptions when your app is too lazy to check
- * what state a descriptor is in, this sets the epoll descriptor
- * to watch an +io+ with the given +flags+
+ * 	epoll_io.epoll_ctl(op, io, events)	-> nil
  *
- * +flags+ may be an array of symbols or an unsigned Integer bit mask:
+ * Register, modify, or register a watch for a given +io+ for events.
  *
- * - flags = [ :IN, :ET ]
- * - flags = SleepyPenguin::Epoll::IN | SleepyPenguin::Epoll::ET
+ * +op+ may be one of +EPOLL_CTL_ADD+, +EPOLL_CTL_MOD+, or +EPOLL_CTL_DEL+
+ * +io+ is an IO object or one which proxies via the +to_io+ method.
+ * +events+ is an integer mask of events to watch for.
  *
- * See constants in Epoll for more information.
+ * Returns nil on success.
  */
-static VALUE set(VALUE self, VALUE io, VALUE flags)
+static VALUE epctl(VALUE self, VALUE _op, VALUE io, VALUE events)
 {
 	struct epoll_event event;
-	struct rb_epoll *ep = ep_get(self);
+	int epfd = rb_sp_fileno(self);
 	int fd = rb_sp_fileno(io);
+	int op = NUM2INT(_op);
 	int rv;
-	VALUE cur_io = rb_ary_entry(ep->marks, fd);
 
-	ep_check(ep);
-	event.events = rb_sp_get_uflags(self, flags);
+	event.events = NUM2UINT(events);
 	pack_event_data(&event, io);
 
-	if (cur_io == io) {
-		VALUE cur_flags = rb_ary_entry(ep->flag_cache, fd);
-		uint32_t cur_events;
-
-		assert(!NIL_P(cur_flags) && "cur_flags nil but cur_io is not");
-		cur_events = NUM2UINT(cur_flags);
-
-		if (!(cur_events & EPOLLONESHOT) && cur_events == event.events)
-			return Qnil;
-
-fallback_mod:
-		rv = epoll_ctl(ep->fd, EPOLL_CTL_MOD, fd, &event);
-		if (rv == -1) {
-			if (errno != ENOENT)
-				rb_sys_fail("epoll_ctl - mod");
-			errno = 0;
-			rb_warn("epoll flag_cache failed (mod -> add)");
-			goto fallback_add;
-		}
-	} else {
-fallback_add:
-		rv = epoll_ctl(ep->fd, EPOLL_CTL_ADD, fd, &event);
-		if (rv == -1) {
-			if (errno != EEXIST)
-				rb_sys_fail("epoll_ctl - add");
-			errno = 0;
-			rb_warn("epoll flag_cache failed (add -> mod)");
-			goto fallback_mod;
-		}
-		rb_ary_store(ep->marks, fd, io);
-	}
-	flags = UINT2NUM(event.events);
-	rb_ary_store(ep->flag_cache, fd, flags);
-
-	return INT2NUM(rv);
-}
-
-/*
- * call-seq:
- *	epoll.delete(io) -> io or nil
- *
- * Stops an +io+ object from being monitored.  This is like Epoll#del
- * but returns +nil+ on ENOENT instead of raising an error.  This is
- * useful for apps that do not care to track the status of an
- * epoll object itself.
- */
-static VALUE delete(VALUE self, VALUE io)
-{
-	struct rb_epoll *ep = ep_get(self);
-	int fd = rb_sp_fileno(io);
-	int rv;
-	VALUE cur_io;
-
-	ep_check(ep);
-	if (rb_sp_io_closed(io))
-		goto out;
-
-	cur_io = rb_ary_entry(ep->marks, fd);
-	if (NIL_P(cur_io) || rb_sp_io_closed(cur_io))
-		return Qnil;
-
-	rv = epoll_ctl(ep->fd, EPOLL_CTL_DEL, fd, NULL);
-	if (rv == -1) {
-		/* beware of IO.for_fd-created descriptors */
-		if (errno == ENOENT || errno == EBADF) {
-			errno = 0;
-			io = Qnil;
-		} else {
-			rb_sys_fail("epoll_ctl - del");
-		}
-	}
-out:
-	rb_ary_store(ep->marks, fd, Qnil);
-	rb_ary_store(ep->flag_cache, fd, Qnil);
+	rv = epoll_ctl(epfd, op, fd, &event);
+	if (rv < 0)
+		rb_sys_fail("epoll_ctl");
 
-	return io;
+	return Qnil;
 }
 
 static VALUE epwait_result(struct ep_per_thread *ept, int n)
@@ -342,7 +156,7 @@ static VALUE epwait_result(struct ep_per_thread *ept, int n)
 	struct epoll_event *epoll_event = ept->events;
 	VALUE obj_events, obj;
 
-	if (n == -1)
+	if (n < 0)
 		rb_sys_fail("epoll_wait");
 
 	for (i = n; --i >= 0; epoll_event++) {
@@ -358,7 +172,7 @@ static int epoll_resume_p(uint64_t expire_at, struct ep_per_thread *ept)
 {
 	uint64_t now;
 
-	ep_fd_check(ept->ep);
+	ep_fd_check(ept); /* may raise IOError */
 
 	if (errno != EINTR)
 		return 0;
@@ -369,326 +183,61 @@ static int epoll_resume_p(uint64_t expire_at, struct ep_per_thread *ept)
 	return 1;
 }
 
-#if defined(HAVE_RB_THREAD_BLOCKING_REGION)
 static VALUE nogvl_wait(void *args)
 {
 	struct ep_per_thread *ept = args;
-	int fd = ept->ep->fd;
-	int n = epoll_wait(fd, ept->events, ept->maxevents, ept->timeout);
+	int n = epoll_wait(ept->fd, ept->events, ept->maxevents, ept->timeout);
 
 	return (VALUE)n;
 }
 
 static VALUE real_epwait(struct ep_per_thread *ept)
 {
-	int n;
+	long n;
 	uint64_t expire_at = ept->timeout > 0 ? now_ms() + ept->timeout : 0;
 
 	do {
-		n = (int)rb_sp_fd_region(nogvl_wait, ept, ept->ep->fd);
-	} while (n == -1 && epoll_resume_p(expire_at, ept));
+		n = (long)rb_sp_fd_region(nogvl_wait, ept, ept->fd);
+	} while (n < 0 && epoll_resume_p(expire_at, ept));
 
-	return epwait_result(ept, n);
+	return epwait_result(ept, (int)n);
 }
-#else /* 1.8 Green thread compatible code */
-#  include "epoll_green.h"
-#endif /* 1.8 Green thread compatibility code */
 
 /*
  * call-seq:
- *	epoll.wait([maxevents[, timeout]]) { |flags, io| ... }
+ *	ep_io.epoll_wait([maxevents[, timeout]]) { |events, io| ... }
  *
- * Calls epoll_wait(2) and yields Integer +flags+ and IO objects watched
+ * Calls epoll_wait(2) and yields Integer +events+ and IO objects watched
  * for.  +maxevents+ is the maximum number of events to process at once,
- * lower numbers may prevent starvation when used by dup-ed Epoll objects
- * in multiple threads. +timeout+ is specified in milliseconds, +nil+
+ * lower numbers may prevent starvation when used by epoll_wait in multiple
+ * threads.  Larger +maxevents+ reduces syscall overhead for
+ * single-threaded applications. +maxevents+ defaults to 64 events.
+ * +timeout+ is specified in milliseconds, +nil+
  * (the default) meaning it will block and wait indefinitely.
  */
 static VALUE epwait(int argc, VALUE *argv, VALUE self)
 {
 	VALUE timeout, maxevents;
-	struct rb_epoll *ep = ep_get(self);
 	struct ep_per_thread *ept;
 
-	ep_check(ep);
 	rb_need_block();
 	rb_scan_args(argc, argv, "02", &maxevents, &timeout);
-	ept = ept_get(NIL_P(maxevents) ? 64 : NUM2INT(maxevents));
+
+	ept = ept_get(self, NIL_P(maxevents) ? 64 : NUM2INT(maxevents));
 	ept->timeout = NIL_P(timeout) ? -1 : NUM2INT(timeout);
-	ept->ep = ep;
 
 	return real_epwait(ept);
 }
 
-/*
- * call-seq:
- *	epoll.add(io, flags)	->  0
- *
- * Starts watching a given +io+ object with +flags+ which may be an Integer
- * bitmask or Array representing arrays to watch for.  Consider Epoll#set
- * instead as it is easier to use.
- */
-static VALUE add(VALUE self, VALUE io, VALUE flags)
-{
-	return ctl(self, io, flags, EPOLL_CTL_ADD);
-}
-
-/*
- * call-seq:
- *	epoll.del(io)	-> 0
- *
- * Disables an IO object from being watched.  Consider Epoll#delete as
- * it is easier to use.
- */
-static VALUE del(VALUE self, VALUE io)
-{
-	return ctl(self, io, INT2FIX(0), EPOLL_CTL_DEL);
-}
-
-/*
- * call-seq:
- *	epoll.mod(io, flags)	-> 0
- *
- * Changes the watch for an existing IO object based on +flags+.
- * Consider Epoll#set instead as it is easier to use.
- */
-static VALUE mod(VALUE self, VALUE io, VALUE flags)
+/* :nodoc: */
+static VALUE event_flags(VALUE self, VALUE flags)
 {
-	return ctl(self, io, flags, EPOLL_CTL_MOD);
-}
-
-/*
- * call-seq:
- *	epoll.to_io	-> Epoll::IO object
- *
- * Used to expose the given Epoll object as an Epoll::IO object for IO.select
- * or IO#stat.  This is unlikely to be useful directly, but is used internally
- * by IO.select.
- */
-static VALUE to_io(VALUE self)
-{
-	struct rb_epoll *ep = ep_get(self);
-
-	ep_check(ep);
-
-	if (NIL_P(ep->io))
-		ep->io = rb_funcall(cEpoll_IO, id_for_fd, 1, INT2NUM(ep->fd));
-
-	return ep->io;
-}
-
-/*
- * call-seq:
- *	epoll.close	-> nil
- *
- * Closes an existing Epoll object and returns memory back to the kernel.
- * Raises IOError if object is already closed.
- */
-static VALUE epclose(VALUE self)
-{
-	struct rb_epoll *ep = ep_get(self);
-
-	if (ep->fd >= 0) {
-		st_data_t key = ep->fd;
-		st_delete(active, &key, NULL);
-	}
-
-	if (NIL_P(ep->io)) {
-		ep_fd_check(ep);
-
-		if (ep->fd == EP_RECREATE) {
-			ep->fd = -1; /* success */
-		} else {
-			int err;
-			int fd = ep->fd;
-
-			ep->fd = -1;
-			rb_thread_fd_close(fd);
-			err = close(fd);
-			if (err == -1)
-				rb_sys_fail("close");
-		}
-	} else {
-		ep->fd = -1;
-		rb_io_close(ep->io);
-	}
-
-	return Qnil;
-}
-
-/*
- * call-seq:
- *	epoll.closed?	-> true or false
- *
- * Returns whether or not an Epoll object is closed.
- */
-static VALUE epclosed(VALUE self)
-{
-	struct rb_epoll *ep = ep_get(self);
-
-	return ep->fd == -1 ? Qtrue : Qfalse;
-}
-
-static int cloexec_dup(struct rb_epoll *ep)
-{
-#ifdef F_DUPFD_CLOEXEC
-	int flags = ep->flags & EPOLL_CLOEXEC ? F_DUPFD_CLOEXEC : F_DUPFD;
-	int fd = fcntl(ep->fd, flags, 0);
-#else /* potentially racy on GVL-free systems: */
-	int fd = dup(ep->fd);
-	if (fd >= 0)
-		(void)fcntl(fd, F_SETFD, FD_CLOEXEC);
-#endif
-	return fd;
-}
-
-/*
- * call-seq:
- *	epoll.dup	-> another Epoll object
- *
- * Duplicates an Epoll object and userspace buffers related to this library.
- * This allows the same epoll object in the Linux kernel to be safely used
- * across multiple native threads as long as there is one SleepyPenguin::Epoll
- * object per-thread.
- */
-static VALUE init_copy(VALUE copy, VALUE orig)
-{
-	struct rb_epoll *a = ep_get(orig);
-	struct rb_epoll *b = ep_get(copy);
-
-	assert(NIL_P(b->io) && "Ruby broken?");
-
-	ep_check(a);
-	assert(NIL_P(b->marks) && "mark array not nil");
-	assert(NIL_P(b->flag_cache) && "flag_cache not nil");
-	b->marks = a->marks;
-	b->flag_cache = a->flag_cache;
-	assert(TYPE(b->marks) == T_ARRAY && "mark array not initialized");
-	assert(TYPE(b->flag_cache) == T_ARRAY && "flag_cache not initialized");
-	b->flags = a->flags;
-	b->fd = cloexec_dup(a);
-	if (b->fd == -1) {
-		if (errno == ENFILE || errno == EMFILE) {
-			rb_gc();
-			b->fd = cloexec_dup(a);
-		}
-		if (b->fd == -1)
-			rb_sys_fail("dup");
-	}
-	st_insert(active, (st_data_t)b->fd, (st_data_t)b);
-
-	return copy;
-}
-
-/* occasionally it's still useful to lookup aliased IO objects
- * based on for debugging */
-static int my_fileno(VALUE obj)
-{
-	if (T_FIXNUM == TYPE(obj))
-		return FIX2INT(obj);
-	return rb_sp_fileno(obj);
-}
-
-/*
- * call-seq:
- *	epoll.io_for(io)	-> object
- *
- * Returns the given IO object currently being watched for.  Different
- * IO objects may internally refer to the same process file descriptor.
- * Mostly used for debugging.
- */
-static VALUE io_for(VALUE self, VALUE obj)
-{
-	struct rb_epoll *ep = ep_get(self);
-
-	return rb_ary_entry(ep->marks, my_fileno(obj));
-}
-
-/*
- * call-seq:
- *	epoll.flags_for(io)	-> Integer
- *
- * Returns the flags currently watched for in current Epoll object.
- * Mostly used for debugging.
- */
-static VALUE flags_for(VALUE self, VALUE obj)
-{
-	struct rb_epoll *ep = ep_get(self);
-
-	return rb_ary_entry(ep->flag_cache, my_fileno(obj));
-}
-
-/*
- * call-seq:
- *	epoll.include?(io) => true or false
- *
- * Returns whether or not a given IO is watched and prevented from being
- * garbage-collected by the current Epoll object.  This may include
- * closed IO objects.
- */
-static VALUE include_p(VALUE self, VALUE obj)
-{
-	struct rb_epoll *ep = ep_get(self);
-
-	return NIL_P(rb_ary_entry(ep->marks, my_fileno(obj))) ? Qfalse : Qtrue;
-}
-
-/*
- * we close (or lose to GC) epoll descriptors at fork to avoid leakage
- * and invalid objects being referenced later in the child
- */
-static int ep_atfork(st_data_t key, st_data_t value, void *ignored)
-{
-	struct rb_epoll *ep = (struct rb_epoll *)value;
-
-	if (NIL_P(ep->io)) {
-		if (ep->fd >= 0)
-			(void)close(ep->fd);
-	} else {
-		ep->io = Qnil; /* must let GC take care of it later :< */
-	}
-	ep->fd = EP_RECREATE;
-
-	return ST_CONTINUE;
-}
-
-static void atfork_child(void)
-{
-	st_table *old = active;
-
-	active = st_init_numtable();
-	st_foreach(old, ep_atfork, (st_data_t)NULL);
-	st_free_table(old);
-}
-
-static void epoll_once(void)
-{
-	int err = pthread_key_create(&epoll_key, free);
-
-	if (err) {
-		errno = err;
-		rb_sys_fail("pthread_key_create");
-	}
-
-	active = st_init_numtable();
-
-	if (pthread_atfork(NULL, NULL, atfork_child) != 0) {
-		rb_gc();
-		if (pthread_atfork(NULL, NULL, atfork_child) != 0)
-			rb_memerror();
-	}
+	return UINT2NUM(rb_sp_get_uflags(self, flags));
 }
 
 void sleepy_penguin_init_epoll(void)
 {
-	VALUE mSleepyPenguin, cEpoll;
-	pthread_once_t once = PTHREAD_ONCE_INIT;
-	int err = pthread_once(&once, epoll_once);
-
-	if (err) {
-		errno = err;
-		rb_sys_fail("pthread_once(.., epoll_once)");
-	}
+	VALUE mSleepyPenguin, cEpoll_IO;
 
 	/*
 	 * Document-module: SleepyPenguin
@@ -707,6 +256,7 @@ void sleepy_penguin_init_epoll(void)
 	 * And then access classes via:
 	 *
 	 * - SP::Epoll
+	 * - SP::Epoll::IO
 	 * - SP::EventFD
 	 * - SP::Inotify
 	 * - SP::TimerFD
@@ -716,36 +266,36 @@ void sleepy_penguin_init_epoll(void)
 	/*
 	 * Document-class: SleepyPenguin::Epoll
 	 *
-	 * The Epoll class provides access to epoll(7) functionality in the
-	 * Linux 2.6 kernel.  It provides fork and GC-safety for Ruby
-	 * objects stored within the IO object and may be passed as an
-	 * argument to IO.select.
+	 * The Epoll class provides high-level access to epoll(7)
+	 * functionality in the Linux 2.6 and later kernels.  It provides
+	 * fork and GC-safety for Ruby objects stored within the IO object
+	 * and may be passed as an argument to IO.select.
 	 */
 	cEpoll = rb_define_class_under(mSleepyPenguin, "Epoll", rb_cObject);
 
 	/*
 	 * Document-class: SleepyPenguin::Epoll::IO
 	 *
-	 * Epoll::IO is an internal class.  Its only purpose is to be
-	 * compatible with IO.select and related methods and should
-	 * never be used directly, use Epoll instead.
+	 * Epoll::IO is a low-level class.  It does not provide fork nor
+	 * GC-safety, so Ruby IO objects added via epoll_ctl must be retained
+	 * by the application until IO#close is called.
 	 */
 	cEpoll_IO = rb_define_class_under(cEpoll, "IO", rb_cIO);
-	rb_define_method(cEpoll, "initialize", init, -1);
-	rb_define_method(cEpoll, "initialize_copy", init_copy, 1);
-	rb_define_alloc_func(cEpoll, alloc);
-	rb_define_method(cEpoll, "to_io", to_io, 0);
-	rb_define_method(cEpoll, "close", epclose, 0);
-	rb_define_method(cEpoll, "closed?", epclosed, 0);
-	rb_define_method(cEpoll, "add", add, 2);
-	rb_define_method(cEpoll, "mod", mod, 2);
-	rb_define_method(cEpoll, "del", del, 1);
-	rb_define_method(cEpoll, "delete", delete, 1);
-	rb_define_method(cEpoll, "io_for", io_for, 1);
-	rb_define_method(cEpoll, "flags_for", flags_for, 1);
-	rb_define_method(cEpoll, "include?", include_p, 1);
-	rb_define_method(cEpoll, "set", set, 2);
-	rb_define_method(cEpoll, "wait", epwait, -1);
+	rb_define_singleton_method(cEpoll_IO, "new", s_new, 1);
+
+	rb_define_method(cEpoll_IO, "epoll_ctl", epctl, 3);
+	rb_define_method(cEpoll_IO, "epoll_wait", epwait, -1);
+
+	rb_define_method(cEpoll, "__event_flags", event_flags, 1);
+
+	/* registers an IO object via epoll_ctl */
+	rb_define_const(cEpoll, "CTL_ADD", INT2NUM(EPOLL_CTL_ADD));
+
+	/* unregisters an IO object via epoll_ctl */
+	rb_define_const(cEpoll, "CTL_DEL", INT2NUM(EPOLL_CTL_DEL));
+
+	/* modifies the registration of an IO object via epoll_ctl */
+	rb_define_const(cEpoll, "CTL_MOD", INT2NUM(EPOLL_CTL_MOD));
 
 	/* specifies whether close-on-exec flag is set for Epoll.new */
 	rb_define_const(cEpoll, "CLOEXEC", INT2NUM(EPOLL_CLOEXEC));
@@ -764,6 +314,15 @@ void sleepy_penguin_init_epoll(void)
 	rb_define_const(cEpoll, "RDHUP", UINT2NUM(EPOLLRDHUP));
 #endif
 
+#ifdef EPOLLWAKEUP
+	/*
+	 * This prevents system suspend while event is ready.
+	 * This requires the caller to have the CAP_BLOCK_SUSPEND capability
+	 * Available since Linux 3.5
+	 */
+	rb_define_const(cEpoll, "WAKEUP", UINT2NUM(EPOLLWAKEUP));
+#endif
+
 	/* watch for urgent read(2) data */
 	rb_define_const(cEpoll, "PRI", UINT2NUM(EPOLLPRI));
 
@@ -786,4 +345,7 @@ void sleepy_penguin_init_epoll(void)
 	rb_define_const(cEpoll, "ONESHOT", UINT2NUM(EPOLLONESHOT));
 
 	id_for_fd = rb_intern("for_fd");
+
+	if (RB_SP_GREEN_THREAD)
+		rb_require("sleepy_penguin/epoll/io");
 }