polyphony 0.82 → 0.84.1

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"
@@ -304,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);
   }
@@ -329,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);
@@ -338,7 +356,6 @@ 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.len) buf_pos = buffer.len;
@@ -365,11 +382,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
   }
 
   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;
@@ -378,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.ptr, buffer.len, -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);
@@ -417,7 +430,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
 
   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;
 
@@ -426,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;
@@ -450,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);
@@ -478,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;
@@ -503,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);
@@ -531,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.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;
@@ -551,7 +552,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
     int result;
     int completed;
 
-    io_uring_prep_write(sqe, fptr->fd, buffer.ptr, 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);
@@ -575,20 +576,16 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
 
 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++) {
@@ -606,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);
@@ -656,13 +653,13 @@ 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;
   struct io_buffer buffer = get_io_buffer(str);
   long buf_pos = NUM2INT(pos);
   int shrinkable_string = 0;
   int expandable_buffer = 0;
   long total = 0;
-  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;
@@ -689,11 +686,7 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE 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;
@@ -702,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, buffer.ptr, buffer.len, 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);
@@ -723,7 +716,7 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
 
   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;
 
@@ -732,22 +725,18 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
 
 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;
@@ -756,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);
@@ -783,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;
@@ -808,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);
@@ -835,19 +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;
 
   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_unset_nonblock(fptr, io);
+  fd = fd_from_io(io, &fptr, 1, 0);
 
   while (left > 0) {
     VALUE resume_value = Qnil;
@@ -856,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, buffer.ptr, 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,15 +860,13 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
 }
 
 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;
@@ -896,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);
@@ -946,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);
@@ -969,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);
@@ -989,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);
 }
 
@@ -1000,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;
@@ -1014,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);
@@ -1035,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);
@@ -1054,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);
@@ -1081,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;
 // }
 
@@ -1165,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);
   }
@@ -1267,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;
 }
 
@@ -1375,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);
       }
@@ -1406,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);
@@ -1473,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);
 }
@@ -1509,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);
 
@@ -1538,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++;
   }
 
@@ -1548,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);
@@ -1561,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++;
     }
 
@@ -1582,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) {
@@ -1684,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);