polyphony 0.81.1 → 0.84

data/ext/polyphony/backend_io_uring.c

@@ -14,7 +14,7 @@
 #include <errno.h>
 
 #include "polyphony.h"
-#include "../liburing/liburing.h"
+#include "liburing.h"
 #include "backend_io_uring_context.h"
 #include "ruby/thread.h"
 #include "ruby/io.h"
@@ -102,24 +102,6 @@ static VALUE Backend_initialize(VALUE self) {
   return self;
 }
 
-static inline struct io_buffer get_io_buffer(VALUE in) {
-  if (FIXNUM_P(in)) {
-    struct raw_buffer *raw = (struct raw_buffer *)(FIX2LONG(in));
-    return (struct io_buffer){ raw->base, raw->size, 1 };
-  }
-  return (struct io_buffer){ RSTRING_PTR(in), RSTRING_LEN(in), 0 };
-}
-
-static inline VALUE coerce_io_string_or_buffer(VALUE buf) {
-  switch (TYPE(buf)) {
-    case T_STRING:
-    case T_FIXNUM:
-      return buf;
-    default:
-      return StringValue(buf);
-  }
-}
-
 VALUE Backend_finalize(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
@@ -322,7 +304,7 @@ int io_uring_backend_defer_submit_and_await(
     // op was not completed (an exception was raised), so we need to cancel it
     ctx->result = -ECANCELED;
     sqe = io_uring_get_sqe(&backend->ring);
-    io_uring_prep_cancel(sqe, ctx, 0);
+    io_uring_prep_cancel(sqe, (__u64)ctx, 0);
     backend->pending_sqes = 0;
     io_uring_submit(&backend->ring);
   }
@@ -347,8 +329,26 @@ VALUE io_uring_backend_wait_fd(Backend_t *backend, int fd, int write) {
   return resumed_value;
 }
 
+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;
+    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_unset_nonblock(*fptr, io);
+    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;
+  int fd;
   rb_io_t *fptr;
   struct io_buffer buffer = get_io_buffer(str);
   long buf_pos = NUM2INT(pos);
@@ -356,38 +356,33 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
   int expandable_buffer = 0;
   long total = 0;
   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.size) buf_pos = buffer.size;
-    buffer.base += buf_pos;
-    buffer.size -= buf_pos;
+    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.size) buf_pos = buffer.size;
+    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.base = RSTRING_PTR(str) + buf_pos;
-      buffer.size = expected_read_length;
+      buffer.ptr = RSTRING_PTR(str) + buf_pos;
+      buffer.len = expected_read_length;
     }
     else {
-      buffer.base += buf_pos;
-      buffer.size = string_cap - buf_pos;
-      if (buffer.size > expected_read_length)
-        buffer.size = expected_read_length;
+      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_unset_nonblock(fptr, io);
-  rectify_io_file_pos(fptr);
+  fd = fd_from_io(io, &fptr, 0, 1);
 
   while (1) {
     VALUE resume_value = Qnil;
@@ -396,7 +391,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
     int result;
     int completed;
     
-    io_uring_prep_read(sqe, fptr->fd, buffer.base, buffer.size, -1);
+    io_uring_prep_read(sqe, fd, buffer.ptr, buffer.len, -1);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -415,29 +410,28 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
       total += result;
       if (!read_to_eof) break;
 
-      if (result == buffer.size) {
+      if (result == buffer.len) {
         if (!expandable_buffer) break;
 
         // 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.base = RSTRING_PTR(str) + total + buf_pos;
-        buffer.size = rb_str_capacity(str) - total - buf_pos;
+        buffer.ptr = RSTRING_PTR(str) + total + buf_pos;
+        buffer.len = rb_str_capacity(str) - total - buf_pos;
       }
       else {
-        buffer.base += result;
-        buffer.size -= result;
-        if (!buffer.size) break;
+        buffer.ptr += result;
+        buffer.len -= result;
+        if (!buffer.len) break;
       }
     }
   }
 
   if (!buffer.raw) {
     io_set_read_length(str, buf_pos + total, shrinkable_string);
-    io_enc_str(str, fptr);
+    if (fptr) io_enc_str(str, fptr);
   }
-
   if (!total) return Qnil;
 
   return buffer.raw ? INT2FIX(total) : str;
@@ -445,22 +439,18 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
 
 VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
   Backend_t *backend;
+  int fd;
   rb_io_t *fptr;
   VALUE str;
   long total;
   long len = NUM2INT(maxlen);
   int shrinkable;
   char *buf;
-  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_unset_nonblock(fptr, io);
-  rectify_io_file_pos(fptr);
+  fd = fd_from_io(io, &fptr, 0, 1);
 
   while (1) {
     VALUE resume_value = Qnil;
@@ -469,7 +459,7 @@ VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
     ssize_t result;
     int completed;
 
-    io_uring_prep_read(sqe, fptr->fd, buf, len, -1);
+    io_uring_prep_read(sqe, fd, buf, len, -1);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -497,23 +487,19 @@ VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
 
 VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
   Backend_t *backend;
+  int fd;
   rb_io_t *fptr;
   VALUE str;
   long total;
   long len = 8192;
   int shrinkable;
   char *buf;
-  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_unset_nonblock(fptr, io);
-  rectify_io_file_pos(fptr);
+  fd = fd_from_io(io, &fptr, 0, 1);
 
   while (1) {
     VALUE resume_value = Qnil;
@@ -522,7 +508,7 @@ VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
     ssize_t result;
     int completed;
 
-    io_uring_prep_read(sqe, fptr->fd, buf, len, -1);
+    io_uring_prep_read(sqe, fd, buf, len, -1);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -550,18 +536,14 @@ VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
 
 VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   Backend_t *backend;
+  int fd;
   rb_io_t *fptr;
-  VALUE underlying_io;
 
   struct io_buffer buffer = get_io_buffer(str);
-  long left = buffer.size;
+  long left = buffer.len;
 
-  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_unset_nonblock(fptr, io);
+  fd = fd_from_io(io, &fptr, 1, 0);
 
   while (left > 0) {
     VALUE resume_value = Qnil;
@@ -570,7 +552,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
     int result;
     int completed;
 
-    io_uring_prep_write(sqe, fptr->fd, buffer.base, left, 0);
+    io_uring_prep_write(sqe, fd, buffer.ptr, left, 0);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -584,31 +566,26 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
     if (result < 0)
       rb_syserr_fail(-result, strerror(-result));
     else {
-      buffer.base += result;
-      buffer.size -= result;
+      buffer.ptr += result;
       left -= result;
     }
   }
 
-  return INT2NUM(buffer.size);
+  return INT2NUM(buffer.len);
 }
 
 VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
   Backend_t *backend;
+  int fd;
   rb_io_t *fptr;
-  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_unset_nonblock(fptr, io);
+  fd = fd_from_io(io, &fptr, 1, 0);
 
   iov = malloc(iov_count * sizeof(struct iovec));
   for (int i = 0; i < argc; i++) {
@@ -626,7 +603,7 @@ VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
     int result;
     int completed;
 
-    io_uring_prep_writev(sqe, fptr->fd, iov_ptr, iov_count, -1);
+    io_uring_prep_writev(sqe, fd, iov_ptr, iov_count, -1);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -676,29 +653,40 @@ VALUE Backend_write_m(int argc, VALUE *argv, VALUE self) {
 
 VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
   Backend_t *backend;
+  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);
-  int shrinkable;
-  char *buf;
+  int shrinkable_string = 0;
+  int expandable_buffer = 0;
   long total = 0;
-  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);;
 
-  if (str != Qnil) {
-    int current_len = RSTRING_LEN(str);
-    if (buf_pos < 0 || buf_pos > current_len) buf_pos = current_len;
+  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;
+    }
   }
-  else buf_pos = 0;
-  shrinkable = io_setstrbuf(&str, buf_pos + len);
-  buf = RSTRING_PTR(str) + buf_pos;
 
   GetBackend(self, backend);
-  if (underlying_io != Qnil) io = underlying_io;
-  GetOpenFile(io, fptr);
-  rb_io_check_byte_readable(fptr);
-  io_unset_nonblock(fptr, io);
-  rectify_io_file_pos(fptr);
+  fd = fd_from_io(io, &fptr, 0, 0);
 
   while (1) {
     VALUE resume_value = Qnil;
@@ -707,7 +695,7 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
     int result;
     int completed;
 
-    io_uring_prep_recv(sqe, fptr->fd, buf, len - total, 0);
+    io_uring_prep_recv(sqe, fd, buffer.ptr, buffer.len, 0);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -726,32 +714,29 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
     }
   }
 
-  io_set_read_length(str, buf_pos + total, shrinkable);
-  io_enc_str(str, fptr);
-
+  if (!buffer.raw) {
+    io_set_read_length(str, buf_pos + total, shrinkable_string);
+    if (fptr) io_enc_str(str, fptr);
+  }
   if (!total) return Qnil;
 
-  return str;
+  return buffer.raw ? INT2FIX(total) : str;
 }
 
 VALUE Backend_recv_loop(VALUE self, VALUE io, VALUE maxlen) {
   Backend_t *backend;
+  int fd;
   rb_io_t *fptr;
   VALUE str;
   long total;
   long len = NUM2INT(maxlen);
   int shrinkable;
   char *buf;
-  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_unset_nonblock(fptr, io);
-  rectify_io_file_pos(fptr);
+  fd = fd_from_io(io, &fptr, 0, 0);
 
   while (1) {
     VALUE resume_value = Qnil;
@@ -760,7 +745,7 @@ VALUE Backend_recv_loop(VALUE self, VALUE io, VALUE maxlen) {
     int result;
     int completed;
 
-    io_uring_prep_recv(sqe, fptr->fd, buf, len, 0);
+    io_uring_prep_recv(sqe, fd, buf, len, 0);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -787,23 +772,19 @@ VALUE Backend_recv_loop(VALUE self, VALUE io, VALUE maxlen) {
 
 VALUE Backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
   Backend_t *backend;
+  int fd;
   rb_io_t *fptr;
   VALUE str;
   long total;
   long len = 8192;
   int shrinkable;
   char *buf;
-  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_unset_nonblock(fptr, io);
-  rectify_io_file_pos(fptr);
+  fd = fd_from_io(io, &fptr, 0, 0);
 
   while (1) {
     VALUE resume_value = Qnil;
@@ -812,7 +793,7 @@ VALUE Backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method)
     int result;
     int completed;
 
-    io_uring_prep_recv(sqe, fptr->fd, buf, len, 0);
+    io_uring_prep_recv(sqe, fd, buf, len, 0);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -839,24 +820,15 @@ VALUE Backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method)
 
 VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
   Backend_t *backend;
+  int fd;
   rb_io_t *fptr;
-  VALUE underlying_io;
-  char *buf;
-  long len;
-  long left;
-  int flags_int;
 
-  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_unset_nonblock(fptr, io);
+  struct io_buffer buffer = get_io_buffer(str);
+  long left = buffer.len;
+  int flags_int = NUM2INT(flags);
 
-  buf = StringValuePtr(str);
-  len = RSTRING_LEN(str);
-  left = len;
-  flags_int = NUM2INT(flags);
+  GetBackend(self, backend);
+  fd = fd_from_io(io, &fptr, 1, 0);
 
   while (left > 0) {
     VALUE resume_value = Qnil;
@@ -865,7 +837,7 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
     int result;
     int completed;
 
-    io_uring_prep_send(sqe, fptr->fd, buf, left, flags_int);
+    io_uring_prep_send(sqe, fd, buffer.ptr, left, flags_int);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -879,24 +851,22 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
     if (result < 0)
       rb_syserr_fail(-result, strerror(-result));
     else {
-      buf += result;
+      buffer.ptr += result;
       left -= result;
     }
   }
 
-  return INT2NUM(len);
+  return INT2NUM(buffer.len);
 }
 
 VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, VALUE socket_class, int loop) {
-  rb_io_t *fptr;
+  int server_fd;
+  rb_io_t *server_fptr;
   struct sockaddr addr;
   socklen_t len = (socklen_t)sizeof addr;
   VALUE socket = Qnil;
-  VALUE underlying_sock = rb_ivar_get(server_socket, ID_ivar_io);
-  if (underlying_sock != Qnil) server_socket = underlying_sock;
 
-  GetOpenFile(server_socket, fptr);
-  io_unset_nonblock(fptr, server_socket);
+  server_fd = fd_from_io(server_socket, &server_fptr, 0, 0);
 
   while (1) {
     VALUE resume_value = Qnil;
@@ -905,7 +875,7 @@ VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, VALUE soc
     int fd;
     int completed;
 
-    io_uring_prep_accept(sqe, fptr->fd, &addr, &len, 0);
+    io_uring_prep_accept(sqe, server_fd, &addr, &len, 0);
 
     fd = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -955,22 +925,15 @@ VALUE Backend_accept_loop(VALUE self, VALUE server_socket, VALUE socket_class) {
 }
 
 VALUE io_uring_backend_splice(Backend_t *backend, VALUE src, VALUE dest, VALUE maxlen, int loop) {
+  int src_fd;
+  int dest_fd;
   rb_io_t *src_fptr;
   rb_io_t *dest_fptr;
-  VALUE underlying_io;
   int total = 0;
   VALUE resume_value = Qnil;
 
-  underlying_io = rb_ivar_get(src, ID_ivar_io);
-  if (underlying_io != Qnil) src = underlying_io;
-  GetOpenFile(src, src_fptr);
-  io_unset_nonblock(src_fptr, src);
-
-  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_unset_nonblock(dest_fptr, dest);
+  src_fd = fd_from_io(src, &src_fptr, 0, 0);
+  dest_fd = fd_from_io(dest, &dest_fptr, 1, 0);
 
   while (1) {
     op_context_t *ctx = context_store_acquire(&backend->store, OP_SPLICE);
@@ -978,7 +941,7 @@ VALUE io_uring_backend_splice(Backend_t *backend, VALUE src, VALUE dest, VALUE m
     int result;
     int completed;
 
-    io_uring_prep_splice(sqe, src_fptr->fd, -1, dest_fptr->fd, -1, NUM2INT(maxlen), 0);
+    io_uring_prep_splice(sqe, src_fd, -1, dest_fd, -1, NUM2INT(maxlen), 0);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -998,7 +961,6 @@ VALUE io_uring_backend_splice(Backend_t *backend, VALUE src, VALUE dest, VALUE m
 VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   Backend_t *backend;
   GetBackend(self, backend);
-
   return io_uring_backend_splice(backend, src, dest, maxlen, 0);
 }
 
@@ -1009,12 +971,47 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE chunksize)
   return io_uring_backend_splice(backend, src, dest, chunksize, 1);
 }
 
+VALUE Backend_tee(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  int src_fd;
+  int dest_fd;
+  rb_io_t *src_fptr;
+  rb_io_t *dest_fptr;
+  VALUE resume_value = Qnil;
+
+  src_fd = fd_from_io(src, &src_fptr, 0, 0);
+  dest_fd = fd_from_io(dest, &dest_fptr, 1, 0);
+
+  while (1) {
+    op_context_t *ctx = context_store_acquire(&backend->store, OP_SPLICE);
+    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    int result;
+    int completed;
+
+    io_uring_prep_tee(sqe, src_fd, dest_fd, NUM2INT(maxlen), 0);
+
+    result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
+    completed = context_store_release(&backend->store, ctx);
+    RAISE_IF_EXCEPTION(resume_value);
+    if (!completed) return resume_value;
+
+    if (result < 0)
+      rb_syserr_fail(-result, strerror(-result));
+
+    return INT2NUM(result);
+  }
+
+  RB_GC_GUARD(resume_value);
+}
+
 VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
   Backend_t *backend;
+  int fd;
   rb_io_t *fptr;
   struct sockaddr *ai_addr;
   int ai_addrlen;
-  VALUE underlying_sock = rb_ivar_get(sock, ID_ivar_io);
   VALUE resume_value = Qnil;
   op_context_t *ctx;
   struct io_uring_sqe *sqe;
@@ -1023,15 +1020,11 @@ VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
 
   ai_addrlen = backend_getaddrinfo(host, port, &ai_addr);
 
-  if (underlying_sock != Qnil) sock = underlying_sock;
-
   GetBackend(self, backend);
-  GetOpenFile(sock, fptr);
-  io_unset_nonblock(fptr, sock);
-
+  fd = fd_from_io(sock, &fptr, 1, 0);
   ctx = context_store_acquire(&backend->store, OP_CONNECT);
   sqe = io_uring_get_sqe(&backend->ring);
-  io_uring_prep_connect(sqe, fptr->fd, ai_addr, ai_addrlen);
+  io_uring_prep_connect(sqe, fd, ai_addr, ai_addrlen);
   result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
   completed = context_store_release(&backend->store, ctx);
   RAISE_IF_EXCEPTION(resume_value);
@@ -1044,16 +1037,14 @@ VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
 
 VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
   Backend_t *backend;
+  int fd;
   rb_io_t *fptr;
-  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
   VALUE resume_value;
+  int write_mode = RTEST(write);
 
-  if (underlying_io != Qnil) io = underlying_io;
   GetBackend(self, backend);
-  GetOpenFile(io, fptr);
-  io_unset_nonblock(fptr, io);
-
-  resume_value = io_uring_backend_wait_fd(backend, fptr->fd, RTEST(write));
+  fd = fd_from_io(io, &fptr, write_mode, 0);
+  resume_value = io_uring_backend_wait_fd(backend, fd, write_mode);
 
   RAISE_IF_EXCEPTION(resume_value);
   RB_GC_GUARD(resume_value);
@@ -1063,24 +1054,19 @@ VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
 // VALUE Backend_close(VALUE self, VALUE io) {
 //   Backend_t *backend;
 //   rb_io_t *fptr;
-//   VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
 //   VALUE resume_value = Qnil;
 //   op_context_t *ctx;
 //   struct io_uring_sqe *sqe;
 //   int result;
 //   int completed;
 
-//   if (underlying_io != Qnil) io = underlying_io;
-//   GetBackend(self, backend);
-//   GetOpenFile(io, fptr);
-
-//   if (fptr->fd < 0) return Qnil;
+//   if (fd < 0) return Qnil;
 
 //   io_unset_nonblock(fptr, io);
 
 //   ctx = context_store_acquire(&backend->store, OP_CLOSE);
 //   sqe = io_uring_get_sqe(&backend->ring);
-//   io_uring_prep_close(sqe, fptr->fd);
+//   io_uring_prep_close(sqe, fd);
 //   result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
 //   completed = context_store_release(&backend->store, ctx);
 //   RAISE_IF_EXCEPTION(resume_value);
@@ -1090,7 +1076,7 @@ VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
 //   if (result < 0) rb_syserr_fail(-result, strerror(-result));
 
 //   fptr_finalize(fptr);
-//   // fptr->fd = -1;
+//   // fd = -1;
 //   return io;
 // }
 
@@ -1174,7 +1160,7 @@ VALUE Backend_timeout_ensure(VALUE arg) {
     timeout_ctx->ctx->result = -ECANCELED;
     // op was not completed, so we need to cancel it
     sqe = io_uring_get_sqe(&timeout_ctx->backend->ring);
-    io_uring_prep_cancel(sqe, timeout_ctx->ctx, 0);
+    io_uring_prep_cancel(sqe, (__u64)timeout_ctx->ctx, 0);
     timeout_ctx->backend->pending_sqes = 0;
     io_uring_submit(&timeout_ctx->backend->ring);
   }
@@ -1276,56 +1262,39 @@ VALUE Backend_kind(VALUE self) {
 }
 
 struct io_uring_sqe *Backend_chain_prepare_write(Backend_t *backend, VALUE io, VALUE str) {
+  int fd;
   rb_io_t *fptr;
-  VALUE underlying_io;
   struct io_uring_sqe *sqe;
 
-  underlying_io = rb_ivar_get(io, ID_ivar_io);
-  if (underlying_io != Qnil) io = underlying_io;
-  io = rb_io_get_write_io(io);
-  GetOpenFile(io, fptr);
-  io_unset_nonblock(fptr, io);
-
+  fd = fd_from_io(io, &fptr, 1, 0);
   sqe = io_uring_get_sqe(&backend->ring);
-  io_uring_prep_write(sqe, fptr->fd, StringValuePtr(str), RSTRING_LEN(str), 0);
+  io_uring_prep_write(sqe, fd, StringValuePtr(str), RSTRING_LEN(str), 0);
   return sqe;
 }
 
 struct io_uring_sqe *Backend_chain_prepare_send(Backend_t *backend, VALUE io, VALUE str, VALUE flags) {
+  int fd;
   rb_io_t *fptr;
-  VALUE underlying_io;
   struct io_uring_sqe *sqe;
 
-  underlying_io = rb_ivar_get(io, ID_ivar_io);
-  if (underlying_io != Qnil) io = underlying_io;
-  io = rb_io_get_write_io(io);
-  GetOpenFile(io, fptr);
-  io_unset_nonblock(fptr, io);
+  fd = fd_from_io(io, &fptr, 1, 0);
 
   sqe = io_uring_get_sqe(&backend->ring);
-  io_uring_prep_send(sqe, fptr->fd, StringValuePtr(str), RSTRING_LEN(str), NUM2INT(flags));
+  io_uring_prep_send(sqe, fd, StringValuePtr(str), RSTRING_LEN(str), NUM2INT(flags));
   return sqe;
 }
 
 struct io_uring_sqe *Backend_chain_prepare_splice(Backend_t *backend, VALUE src, VALUE dest, VALUE maxlen) {
+  int src_fd;
+  int dest_fd;
   rb_io_t *src_fptr;
   rb_io_t *dest_fptr;
-  VALUE underlying_io;
   struct io_uring_sqe *sqe;
 
-  underlying_io = rb_ivar_get(src, ID_ivar_io);
-  if (underlying_io != Qnil) src = underlying_io;
-  GetOpenFile(src, src_fptr);
-  io_unset_nonblock(src_fptr, src);
-
-  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_unset_nonblock(dest_fptr, dest);
-
+  src_fd = fd_from_io(src, &src_fptr, 0, 0);
+  dest_fd = fd_from_io(dest, &dest_fptr, 1, 0);
   sqe = io_uring_get_sqe(&backend->ring);
-  io_uring_prep_splice(sqe, src_fptr->fd, -1, dest_fptr->fd, -1, NUM2INT(maxlen), 0);
+  io_uring_prep_splice(sqe, src_fd, -1, dest_fd, -1, NUM2INT(maxlen), 0);
   return sqe;
 }
 
@@ -1384,7 +1353,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
         ctx->ref_count = sqe_count;
         ctx->result = -ECANCELED;
         sqe = io_uring_get_sqe(&backend->ring);
-        io_uring_prep_cancel(sqe, ctx, 0);
+        io_uring_prep_cancel(sqe, (__u64)ctx, 0);
         backend->pending_sqes = 0;
         io_uring_submit(&backend->ring);
       }
@@ -1415,7 +1384,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
     // op was not completed (an exception was raised), so we need to cancel it
     ctx->result = -ECANCELED;
     sqe = io_uring_get_sqe(&backend->ring);
-    io_uring_prep_cancel(sqe, ctx, 0);
+    io_uring_prep_cancel(sqe, (__u64)ctx, 0);
     backend->pending_sqes = 0;
     io_uring_submit(&backend->ring);
     RAISE_IF_EXCEPTION(resume_value);
@@ -1482,7 +1451,7 @@ static inline void splice_chunks_cancel(Backend_t *backend, op_context_t *ctx) {
   
   ctx->result = -ECANCELED;
   sqe = io_uring_get_sqe(&backend->ring);
-  io_uring_prep_cancel(sqe, ctx, 0);
+  io_uring_prep_cancel(sqe, (__u64)ctx, 0);
   backend->pending_sqes = 0;
   io_uring_submit(&backend->ring);
 }
@@ -1518,25 +1487,17 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
   op_context_t *ctx = 0;
   struct io_uring_sqe *sqe = 0;
   int maxlen;
-  VALUE underlying_io;
   VALUE str = Qnil;
   VALUE chunk_len_value = Qnil;
+  int src_fd;
+  int dest_fd;
   rb_io_t *src_fptr;
   rb_io_t *dest_fptr;
   int pipefd[2] = { -1, -1 };
 
   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, Qtrue);
-
-  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, Qtrue);
+  src_fd = fd_from_io(src, &src_fptr, 0, 0);
+  dest_fd = fd_from_io(dest, &dest_fptr, 1, 0);
 
   maxlen = NUM2INT(chunk_size);
 
@@ -1547,7 +1508,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
 
   if (prefix != Qnil) {
     splice_chunks_get_sqe(backend, &ctx, &sqe, OP_WRITE);
-    splice_chunks_prep_write(ctx, sqe, dest_fptr->fd, prefix);
+    splice_chunks_prep_write(ctx, sqe, dest_fd, prefix);
     backend->base.op_count++;
   }
 
@@ -1557,7 +1518,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
     VALUE chunk_postfix_str = Qnil;
 
     splice_chunks_get_sqe(backend, &ctx, &sqe, OP_SPLICE);
-    splice_chunks_prep_splice(ctx, sqe, src_fptr->fd, pipefd[1], maxlen);
+    splice_chunks_prep_splice(ctx, sqe, src_fd, pipefd[1], maxlen);
     backend->base.op_count++;
 
     SPLICE_CHUNKS_AWAIT_OPS(backend, &ctx, &chunk_len, &switchpoint_result);
@@ -1570,18 +1531,18 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
     if (chunk_prefix != Qnil) {
       chunk_prefix_str = (TYPE(chunk_prefix) == T_STRING) ? chunk_prefix : rb_funcall(chunk_prefix, ID_call, 1, chunk_len_value);
       splice_chunks_get_sqe(backend, &ctx, &sqe, OP_WRITE);
-      splice_chunks_prep_write(ctx, sqe, dest_fptr->fd, chunk_prefix_str);
+      splice_chunks_prep_write(ctx, sqe, dest_fd, chunk_prefix_str);
       backend->base.op_count++;
     }
 
     splice_chunks_get_sqe(backend, &ctx, &sqe, OP_SPLICE);
-    splice_chunks_prep_splice(ctx, sqe, pipefd[0], dest_fptr->fd, chunk_len);
+    splice_chunks_prep_splice(ctx, sqe, pipefd[0], dest_fd, chunk_len);
     backend->base.op_count++;
 
     if (chunk_postfix != Qnil) {
       chunk_postfix_str = (TYPE(chunk_postfix) == T_STRING) ? chunk_postfix : rb_funcall(chunk_postfix, ID_call, 1, chunk_len_value);
       splice_chunks_get_sqe(backend, &ctx, &sqe, OP_WRITE);
-      splice_chunks_prep_write(ctx, sqe, dest_fptr->fd, chunk_postfix_str);
+      splice_chunks_prep_write(ctx, sqe, dest_fd, chunk_postfix_str);
       backend->base.op_count++;
     }
 
@@ -1591,7 +1552,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
 
   if (postfix != Qnil) {
     splice_chunks_get_sqe(backend, &ctx, &sqe, OP_WRITE);
-    splice_chunks_prep_write(ctx, sqe, dest_fptr->fd, postfix);
+    splice_chunks_prep_write(ctx, sqe, dest_fd, postfix);
     backend->base.op_count++;
   }
   if (ctx) {
@@ -1693,6 +1654,7 @@ void Init_Backend() {
   rb_define_method(cBackend, "sleep", Backend_sleep, 1);
   rb_define_method(cBackend, "splice", Backend_splice, 3);
   rb_define_method(cBackend, "splice_to_eof", Backend_splice_to_eof, 3);
+  rb_define_method(cBackend, "tee", Backend_tee, 3);
   rb_define_method(cBackend, "timeout", Backend_timeout, -1);
   rb_define_method(cBackend, "timer_loop", Backend_timer_loop, 1);
   rb_define_method(cBackend, "wait_event", Backend_wait_event, 1);