polyphony 0.81.1 → 0.84

data/ext/polyphony/backend_libev.c

@@ -266,41 +266,74 @@ VALUE libev_wait_fd(Backend_t *backend, int fd, int events, int raise_exception)
   return switchpoint_result;
 }
 
+static inline int fd_from_io(VALUE io, rb_io_t **fptr, int write_mode, int rectify_file_pos) {
+  if (rb_obj_class(io) == cPipe) {
+    *fptr = NULL;
+    Pipe_verify_blocking_mode(io, Qfalse);
+    return Pipe_get_fd(io, write_mode);
+  }
+  else {
+    VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
+    if (underlying_io != Qnil) io = underlying_io;
+
+    GetOpenFile(io, *fptr);
+    io_verify_blocking_mode(*fptr, io, Qfalse);
+    if (rectify_file_pos) rectify_io_file_pos(*fptr);
+
+    return (*fptr)->fd;
+  }
+}
+
 VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof, VALUE pos) {
   Backend_t *backend;
   struct libev_io watcher;
+  int fd;
   rb_io_t *fptr;
-  long dynamic_len = length == Qnil;
-  long len = dynamic_len ? 4096 : NUM2INT(length);
+
+  struct io_buffer buffer = get_io_buffer(str);
   long buf_pos = NUM2INT(pos);
-  if (str != Qnil) {
-    int current_len = RSTRING_LEN(str);
-    if (buf_pos < 0 || buf_pos > current_len) buf_pos = current_len;
-  }
-  else buf_pos = 0;
-  int shrinkable = io_setstrbuf(&str, buf_pos + len);
-  char *buf = RSTRING_PTR(str) + buf_pos;
+  int shrinkable_string = 0;
+  int expandable_buffer = 0;
   long total = 0;
   VALUE switchpoint_result = Qnil;
   int read_to_eof = RTEST(to_eof);
-  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
+
+  if (buffer.raw) {
+    if (buf_pos < 0 || buf_pos > buffer.len) buf_pos = buffer.len;
+    buffer.ptr += buf_pos;
+    buffer.len -= buf_pos;
+  }
+  else {
+    expandable_buffer = length == Qnil;
+    long expected_read_length = expandable_buffer ? 4096 : FIX2INT(length);
+    long string_cap = rb_str_capacity(str);
+    if (buf_pos < 0 || buf_pos > buffer.len) buf_pos = buffer.len;
+
+    if (string_cap < expected_read_length + buf_pos) {
+      shrinkable_string = io_setstrbuf(&str, expected_read_length + buf_pos);
+      buffer.ptr = RSTRING_PTR(str) + buf_pos;
+      buffer.len = expected_read_length;
+    }
+    else {
+      buffer.ptr += buf_pos;
+      buffer.len = string_cap - buf_pos;
+      if (buffer.len > expected_read_length)
+        buffer.len = expected_read_length;
+    }
+  }
 
   GetBackend(self, backend);
-  if (underlying_io != Qnil) io = underlying_io;
-  GetOpenFile(io, fptr);
-  rb_io_check_byte_readable(fptr);
-  io_verify_blocking_mode(fptr, io, Qfalse);
-  rectify_io_file_pos(fptr);
+  fd = fd_from_io(io, &fptr, 0, 1);
   watcher.fiber = Qnil;
 
   while (1) {
     backend->base.op_count++;
-    ssize_t n = read(fptr->fd, buf, len - total);
-    if (n < 0) {
+    ssize_t result = read(fd, buffer.ptr, buffer.len);
+    if (result < 0) {
       int e = errno;
       if (e != EWOULDBLOCK && e != EAGAIN) rb_syserr_fail(e, strerror(e));
 
-      switchpoint_result = libev_wait_fd_with_watcher(backend, fptr->fd, &watcher, EV_READ);
+      switchpoint_result = libev_wait_fd_with_watcher(backend, fd, &watcher, EV_READ);
 
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
@@ -308,32 +341,39 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
       switchpoint_result = backend_snooze(&backend->base);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
 
-      if (n == 0) break; // EOF
-      total = total + n;
+      if (!result) break; // EOF
+
+      total += result;
       if (!read_to_eof) break;
 
-      if (total == len) {
-        if (!dynamic_len) break;
+      if (result == buffer.len) {
+        if (!expandable_buffer) break;
 
-        rb_str_resize(str, buf_pos + total);
-        rb_str_modify_expand(str, len);
-        buf = RSTRING_PTR(str) + buf_pos + total;
-        shrinkable = 0;
-        len += len;
+        // resize buffer to double its capacity
+        rb_str_resize(str, total + buf_pos);
+        rb_str_modify_expand(str, rb_str_capacity(str));
+        shrinkable_string = 0;
+        buffer.ptr = RSTRING_PTR(str) + total + buf_pos;
+        buffer.len = rb_str_capacity(str) - total - buf_pos;
+      }
+      else {
+        buffer.ptr += result;
+        buffer.len -= result;
+        if (!buffer.len) break;
       }
-      else buf += n;
     }
   }
 
-  io_set_read_length(str, buf_pos + total, shrinkable);
-  io_enc_str(str, fptr);
-
-  if (total == 0) return Qnil;
+  if (!buffer.raw) {
+    io_set_read_length(str, buf_pos + total, shrinkable_string);
+    if (fptr) io_enc_str(str, fptr);
+  }
+  if (!total) return Qnil;
 
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
 
-  return str;
+  return buffer.raw ? INT2FIX(total) : str;
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
@@ -345,6 +385,7 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
 VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
   Backend_t *backend;
   struct libev_io watcher;
+  int fd;
   rb_io_t *fptr;
   VALUE str;
   long total;
@@ -352,26 +393,21 @@ VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
   int shrinkable;
   char *buf;
   VALUE switchpoint_result = Qnil;
-  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
 
   READ_LOOP_PREPARE_STR();
 
   GetBackend(self, backend);
-  if (underlying_io != Qnil) io = underlying_io;
-  GetOpenFile(io, fptr);
-  rb_io_check_byte_readable(fptr);
-  io_verify_blocking_mode(fptr, io, Qfalse);
-  rectify_io_file_pos(fptr);
+  fd = fd_from_io(io, &fptr, 0, 1);
   watcher.fiber = Qnil;
 
   while (1) {
     backend->base.op_count++;
-    ssize_t n = read(fptr->fd, buf, len);
+    ssize_t n = read(fd, buf, len);
     if (n < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-      switchpoint_result = libev_wait_fd_with_watcher(backend, fptr->fd, &watcher, EV_READ);
+      switchpoint_result = libev_wait_fd_with_watcher(backend, fd, &watcher, EV_READ);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
@@ -397,6 +433,7 @@ error:
 VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
   Backend_t *backend;
   struct libev_io watcher;
+  int fd;
   rb_io_t *fptr;
   VALUE str;
   long total;
@@ -404,27 +441,22 @@ VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
   int shrinkable;
   char *buf;
   VALUE switchpoint_result = Qnil;
-  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
   ID method_id = SYM2ID(method);
 
   READ_LOOP_PREPARE_STR();
 
   GetBackend(self, backend);
-  if (underlying_io != Qnil) io = underlying_io;
-  GetOpenFile(io, fptr);
-  rb_io_check_byte_readable(fptr);
-  io_verify_blocking_mode(fptr, io, Qfalse);
-  rectify_io_file_pos(fptr);
+  fd = fd_from_io(io, &fptr, 0, 1);
   watcher.fiber = Qnil;
 
   while (1) {
     backend->base.op_count++;
-    ssize_t n = read(fptr->fd, buf, len);
+    ssize_t n = read(fd, buf, len);
     if (n < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-      switchpoint_result = libev_wait_fd_with_watcher(backend, fptr->fd, &watcher, EV_READ);
+      switchpoint_result = libev_wait_fd_with_watcher(backend, fd, &watcher, EV_READ);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
@@ -450,35 +482,31 @@ error:
 VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   Backend_t *backend;
   struct libev_io watcher;
+  int fd;
   rb_io_t *fptr;
   VALUE switchpoint_result = Qnil;
-  VALUE underlying_io;
-  char *buf = StringValuePtr(str);
-  long len = RSTRING_LEN(str);
-  long left = len;
 
-  underlying_io = rb_ivar_get(io, ID_ivar_io);
-  if (underlying_io != Qnil) io = underlying_io;
+  struct io_buffer buffer = get_io_buffer(str);
+  long left = buffer.len;
+
   GetBackend(self, backend);
-  io = rb_io_get_write_io(io);
-  GetOpenFile(io, fptr);
-  io_verify_blocking_mode(fptr, io, Qfalse);
+  fd = fd_from_io(io, &fptr, 1, 0);
   watcher.fiber = Qnil;
 
   while (left > 0) {
     backend->base.op_count++;
-    ssize_t n = write(fptr->fd, buf, left);
-    if (n < 0) {
+    ssize_t result = write(fd, buffer.ptr, left);
+    if (result < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-      switchpoint_result = libev_wait_fd_with_watcher(backend, fptr->fd, &watcher, EV_WRITE);
+      switchpoint_result = libev_wait_fd_with_watcher(backend, fd, &watcher, EV_WRITE);
 
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
-      buf += n;
-      left -= n;
+      buffer.ptr += result;
+      left -= result;
     }
   }
 
@@ -491,7 +519,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
 
-  return INT2NUM(len);
+  return INT2NUM(buffer.len);
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
@@ -499,21 +527,17 @@ error:
 VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
   Backend_t *backend;
   struct libev_io watcher;
+  int fd;
   rb_io_t *fptr;
   VALUE switchpoint_result = Qnil;
-  VALUE underlying_io;
   long total_length = 0;
   long total_written = 0;
   struct iovec *iov = 0;
   struct iovec *iov_ptr = 0;
   int iov_count = argc;
 
-  underlying_io = rb_ivar_get(io, ID_ivar_io);
-  if (underlying_io != Qnil) io = underlying_io;
   GetBackend(self, backend);
-  io = rb_io_get_write_io(io);
-  GetOpenFile(io, fptr);
-  io_verify_blocking_mode(fptr, io, Qfalse);
+  fd = fd_from_io(io, &fptr, 1, 0);
   watcher.fiber = Qnil;
 
   iov = malloc(iov_count * sizeof(struct iovec));
@@ -527,7 +551,7 @@ VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
 
   while (1) {
     backend->base.op_count++;
-    ssize_t n = writev(fptr->fd, iov_ptr, iov_count);
+    ssize_t n = writev(fd, iov_ptr, iov_count);
     if (n < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) {
@@ -535,7 +559,7 @@ VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
         rb_syserr_fail(e, strerror(e));
       }
 
-      switchpoint_result = libev_wait_fd_with_watcher(backend, fptr->fd, &watcher, EV_WRITE);
+      switchpoint_result = libev_wait_fd_with_watcher(backend, fd, &watcher, EV_WRITE);
 
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
@@ -585,26 +609,25 @@ VALUE Backend_write_m(int argc, VALUE *argv, VALUE self) {
 VALUE Backend_accept(VALUE self, VALUE server_socket, VALUE socket_class) {
   Backend_t *backend;
   struct libev_io watcher;
-  rb_io_t *fptr;
+  int server_fd;
+  rb_io_t *server_fptr;
   int fd;
   struct sockaddr addr;
   socklen_t len = (socklen_t)sizeof addr;
   VALUE switchpoint_result = Qnil;
-  VALUE underlying_sock = rb_ivar_get(server_socket, ID_ivar_io);
-  if (underlying_sock != Qnil) server_socket = underlying_sock;
 
   GetBackend(self, backend);
-  GetOpenFile(server_socket, fptr);
-  io_verify_blocking_mode(fptr, server_socket, Qfalse);
+  server_fd = fd_from_io(server_socket, &server_fptr, 0, 0);
   watcher.fiber = Qnil;
+
   while (1) {
     backend->base.op_count++;
-    fd = accept(fptr->fd, &addr, &len);
+    fd = accept(server_fd, &addr, &len);
     if (fd < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-      switchpoint_result = libev_wait_fd_with_watcher(backend, fptr->fd, &watcher, EV_READ);
+      switchpoint_result = libev_wait_fd_with_watcher(backend, server_fd, &watcher, EV_READ);
 
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
@@ -642,28 +665,25 @@ error:
 VALUE Backend_accept_loop(VALUE self, VALUE server_socket, VALUE socket_class) {
   Backend_t *backend;
   struct libev_io watcher;
-  rb_io_t *fptr;
-  int fd;
+  int server_fd;
+  rb_io_t *server_fptr;
   struct sockaddr addr;
   socklen_t len = (socklen_t)sizeof addr;
   VALUE switchpoint_result = Qnil;
   VALUE socket = Qnil;
-  VALUE underlying_sock = rb_ivar_get(server_socket, ID_ivar_io);
-  if (underlying_sock != Qnil) server_socket = underlying_sock;
 
   GetBackend(self, backend);
-  GetOpenFile(server_socket, fptr);
-  io_verify_blocking_mode(fptr, server_socket, Qfalse);
+  server_fd = fd_from_io(server_socket, &server_fptr, 0, 0);
   watcher.fiber = Qnil;
 
   while (1) {
     backend->base.op_count++;
-    fd = accept(fptr->fd, &addr, &len);
+    int fd = accept(server_fd, &addr, &len);
     if (fd < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-      switchpoint_result = libev_wait_fd_with_watcher(backend, fptr->fd, &watcher, EV_READ);
+      switchpoint_result = libev_wait_fd_with_watcher(backend, server_fd, &watcher, EV_READ);
 
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
@@ -701,28 +721,25 @@ error:
 VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
   Backend_t *backend;
   struct libev_io watcher;
+  int fd;
   rb_io_t *fptr;
   struct sockaddr *ai_addr;
   int ai_addrlen;
   VALUE switchpoint_result = Qnil;
-  VALUE underlying_sock = rb_ivar_get(sock, ID_ivar_io);
 
   ai_addrlen = backend_getaddrinfo(host, port, &ai_addr);
 
-  if (underlying_sock != Qnil) sock = underlying_sock;
-
   GetBackend(self, backend);
-  GetOpenFile(sock, fptr);
-  io_verify_blocking_mode(fptr, sock, Qfalse);
+  fd = fd_from_io(sock, &fptr, 1, 0);
   watcher.fiber = Qnil;
 
   backend->base.op_count++;
-  int result = connect(fptr->fd, ai_addr, ai_addrlen);
+  int result = connect(fd, ai_addr, ai_addrlen);
   if (result < 0) {
     int e = errno;
     if (e != EINPROGRESS) rb_syserr_fail(e, strerror(e));
 
-    switchpoint_result = libev_wait_fd_with_watcher(backend, fptr->fd, &watcher, EV_WRITE);
+    switchpoint_result = libev_wait_fd_with_watcher(backend, fd, &watcher, EV_WRITE);
 
     if (TEST_EXCEPTION(switchpoint_result)) goto error;
   }
@@ -740,36 +757,32 @@ error:
 VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
   Backend_t *backend;
   struct libev_io watcher;
+  int fd;
   rb_io_t *fptr;
   VALUE switchpoint_result = Qnil;
-  VALUE underlying_io;
-  char *buf = StringValuePtr(str);
-  long len = RSTRING_LEN(str);
-  long left = len;
+
+  struct io_buffer buffer = get_io_buffer(str);
+  long left = buffer.len;
   int flags_int = NUM2INT(flags);
 
-  underlying_io = rb_ivar_get(io, ID_ivar_io);
-  if (underlying_io != Qnil) io = underlying_io;
   GetBackend(self, backend);
-  io = rb_io_get_write_io(io);
-  GetOpenFile(io, fptr);
-  io_verify_blocking_mode(fptr, io, Qfalse);
+  fd = fd_from_io(io, &fptr, 1, 0);
   watcher.fiber = Qnil;
 
   while (left > 0) {
     backend->base.op_count++;
-    ssize_t n = send(fptr->fd, buf, left, flags_int);
-    if (n < 0) {
+    ssize_t result = send(fd, buffer.ptr, left, flags_int);
+    if (result < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-      switchpoint_result = libev_wait_fd_with_watcher(backend, fptr->fd, &watcher, EV_WRITE);
+      switchpoint_result = libev_wait_fd_with_watcher(backend, fd, &watcher, EV_WRITE);
 
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
-      buf += n;
-      left -= n;
+      buffer.ptr += result;
+      left -= result;
     }
   }
 
@@ -782,7 +795,7 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
   RB_GC_GUARD(watcher.fiber);
   RB_GC_GUARD(switchpoint_result);
 
-  return INT2NUM(len);
+  return INT2NUM(buffer.len);
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
@@ -837,41 +850,30 @@ VALUE libev_wait_rw_fd_with_watcher(Backend_t *backend, int r_fd, int w_fd, stru
   return switchpoint_result;
 }
 
-
-
-
 #ifdef POLYPHONY_LINUX
 VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   Backend_t *backend;
   struct libev_rw_io watcher;
   VALUE switchpoint_result = Qnil;
-  VALUE underlying_io;
+  int src_fd;
+  int dest_fd;
   rb_io_t *src_fptr;
   rb_io_t *dest_fptr;
   int len;
 
   GetBackend(self, backend);
-
-  underlying_io = rb_ivar_get(src, ID_ivar_io);
-  if (underlying_io != Qnil) src = underlying_io;
-  GetOpenFile(src, src_fptr);
-  io_verify_blocking_mode(src_fptr, src, Qfalse);
-
-  underlying_io = rb_ivar_get(dest, ID_ivar_io);
-  if (underlying_io != Qnil) dest = underlying_io;
-  dest = rb_io_get_write_io(dest);
-  GetOpenFile(dest, dest_fptr);
-  io_verify_blocking_mode(dest_fptr, dest, Qfalse);
-
+  src_fd = fd_from_io(src, &src_fptr, 0, 0);
+  dest_fd = fd_from_io(dest, &dest_fptr, 1, 0);
   watcher.ctx.fiber = Qnil;
+
   while (1) {
     backend->base.op_count++;
-    len = splice(src_fptr->fd, 0, dest_fptr->fd, 0, NUM2INT(maxlen), 0);
+    len = splice(src_fd, 0, dest_fd, 0, NUM2INT(maxlen), 0);
     if (len < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-      switchpoint_result = libev_wait_rw_fd_with_watcher(backend, src_fptr->fd, dest_fptr->fd, &watcher);
+      switchpoint_result = libev_wait_rw_fd_with_watcher(backend, src_fd, dest_fd, &watcher);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
@@ -896,34 +898,26 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   Backend_t *backend;
   struct libev_rw_io watcher;
   VALUE switchpoint_result = Qnil;
-  VALUE underlying_io;
+  int src_fd;
+  int dest_fd;
   rb_io_t *src_fptr;
   rb_io_t *dest_fptr;
   int len;
   int total = 0;
 
   GetBackend(self, backend);
-
-  underlying_io = rb_ivar_get(src, ID_ivar_io);
-  if (underlying_io != Qnil) src = underlying_io;
-  GetOpenFile(src, src_fptr);
-  io_verify_blocking_mode(src_fptr, src, Qfalse);
-
-  underlying_io = rb_ivar_get(dest, ID_ivar_io);
-  if (underlying_io != Qnil) dest = underlying_io;
-  dest = rb_io_get_write_io(dest);
-  GetOpenFile(dest, dest_fptr);
-  io_verify_blocking_mode(dest_fptr, dest, Qfalse);
-
+  src_fd = fd_from_io(src, &src_fptr, 0, 0);
+  dest_fd = fd_from_io(dest, &dest_fptr, 1, 0);
   watcher.ctx.fiber = Qnil;
+
   while (1) {
     backend->base.op_count++;
-    len = splice(src_fptr->fd, 0, dest_fptr->fd, 0, NUM2INT(maxlen), 0);
+    len = splice(src_fd, 0, dest_fd, 0, NUM2INT(maxlen), 0);
     if (len < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-      switchpoint_result = libev_wait_rw_fd_with_watcher(backend, src_fptr->fd, dest_fptr->fd, &watcher);
+      switchpoint_result = libev_wait_rw_fd_with_watcher(backend, src_fd, dest_fd, &watcher);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else if (len == 0) {
@@ -946,12 +940,58 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
 error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
+
+VALUE Backend_tee(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
+  Backend_t *backend;
+  struct libev_rw_io watcher;
+  VALUE switchpoint_result = Qnil;
+  int src_fd;
+  int dest_fd;
+  rb_io_t *src_fptr;
+  rb_io_t *dest_fptr;
+  int len;
+
+  GetBackend(self, backend);
+  src_fd = fd_from_io(src, &src_fptr, 0, 0);
+  dest_fd = fd_from_io(dest, &dest_fptr, 1, 0);
+  watcher.ctx.fiber = Qnil;
+
+  while (1) {
+    backend->base.op_count++;
+    len = tee(src_fd, dest_fd, NUM2INT(maxlen), 0);
+    if (len < 0) {
+      int e = errno;
+      if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
+
+      switchpoint_result = libev_wait_rw_fd_with_watcher(backend, src_fd, dest_fd, &watcher);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    }
+    else {
+      break;
+    }
+  }
+
+  if (watcher.ctx.fiber == Qnil) {
+    switchpoint_result = backend_snooze(&backend->base);
+    if (TEST_EXCEPTION(switchpoint_result)) goto error;
+  }
+
+  RB_GC_GUARD(watcher.ctx.fiber);
+  RB_GC_GUARD(switchpoint_result);
+
+  return INT2NUM(len);
+error:
+  return RAISE_EXCEPTION(switchpoint_result);
+}
+
 #else
+
 VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   Backend_t *backend;
   struct libev_io watcher;
   VALUE switchpoint_result = Qnil;
-  VALUE underlying_io;
+  int src_fd;
+  int dest_fd;
   rb_io_t *src_fptr;
   rb_io_t *dest_fptr;
   int len = NUM2INT(maxlen);
@@ -961,28 +1001,18 @@ VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   int total = 0;
 
   GetBackend(self, backend);
-
-  underlying_io = rb_ivar_get(src, ID_ivar_io);
-  if (underlying_io != Qnil) src = underlying_io;
-  GetOpenFile(src, src_fptr);
-  io_verify_blocking_mode(src_fptr, src, Qfalse);
-
-  underlying_io = rb_ivar_get(dest, ID_ivar_io);
-  if (underlying_io != Qnil) dest = underlying_io;
-  dest = rb_io_get_write_io(dest);
-  GetOpenFile(dest, dest_fptr);
-  io_verify_blocking_mode(dest_fptr, dest, Qfalse);
-
+  src_fd = fd_from_io(src, &src_fptr, 0, 0);
+  dest_fd = fd_from_io(dest, &dest_fptr, 1, 0);
   watcher.fiber = Qnil;
 
   while (1) {
     backend->base.op_count++;
-    ssize_t n = read(src_fptr->fd, buf, len);
+    ssize_t n = read(src_fd, buf, len);
     if (n < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-      switchpoint_result = libev_wait_fd_with_watcher(backend, src_fptr->fd, &watcher, EV_READ);
+      switchpoint_result = libev_wait_fd_with_watcher(backend, src_fd, &watcher, EV_READ);
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
     else {
@@ -993,12 +1023,12 @@ VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
 
   while (left > 0) {
     backend->base.op_count++;
-    ssize_t n = write(dest_fptr->fd, buf, left);
+    ssize_t n = write(dest_fd, buf, left);
     if (n < 0) {
       int e = errno;
       if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-      switchpoint_result = libev_wait_fd_with_watcher(backend, dest_fptr->fd, &watcher, EV_WRITE);
+      switchpoint_result = libev_wait_fd_with_watcher(backend, dest_fd, &watcher, EV_WRITE);
 
       if (TEST_EXCEPTION(switchpoint_result)) goto error;
     }
@@ -1026,7 +1056,8 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   Backend_t *backend;
   struct libev_io watcher;
   VALUE switchpoint_result = Qnil;
-  VALUE underlying_io;
+  int src_fd;
+  int dest_fd;
   rb_io_t *src_fptr;
   rb_io_t *dest_fptr;
   int len = NUM2INT(maxlen);
@@ -1036,30 +1067,20 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   int total = 0;
 
   GetBackend(self, backend);
-
-  underlying_io = rb_ivar_get(src, ID_ivar_io);
-  if (underlying_io != Qnil) src = underlying_io;
-  GetOpenFile(src, src_fptr);
-  io_verify_blocking_mode(src_fptr, src, Qfalse);
-
-  underlying_io = rb_ivar_get(dest, ID_ivar_io);
-  if (underlying_io != Qnil) dest = underlying_io;
-  dest = rb_io_get_write_io(dest);
-  GetOpenFile(dest, dest_fptr);
-  io_verify_blocking_mode(dest_fptr, dest, Qfalse);
-
+  src_fd = fd_from_io(src, &src_fptr, 0, 0);
+  dest_fd = fd_from_io(dest, &dest_fptr, 1, 0);
   watcher.fiber = Qnil;
 
   while (1) {
     char *ptr = buf;
     while (1) {
       backend->base.op_count++;
-      ssize_t n = read(src_fptr->fd, ptr, len);
+      ssize_t n = read(src_fd, ptr, len);
       if (n < 0) {
         int e = errno;
         if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-        switchpoint_result = libev_wait_fd_with_watcher(backend, src_fptr->fd, &watcher, EV_READ);
+        switchpoint_result = libev_wait_fd_with_watcher(backend, src_fd, &watcher, EV_READ);
         if (TEST_EXCEPTION(switchpoint_result)) goto error;
       }
       else if (n == 0) goto done;
@@ -1072,12 +1093,12 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
 
     while (left > 0) {
       backend->base.op_count++;
-      ssize_t n = write(dest_fptr->fd, ptr, left);
+      ssize_t n = write(dest_fd, ptr, left);
       if (n < 0) {
         int e = errno;
         if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
 
-        switchpoint_result = libev_wait_fd_with_watcher(backend, dest_fptr->fd, &watcher, EV_WRITE);
+        switchpoint_result = libev_wait_fd_with_watcher(backend, dest_fd, &watcher, EV_WRITE);
         if (TEST_EXCEPTION(switchpoint_result)) goto error;
       }
       else {
@@ -1105,15 +1126,15 @@ error:
 
 VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
   Backend_t *backend;
+  int fd;
   rb_io_t *fptr;
-  int events = RTEST(write) ? EV_WRITE : EV_READ;
-  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
-  if (underlying_io != Qnil) io = underlying_io;
+  int write_mode = RTEST(write);
+  int events = write_mode ? EV_WRITE : EV_READ;
   GetBackend(self, backend);
-  GetOpenFile(io, fptr);
+  fd = fd_from_io(io, &fptr, write_mode, 0);
 
   backend->base.op_count++;
-  return libev_wait_fd(backend, fptr->fd, events, 1);
+  return libev_wait_fd(backend, fd, events, 1);
 }
 
 struct libev_timer {
@@ -1460,19 +1481,13 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
   int err = 0;
   VALUE result = Qnil;
 
+  int src_fd;
+  int dest_fd;
   rb_io_t *src_fptr;
   rb_io_t *dest_fptr;
 
-  VALUE underlying_io = rb_ivar_get(src, ID_ivar_io);
-  if (underlying_io != Qnil) src = underlying_io;
-  GetOpenFile(src, src_fptr);
-  io_verify_blocking_mode(src_fptr, src, Qfalse);
-
-  underlying_io = rb_ivar_get(dest, ID_ivar_io);
-  if (underlying_io != Qnil) dest = underlying_io;
-  dest = rb_io_get_write_io(dest);
-  GetOpenFile(dest, dest_fptr);
-  io_verify_blocking_mode(dest_fptr, dest, Qfalse);
+  src_fd = fd_from_io(src, &src_fptr, 0, 0);
+  dest_fd = fd_from_io(dest, &dest_fptr, 1, 0);
 
   struct libev_rw_io watcher;
   watcher.ctx.fiber = Qnil;
@@ -1490,12 +1505,12 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
   fcntl(pipefd[1], F_SETFL, O_NONBLOCK);
 
   if (prefix != Qnil) {
-    err = splice_chunks_write(backend, dest_fptr->fd, prefix, &watcher, &result);
+    err = splice_chunks_write(backend, dest_fd, prefix, &watcher, &result);
     if (err == -1) goto error; else if (err) goto syscallerror;
   }
   while (1) {
     int chunk_len = 0;
-    err = splice_chunks_splice(backend, src_fptr->fd, pipefd[1], maxlen, &watcher, &result, &chunk_len);
+    err = splice_chunks_splice(backend, src_fd, pipefd[1], maxlen, &watcher, &result, &chunk_len);
     if (err == -1) goto error; else if (err) goto syscallerror;
     if (chunk_len == 0) break;
 
@@ -1504,14 +1519,14 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
 
     if (chunk_prefix != Qnil) {
       VALUE str = (TYPE(chunk_prefix) == T_STRING) ? chunk_prefix : rb_funcall(chunk_prefix, ID_call, 1, chunk_len_value);
-      int err = splice_chunks_write(backend, dest_fptr->fd, str, &watcher, &result);
+      int err = splice_chunks_write(backend, dest_fd, str, &watcher, &result);
       if (err == -1) goto error; else if (err) goto syscallerror;
     }
 
     int left = chunk_len;
     while (left > 0) {
       int len;
-      err = splice_chunks_splice(backend, pipefd[0], dest_fptr->fd, left, &watcher, &result, &len);
+      err = splice_chunks_splice(backend, pipefd[0], dest_fd, left, &watcher, &result, &len);
       if (err == -1) goto error; else if (err) goto syscallerror;
 
       left -= len;
@@ -1519,13 +1534,13 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
 
     if (chunk_postfix != Qnil) {
       VALUE str = (TYPE(chunk_postfix) == T_STRING) ? chunk_postfix : rb_funcall(chunk_postfix, ID_call, 1, chunk_len_value);
-      int err = splice_chunks_write(backend, dest_fptr->fd, str, &watcher, &result);
+      int err = splice_chunks_write(backend, dest_fd, str, &watcher, &result);
       if (err == -1) goto error; else if (err) goto syscallerror;
     }
   }
 
   if (postfix != Qnil) {
-    int err = splice_chunks_write(backend, dest_fptr->fd, postfix, &watcher, &result);
+    int err = splice_chunks_write(backend, dest_fd, postfix, &watcher, &result);
     if (err == -1) goto error; else if (err) goto syscallerror;
   }