polyphony 0.87 → 0.91

data/ext/polyphony/backend_io_uring.c

@@ -262,6 +262,21 @@ inline struct backend_stats backend_get_stats(VALUE self) {
   return backend_base_stats(&backend->base);
 }
 
+static inline struct io_uring_sqe *io_uring_backend_get_sqe(Backend_t *backend) {
+  struct io_uring_sqe *sqe;
+  sqe = io_uring_get_sqe(&backend->ring);
+  if (sqe) goto done;
+
+  if (backend->pending_sqes)
+    io_uring_backend_immediate_submit(backend);
+  else {
+    VALUE resume_value = backend_snooze(&backend->base);
+    RAISE_IF_EXCEPTION(resume_value);
+  }
+done:
+  return sqe;
+}
+
 VALUE Backend_wakeup(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
@@ -269,7 +284,7 @@ VALUE Backend_wakeup(VALUE self) {
   if (backend->base.currently_polling) {
     // Since we're currently blocking while waiting for a completion, we add a
     // NOP which would cause the io_uring_enter syscall to return
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     io_uring_prep_nop(sqe);
     io_uring_backend_immediate_submit(backend);
 
@@ -302,7 +317,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);
+    sqe = io_uring_backend_get_sqe(backend);
     io_uring_prep_cancel(sqe, (__u64)ctx, 0);
     io_uring_backend_immediate_submit(backend);
   }
@@ -317,7 +332,7 @@ VALUE io_uring_backend_wait_fd(Backend_t *backend, int fd, int write) {
   op_context_t *ctx = context_store_acquire(&backend->store, OP_POLL);
   VALUE resumed_value = Qnil;
 
-  struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+  struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
   io_uring_prep_poll_add(sqe, fd, write ? POLLOUT : POLLIN);
 
   io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resumed_value);
@@ -349,7 +364,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
   int fd;
   rb_io_t *fptr;
   struct io_buffer buffer = get_io_buffer(str);
-  long buf_pos = NUM2INT(pos);
+  long buf_pos = FIX2INT(pos);
   int shrinkable_string = 0;
   int expandable_buffer = 0;
   long total = 0;
@@ -368,7 +383,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
 
     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.ptr = (unsigned char *)RSTRING_PTR(str) + buf_pos;
       buffer.len = expected_read_length;
     }
     else {
@@ -385,7 +400,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
   while (1) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_READ);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int result;
     int completed;
     
@@ -415,7 +430,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof,
         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.ptr = (unsigned char *)RSTRING_PTR(str) + total + buf_pos;
         buffer.len = rb_str_capacity(str) - total - buf_pos;
       }
       else {
@@ -441,7 +456,7 @@ VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
   rb_io_t *fptr;
   VALUE str;
   long total;
-  long len = NUM2INT(maxlen);
+  long len = FIX2INT(maxlen);
   int shrinkable;
   char *buf;
 
@@ -453,7 +468,7 @@ VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
   while (1) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_READ);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     ssize_t result;
     int completed;
 
@@ -502,7 +517,7 @@ VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
   while (1) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_READ);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     ssize_t result;
     int completed;
 
@@ -546,7 +561,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   while (left > 0) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_WRITE);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int result;
     int completed;
 
@@ -569,7 +584,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
     }
   }
 
-  return INT2NUM(buffer.len);
+  return INT2FIX(buffer.len);
 }
 
 VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
@@ -597,7 +612,7 @@ VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
   while (1) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_WRITEV);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int result;
     int completed;
 
@@ -637,7 +652,7 @@ VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
   }
 
   free(iov);
-  return INT2NUM(total_written);
+  return INT2FIX(total_written);
 }
 
 VALUE Backend_write_m(int argc, VALUE *argv, VALUE self) {
@@ -654,7 +669,7 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
   int fd;
   rb_io_t *fptr;
   struct io_buffer buffer = get_io_buffer(str);
-  long buf_pos = NUM2INT(pos);
+  long buf_pos = FIX2INT(pos);
   int shrinkable_string = 0;
   int expandable_buffer = 0;
   long total = 0;
@@ -672,7 +687,7 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
 
     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.ptr = (unsigned char *)RSTRING_PTR(str) + buf_pos;
       buffer.len = expected_read_length;
     }
     else {
@@ -689,7 +704,7 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length, VALUE pos) {
   while (1) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_RECV);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int result;
     int completed;
 
@@ -727,7 +742,7 @@ VALUE Backend_recv_loop(VALUE self, VALUE io, VALUE maxlen) {
   rb_io_t *fptr;
   VALUE str;
   long total;
-  long len = NUM2INT(maxlen);
+  long len = FIX2INT(maxlen);
   int shrinkable;
   char *buf;
 
@@ -739,7 +754,7 @@ VALUE Backend_recv_loop(VALUE self, VALUE io, VALUE maxlen) {
   while (1) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_RECV);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int result;
     int completed;
 
@@ -787,7 +802,7 @@ VALUE Backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method)
   while (1) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_RECV);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int result;
     int completed;
 
@@ -823,7 +838,7 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
 
   struct io_buffer buffer = get_io_buffer(str);
   long left = buffer.len;
-  int flags_int = NUM2INT(flags);
+  int flags_int = FIX2INT(flags);
 
   GetBackend(self, backend);
   fd = fd_from_io(io, &fptr, 1, 0);
@@ -831,7 +846,7 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
   while (left > 0) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_SEND);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int result;
     int completed;
 
@@ -854,7 +869,7 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
     }
   }
 
-  return INT2NUM(buffer.len);
+  return INT2FIX(buffer.len);
 }
 
 VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, VALUE socket_class, int loop) {
@@ -869,7 +884,7 @@ VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, VALUE soc
   while (1) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = context_store_acquire(&backend->store, OP_ACCEPT);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int fd;
     int completed;
 
@@ -935,11 +950,11 @@ VALUE io_uring_backend_splice(Backend_t *backend, VALUE src, VALUE dest, VALUE m
 
   while (1) {
     op_context_t *ctx = context_store_acquire(&backend->store, OP_SPLICE);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int result;
     int completed;
 
-    io_uring_prep_splice(sqe, src_fd, -1, dest_fd, -1, NUM2INT(maxlen), 0);
+    io_uring_prep_splice(sqe, src_fd, -1, dest_fd, -1, FIX2INT(maxlen), 0);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -950,7 +965,7 @@ VALUE io_uring_backend_splice(Backend_t *backend, VALUE src, VALUE dest, VALUE m
       rb_syserr_fail(-result, strerror(-result));
 
     total += result;
-    if (result == 0 || !loop) return INT2NUM(total);
+    if (result == 0 || !loop) return INT2FIX(total);
   }
 
   RB_GC_GUARD(resume_value);
@@ -969,6 +984,112 @@ VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE chunksize)
   return io_uring_backend_splice(backend, src, dest, chunksize, 1);
 }
 
+struct double_splice_ctx {
+  Backend_t *backend;
+  VALUE src;
+  VALUE dest;
+  int pipefd[2];
+};
+
+#define DOUBLE_SPLICE_MAXLEN (1 << 16)
+
+static inline op_context_t *prepare_double_splice_ctx(Backend_t *backend, int src_fd, int dest_fd) {
+  op_context_t *ctx = context_store_acquire(&backend->store, OP_SPLICE);
+  struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
+  io_uring_prep_splice(sqe, src_fd, -1, dest_fd, -1, DOUBLE_SPLICE_MAXLEN, 0);
+  io_uring_sqe_set_data(sqe, ctx);
+  io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);
+  backend->base.op_count += 1;
+  backend->pending_sqes += 1;
+
+  return ctx;
+}
+
+static inline void io_uring_backend_cancel(Backend_t *backend, op_context_t *ctx) {
+  struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
+  ctx->result = -ECANCELED;
+  io_uring_prep_cancel(sqe, (__u64)ctx, 0);
+}
+
+VALUE double_splice_to_eof_safe(struct double_splice_ctx *ctx) {
+  int src_fd;
+  int dest_fd;
+  rb_io_t *src_fptr;
+  rb_io_t *dest_fptr;
+  int total = 0;
+  VALUE resume_value = Qnil;
+
+  src_fd = fd_from_io(ctx->src, &src_fptr, 0, 0);
+  dest_fd = fd_from_io(ctx->dest, &dest_fptr, 1, 0);
+
+  op_context_t *ctx_src = prepare_double_splice_ctx(ctx->backend, src_fd, ctx->pipefd[1]);
+  op_context_t *ctx_dest = prepare_double_splice_ctx(ctx->backend, ctx->pipefd[0], dest_fd);
+
+  if (ctx->backend->pending_sqes >= ctx->backend->prepared_limit)
+    io_uring_backend_immediate_submit(ctx->backend);
+
+  while (1) {
+    resume_value = backend_await((struct Backend_base *)ctx->backend);
+
+    if ((ctx_src && ctx_src->ref_count == 2 && ctx_dest && ctx_dest->ref_count == 2) || TEST_EXCEPTION(resume_value)) {
+      if (ctx_src) {
+        context_store_release(&ctx->backend->store, ctx_src);
+        io_uring_backend_cancel(ctx->backend, ctx_src);
+      }
+      if (ctx_dest) {
+        context_store_release(&ctx->backend->store, ctx_dest);
+        io_uring_backend_cancel(ctx->backend, ctx_dest);
+      }
+      io_uring_backend_immediate_submit(ctx->backend);
+      RAISE_IF_EXCEPTION(resume_value);
+      return resume_value;
+    }
+
+    if (ctx_src && ctx_src->ref_count == 1) {
+      context_store_release(&ctx->backend->store, ctx_src);
+      if (ctx_src->result == 0) {
+        // close write end of pipe
+        close(ctx->pipefd[1]);
+        ctx_src = NULL;
+      }
+      else {
+        ctx_src = prepare_double_splice_ctx(ctx->backend, src_fd, ctx->pipefd[1]);
+      }
+    }
+    if (ctx_dest && ctx_dest->ref_count == 1) {
+      context_store_release(&ctx->backend->store, ctx_dest);
+      if (ctx_dest->result == 0)
+        break;
+      else {
+        total += ctx_dest->result;
+        ctx_dest = prepare_double_splice_ctx(ctx->backend, ctx->pipefd[0], dest_fd);
+      }
+    }
+
+    if (ctx->backend->pending_sqes >= ctx->backend->prepared_limit)
+      io_uring_backend_immediate_submit(ctx->backend);
+  }
+  RB_GC_GUARD(resume_value);
+  return INT2FIX(total);
+}
+
+VALUE double_splice_to_eof_cleanup(struct double_splice_ctx *ctx) {
+  if (ctx->pipefd[0]) close(ctx->pipefd[0]);
+  if (ctx->pipefd[1]) close(ctx->pipefd[1]);
+  return Qnil;
+}
+
+VALUE Backend_double_splice_to_eof(VALUE self, VALUE src, VALUE dest) {
+  struct double_splice_ctx ctx = { NULL, src, dest, 0, 0 };
+  GetBackend(self, ctx.backend);
+  if (pipe(ctx.pipefd) == -1) rb_syserr_fail(errno, strerror(errno));
+
+  return rb_ensure(
+    SAFE(double_splice_to_eof_safe), (VALUE)&ctx,
+    SAFE(double_splice_to_eof_cleanup), (VALUE)&ctx
+  );
+}
+
 VALUE Backend_tee(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
   Backend_t *backend;
   GetBackend(self, backend);
@@ -984,11 +1105,11 @@ VALUE Backend_tee(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
 
   while (1) {
     op_context_t *ctx = context_store_acquire(&backend->store, OP_SPLICE);
-    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
     int result;
     int completed;
 
-    io_uring_prep_tee(sqe, src_fd, dest_fd, NUM2INT(maxlen), 0);
+    io_uring_prep_tee(sqe, src_fd, dest_fd, FIX2INT(maxlen), 0);
 
     result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
@@ -998,7 +1119,7 @@ VALUE Backend_tee(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
     if (result < 0)
       rb_syserr_fail(-result, strerror(-result));
 
-    return INT2NUM(result);
+    return INT2FIX(result);
   }
 
   RB_GC_GUARD(resume_value);
@@ -1021,7 +1142,7 @@ VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
   GetBackend(self, backend);
   fd = fd_from_io(sock, &fptr, 1, 0);
   ctx = context_store_acquire(&backend->store, OP_CONNECT);
-  sqe = io_uring_get_sqe(&backend->ring);
+  sqe = io_uring_backend_get_sqe(backend);
   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);
@@ -1063,7 +1184,7 @@ VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
 //   io_unset_nonblock(fptr, io);
 
 //   ctx = context_store_acquire(&backend->store, OP_CLOSE);
-//   sqe = io_uring_get_sqe(&backend->ring);
+//   sqe = io_uring_backend_get_sqe(backend);
 //   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);
@@ -1094,7 +1215,7 @@ inline struct __kernel_timespec duration_to_timespec(VALUE duration) {
 // returns true if completed, 0 otherwise
 int io_uring_backend_submit_timeout_and_await(Backend_t *backend, double duration, VALUE *resume_value) {
   struct __kernel_timespec ts = double_to_timespec(duration);
-  struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+  struct io_uring_sqe *sqe = io_uring_backend_get_sqe(backend);
   op_context_t *ctx = context_store_acquire(&backend->store, OP_TIMEOUT);
   
   io_uring_prep_timeout(sqe, &ts, 0, 0);
@@ -1183,7 +1304,7 @@ VALUE Backend_timeout(int argc, VALUE *argv, VALUE self) {
   GetBackend(self, backend);
   timeout = rb_funcall(cTimeoutException, ID_new, 0);
 
-  sqe = io_uring_get_sqe(&backend->ring);
+  sqe = io_uring_backend_get_sqe(backend);
   ctx = context_store_acquire(&backend->store, OP_TIMEOUT);
   ctx->resume_value = timeout;
   io_uring_prep_timeout(sqe, &ts, 0, 0);
@@ -1207,7 +1328,7 @@ VALUE Backend_timeout(int argc, VALUE *argv, VALUE self) {
 }
 
 VALUE Backend_waitpid(VALUE self, VALUE pid) {
-  int pid_int = NUM2INT(pid);
+  int pid_int = FIX2INT(pid);
   int fd = pidfd_open(pid_int, 0);
   int status;
   pid_t ret;
@@ -1231,7 +1352,7 @@ VALUE Backend_waitpid(VALUE self, VALUE pid) {
     else
       rb_syserr_fail(e, strerror(e));
   }
-  return rb_ary_new_from_args(2, INT2NUM(ret), INT2NUM(WEXITSTATUS(status)));
+  return rb_ary_new_from_args(2, INT2FIX(ret), INT2FIX(WEXITSTATUS(status)));
 }
 
 /*
@@ -1259,7 +1380,7 @@ VALUE Backend_wait_event(VALUE self, VALUE raise) {
     struct io_uring_sqe *sqe;
 
     backend->event_fd_ctx = context_store_acquire(&backend->store, OP_POLL);
-    sqe = io_uring_get_sqe(&backend->ring);
+    sqe = io_uring_backend_get_sqe(backend);
     io_uring_prep_poll_add(sqe, backend->event_fd, POLLIN);
     backend->base.op_count++;
     io_uring_sqe_set_data(sqe, backend->event_fd_ctx);
@@ -1275,7 +1396,7 @@ VALUE Backend_wait_event(VALUE self, VALUE raise) {
 
     // last fiber to use the eventfd, so we cancel the ongoing poll
     struct io_uring_sqe *sqe;
-    sqe = io_uring_get_sqe(&backend->ring);
+    sqe = io_uring_backend_get_sqe(backend);
     io_uring_prep_cancel(sqe, (__u64)backend->event_fd_ctx, 0);
     io_uring_backend_immediate_submit(backend);
     backend->event_fd_ctx = NULL;
@@ -1296,7 +1417,7 @@ struct io_uring_sqe *Backend_chain_prepare_write(Backend_t *backend, VALUE io, V
   struct io_uring_sqe *sqe;
 
   fd = fd_from_io(io, &fptr, 1, 0);
-  sqe = io_uring_get_sqe(&backend->ring);
+  sqe = io_uring_backend_get_sqe(backend);
   io_uring_prep_write(sqe, fd, StringValuePtr(str), RSTRING_LEN(str), 0);
   return sqe;
 }
@@ -1308,8 +1429,8 @@ struct io_uring_sqe *Backend_chain_prepare_send(Backend_t *backend, VALUE io, VA
 
   fd = fd_from_io(io, &fptr, 1, 0);
 
-  sqe = io_uring_get_sqe(&backend->ring);
-  io_uring_prep_send(sqe, fd, StringValuePtr(str), RSTRING_LEN(str), NUM2INT(flags));
+  sqe = io_uring_backend_get_sqe(backend);
+  io_uring_prep_send(sqe, fd, StringValuePtr(str), RSTRING_LEN(str), FIX2INT(flags));
   return sqe;
 }
 
@@ -1322,8 +1443,8 @@ struct io_uring_sqe *Backend_chain_prepare_splice(Backend_t *backend, VALUE src,
 
   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_fd, -1, dest_fd, -1, NUM2INT(maxlen), 0);
+  sqe = io_uring_backend_get_sqe(backend);
+  io_uring_prep_splice(sqe, src_fd, -1, dest_fd, -1, FIX2INT(maxlen), 0);
   return sqe;
 }
 
@@ -1381,7 +1502,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);
+        sqe = io_uring_backend_get_sqe(backend);
         io_uring_prep_cancel(sqe, (__u64)ctx, 0);
         io_uring_backend_immediate_submit(backend);
       }
@@ -1411,7 +1532,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);
+    sqe = io_uring_backend_get_sqe(backend);
     io_uring_prep_cancel(sqe, (__u64)ctx, 0);
     io_uring_backend_immediate_submit(backend);
     RAISE_IF_EXCEPTION(resume_value);
@@ -1419,7 +1540,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
   }
 
   RB_GC_GUARD(resume_value);
-  return INT2NUM(result);
+  return INT2FIX(result);
 }
 
 VALUE Backend_idle_gc_period_set(VALUE self, VALUE period) {
@@ -1470,14 +1591,14 @@ static inline void splice_chunks_get_sqe(
   }
   else
     *ctx = context_store_acquire(&backend->store, type);
-  (*sqe) = io_uring_get_sqe(&backend->ring);
+  (*sqe) = io_uring_backend_get_sqe(backend);
 }
 
 static inline void splice_chunks_cancel(Backend_t *backend, op_context_t *ctx) {
   struct io_uring_sqe *sqe;
   
   ctx->result = -ECANCELED;
-  sqe = io_uring_get_sqe(&backend->ring);
+  sqe = io_uring_backend_get_sqe(backend);
   io_uring_prep_cancel(sqe, (__u64)ctx, 0);
   io_uring_backend_immediate_submit(backend);
 }
@@ -1525,7 +1646,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
   src_fd = fd_from_io(src, &src_fptr, 0, 0);
   dest_fd = fd_from_io(dest, &dest_fptr, 1, 0);
 
-  maxlen = NUM2INT(chunk_size);
+  maxlen = FIX2INT(chunk_size);
 
   if (pipe(pipefd) == -1) {
     err = errno;
@@ -1551,7 +1672,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
     if (chunk_len == 0) break;
 
     total += chunk_len;
-    chunk_len_value = INT2NUM(chunk_len);
+    chunk_len_value = INT2FIX(chunk_len);
 
 
     if (chunk_prefix != Qnil) {
@@ -1590,7 +1711,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
   RB_GC_GUARD(switchpoint_result);
   if (pipefd[0] != -1) close(pipefd[0]);
   if (pipefd[1] != -1) close(pipefd[1]);
-  return INT2NUM(total);
+  return INT2FIX(total);
 syscallerror:
   if (pipefd[0] != -1) close(pipefd[0]);
   if (pipefd[1] != -1) close(pipefd[1]);
@@ -1678,9 +1799,12 @@ void Init_Backend() {
   rb_define_method(cBackend, "send", Backend_send, 3);
   rb_define_method(cBackend, "sendv", Backend_sendv, 3);
   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, "double_splice_to_eof", Backend_double_splice_to_eof, 2);
   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);