eio 0.1

data/LICENSE

@@ -0,0 +1,16 @@
+eio is copyrighted Free Software by all contributors, see logs in
+revision control for names and email addresses of all of them.
+
+You can redistribute it and/or modify it under the terms of the GNU
+Lesser General Public License as published by the Free Software Foundation,
+version 2.1 or later {LGPLv2.1}[http://www.gnu.org/licenses/lgpl-2.1.txt]
+(see link:COPYING).
+
+eio is distributed in the hope that it will be useful, but WITHOUT
+ANY WARRANTY; without even the implied warranty of 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

data/README.rdoc

@@ -0,0 +1,201 @@
+= eio - a libeio wrapper for Ruby
+
+(c) 2011 Lourens Naudé (methodmissing)
+
+  http://github.com/methodmissing/eio
+
+== Why you may need this
+
+Changing a file descriptor that references a normal file to non-blocking mode (O_NONBLOCK flag) have
+absolutely no effect. Regular files are always readable and always writable. Readability and writability
+checks will also succeed immediately. Such operations can however still block for a undefined amount of time - busy disks, slow disks (EBS) etc. and usually also include a chunk of disk seek time as well
+Manipulating directories, stat'ing files, changing permissions, ownership etc. is only defined through
+synchronous APIs. This is a major drawback for environments where throughput is critical and a high
+degree of interactivity is demanded at all times.
+
+== How it works
+
+A number of OS (pthread) threads is started to execute blocking I/O requests and signal their completion.
+The I/O operations will still block, but you're application's able to do something else and will be
+notified of completion status sometime in the future. This library wraps libeio
+(http://software.schmorp.de/pkg/libeio.html), which also powers node.js's FS module and supports both
+Ruby MRI 1.8 and 1.9.
+
+It's designed to run in a single threaded environment and libeio will manage a pool of OS threads,
+effectively scheduling out I/O ops across multiple cores. This is the same pattern very common in
+implementations of the Reactor Pattern (http://en.wikipedia.org/wiki/Reactor_pattern, Eventmachine) where
+I/O requests and callbacks are always submitted and handled on the reactor thread. This library thus
+naturally fits into event driven applications and exposes a file descriptor that can wake up an event
+loop when readable and execute callbacks for completed requests on the reactor thread as well.
+
+Event loop integration is however much closer to the Proactor Pattern (http://en.wikipedia.org/wiki/Proactor_pattern).
+The I/O multiplexer in a Reactor implementation merely notifies of file descriptor state changes - a
+handler is still responsible for reading or writing data on the reactor thread. Callbacks for file system
+and other blocking system calls wrapped by this library receive results as arguments - there's nothing
+else to do. Nothing to read, nothing to write, no system calls or other context switches. In other words,
+the Reactor pattern asynchronously notify of state changes, but act on those synchronously, on the
+Reactor thread, which incurs some processing overhead.
+
+In addition to wrapping known blocking system calls, libeio also expose several fallback implementations
+such as readahead, sendfile etc. and is also very effective with system calls that incur a lot of CPU
+overhead managing user space buffers, memcpy etc.
+
+== Sweet Spot
+
+This library solves a specific problem of avoiding blocking I/O work on POSIX APIs that traditionally
+don't support the O_NONBLOCK flag or only have a synchronous interface defined. As with most event driven
+I/O, the goal is increased throughput and not necessarily a faster per request guarantee. To serve more
+clients with the same or less infrastructure without degrading quality of service.
+
+== Requirements
+
+* A POSIX compliant OS, known to work well on Linux, BSD variants and Mac OS X
+* Ruby MRI 1.8 or 1.9
+* Platform that supports the __VA_ARGS__ macro.
+* It's recommended to use this library in conjunction with an event loop
+* Best results with I/O bound work on disks / volumes with variable performance characteristics, such as
+  Amazon EBS.
+
+== Installation
+
+Rubygems installation
+
+    gem install eio
+
+Building from source
+
+    git clone git@github.com:methodmissing/eio.git
+    rake compile:eio_ext
+
+Running tests
+
+    rake test
+
+== Documentation
+
+See http://methodmissing.github.com/eio for RDOC documentation.
+
+== How to - with an event loop
+
+The Eventmachine handler watches the read end of a pipe which wakes up the event loop whenever there's
+results to process. This is entirely driven from libeio which writes a char to the write end of the pipe
+to wake up the loop. The EIO.poll callback will fire as many times as it needs to as we don't read data from the pipe through the reactor. A separate callback invoked by libeio will read the char and clear
+it's readable state.
+
+    require 'eio/eventmachine'
+
+    EM.run do
+      EIO.eventmachine_handler # let libeio notify when there's result callbacks to invoke
+
+      EIO.open(__FILE__) do |fd|
+        EIO.read(fd) do |data|
+          p data
+          EIO.close{ EM.stop }
+        end
+      end
+    end
+
+== How to - manually drain the result queue
+
+This library ships with trivial Rack middleware that acts like a barrier at the end of each request. This
+pattern can be applied to any other context as well.
+
+    module EIO
+      class Middleware
+        def initialize(app, opts = {})
+           @app = app
+           @options = opts
+        end
+
+        def call(env)
+          ret = @app.call(env)
+          EIO.wait # flush the libeio request queue
+          ret
+        end
+      end
+    end
+
+    use EIO::Middleware
+
+The call to EIO.wait blocks until callbacks for all completed requests have been invoked. This workflow
+is comparable to a 100m race with each line representing a libeio request and EIO.wait being the
+finishing line / completion barrier. Each I/O operation may be scheduled on a different CPU core and will
+complete in parallel, proportional to the slowest request, with some minor overhead to boot.
+
+See the unit tests for further examples.
+
+== Configuration
+
+The thread pool can be configured for specific workloads. It's very important to schedule callback
+processing in small batches when integrating with an event loop to not block other work. Use
+EIO.max_poll_time and EIO.max_poll_request to restrict time spent or callbacks invoked per libeio
+notification.
+
+    # Set the maximum amount of time spent in each eio_poll() invocation
+    EIO.max_poll_time = 0.1
+
+    # Set the maximum number of requests by each eio_poll() invocation
+    EIO.max_poll_reqs = x
+
+Hundreds of threads can be spawned, however do note that stack sizes vary significantly between
+platforms and this will most definitely affect your memory footprint. The default pool size is 8
+threads.
+
+    # Set the minimum number of libeio threads to run in parallel. default: 8
+    EIO.min_parallel = x
+
+    # Set the maximum number of AIO threads to run in parallel. default: 8
+    EIO.max_parallel = x
+
+    # Limit the number of threads allowed to be idle
+    EIO.max_idle = x
+
+    # Set the minimum idle timeout before a thread is allowed to exit
+    EIO.idle_timeout = x
+
+== Visibility
+
+A simple API for integration with monitoring infrastructure's exposed as well. These stats may not be
+very insightful or even accurate for a small number of in flight requests.
+
+    # Number of requests currently in the ready, execute or pending states
+    EIO.requests
+
+    # Number of requests currently in the ready state (not yet executed)
+    EIO.ready
+
+    # Number of requests currently in the pending state
+    EIO.pending
+
+    # Number of worker threads spawned
+    EIO.threads
+
+== Managing requests
+
+Use the following methods for manually scheduling request processing.
+
+    # Read end of the pipe an event loop can monitor for readability
+    EIO.fd
+
+    # Called when pending requests need finishing. The amount of work done is controlled by
+    # EIO.max_poll_time and EIO.max_poll_requests
+    EIO.poll
+
+    # Drain / flush all pending requests. This method blocks until all requests have been processed,
+    # regardless of configuration constraints imposed on requests per EIO.poll invocation.
+    EIO.wait
+
+== Todo
+
+* Finer grained priority support, especially stacked open, read etc.
+* Grouped requests
+* Richer EIO::Request API
+* Implement and support all libeio wrapped syscalls
+* Better guidelines for optimal configuration and tuning
+
+== Contact, feedback and bugs
+
+This project is very much work in progress and I'm looking for guidance on API design, use cases and
+any outlier experiences. Please log bugs and suggestions at https://github.com/methodmissing/eio/issues
+
+Thanks !

data/Rakefile

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'rake/extensiontask'
+require 'rake/testtask'
+require 'rdoc/task'
+
+spec = eval(IO.read('eio.gemspec'))
+
+task :compile => :build_libeio
+task :clobber => :clobber_libeio
+
+Rake::ExtensionTask.new('eio', spec) do |ext|
+  ext.name = 'eio_ext'
+  ext.ext_dir = 'ext/eio'
+end
+
+task :clobber_libeio do
+  Dir.chdir "ext/libeio" do
+    sh "make clean"
+  end
+end
+
+task :build_libeio do
+  Dir.chdir "ext/libeio" do
+    sh "./autogen.sh"
+    sh "./configure"
+    sh "make"
+  end unless File.exist?("ext/libeio/.libs/eio.o")
+end
+
+RDOC_FILES = FileList["README.rdoc", "ext/eio/eio_ext.c", "lib/eio.rb", "lib/eio/eventmachine.rb", "lib/eio/middleware.rb"]
+
+Rake::RDocTask.new do |rd|
+  rd.title = "eio - a libeio wrapper for Ruby"
+  rd.main = "README.rdoc"
+  rd.rdoc_dir = "doc"
+  rd.rdoc_files.include(RDOC_FILES)
+end
+
+desc 'Run EIO tests'
+Rake::TestTask.new(:test) do |t|
+  t.pattern = "test/test_*.rb"
+  t.verbose = true
+  t.warning = true
+end
+task :test => :compile
+
+task :default => :test

data/bench/eventmachine.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+
+$:.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+require 'eio'
+require 'rubygems'
+require 'eio/eventmachine'
+
+EM.kqueue
+EM.set_descriptor_table_size 10_000
+
+class SyncIoConnection < EM::Connection
+  def self.stop
+    EM.stop
+  end
+
+  # Syncronous I/O during request lifetime
+  def receive_data(data)
+    start = EM.current_time
+    f = File.open(__FILE__)
+    f.read
+    Dir.entries(File.dirname(__FILE__))
+    f.close
+    send_data (Time.now - start).to_f
+    close_connection_after_writing
+  end
+end
+
+class AsyncIoConnection < EM::Connection
+  def self.stop
+    EIO.wait
+    EM.stop
+  end
+
+  # Asyncronous I/O during request lifetime - request finish before all work's complete
+  def receive_data(data)
+    start = EM.current_time
+    EIO.open(__FILE__) do |fd|
+      EIO.read(fd) do |buf|
+        EIO.readdir(File.dirname(__FILE__)) do |entries|
+          EIO.close(fd){ close_connection }
+        end
+      end
+    end
+    send_data (Time.now - start).to_f
+  end
+end
+
+class IoClient < EM::Connection
+  REQ_TIMINGS = []
+  WORK_TIMINGS = []
+
+  def self.stats(ctx, conns)
+    puts SEP_STR
+    puts FMT_STR % ["#{ctx} (#{conns} conns)"].concat(stats_for(REQ_TIMINGS)).concat(stats_for(WORK_TIMINGS))
+    EM.stop
+  end
+
+  def send_data(data)
+    @start = Time.now
+    super
+  end
+
+  def receive_data(data)
+    REQ_TIMINGS << data.to_f
+  end
+
+  def unbind
+    WORK_TIMINGS << (Time.now - @start).to_f
+  end
+
+  private
+  def self.stats_for(feature)
+    total = feature.inject(0){|a,i|a + i}
+    avg = (total / feature.size).to_f
+    feature.minmax.concat([avg, total])
+  ensure
+    feature.clear
+  end
+end
+
+def sync_io_server(conns)
+  conn = SyncIoConnection
+  EM.fork_reactor do
+    trap(:TERM){ conn.stop }
+    EM.start_server("0.0.0.0", 8000, conn)
+  end
+end
+
+def async_io_server(conns)
+  conn = AsyncIoConnection
+  EM.fork_reactor do
+    EIO.max_idle = conns / 10
+    EIO.min_parallel = conns / 10
+    EIO.max_parallel = conns / 20
+    EIO.max_poll_reqs = conns / 50
+
+    trap(:TERM){ conn.stop }
+    EIO.eventmachine_handler
+    EM.start_server("0.0.0.0", 8000, conn)
+  end
+end
+
+def run(server, conns = 300)
+  server_pid = send(server, conns)
+  EM.run do
+    EM.add_timer((conns / 50) + 0.5){ IoClient.stats(server, conns) }
+    conns.times do
+      c = EM.connect("0.0.0.0", 8000, IoClient)
+      c.send_data('*')
+    end
+  end
+ensure
+  Process.kill(:TERM, server_pid)
+  sleep 1
+end
+
+HEADINGS = [ 'Context', 'Min req time', 'Max req time', 'Avg req time', 'Total req time',
+             'Min work time', 'Max work time', 'Avg work time', 'Total work time']
+FMT_STR = "| %-30s | %-12.5f | %-12.5f | %-12.5f | %-14.5f | %-13.5f | %-13.5f | %-13.5f | %-15.5f |"
+SEP_STR = "|#{'-' * 160}|"
+
+puts SEP_STR
+puts "| %-30s | %-12s | %-12s | %-12s | %-14s | %-13s | %-13s | %-13s | %-15s |" % HEADINGS
+
+run :sync_io_server, 100
+run :async_io_server, 100
+
+run :sync_io_server, 200
+run :async_io_server, 200
+
+run :sync_io_server, 300
+run :async_io_server, 300
+
+puts SEP_STR

data/eio.gemspec

@@ -0,0 +1,17 @@
+Gem::Specification.new do |s|
+  s.name = "eio"
+  s.version = defined?(EIO) ? EIO::VERSION : (ENV['VERSION'] || '0.1')
+  s.summary = "eio - a libeio wrapper for Ruby"
+  s.description = "eio - a libeio wrapper for Ruby"
+  s.authors = ["Lourens Naudé"]
+  s.email = ["lourens@methodmissing.com"]
+  s.homepage = "http://github.com/methodmissing/eio"
+  s.date = Time.now.utc.strftime('%Y-%m-%d')
+  s.platform = Gem::Platform::RUBY
+  s.extensions = Dir["ext/eio/extconf.rb"]
+  s.has_rdoc = true
+  s.files = `git ls-files`.split
+  s.test_files = Dir['test/test_*.rb']
+  s.add_development_dependency('rake-compiler', '~> 0.7.7')
+  s.add_development_dependency('eventmachine', '~> 0.12.3')
+end

data/ext/eio/eio_ext.c

@@ -0,0 +1,1447 @@
+#define EIO_REQ_MEMBERS short int complete;
+
+#include "../libeio/config.h"
+#include "../libeio/eio.h"
+#include "../libeio/xthread.h"
+#include "../libeio/eio.c"
+#include "ruby.h"
+
+/*
+ *  Ruby 1.9 specific macros
+ */
+#ifdef RUBY_VM
+#include <ruby/encoding.h>
+#include <ruby/io.h>
+#define NO_CB_ARGS 0
+#define EioEncode(str) rb_enc_associate(str, rb_default_internal_encoding())
+#define TRAP_BEG
+#define TRAP_END
+static size_t
+stat_memsize(const void *p)
+{
+   return p ? sizeof(struct stat) : 0;
+}
+
+static const rb_data_type_t stat_data_type = {
+    "stat",
+    {NULL, RUBY_TYPED_DEFAULT_FREE, stat_memsize,},
+};
+#else
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(str) RSTRING(str)->ptr
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+#include "rubyio.h"
+#include "rubysig.h"
+#define NO_CB_ARGS -1
+#define EioEncode(str) str
+#endif
+
+/*
+ *  Synchronous I/O fallback
+ */
+#define s_fsync fsync
+#define s_open open
+#define s_close close
+#define s_readahead(fd, len, off) read(fd, off, len)
+#define s_sendfile eio_sendfile_sync
+#define s_mkdir mkdir
+#define s_rmdir rmdir
+#define s_unlink unlink
+#define s_rename rename
+#define s_chmod chmod
+#define s_fchmod fchmod
+#define s_ftruncate ftruncate
+#define s_truncate truncate
+#define s_chown chown
+#define s_fchown fchown
+#define s_link link
+#define s_symlink symlink
+
+VALUE mEio;
+VALUE cEioReq;
+
+/*
+ *  Symbols
+ */
+static VALUE sym_call;
+static VALUE sym_arity;
+static VALUE sym_pipe;
+static VALUE sym_readlink;
+static VALUE sym_stat;
+static VALUE sym_pipe_r_fd;
+static VALUE sym_pipe_w_fd;
+
+/*
+ *  Common fixnums
+ */
+static VALUE eio_zero;
+static VALUE eio_default_bufsize;
+static VALUE eio_default_mode;
+
+/*
+ *  Pipe r / w fds
+ */
+static int eio_pipe_r_fd;
+static int eio_pipe_w_fd;
+
+static void rb_eio_recreate_pipe(void);
+static VALUE rb_eio_wrap_request(eio_req *r);
+
+/*
+ *  Assert a valid Proc and arity as callback
+ */
+#define AssertCallback(cb, arity) \
+    if (NIL_P(cb)) cb = proc; \
+    if (!NIL_P(cb)){ \
+        if (rb_class_of(cb) != rb_cProc) \
+            rb_raise(rb_eTypeError, "Expected a Proc callback"); \
+        if (rb_funcall(cb, sym_arity, 0) != INT2NUM(arity)) \
+          rb_raise(rb_eArgError, "Callback expects %d argument(s), got %d", arity, FIX2INT(rb_funcall(cb, sym_arity, 0))); \
+    }
+
+/*
+ *  Wrap the eio_req struct for a given object. Raises TypeError if the struct has been recycled by
+ *  a libeio finish callback.
+ */
+#define GetRequest(obj) \
+    eio_req * req; \
+    Data_Get_Struct(obj, eio_req, req); \
+    if (!req) rb_raise(rb_eTypeError, "uninitialized EIO::Request");
+
+/*
+ *  libeio callback handler. Respects cancelled requests and bubbles up any errors (-1 results).
+ */
+#define EioCallback(req, statements) \
+    VALUE cb; \
+    assert(req); \
+    cb = (VALUE)req->data; \
+    if EIO_CANCELLED(req){ \
+        rb_gc_unregister_address(&cb); \
+        return 0; \
+    } \
+    if (req->result == -1){ \
+         rb_gc_unregister_address(&cb); \
+         errno = req->errorno; \
+         req->complete = 1; \
+         (!req->ptr1) ? rb_sys_fail(0) : rb_sys_fail(req->ptr1); \
+         return -1; \
+    } else { \
+        if (!NIL_P(cb)){ \
+            statements; \
+            req->complete = 1; \
+            rb_gc_unregister_address(&cb); \
+        } \
+    } \
+    return 0;
+
+/*
+ *  Synchronous I/O request
+ */
+#define SyncRequest(statements) \
+    if (!rb_block_given_p()){ \
+        TRAP_BEG; \
+        statements; \
+        TRAP_END; \
+    }
+
+/*
+ *  Asynchronous I/O request
+ */
+#define AsyncRequest(syscall, callback, ...) \
+    if (rb_thread_current() != rb_thread_main()) \
+        rb_raise(rb_eThreadError, "EIO requests can only be submitted on the main thread."); \
+    rb_gc_register_address(&cb); \
+    return rb_eio_wrap_request(eio_ ## syscall(__VA_ARGS__, EIO_PRI_DEFAULT, callback, (void*)cb)); \
+
+/*
+ *  Abstraction for conditional sync / async I/O
+ */
+#define SubmitRequest(syscall, callback, ...) \
+    if (rb_block_given_p()){ \
+        AsyncRequest(syscall, callback, ##__VA_ARGS__); \
+    } else { \
+        TRAP_BEG; \
+        ret = s_ ## syscall(__VA_ARGS__); \
+        TRAP_END; \
+        if (ret == -1) rb_sys_fail(#syscall); \
+        return INT2NUM(ret); \
+    }
+
+/*
+ *  Callback for when libeio wants attention. Writes a char to pipe to wake up the event loop.
+ */
+static void
+want_poll(void)
+{
+    char heartbeat;
+    assert(write(eio_pipe_w_fd, &heartbeat, 1) == 1);
+}
+
+/*
+ *  Callback invoked when all pending work's been done. Reads a char from the pipe.
+ */
+static void
+done_poll(void)
+{
+    char heartbeat;
+    assert(read(eio_pipe_r_fd, &heartbeat, 1) == 1);
+}
+
+/*
+ *  Drain all pending libeio requests
+ */
+static void
+rb_eio_s_wait0()
+{
+    fd_set rdset;
+    int fd, size;
+    fd = eio_pipe_r_fd;
+
+    while (eio_nreqs())
+    {
+        X_LOCK(reslock);
+        size = res_queue.size;
+        X_UNLOCK(reslock);
+
+        if (size) return;
+
+        etp_maybe_start_thread();
+
+        FD_ZERO(&rdset);
+        FD_SET(fd, &rdset);
+        if (rb_thread_select(fd + 1, &rdset, NULL, NULL, NULL) < 0) rb_sys_fail(0);
+    }
+}
+
+/*
+ *  Generic callback, invoked with no args
+ */
+int
+rb_eio_generic_cb(eio_req *req)
+{
+    EioCallback(req,{
+        rb_funcall(cb, sym_call, 0);
+    });
+}
+
+/*
+ *  Open callback, invoked with a single Fixnum arg
+ */
+int
+rb_eio_open_cb(eio_req *req)
+{
+    EioCallback(req,{
+        rb_funcall(cb, sym_call, 1, INT2NUM(EIO_RESULT(req)));
+    });
+}
+
+/*
+ *  Read callback, invoked with a single String arg
+ */
+int
+rb_eio_read_cb(eio_req *req)
+{
+    EioCallback(req,{
+        rb_funcall(cb, sym_call, 1, EioEncode(rb_str_new((const char*)EIO_BUF(req), EIO_RESULT(req))));
+    });
+}
+
+/*
+ *  Readdir callback, invoked with a single Array arg
+ */
+int
+rb_eio_readdir_cb(eio_req *req)
+{
+    int ret;
+    VALUE result;
+    char *entries;
+    EioCallback(req, {
+        result = rb_ary_new2(EIO_RESULT(req));
+        entries = (char *)EIO_BUF(req);
+        while (EIO_RESULT(req)--)
+        {
+            rb_ary_push(result, EioEncode(rb_str_new2(entries)));
+            entries += strlen(entries) + 1;
+        }
+        rb_funcall(cb, sym_call, 1, result);
+    });
+}
+
+/*
+ *  Write callback, invoked with a single Fixnum arg
+ */
+int
+rb_eio_write_cb(eio_req *req)
+{
+    EioCallback(req,{
+        rb_funcall(cb, sym_call, 1, INT2NUM(EIO_RESULT(req)));
+    });
+}
+
+/*
+ *  Stat callback, invoked with a single File::Stat arg
+ */
+int
+rb_eio_stat_cb(eio_req *req)
+{
+    EioCallback(req,{
+#ifdef RUBY_VM
+        rb_funcall(cb, sym_call, 1, TypedData_Wrap_Struct(rb_cStat, &stat_data_type, EIO_BUF(req)));
+#else
+        rb_funcall(cb, sym_call, 1, Data_Wrap_Struct(rb_cStat, NULL, NULL, EIO_BUF(req)));
+#endif
+    });
+}
+
+/*
+ *  call-seq:
+ *     EIO.wait                    =>  nil
+ * 
+ *  Drain / flush all pending requests - BLOCKS
+ *
+ */
+static VALUE
+rb_eio_s_wait(VALUE eio)
+{
+    int res;
+    eio_req *req;
+    req = eio_sync(EIO_PRI_DEFAULT, NULL, NULL);
+    assert(req);
+    while (eio_nreqs())
+    {
+        rb_eio_s_wait0();
+        res = eio_poll();
+        if (res > 0) rb_sys_fail("eio_poll");
+    }
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     EIO.poll                    =>  Fixnum
+ *
+ *  Called when pending requests need finishing
+ *
+ */
+static VALUE
+rb_eio_s_poll(VALUE eio)
+{
+    int res;
+    res = eio_poll();
+    if (res > 0) rb_sys_fail("eio_poll");
+    return INT2NUM(res);
+}
+
+/*
+ *  call-seq:
+ *     EIO.requests                 =>  Fixnum
+ *
+ *  Number of requests currently in the ready, execute or pending states
+ *
+ */
+static VALUE
+rb_eio_s_requests(VALUE eio)
+{
+    return INT2NUM(eio_nreqs());
+}
+
+/*
+ *  call-seq:
+ *     EIO.ready                 =>  Fixnum
+ *
+ *  Number of requests currently in the ready state (not yet executed)
+ *
+ */
+static VALUE
+rb_eio_s_ready(VALUE eio)
+{
+    return INT2NUM(eio_nready());
+}
+
+/*
+ *  call-seq:
+ *     EIO.pending                 =>  Fixnum
+ *
+ *  Number of requests currently in the pending state
+ *
+ */
+static VALUE
+rb_eio_s_pending(VALUE eio)
+{
+    return INT2NUM(eio_npending());
+}
+
+/*
+ *  call-seq:
+ *     EIO.threads                 =>  Fixnum
+ *
+ *  Number of worker threads spawned
+ *
+ */
+static VALUE
+rb_eio_s_threads(VALUE eio)
+{
+    return INT2NUM(eio_nthreads());
+}
+
+/*
+ *  call-seq:
+ *     EIO.fd                 =>  Fixnum
+ *
+ *  Read end of the pipe an event loop can monitor for readability
+ *
+ */
+static VALUE
+rb_eio_s_fd(VALUE eio)
+{
+    return INT2NUM(eio_pipe_r_fd);
+}
+
+/*
+ *  call-seq:
+ *     EIO.max_poll_time = x                 =>  Fixnum
+ *
+ *  Set the maximum amount of time spent in each eio_poll() invocation
+ *
+ */
+static VALUE
+rb_eio_s_set_max_poll_time(VALUE eio, VALUE seconds)
+{
+    eio_set_max_poll_time(FIX2LONG(seconds));
+    return seconds;
+}
+
+/*
+ *  call-seq:
+ *     EIO.max_poll_reqs = x                 =>  Fixnum
+ *
+ *  Set the maximum number of requests by each eio_poll() invocation
+ *
+ */
+static VALUE
+rb_eio_s_set_max_poll_reqs(VALUE eio, VALUE requests)
+{
+    eio_set_max_poll_reqs(FIX2INT(requests));
+    return requests;
+}
+
+/*
+ *  call-seq:
+ *     EIO.min_parallel = x                 =>  Fixnum
+ *
+ *  Set the minimum number of libeio threads to run in parallel. default: 8
+ *
+ */
+static VALUE
+rb_eio_s_set_min_parallel(VALUE eio, VALUE threads)
+{
+    eio_set_min_parallel(FIX2INT(threads));
+    return threads;
+}
+
+/*
+ *  call-seq:
+ *     EIO.max_parallel = x                 =>  Fixnum
+ *
+ *  Set the maximum number of AIO threads to run in parallel. default: 8
+ *
+ */
+static VALUE
+rb_eio_s_set_max_parallel(VALUE eio, VALUE threads)
+{
+    eio_set_max_parallel(FIX2INT(threads));
+    return threads;
+}
+
+/*
+ *  call-seq:
+ *     EIO.max_idle = x                 =>  Fixnum
+ *
+ *  Limit the number of threads allowed to be idle
+ *
+ */
+static VALUE
+rb_eio_s_set_max_idle(VALUE eio, VALUE threads)
+{
+    eio_set_max_idle(FIX2INT(threads));
+    return threads;
+}
+
+/*
+ *  call-seq:
+ *     EIO.idle_timeout = x                 =>  Fixnum
+ *
+ *  Set the minimum idle timeout before a thread is allowed to exit
+ *
+ */
+static VALUE
+rb_eio_s_set_idle_timeout(VALUE eio, VALUE seconds)
+{
+    eio_set_idle_timeout(FIX2INT(seconds));
+    return seconds;
+}
+
+/*
+ *  call-seq:
+ *     EIO.open('/path/file'){|fd| p fd }                    =>  EIO::Request
+ *
+ *  Asynchronously open or create a file and call the callback with a newly created file handle
+ *  for the file.
+ *
+ * === Examples
+ *     EIO.open('/path/file', EIO::RDONLY){|fd| p fd }       =>  EIO::Request
+ *     EIO.open('/path/file', EIO::RDWR, 0777){|fd| p fd }   =>  EIO::Request
+ *     cb = Proc.new{|fd| p fd }
+ *     EIO.open('/path/file', EIO::RDWR, 0777, cb)           =>  EIO::Request
+ *
+ *     EIO.open('/path/file')                                =>  Fixnum
+ *     EIO.open('/path/file', EIO::RDWR)                     =>  Fixnum
+ *     EIO.open('/path/file', EIO::RDWR, 0777)               =>  Fixnum
+ *
+ */
+static VALUE
+rb_eio_s_open(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE path, flags, mode, proc, cb;
+    rb_scan_args(argc, argv, "13&", &path, &flags, &mode, &proc, &cb);
+    AssertCallback(cb, 1);
+    Check_Type(path, T_STRING);
+    if (NIL_P(flags)) flags = INT2NUM(O_RDONLY);
+    Check_Type(flags, T_FIXNUM);
+    if (NIL_P(mode)) mode = eio_default_mode;
+    Check_Type(mode, T_FIXNUM);
+    SubmitRequest(open, rb_eio_open_cb, StringValueCStr(path), FIX2INT(flags), FIX2INT(mode));
+}
+
+/*
+ *  call-seq:
+ *     EIO.close(fd){ p :closed }  =>  EIO::Request
+ *
+ *  Asynchronously close a file and call the callback with the result code.
+ *
+ * === Examples
+ *     cb = Proc.new{ p :closed }
+ *     EIO.close(fd, cb)           =>  EIO::Request
+ *
+ *     EIO.close(fd)               =>  Fixnum
+ *
+ */
+static VALUE
+rb_eio_s_close(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE fd, proc, cb;
+    rb_scan_args(argc, argv, "11&", &fd, &proc, &cb);
+    AssertCallback(cb, NO_CB_ARGS);
+    Check_Type(fd, T_FIXNUM);
+    SubmitRequest(close, rb_eio_generic_cb, FIX2INT(fd));
+}
+
+/*
+ *  call-seq:
+ *     EIO.fsync(fd){ p :synced }  =>  EIO::Request
+ *
+ *  Asynchronously call fsync on the given filehandle and call the callback with the result
+ *  code.
+ *
+ * === Examples
+ *     cb = Proc.new{ p :synced }
+ *     EIO.fsync(fd, cb)           =>  EIO::Request
+ *
+ *     EIO.fsync(fd)               =>  Fixnum
+ *
+ */
+static VALUE
+rb_eio_s_fsync(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE fd, proc, cb;
+    rb_scan_args(argc, argv, "11&", &fd, &proc, &cb);
+    AssertCallback(cb, NO_CB_ARGS);
+    Check_Type(fd, T_FIXNUM);
+    SubmitRequest(fsync, rb_eio_generic_cb, FIX2INT(fd));
+}
+
+/*
+ *  call-seq:
+ *     EIO.fdatasync(fd){ p :synced }  =>  EIO::Request
+ *
+ *  Asynchronously call fdatasync on the given filehandle and call the callback with the result
+ *  code.
+ *
+ * === Examples
+ *     cb = Proc.new{ p :synced }
+ *     EIO.fdatasync(fd, cb)           =>  EIO::Request
+ *
+ *     EIO.fdatasync(fd)               =>  Fixnum
+ *
+ */
+static VALUE
+rb_eio_s_fdatasync(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE fd, proc, cb;
+    rb_scan_args(argc, argv, "11&", &fd, &proc, &cb);
+    AssertCallback(cb, NO_CB_ARGS);
+    Check_Type(fd, T_FIXNUM);
+    SyncRequest({
+#if HAVE_FDATASYNC
+       ret = fdatasync(FIX2INT(fd));
+#else
+       ret = fsync(FIX2INT(fd));
+#endif
+       if (ret == -1) rb_sys_fail("fdatasync");
+       return INT2NUM(ret);
+    });
+    AsyncRequest(fdatasync, rb_eio_generic_cb, FIX2INT(fd));
+}
+
+/*
+ *  call-seq:
+ *     EIO.read(fd){|d| p d }           =>  EIO::Request
+ *
+ *  Asynchronously reads length bytes from a specified offset into a buffer.
+ *
+ * === Examples
+ *     EIO.read(fd, 100){|d| p d }      =>  EIO::Request
+ *     EIO.read(fd, 100, 50){|d| p d }  =>  EIO::Request
+ *     cb = Proc.new{|d| p d }
+ *     EIO.read(fd, 100, 50, cb)        =>  EIO::Request
+ *
+ *     EIO.read(fd)                     =>  String
+ *     EIO.read(fd, 100)                =>  String
+ *     EIO.read(fd, 100, 50)            =>  String
+ *
+ */
+static VALUE
+rb_eio_s_read(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE fd, len, offset, proc, cb;
+    VALUE buf;
+    rb_scan_args(argc, argv, "13&", &fd, &len, &offset, &proc, &cb);
+    AssertCallback(cb, 1);
+    Check_Type(fd, T_FIXNUM);
+    if (NIL_P(len)) len = eio_default_bufsize;
+    Check_Type(len, T_FIXNUM);
+    if (len == eio_zero) len = eio_default_bufsize;
+    if (NIL_P(offset)) offset = eio_zero;
+    Check_Type(offset, T_FIXNUM);
+    SyncRequest({
+        buf = rb_str_new(0, FIX2INT(len));
+        if (offset == eio_zero){
+            ret = read(FIX2INT(fd), RSTRING_PTR(buf), FIX2INT(len));
+        } else {
+            ret = pread(FIX2INT(fd), RSTRING_PTR(buf), FIX2INT(len), FIX2INT(offset));
+        }
+        if (ret == -1) rb_sys_fail("read");
+        return buf;
+    });
+    AsyncRequest(read, rb_eio_read_cb, FIX2INT(fd), 0, FIX2INT(len), FIX2INT(offset));
+}
+
+/*
+ *  call-seq:
+ *     EIO.readahead(fd){|d| p :read }        =>  EIO::Request
+ *
+ *  Populates the page cache with data from a file so that subsequent reads from that file will
+ *  not block on disk I/O.
+ *
+ * === Examples
+ *     EIO.readahead(fd, 100){|d| p :read }   =>  EIO::Request
+ *     EIO.readahead(fd, 100, 50){ p :read }  =>  EIO::Request
+ *     cb = Proc.new{ p :read }
+ *     EIO.readahead(fd, 100, 50, cb)         =>  EIO::Request
+ *
+ *     EIO.readahead(fd)                      =>  Fixnum
+ *     EIO.readahead(fd, 100)                 =>  Fixnum
+ *     EIO.readahead(fd, 100, 50)             =>  Fixnum
+ *
+ */
+static VALUE
+rb_eio_s_readahead(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE fd, len, offset, proc, cb;
+    rb_scan_args(argc, argv, "13&", &fd, &len, &offset, &proc, &cb);
+    AssertCallback(cb, NO_CB_ARGS);
+    Check_Type(fd, T_FIXNUM);
+    if (NIL_P(len)) len = eio_default_bufsize;
+    Check_Type(len, T_FIXNUM);
+    if (len == eio_zero) len = eio_default_bufsize;
+    if (NIL_P(offset)) offset = eio_zero;
+    Check_Type(offset, T_FIXNUM);
+    SubmitRequest(readahead, rb_eio_generic_cb, FIX2INT(fd), FIX2INT(offset), FIX2INT(len));
+}
+
+/*
+ *  call-seq:
+ *     EIO.write(fd, buf){|b| p b }           =>  EIO::Request
+ *
+ *  Asynchronously writes length bytes from a specified offset into a buffer.
+ *
+ * === Examples
+ *     EIO.write(fd, buf, 100){|b| p b }      =>  EIO::Request
+ *     EIO.write(fd, buf, 100, 50){|b| p b }  =>  EIO::Request
+ *     cb = Proc.new{|b| p b }
+ *     EIO.write(fd, buf, 100, 50, cb)        =>  EIO::Request
+ *
+ *     EIO.write(fd, buf)                     =>  Fixnum
+ *     EIO.write(fd, buf, 100)                =>  Fixnum
+ *     EIO.write(fd, buf, 100, 50)            =>  Fixnum
+ *
+ */
+static VALUE
+rb_eio_s_write(int argc, VALUE *argv, VALUE eio)
+{
+    int ret, i_len, i_offset;
+    VALUE fd, buf, len, offset, proc, cb, buf_len;
+    rb_scan_args(argc, argv, "23&", &fd, &buf, &len, &offset, &proc, &cb);
+    AssertCallback(cb, 1);
+    Check_Type(fd, T_FIXNUM);
+    Check_Type(buf, T_STRING);
+    if (NIL_P(len)) len = INT2NUM(RSTRING_LEN(buf));
+    Check_Type(len, T_FIXNUM);
+    if (NIL_P(offset)) offset = eio_zero;
+    Check_Type(offset, T_FIXNUM);
+    i_offset = FIX2INT(offset);
+    i_len = FIX2INT(len);
+    if (i_offset >= RSTRING_LEN(buf)) rb_raise(rb_eArgError, "out of bounds offset");
+    if ((i_offset + i_len) > RSTRING_LEN(buf)) rb_raise(rb_eArgError, "length extends beyond buffer");
+    SyncRequest({
+        if (offset == eio_zero){
+            ret = write(FIX2INT(fd), StringValueCStr(buf), i_len);
+        } else {
+            ret = pwrite(FIX2INT(fd), StringValueCStr(buf), i_len, i_offset);
+        }
+        if (ret == -1) rb_sys_fail("write");
+        return INT2NUM(ret);
+    });
+    AsyncRequest(write, rb_eio_write_cb, FIX2INT(fd), StringValueCStr(buf), i_len, i_offset);
+}
+
+/*
+ *  call-seq:
+ *     EIO.sendfile(in_fd, out_fd){|b| p b }           =>  EIO::Request
+ *
+ *  Tries to copy length bytes from in fd to out fd, starting at a given offset.
+ *
+ * === Examples
+ *     EIO.sendfile(in_fd, out_fd, 100){|b| p b }      =>  EIO::Request
+ *     EIO.sendfile(in_fd, out_fd, 100, 50){|b| p b }  =>  EIO::Request
+ *     cb = Proc.new{|b| p b }
+ *     EIO.sendfile(in_fd, out_fd, 100, 50, cb)        =>  EIO::Request
+ *
+ *     EIO.sendfile(in_fd, out_fd)                     =>  Fixnum
+ *     EIO.sendfile(in_fd, out_fd, 100)                =>  Fixnum
+ *     EIO.sendfile(in_fd, out_fd, 100, 50)            =>  Fixnum
+ *
+ */
+static VALUE
+rb_eio_s_sendfile(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE out_fd, in_fd, offset, len, proc, cb;
+    rb_scan_args(argc, argv, "23&", &out_fd, &in_fd, &offset, &len, &proc, &cb);
+    AssertCallback(cb, 1);
+    Check_Type(in_fd, T_FIXNUM);
+    Check_Type(out_fd, T_FIXNUM);
+    if (NIL_P(len)) len = eio_default_bufsize;
+    Check_Type(len, T_FIXNUM);
+    if (len == eio_zero) len = eio_default_bufsize;
+    if (NIL_P(offset)) offset = eio_zero;
+    Check_Type(offset, T_FIXNUM);
+    SubmitRequest(sendfile, rb_eio_write_cb, FIX2INT(out_fd), FIX2INT(in_fd), FIX2INT(offset), FIX2INT(len));
+}
+
+/*
+ *  call-seq:
+ *     EIO.readdir('/path'){|fs| p fs }   =>  EIO::Request
+ *
+ *  Unlike the POSIX call of the same name, aio_readdir reads an entire directory (i.e.
+ *  opendir + readdir + closedir). The entries will not be sorted, and will NOT include the
+ *  . and .. entries.
+ *
+ * === Examples
+ *     cb = Proc.new{|b| p b }
+ *     EIO.readdir('/path', cb)           =>  EIO::Request
+ *
+ *     EIO.readdir('/path')               =>  Array
+ *
+ */
+static VALUE
+rb_eio_s_readdir(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE path, proc, cb;
+    VALUE files;
+    char *name;
+    struct dirent *ent;
+    rb_scan_args(argc, argv, "11&", &path, &proc, &cb);
+    AssertCallback(cb, 1);
+    Check_Type(path, T_STRING);
+    SyncRequest({
+        DIR *dir = opendir(StringValueCStr(path));
+        if (!dir) rb_sys_fail(StringValueCStr(path));
+
+        files = rb_ary_new();
+
+        while ((ent = readdir(dir))) {
+          name = ent->d_name;
+          if (name[0] != '.' || (name[1] && (name[1] != '.' || name[2]))) {
+              rb_ary_push(files, rb_str_new2(name));
+          }
+        }
+        ret = closedir(dir);
+        if (ret == -1) rb_sys_fail("closedir");
+        return(files);
+    });
+    AsyncRequest(readdir, rb_eio_readdir_cb, StringValueCStr(path), EIO_READDIR_STAT_ORDER);
+}
+
+/*
+ *  call-seq:
+ *     EIO.mkdir('/path'){ p :created }         =>  EIO::Request
+ *
+ *  Asynchronously mkdir (create) a directory and call the callback with the result code.
+ *
+ * === Examples
+ *     EIO.mkdir('/path', 0777){ p :created }   =>  EIO::Request
+ *     cb = Proc.new{ p :created }
+ *     EIO.mkdir('/path', 0777, cb)             =>  EIO::Request
+ *
+ *     EIO.mkdir('/path')                       =>  Fixnum
+ *     EIO.mkdir('/path', 0777)                 =>  Fixnum
+ *
+ */
+static VALUE
+rb_eio_s_mkdir(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE path, mode, proc, cb;
+    rb_scan_args(argc, argv, "12&", &path, &mode, &proc, &cb);
+    AssertCallback(cb, NO_CB_ARGS);
+    Check_Type(path, T_STRING);
+    if (NIL_P(mode)) mode = eio_default_mode;
+    Check_Type(mode, T_FIXNUM);
+    SubmitRequest(mkdir, rb_eio_generic_cb, StringValueCStr(path), FIX2INT(mode));
+}
+
+/*
+ *  call-seq:
+ *     EIO.rmdir('/path'){ p :removed }   =>  EIO::Request
+ *
+ *  Asynchronously rmdir (delete) a directory and call the callback with the result code.
+ *
+ * === Examples
+ *     cb = Proc.new{ p :removed }
+ *     EIO.rmdir('/path', cb)             =>  EIO::Request
+ *
+ *     EIO.rmdir('/path')                 =>  Fixnum
+ *
+ */
+static VALUE
+rb_eio_s_rmdir(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE path, proc, cb;
+    rb_scan_args(argc, argv, "11&", &path, &proc, &cb);
+    AssertCallback(cb, NO_CB_ARGS);
+    Check_Type(path, T_STRING);
+    SubmitRequest(rmdir, rb_eio_generic_cb, StringValueCStr(path));
+}
+
+/*
+ *  call-seq:
+ *     EIO.unlink('/path/file'){ p :removed }   =>  EIO::Request
+ *
+ *  Asynchronously unlink (delete) a file and call the callback with the result code.
+ *
+ * === Examples
+ *     cb = Proc.new{ p :removed }
+ *     EIO.unlink('/path/file', cb)             =>  EIO::Request
+ *
+ *     EIO.unlink('/path/file')                 =>  Fixnum
+ *
+ */
+static VALUE
+rb_eio_s_unlink(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE path, proc, cb;
+    rb_scan_args(argc, argv, "11&", &path, &proc, &cb);
+    AssertCallback(cb, NO_CB_ARGS);
+    Check_Type(path, T_STRING);
+    SubmitRequest(unlink, rb_eio_generic_cb, StringValueCStr(path));
+}
+
+/*
+ *  call-seq:
+ *     EIO.readlink('/path/link'){|l| p l }   =>  EIO::Request
+ *
+ *  Asynchronously read the symlink specified by path and pass it to the callback.
+ *
+ * === Examples
+ *     cb = Proc.new{|l| p l }
+ *     EIO.readlink('/path/link', cb)         =>  EIO::Request
+ *
+ *     EIO.readlink('/path/link')             =>  Fixnum
+ *
+ */
+static VALUE
+rb_eio_s_readlink(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE path, proc, cb;
+    rb_scan_args(argc, argv, "11&", &path, &proc, &cb);
+    AssertCallback(cb, 1);
+    Check_Type(path, T_STRING);
+    SyncRequest({
+        return rb_funcall(rb_cFile, sym_readlink, 1, path);
+    });
+    AsyncRequest(readlink, rb_eio_read_cb, StringValueCStr(path));
+}
+
+/*
+ *  call-seq:
+ *     EIO.stat('/path/file'){|s| p s }   =>  EIO::Request
+ *
+ *  Works like Ruby's stat. The callback will be called after the stat.
+ *
+ * === Examples
+ *     cb = Proc.new{|s| p s }
+ *     EIO.stat('/path/file', cb)         =>  EIO::Request
+ *
+ *     EIO.stat('/path/file')             =>  File::Stat
+ *
+ */
+static VALUE
+rb_eio_s_stat(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE path, proc, cb;
+    rb_scan_args(argc, argv, "11&", &path, &proc, &cb);
+    AssertCallback(cb, 1);
+    Check_Type(path, T_STRING);
+    SyncRequest({
+        return rb_funcall(rb_cFile, sym_stat, 1, path);
+    });
+    AsyncRequest(stat, rb_eio_stat_cb, StringValueCStr(path));
+}
+
+/*
+ *  call-seq:
+ *     EIO.rename('/path/a', '/path/b'){ p :renamed }  =>  EIO::Request
+ *
+ *  Asynchronously rename the object at source path to destination path
+ *
+ * === Examples
+ *     cb = Proc.new{ p :renamed }
+ *     EIO.rename('/path/a', '/path/b', cb)            =>  EIO::Request
+ *
+ *     EIO.rename('/path/a', '/path/b')                =>  Fixnum
+ *
+ */
+static VALUE
+rb_eio_s_rename(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE path, new_path, proc, cb;
+    rb_scan_args(argc, argv, "21&", &path, &new_path, &proc, &cb);
+    AssertCallback(cb, NO_CB_ARGS);
+    Check_Type(path, T_STRING);
+    Check_Type(new_path, T_STRING);
+    SubmitRequest(rename, rb_eio_generic_cb, StringValueCStr(path), StringValueCStr(new_path));
+}
+
+/*
+ *  call-seq:
+ *     EIO.chmod('/path/file'){ p :chmodded }        =>  EIO::Request
+ *
+ *  Asynchronously change permissions for a given file path.
+ *
+ * === Examples
+ *     EIO.chmod('/path/file', 0777){ p :chmodded }  =>  EIO::Request
+ *     cb = Proc.new{ p :chmodded }
+ *     EIO.chmod('/path/file', 0777, cb)             =>  EIO::Request
+ *
+ *     EIO.chmod('/path/file')                       =>  Fixnum
+ *     EIO.chmod('/path/file', 0777)                 =>  Fixnum
+ *
+ */
+static VALUE
+rb_eio_s_chmod(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE path, mode, proc, cb;
+    rb_scan_args(argc, argv, "12&", &path, &mode, &proc, &cb);
+    AssertCallback(cb, NO_CB_ARGS);
+    Check_Type(path, T_STRING);
+    if (NIL_P(mode)) mode = eio_default_mode;
+    Check_Type(mode, T_FIXNUM);
+    SubmitRequest(chmod, rb_eio_generic_cb, StringValueCStr(path), FIX2INT(mode));
+}
+
+/*
+ *  call-seq:
+ *     EIO.fchmod(fd){ p :chmodded }        =>  EIO::Request
+ *
+ *  Asynchronously change ownership for a given file descriptor.
+ *
+ * === Examples
+ *     EIO.fchmod(fd, 0777){ p :chmodded }  =>  EIO::Request
+ *     cb = Proc.new{ p :chmodded }
+ *     EIO.fchmod(fd, 0777, cb)             =>  EIO::Request
+ *
+ *     EIO.fchmod(fd)                       =>  Fixnum
+ *     EIO.fchmod(fd, 0777)                 =>  Fixnum
+ *
+ */
+static VALUE
+rb_eio_s_fchmod(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE fd, mode, proc, cb;
+    rb_scan_args(argc, argv, "12&", &fd, &mode, &proc, &cb);
+    AssertCallback(cb, NO_CB_ARGS);
+    Check_Type(fd, T_FIXNUM);
+    if (NIL_P(mode)) mode = eio_default_mode;
+    Check_Type(mode, T_FIXNUM);
+    SubmitRequest(fchmod, rb_eio_generic_cb, FIX2INT(fd), FIX2INT(mode));
+}
+
+/*
+ *  call-seq:
+ *     EIO.truncate('/path/file'){ p :truncated }       =>  EIO::Request
+ *
+ *  Asynchronously truncates a given file path.
+ *
+ * === Examples
+ *     EIO.truncate('/path/file', 100){ p :truncated }  =>  EIO::Request
+ *     cb = Proc.new{ p :truncated }
+ *     EIO.truncate('/path/file', 100, cb)              =>  EIO::Request
+ *
+ *     EIO.truncate('/path/file')                       =>  Fixnum
+ *     EIO.truncate('/path/file', 100)                  =>  Fixnum
+ *
+ */
+static VALUE
+rb_eio_s_truncate(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE path, offset, proc, cb;
+    rb_scan_args(argc, argv, "12&", &path, &offset, &proc, &cb);
+    AssertCallback(cb, NO_CB_ARGS);
+    Check_Type(path, T_STRING);
+    if (NIL_P(offset)) offset = eio_zero;
+    Check_Type(offset, T_FIXNUM);
+    SubmitRequest(truncate, rb_eio_generic_cb, StringValueCStr(path), FIX2INT(offset));
+}
+
+/*
+ *  call-seq:
+ *     EIO.ftruncate(fd){ p :truncated }       =>  EIO::Request
+ *
+ *  Asynchronously truncates a given file descriptor.
+ *
+ * === Examples
+ *     EIO.ftruncate(fd, 100){ p :truncated }  =>  EIO::Request
+ *     cb = Proc.new{ p :truncated }
+ *     EIO.ftruncate(fd, 100, cb)              =>  EIO::Request
+ *
+ *     EIO.ftruncate(fd)                       =>  Fixnum
+ *     EIO.ftruncate(fd, 100)                  =>  Fixnum
+ *
+ */
+static VALUE
+rb_eio_s_ftruncate(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE fd, offset, proc, cb;
+    rb_scan_args(argc, argv, "12&", &fd, &offset, &proc, &cb);
+    AssertCallback(cb, NO_CB_ARGS);
+    Check_Type(fd, T_FIXNUM);
+    if (NIL_P(offset)) offset = eio_zero;
+    Check_Type(offset, T_FIXNUM);
+    SubmitRequest(ftruncate, rb_eio_generic_cb, FIX2INT(fd), FIX2INT(offset));
+}
+
+/*
+ *  call-seq:
+ *     EIO.chown('/path/file'){ p :chowned }            =>  EIO::Request
+ *
+ *  Asynchronously changes ownership for a given file path.
+ *
+ * === Examples
+ *     EIO.chown('/path/file', 500){ p :chowned }       =>  EIO::Request
+ *     EIO.chown('/path/file', 500, 500){ p :chowned }  =>  EIO::Request
+ *     cb = Proc.new{ p :chowned }
+ *     EIO.chown('/path/file', 500, 500, cb)            =>  EIO::Request
+ *
+ *     EIO.chown('/path/file', 500)                     =>  Fixnum
+ *     EIO.chown('/path/file', 500, 500)                =>  Fixnum
+ *
+ */
+static VALUE
+rb_eio_s_chown(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE path, uid, gid, proc, cb;
+    rb_scan_args(argc, argv, "13&", &path, &uid, &gid, &proc, &cb);
+    AssertCallback(cb, NO_CB_ARGS);
+    Check_Type(path, T_STRING);
+    if (NIL_P(uid)) uid = INT2NUM(getuid());
+    Check_Type(uid, T_FIXNUM);
+    if (NIL_P(gid)) gid = INT2NUM(getgid());
+    Check_Type(gid, T_FIXNUM);
+    SubmitRequest(chown, rb_eio_generic_cb, StringValueCStr(path), FIX2INT(uid), FIX2INT(gid));
+}
+
+/*
+ *  call-seq:
+ *     EIO.fchown(fd){ p :chowned }            =>  EIO::Request
+ *
+ *  Asynchronously changes ownership for a given file descriptor.
+ *
+ * === Examples
+ *     EIO.fchown(fd, 500){ p :chowned }       =>  EIO::Request
+ *     EIO.fchown(fd, 500, 500){ p :chowned }  =>  EIO::Request
+ *     cb = Proc.new{ p :chowned }
+ *     EIO.fchown(fd, 500, 500, cb)            =>  EIO::Request
+ *
+ *     EIO.fchown(fd, 500)                     =>  Fixnum
+ *     EIO.fchown(fd, 500, 500)                =>  Fixnum
+ *
+ */
+static VALUE
+rb_eio_s_fchown(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE fd, uid, gid, proc, cb;
+    rb_scan_args(argc, argv, "13&", &fd, &uid, &gid, &proc, &cb);
+    AssertCallback(cb, NO_CB_ARGS);
+    Check_Type(fd, T_FIXNUM);
+    if (NIL_P(uid)) uid = INT2NUM(getuid());
+    Check_Type(uid, T_FIXNUM);
+    if (NIL_P(gid)) gid = INT2NUM(getgid());
+    Check_Type(gid, T_FIXNUM);
+    SubmitRequest(fchown, rb_eio_generic_cb, FIX2INT(fd), FIX2INT(uid), FIX2INT(gid));
+}
+
+/*
+ *  call-seq:
+ *     EIO.link('/path/a', '/path/b'){ p :linked }  =>  EIO::Request
+ *
+ *  Asynchronously create a new link to the existing object at source path at the destination
+ *  path and call the callback with the result code.
+ *
+ * === Examples
+ *     cb = Proc.new{ p :linked }
+ *     EIO.link('/path/a', '/path/b', cb)           =>  EIO::Request
+ *
+ *     EIO.link('/path/a', '/path/b')               =>  Fixnum
+ *
+ */
+static VALUE
+rb_eio_s_link(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE path, new_path, proc, cb;
+    rb_scan_args(argc, argv, "21&", &path, &new_path, &proc, &cb);
+    AssertCallback(cb, NO_CB_ARGS);
+    Check_Type(path, T_STRING);
+    Check_Type(new_path, T_STRING);
+    SubmitRequest(link, rb_eio_generic_cb, StringValueCStr(path), StringValueCStr(new_path));
+}
+
+/*
+ *  call-seq:
+ *     EIO.symlink('/path/a', '/path/b'){ p :linked }  =>  EIO::Request
+ *
+ *  Asynchronously create a new symbolic link to the existing object at sourc path at the
+ *  destination path and call the callback with the result code.
+ *
+ * === Examples
+ *     cb = Proc.new{ p :linked }
+ *     EIO.symlink('/path/a', '/path/b', cb)           =>  EIO::Request
+ *
+ *     EIO.symlink('/path/a', '/path/b')               =>  Fixnum
+ *
+ */
+static VALUE
+rb_eio_s_symlink(int argc, VALUE *argv, VALUE eio)
+{
+    int ret;
+    VALUE path, new_path, proc, cb;
+    rb_scan_args(argc, argv, "21&", &path, &new_path, &proc, &cb);
+    AssertCallback(cb, NO_CB_ARGS);
+    Check_Type(path, T_STRING);
+    Check_Type(new_path, T_STRING);
+    SubmitRequest(symlink, rb_eio_generic_cb, StringValueCStr(path), StringValueCStr(new_path));
+}
+
+/*
+ * Mark an EIO::Request instance
+ */
+static void
+rb_eio_mark_request(eio_req *r)
+{
+}
+
+/*
+ * Free an EIO::Request instance
+ */
+static void
+rb_eio_free_request(eio_req *r)
+{
+}
+
+/*
+ *  Wraps an eio_req struct
+ */
+static VALUE
+rb_eio_wrap_request(eio_req *r)
+{
+    VALUE obj;
+    obj = Data_Wrap_Struct(cEioReq, rb_eio_mark_request, rb_eio_free_request, r);
+    rb_obj_call_init(obj, 0, NULL);
+    return obj;
+}
+
+/*
+ *  call-seq:
+ *     req.errno  =>  Fixnum
+ *
+ *  Request error number, if any.
+ *
+ */
+static VALUE
+rb_eio_req_errno(VALUE obj)
+{
+    GetRequest(obj);
+    return INT2NUM(req->errorno);
+}
+
+/*
+ *  call-seq:
+ *     req.type  =>  Fixnum
+ *
+ *  Request type
+ *
+ */
+static VALUE
+rb_eio_req_type(VALUE obj)
+{
+    GetRequest(obj);
+    return INT2NUM(req->type);
+}
+
+/*
+ *  call-seq:
+ *     req.priority  =>  Fixnum
+ *
+ *  Request priority
+ *
+ */
+static VALUE
+rb_eio_req_priority(VALUE obj)
+{
+    GetRequest(obj);
+    return INT2NUM(req->pri);
+}
+
+/*
+ *  call-seq:
+ *     req.cancel  =>  nil
+ *
+ *  Attempt to cancel an in flight libeio request - no guarantees.
+ *
+ */
+static VALUE
+rb_eio_req_cancel(VALUE obj)
+{
+    GetRequest(obj);
+    eio_cancel(req);
+    return Qnil;
+}
+
+/*
+ *  call-seq:
+ *     req.complete?  =>  Boolean
+ *
+ *  True if the Ruby callback for this request already fired.
+ *
+ */
+static VALUE
+rb_eio_req_complete_p(VALUE obj)
+{
+    GetRequest(obj);
+    return (req->complete == 1) ? Qtrue : Qfalse;
+}
+
+/*
+ * Get the fd from a given I/O instance
+ */
+static int
+rb_eio_pipe_fd(VALUE io)
+{
+    rb_io_t *fptr;
+    GetOpenFile(io, fptr);
+#ifdef RUBY_VM
+    return fptr->fd;
+#else
+    return fileno(fptr->f);
+#endif
+}
+
+/*
+ * create the libeio notify pipe
+ */
+static void
+rb_eio_create_pipe(void)
+{
+    VALUE pipe, pipe_r_fd, pipe_w_fd;
+    pipe = rb_funcall(rb_cIO, sym_pipe, 0);
+
+    rb_gc_register_address(&pipe_r_fd);
+    pipe_r_fd = rb_ary_shift(pipe);
+
+    rb_gc_register_address(&pipe_w_fd);
+    pipe_w_fd = rb_ary_shift(pipe);
+
+    rb_ivar_set(mEio, sym_pipe_r_fd, pipe_r_fd);
+    rb_ivar_set(mEio, sym_pipe_w_fd, pipe_w_fd);
+
+    eio_pipe_r_fd = rb_eio_pipe_fd(pipe_r_fd);
+    eio_pipe_w_fd = rb_eio_pipe_fd(pipe_w_fd);
+}
+
+/* recreate the libeio notify pipe */
+static void
+rb_eio_recreate_pipe(void)
+{
+    rb_eio_create_pipe();
+}
+
+/* recreate the libeio notify pipe on fork */
+static void
+rb_eio_atfork(void)
+{
+    rb_eio_recreate_pipe();
+}
+
+void
+Init_eio_ext()
+{
+    /* Initializes libeio */
+    if (eio_init(want_poll, done_poll) < 0) rb_sys_fail("EIO init failed!");
+
+    mEio = rb_define_module("EIO");
+
+    /* Init symbols ahead of time */
+    sym_call = rb_intern("call");
+    sym_arity = rb_intern("arity");
+    sym_pipe = rb_intern("pipe");
+    sym_readlink = rb_intern("readlink");
+    sym_stat = rb_intern("stat");
+    sym_pipe_r_fd = rb_intern("pipe_r_fd");
+    sym_pipe_w_fd = rb_intern("pipe_w_fd");
+
+    /* Common fixnum defaults */
+    eio_default_mode = INT2NUM(0777);
+    eio_zero = INT2NUM(0);
+    eio_default_bufsize = INT2NUM(BUFSIZ);
+
+    /* Setup a communication pipe between libeio and other I/O frameworks */
+    rb_eio_create_pipe();
+
+    /* Recreate pipe on fork */
+    X_THREAD_ATFORK(0, 0, rb_eio_atfork);
+
+    rb_define_const(mEio, "PRI_MIN", INT2NUM(EIO_PRI_MIN));
+    rb_define_const(mEio, "PRI_MAX", INT2NUM(EIO_PRI_MAX));
+    rb_define_const(mEio, "PRI_DEFAULT", INT2NUM(EIO_PRI_DEFAULT));
+
+    rb_define_const(mEio, "RDONLY", INT2NUM(O_RDONLY));
+    rb_define_const(mEio, "WRONLY", INT2NUM(O_WRONLY));
+    rb_define_const(mEio, "RDWR", INT2NUM(O_RDWR));
+    rb_define_const(mEio, "APPEND", INT2NUM(O_APPEND));
+    rb_define_const(mEio, "CREAT", INT2NUM(O_CREAT));
+    rb_define_const(mEio, "EXCL", INT2NUM(O_EXCL));
+
+    rb_define_module_function(mEio, "poll", rb_eio_s_poll, 0);
+    rb_define_module_function(mEio, "wait", rb_eio_s_wait, 0);
+    rb_define_module_function(mEio, "requests", rb_eio_s_requests, 0);
+    rb_define_module_function(mEio, "ready", rb_eio_s_ready, 0);
+    rb_define_module_function(mEio, "pending", rb_eio_s_pending, 0);
+    rb_define_module_function(mEio, "threads", rb_eio_s_threads, 0);
+    rb_define_module_function(mEio, "fd", rb_eio_s_fd, 0);
+
+    rb_define_module_function(mEio, "max_poll_time=", rb_eio_s_set_max_poll_time, 1);
+    rb_define_module_function(mEio, "max_poll_reqs=", rb_eio_s_set_max_poll_reqs, 1);
+    rb_define_module_function(mEio, "min_parallel=", rb_eio_s_set_min_parallel, 1);
+    rb_define_module_function(mEio, "max_parallel=", rb_eio_s_set_max_parallel, 1);
+    rb_define_module_function(mEio, "max_idle=", rb_eio_s_set_max_idle, 1);
+    rb_define_module_function(mEio, "idle_timeout=", rb_eio_s_set_idle_timeout, 1);
+
+    rb_define_module_function(mEio, "fsync", rb_eio_s_fsync, -1);
+    rb_define_module_function(mEio, "fdatasync", rb_eio_s_fdatasync, -1);
+    rb_define_module_function(mEio, "open", rb_eio_s_open, -1);
+    rb_define_module_function(mEio, "close", rb_eio_s_close, -1);
+    rb_define_module_function(mEio, "read", rb_eio_s_read, -1);
+    rb_define_module_function(mEio, "readahead", rb_eio_s_readahead, -1);
+    rb_define_module_function(mEio, "write", rb_eio_s_write, -1);
+    rb_define_module_function(mEio, "sendfile", rb_eio_s_sendfile, -1);
+    rb_define_module_function(mEio, "mkdir", rb_eio_s_mkdir, -1);
+    rb_define_module_function(mEio, "rmdir", rb_eio_s_rmdir, -1);
+    rb_define_module_function(mEio, "unlink", rb_eio_s_unlink, -1);
+    rb_define_module_function(mEio, "rename", rb_eio_s_rename, -1);
+    rb_define_module_function(mEio, "chmod", rb_eio_s_chmod, -1);
+    rb_define_module_function(mEio, "fchmod", rb_eio_s_fchmod, -1);
+    rb_define_module_function(mEio, "truncate", rb_eio_s_truncate, -1);
+    rb_define_module_function(mEio, "ftruncate", rb_eio_s_ftruncate, -1);
+    rb_define_module_function(mEio, "chown", rb_eio_s_chown, -1);
+    rb_define_module_function(mEio, "fchown", rb_eio_s_fchown, -1);
+    rb_define_module_function(mEio, "link", rb_eio_s_link, -1);
+    rb_define_module_function(mEio, "readlink", rb_eio_s_readlink, -1);
+    rb_define_module_function(mEio, "symlink", rb_eio_s_symlink, -1);
+    rb_define_module_function(mEio, "readdir", rb_eio_s_readdir, -1);
+    rb_define_module_function(mEio, "stat", rb_eio_s_stat, -1);
+
+    cEioReq  = rb_define_class_under(mEio, "Request", rb_cObject);
+
+    rb_define_method(cEioReq, "errno", rb_eio_req_errno, 0);
+    rb_define_method(cEioReq, "type", rb_eio_req_type, 0);
+    rb_define_method(cEioReq, "priority", rb_eio_req_priority, 0);
+    rb_define_method(cEioReq, "cancel", rb_eio_req_cancel, 0);
+    rb_define_method(cEioReq, "complete?", rb_eio_req_complete_p, 0);
+
+    rb_define_const(cEioReq, "OPEN", INT2NUM(EIO_OPEN));
+    rb_define_const(cEioReq, "CLOSE", INT2NUM(EIO_CLOSE));
+    rb_define_const(cEioReq, "READ", INT2NUM(EIO_READ));
+    rb_define_const(cEioReq, "WRITE", INT2NUM(EIO_WRITE));
+    rb_define_const(cEioReq, "READAHEAD", INT2NUM(EIO_READAHEAD));
+    rb_define_const(cEioReq, "SENDFILE", INT2NUM(EIO_SENDFILE));
+    rb_define_const(cEioReq, "STAT", INT2NUM(EIO_STAT));
+    rb_define_const(cEioReq, "TRUNCATE", INT2NUM(EIO_TRUNCATE));
+    rb_define_const(cEioReq, "FTRUNCATE", INT2NUM(EIO_FTRUNCATE));
+    rb_define_const(cEioReq, "CHMOD", INT2NUM(EIO_CHMOD));
+    rb_define_const(cEioReq, "FCHMOD", INT2NUM(EIO_FCHMOD));
+    rb_define_const(cEioReq, "CHOWN", INT2NUM(EIO_CHOWN));
+    rb_define_const(cEioReq, "FCHOWN", INT2NUM(EIO_FCHOWN));
+    rb_define_const(cEioReq, "SYNC", INT2NUM(EIO_SYNC));
+    rb_define_const(cEioReq, "FSYNC", INT2NUM(EIO_FSYNC));
+    rb_define_const(cEioReq, "FDATASYNC", INT2NUM(EIO_FDATASYNC));
+    rb_define_const(cEioReq, "UNLINK", INT2NUM(EIO_UNLINK));
+    rb_define_const(cEioReq, "RMDIR", INT2NUM(EIO_RMDIR));
+    rb_define_const(cEioReq, "MKDIR", INT2NUM(EIO_MKDIR));
+    rb_define_const(cEioReq, "RENAME", INT2NUM(EIO_RENAME));
+    rb_define_const(cEioReq, "READDIR", INT2NUM(EIO_READDIR));
+    rb_define_const(cEioReq, "LINK", INT2NUM(EIO_LINK));
+    rb_define_const(cEioReq, "SYMLINK", INT2NUM(EIO_SYMLINK));
+    rb_define_const(cEioReq, "READLINK", INT2NUM(EIO_READLINK));
+}