polyphony 1.4 → 1.5

data/ext/polyphony/backend_io_uring.c

@@ -138,12 +138,28 @@ VALUE Backend_post_fork(VALUE self) {
 typedef struct poll_context {
   struct io_uring     *ring;
   struct io_uring_cqe *cqe;
+  int                 pending_sqes;
   int                 result;
 } poll_context_t;
 
+// This function combines the functionality of io_uring_wait_cqe() and io_uring_submit_and_wait()
+static inline int io_uring_submit_and_wait_cqe(struct io_uring *ring,
+				    struct io_uring_cqe **cqe_ptr)
+{
+	if (!__io_uring_peek_cqe(ring, cqe_ptr, NULL) && *cqe_ptr) {
+    io_uring_submit(ring);
+		return 0;
+  }
+
+  *cqe_ptr = NULL;
+  return io_uring_submit_and_wait(ring, 1);
+}
+
 void *io_uring_backend_poll_without_gvl(void *ptr) {
   poll_context_t *ctx = (poll_context_t *)ptr;
-  ctx->result = io_uring_wait_cqe(ctx->ring, &ctx->cqe);
+  ctx->result = ctx->pending_sqes ?
+    io_uring_submit_and_wait_cqe(ctx->ring, &ctx->cqe) :
+    io_uring_wait_cqe(ctx->ring, &ctx->cqe);
   return NULL;
 }
 
@@ -152,6 +168,8 @@ static inline bool cq_ring_needs_flush(struct io_uring *ring) {
   return IO_URING_READ_ONCE(*ring->sq.kflags) & IORING_SQ_CQ_OVERFLOW;
 }
 
+#define MULTISHOT_ACCEPT_QUEUE(socket) (rb_ivar_get(socket, ID_ivar_multishot_accept_queue))
+
 static void handle_multishot_accept_completion(op_context_t *ctx, struct io_uring_cqe *cqe, Backend_t *backend) {
   // printf("handle_multishot_accept_completion result: %d\n", ctx->result);
   if (ctx->result == -ECANCELED) {
@@ -162,9 +180,9 @@ static void handle_multishot_accept_completion(op_context_t *ctx, struct io_urin
     if (!(cqe->flags & IORING_CQE_F_MORE)) {
       context_store_release(&backend->store, ctx);
     }
-    VALUE queue = rb_ivar_get(ctx->resume_value, ID_ivar_multishot_accept_queue);
+    VALUE queue = MULTISHOT_ACCEPT_QUEUE(ctx->resume_value);
     if (queue != Qnil)
-      Queue_push(queue, INT2NUM(ctx->result));
+      Queue_push(queue, INT2FIX(ctx->result));
   }
 }
 
@@ -236,7 +254,7 @@ inline void io_uring_backend_defer_submit(Backend_t *backend) {
 void io_uring_backend_poll(Backend_t *backend) {
   poll_context_t poll_ctx;
   poll_ctx.ring = &backend->ring;
-  if (backend->pending_sqes) io_uring_backend_immediate_submit(backend);
+  poll_ctx.pending_sqes = backend->pending_sqes;
 
 wait_cqe:
   backend->base.currently_polling = 1;
@@ -247,8 +265,10 @@ wait_cqe:
     return;
   }
 
-  io_uring_backend_handle_completion(poll_ctx.cqe, backend);
-  io_uring_cqe_seen(&backend->ring, poll_ctx.cqe);
+  if (poll_ctx.cqe) {
+    io_uring_backend_handle_completion(poll_ctx.cqe, backend);
+    io_uring_cqe_seen(&backend->ring, poll_ctx.cqe);
+  }
 }
 
 inline VALUE Backend_poll(VALUE self, VALUE blocking) {
@@ -284,6 +304,7 @@ inline void Backend_unschedule_fiber(VALUE self, VALUE fiber) {
   runqueue_delete(&backend->base.runqueue, fiber);
 }
 
+// This function is deprecated
 inline VALUE Backend_switch_fiber(VALUE self) {
   Backend_t *backend;
   GetBackend(self, backend);
@@ -331,7 +352,22 @@ VALUE Backend_wakeup(VALUE self) {
   return Qnil;
 }
 
+static inline VALUE io_uring_backend_await(VALUE self, struct Backend_t *backend) {
+  backend->base.pending_count++;
+
+  VALUE ret = backend_base_switch_fiber(self, &backend->base);
+
+  // run next fiber
+  COND_TRACE(&backend->base, 4, SYM_unblock, rb_fiber_current(), ret, CALLER());
+
+  backend->base.pending_count--;
+  RB_GC_GUARD(ret);
+  return ret;
+
+}
+
 int io_uring_backend_defer_submit_and_await(
+  VALUE self,
   Backend_t *backend,
   struct io_uring_sqe *sqe,
   op_context_t *ctx,
@@ -344,7 +380,7 @@ int io_uring_backend_defer_submit_and_await(
   if (sqe) io_uring_sqe_set_data(sqe, ctx);
   io_uring_backend_defer_submit(backend);
 
-  switchpoint_result = backend_await((struct Backend_base *)backend);
+  switchpoint_result = io_uring_backend_await(self, backend);
 
   if (ctx->ref_count > 1) {
     struct io_uring_sqe *sqe;
@@ -363,14 +399,14 @@ int io_uring_backend_defer_submit_and_await(
   return ctx->result;
 }
 
-VALUE io_uring_backend_wait_fd(Backend_t *backend, int fd, int write) {
+VALUE io_uring_backend_wait_fd(VALUE self, 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_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);
+  io_uring_backend_defer_submit_and_await(self, backend, sqe, ctx, &resumed_value);
   context_store_release(&backend->store, ctx);
 
   RB_GC_GUARD(resumed_value);
@@ -378,20 +414,24 @@ VALUE io_uring_backend_wait_fd(Backend_t *backend, int fd, int write) {
 }
 
 static inline int fd_from_io(VALUE io, rb_io_t **fptr, int write_mode, int rectify_file_pos) {
+  if (TYPE(io) == T_FIXNUM) {
+    *fptr = NULL;
+    return FIX2INT(io);
+  }
+  
   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);
-    int fd = rb_io_descriptor(io);
-    io_unset_nonblock(io, fd);
-    if (rectify_file_pos) rectify_io_file_pos(*fptr);
-    return fd;
-  }
+
+  VALUE underlying_io = rb_ivar_get(io, ID_ivar_io);
+  if (underlying_io != Qnil) io = underlying_io;
+
+  GetOpenFile(io, *fptr);
+  int fd = rb_io_descriptor(io);
+  io_unset_nonblock(io, fd);
+  if (rectify_file_pos) rectify_io_file_pos(*fptr);
+  return fd;
 }
 
 VALUE Backend_read(VALUE self, VALUE io, VALUE buffer, VALUE length, VALUE to_eof, VALUE pos) {
@@ -415,7 +455,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE buffer, VALUE length, VALUE to_eo
 
     io_uring_prep_read(sqe, fd, buffer_spec.ptr, buffer_spec.len, -1);
 
-    result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
+    result = io_uring_backend_defer_submit_and_await(self, backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
     if (!completed) {
       context_attach_buffers(ctx, 1, &buffer);
@@ -476,7 +516,7 @@ VALUE Backend_read_loop(VALUE self, VALUE io, VALUE maxlen) {
 
     io_uring_prep_read(sqe, fd, ptr, len, -1);
 
-    result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
+    result = io_uring_backend_defer_submit_and_await(self, backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
     if (!completed) {
       context_attach_buffers(ctx, 1, &buffer);
@@ -525,7 +565,7 @@ VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
 
     io_uring_prep_read(sqe, fd, ptr, len, -1);
 
-    result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
+    result = io_uring_backend_defer_submit_and_await(self, backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
     if (!completed) {
       context_attach_buffers(ctx, 1, &buffer);
@@ -569,7 +609,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE buffer) {
 
     io_uring_prep_write(sqe, fd, buffer_spec.ptr, left, -1);
 
-    result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
+    result = io_uring_backend_defer_submit_and_await(self, backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
     if (!completed) {
       context_attach_buffers(ctx, 1, &buffer);
@@ -620,7 +660,7 @@ VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
 
     io_uring_prep_writev(sqe, fd, iov_ptr, iov_count, -1);
 
-    result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
+    result = io_uring_backend_defer_submit_and_await(self, backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
     if (!completed) {
       free(iov);
@@ -686,7 +726,7 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE buffer, VALUE length, VALUE pos)
 
     io_uring_prep_recv(sqe, fd, buffer_spec.ptr, buffer_spec.len, 0);
 
-    result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
+    result = io_uring_backend_defer_submit_and_await(self, backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
     if (!completed) {
       context_attach_buffers(ctx, 1, &buffer);
@@ -744,7 +784,7 @@ VALUE Backend_recvmsg(VALUE self, VALUE io, VALUE buffer, VALUE maxlen, VALUE po
 
     io_uring_prep_recvmsg(sqe, fd, &msg, NUM2INT(flags));
 
-    result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
+    result = io_uring_backend_defer_submit_and_await(self, backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
     if (!completed) {
       context_attach_buffers(ctx, 1, &buffer);
@@ -794,7 +834,7 @@ VALUE Backend_recv_loop(VALUE self, VALUE io, VALUE maxlen) {
 
     io_uring_prep_recv(sqe, fd, ptr, len, 0);
 
-    result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
+    result = io_uring_backend_defer_submit_and_await(self, backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
     if (!completed) {
       context_attach_buffers(ctx, 1, &buffer);
@@ -842,7 +882,7 @@ VALUE Backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method)
 
     io_uring_prep_recv(sqe, fd, ptr, len, 0);
 
-    result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
+    result = io_uring_backend_defer_submit_and_await(self, backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
     if (!completed) {
       context_attach_buffers(ctx, 1, &buffer);
@@ -886,7 +926,7 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE buffer, VALUE flags) {
 
     io_uring_prep_send(sqe, fd, buffer_spec.ptr, left, flags_int);
 
-    result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
+    result = io_uring_backend_defer_submit_and_await(self, backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
     if (!completed) {
       context_attach_buffers(ctx, 1, &buffer);
@@ -947,7 +987,7 @@ VALUE Backend_sendmsg(VALUE self, VALUE io, VALUE buffer, VALUE flags, VALUE des
 
     io_uring_prep_sendmsg(sqe, fd, &msg, flags_int);
 
-    result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
+    result = io_uring_backend_defer_submit_and_await(self, backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
     if (!completed) {
       context_attach_buffers(ctx, 1, &buffer);
@@ -968,7 +1008,20 @@ VALUE Backend_sendmsg(VALUE self, VALUE io, VALUE buffer, VALUE flags, VALUE des
   return INT2FIX(buffer_spec.len);
 }
 
-VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, VALUE socket_class, int loop) {
+inline VALUE create_socket_from_fd(int fd, VALUE socket_class) {
+  rb_io_t *fp;
+
+  VALUE socket = rb_obj_alloc(socket_class);
+  MakeOpenFile(socket, fp);
+  rb_update_max_fd(fd);
+  fp->fd = fd;
+  fp->mode = FMODE_READWRITE | FMODE_DUPLEX;
+  rb_io_ascii8bit_binmode(socket);
+  rb_io_synchronized(fp);
+  return socket;
+}
+
+VALUE io_uring_backend_accept(VALUE self, Backend_t *backend, VALUE server_socket, VALUE socket_class, int loop) {
   int server_fd;
   rb_io_t *server_fptr;
   struct sockaddr addr;
@@ -986,7 +1039,7 @@ VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, VALUE soc
 
     io_uring_prep_accept(sqe, server_fd, &addr, &len, 0);
 
-    fd = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
+    fd = io_uring_backend_defer_submit_and_await(self, backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
     if (!completed) return resume_value;
@@ -995,19 +1048,7 @@ VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, VALUE soc
     if (fd < 0)
       rb_syserr_fail(-fd, strerror(-fd));
     else {
-      rb_io_t *fp;
-
-      socket = rb_obj_alloc(socket_class);
-      MakeOpenFile(socket, fp);
-      rb_update_max_fd(fd);
-      fp->fd = fd;
-      fp->mode = FMODE_READWRITE | FMODE_DUPLEX;
-      rb_io_ascii8bit_binmode(socket);
-      rb_io_synchronized(fp);
-
-      // if (rsock_do_not_reverse_lookup) {
-      //   fp->mode |= FMODE_NOREVLOOKUP;
-      // }
+      socket = create_socket_from_fd(fd, socket_class);
       if (loop) {
         rb_yield(socket);
         socket = Qnil;
@@ -1022,30 +1063,20 @@ VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, VALUE soc
 
 VALUE Backend_accept(VALUE self, VALUE server_socket, VALUE socket_class) {
 #ifdef HAVE_IO_URING_PREP_MULTISHOT_ACCEPT
-  VALUE accept_queue = rb_ivar_get(server_socket, ID_ivar_multishot_accept_queue);
+  VALUE accept_queue = MULTISHOT_ACCEPT_QUEUE(server_socket);
   if (accept_queue != Qnil) {
     VALUE next = Queue_shift(0, 0, accept_queue);
     int fd = NUM2INT(next);
     if (fd < 0)
       rb_syserr_fail(-fd, strerror(-fd));
-    else {
-      rb_io_t *fp;
-
-      VALUE socket = rb_obj_alloc(socket_class);
-      MakeOpenFile(socket, fp);
-      rb_update_max_fd(fd);
-      fp->fd = fd;
-      fp->mode = FMODE_READWRITE | FMODE_DUPLEX;
-      rb_io_ascii8bit_binmode(socket);
-      rb_io_synchronized(fp);
-      return socket;
-    }
+    else
+      return create_socket_from_fd(fd, socket_class);
   }
 #endif
 
   Backend_t *backend;
   GetBackend(self, backend);
-  return io_uring_backend_accept(backend, server_socket, socket_class, 0);
+  return io_uring_backend_accept(self, backend, server_socket, socket_class, 0);
 }
 
 #ifdef HAVE_IO_URING_PREP_MULTISHOT_ACCEPT
@@ -1053,9 +1084,25 @@ VALUE Backend_accept(VALUE self, VALUE server_socket, VALUE socket_class) {
 struct multishot_accept_ctx {
   Backend_t *backend;
   VALUE server_socket;
+  VALUE socket_class;
   op_context_t *op_ctx;
 };
 
+static inline VALUE accept_loop_from_queue(VALUE server_socket, VALUE socket_class) {
+  VALUE accept_queue = MULTISHOT_ACCEPT_QUEUE(server_socket);
+  if (accept_queue == Qnil) return Qnil;
+
+  while (true) {
+    VALUE next = Queue_shift(0, 0, accept_queue);
+    int fd = NUM2INT(next);
+    if (fd < 0)
+      rb_syserr_fail(-fd, strerror(-fd));
+    else
+      rb_yield(create_socket_from_fd(fd, socket_class));
+  }
+  return Qtrue;
+}
+
 VALUE multishot_accept_start(struct multishot_accept_ctx *ctx) {
   int server_fd;
   rb_io_t *server_fptr;
@@ -1071,7 +1118,7 @@ VALUE multishot_accept_start(struct multishot_accept_ctx *ctx) {
   io_uring_sqe_set_data(sqe, ctx->op_ctx);
   io_uring_backend_defer_submit(ctx->backend);
 
-  rb_yield(ctx->server_socket);
+  accept_loop_from_queue(ctx->server_socket, ctx->socket_class);
 
   return Qnil;
 }
@@ -1087,55 +1134,30 @@ VALUE multishot_accept_cleanup(struct multishot_accept_ctx *ctx) {
   return Qnil;
 }
 
-VALUE Backend_multishot_accept(VALUE self, VALUE server_socket) {
-  Backend_t *backend;
-  GetBackend(self, backend);
-
-  struct multishot_accept_ctx ctx;
-  ctx.backend = backend;
-  ctx.server_socket = server_socket;
+VALUE multishot_accept_loop(Backend_t *backend, VALUE server_socket, VALUE socket_class) {
+  struct multishot_accept_ctx ctx = { backend, server_socket, socket_class };
 
   return rb_ensure(
     SAFE(multishot_accept_start), (VALUE)&ctx,
     SAFE(multishot_accept_cleanup), (VALUE)&ctx
   );
 }
-
 #endif
 
 VALUE Backend_accept_loop(VALUE self, VALUE server_socket, VALUE socket_class) {
-#ifdef HAVE_IO_URING_PREP_MULTISHOT_ACCEPT
-  VALUE accept_queue = rb_ivar_get(server_socket, ID_ivar_multishot_accept_queue);
-  if (accept_queue != Qnil) {
-    while (true) {
-      VALUE next = Queue_shift(0, 0, accept_queue);
-      int fd = NUM2INT(next);
-      if (fd < 0)
-        rb_syserr_fail(-fd, strerror(-fd));
-      else {
-        rb_io_t *fp;
-
-        VALUE socket = rb_obj_alloc(socket_class);
-        MakeOpenFile(socket, fp);
-        rb_update_max_fd(fd);
-        fp->fd = fd;
-        fp->mode = FMODE_READWRITE | FMODE_DUPLEX;
-        rb_io_ascii8bit_binmode(socket);
-        rb_io_synchronized(fp);
-        rb_yield(socket);
-      }
-    }
-    return self;
-  }
-#endif
-
   Backend_t *backend;
   GetBackend(self, backend);
-  io_uring_backend_accept(backend, server_socket, socket_class, 1);
+
+#ifdef HAVE_IO_URING_PREP_MULTISHOT_ACCEPT
+  multishot_accept_loop(backend, server_socket, socket_class);
+#else
+  io_uring_backend_accept(self, backend, server_socket, socket_class, 1);
+#endif
+  
   return self;
 }
 
-VALUE io_uring_backend_splice(Backend_t *backend, VALUE src, VALUE dest, int maxlen) {
+VALUE io_uring_backend_splice(VALUE self, Backend_t *backend, VALUE src, VALUE dest, int maxlen) {
   int src_fd;
   int dest_fd;
   rb_io_t *src_fptr;
@@ -1156,7 +1178,7 @@ VALUE io_uring_backend_splice(Backend_t *backend, VALUE src, VALUE dest, int max
 
     io_uring_prep_splice(sqe, src_fd, -1, dest_fd, -1, maxlen, 0);
 
-    result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
+    result = io_uring_backend_defer_submit_and_await(self, backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
     if (!completed) return resume_value;
@@ -1174,10 +1196,11 @@ VALUE io_uring_backend_splice(Backend_t *backend, VALUE src, VALUE dest, int max
 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, FIX2INT(maxlen));
+  return io_uring_backend_splice(self, backend, src, dest, FIX2INT(maxlen));
 }
 
 struct double_splice_ctx {
+  VALUE self;
   Backend_t *backend;
   VALUE src;
   VALUE dest;
@@ -1222,7 +1245,7 @@ VALUE double_splice_safe(struct double_splice_ctx *ctx) {
     io_uring_backend_immediate_submit(ctx->backend);
 
   while (1) {
-    resume_value = backend_await((struct Backend_base *)ctx->backend);
+    resume_value = io_uring_backend_await(ctx->self, ctx->backend);
 
     if ((ctx_src && ctx_src->ref_count == 2 && ctx_dest && ctx_dest->ref_count == 2) || TEST_EXCEPTION(resume_value)) {
       if (ctx_src) {
@@ -1273,7 +1296,7 @@ VALUE double_splice_cleanup(struct double_splice_ctx *ctx) {
 }
 
 VALUE Backend_double_splice(VALUE self, VALUE src, VALUE dest) {
-  struct double_splice_ctx ctx = { NULL, src, dest, {0, 0} };
+  struct double_splice_ctx ctx = { self, NULL, src, dest, {0, 0} };
   GetBackend(self, ctx.backend);
   if (pipe(ctx.pipefd) == -1) rb_syserr_fail(errno, strerror(errno));
 
@@ -1304,7 +1327,7 @@ VALUE Backend_tee(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
 
     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);
+    result = io_uring_backend_defer_submit_and_await(self, backend, sqe, ctx, &resume_value);
     completed = context_store_release(&backend->store, ctx);
     RAISE_IF_EXCEPTION(resume_value);
     if (!completed) return resume_value;
@@ -1337,7 +1360,7 @@ VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
   ctx = context_store_acquire(&backend->store, OP_CONNECT);
   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);
+  result = io_uring_backend_defer_submit_and_await(self, backend, sqe, ctx, &resume_value);
   completed = context_store_release(&backend->store, ctx);
   RAISE_IF_EXCEPTION(resume_value);
   if (!completed) return resume_value;
@@ -1356,7 +1379,7 @@ VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
 
   GetBackend(self, backend);
   fd = fd_from_io(io, &fptr, write_mode, 0);
-  resume_value = io_uring_backend_wait_fd(backend, fd, write_mode);
+  resume_value = io_uring_backend_wait_fd(self, backend, fd, write_mode);
 
   RAISE_IF_EXCEPTION(resume_value);
   RB_GC_GUARD(resume_value);
@@ -1378,7 +1401,7 @@ VALUE Backend_close(VALUE self, VALUE io) {
   ctx = context_store_acquire(&backend->store, OP_CLOSE);
   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);
+  result = io_uring_backend_defer_submit_and_await(self, backend, sqe, ctx, &resume_value);
   completed = context_store_release(&backend->store, ctx);
   RAISE_IF_EXCEPTION(resume_value);
   if (!completed) return resume_value;
@@ -1386,7 +1409,7 @@ VALUE Backend_close(VALUE self, VALUE io) {
 
   if (result < 0) rb_syserr_fail(-result, strerror(-result));
 
-  fptr_finalize(fptr);
+  if (fptr) fptr_finalize(fptr);
   // fd = -1;
   return io;
 }
@@ -1405,13 +1428,13 @@ 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) {
+int io_uring_backend_submit_timeout_and_await(VALUE self, Backend_t *backend, double duration, VALUE *resume_value) {
   struct __kernel_timespec ts = double_to_timespec(duration);
   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);
-  io_uring_backend_defer_submit_and_await(backend, sqe, ctx, resume_value);
+  io_uring_backend_defer_submit_and_await(self, backend, sqe, ctx, resume_value);
   return context_store_release(&backend->store, ctx);
 }
 
@@ -1420,7 +1443,7 @@ VALUE Backend_sleep(VALUE self, VALUE duration) {
   Backend_t *backend;
   GetBackend(self, backend);
 
-  io_uring_backend_submit_timeout_and_await(backend, NUM2DBL(duration), &resume_value);
+  io_uring_backend_submit_timeout_and_await(self, backend, NUM2DBL(duration), &resume_value);
   RAISE_IF_EXCEPTION(resume_value);
   RB_GC_GUARD(resume_value);
   return resume_value;
@@ -1439,7 +1462,7 @@ VALUE Backend_timer_loop(VALUE self, VALUE interval) {
     if (next_time_ns == 0) next_time_ns = now_ns + interval_ns;
     if (next_time_ns > now_ns) {
       double sleep_duration = ((double)(next_time_ns - now_ns))/1e9;
-      int completed = io_uring_backend_submit_timeout_and_await(backend, sleep_duration, &resume_value);
+      int completed = io_uring_backend_submit_timeout_and_await(self, backend, sleep_duration, &resume_value);
       RAISE_IF_EXCEPTION(resume_value);
       if (!completed) return resume_value;
     }
@@ -1531,7 +1554,7 @@ VALUE Backend_waitpid(VALUE self, VALUE pid) {
     Backend_t *backend;
     GetBackend(self, backend);
 
-    resume_value = io_uring_backend_wait_fd(backend, fd, 0);
+    resume_value = io_uring_backend_wait_fd(self, backend, fd, 0);
     close(fd);
     RAISE_IF_EXCEPTION(resume_value);
     RB_GC_GUARD(resume_value);
@@ -1586,7 +1609,7 @@ VALUE Backend_wait_event(VALUE self, VALUE raise) {
   else
     backend->event_fd_ctx->ref_count += 1;
 
-  resume_value = backend_await((struct Backend_base *)backend);
+  resume_value = io_uring_backend_await(self, backend);
   context_store_release(&backend->store, backend->event_fd_ctx);
 
   if (backend->event_fd_ctx->ref_count == 1) {
@@ -1719,7 +1742,7 @@ VALUE Backend_chain(int argc,VALUE *argv, VALUE self) {
   backend->base.op_count += sqe_count;
   ctx->ref_count = sqe_count + 1;
   io_uring_backend_defer_submit(backend);
-  resume_value = backend_await((struct Backend_base *)backend);
+  resume_value = io_uring_backend_await(self, backend);
   result = ctx->result;
   completed = context_store_release(&backend->store, ctx);
   if (!completed) {
@@ -1803,6 +1826,7 @@ static inline void splice_chunks_cancel(Backend_t *backend, op_context_t *ctx) {
 }
 
 static inline int splice_chunks_await_ops(
+  VALUE self,
   Backend_t *backend,
   op_context_t **ctx,
   int *result,
@@ -1810,7 +1834,7 @@ static inline int splice_chunks_await_ops(
 )
 {
   int completed;
-  int res = io_uring_backend_defer_submit_and_await(backend, 0, *ctx, switchpoint_result);
+  int res = io_uring_backend_defer_submit_and_await(self, backend, 0, *ctx, switchpoint_result);
 
   if (result) (*result) = res;
   completed = context_store_release(&backend->store, *ctx);
@@ -1822,8 +1846,8 @@ static inline int splice_chunks_await_ops(
   return 0;
 }
 
-#define SPLICE_CHUNKS_AWAIT_OPS(backend, ctx, result, switchpoint_result) \
-  if (splice_chunks_await_ops(backend, ctx, result, switchpoint_result)) goto error;
+#define SPLICE_CHUNKS_AWAIT_OPS(self, backend, ctx, result, switchpoint_result) \
+  if (splice_chunks_await_ops(self, backend, ctx, result, switchpoint_result)) goto error;
 
 VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VALUE postfix, VALUE chunk_prefix, VALUE chunk_postfix, VALUE chunk_size) {
   Backend_t *backend;
@@ -1866,7 +1890,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
     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);
+    SPLICE_CHUNKS_AWAIT_OPS(self, backend, &ctx, &chunk_len, &switchpoint_result);
     if (chunk_len == 0) break;
 
     total += chunk_len;
@@ -1901,7 +1925,7 @@ VALUE Backend_splice_chunks(VALUE self, VALUE src, VALUE dest, VALUE prefix, VAL
     backend->base.op_count++;
   }
   if (ctx) {
-    SPLICE_CHUNKS_AWAIT_OPS(backend, &ctx, 0, &switchpoint_result);
+    SPLICE_CHUNKS_AWAIT_OPS(self, backend, &ctx, 0, &switchpoint_result);
   }
 
   RB_GC_GUARD(chunk_len_value);
@@ -1989,10 +2013,6 @@ void Init_Backend(void) {
   rb_define_method(cBackend, "connect", Backend_connect, 3);
   rb_define_method(cBackend, "feed_loop", Backend_feed_loop, 3);
 
-  #ifdef HAVE_IO_URING_PREP_MULTISHOT_ACCEPT
-  rb_define_method(cBackend, "multishot_accept", Backend_multishot_accept, 1);
-  #endif
-
   rb_define_method(cBackend, "read", Backend_read, 5);
   rb_define_method(cBackend, "read_loop", Backend_read_loop, 2);
   rb_define_method(cBackend, "recv", Backend_recv, 4);