polyphony 1.4 → 1.6

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,27 @@ 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));
+  }
+}
+
+static void handle_multishot_timeout_completion(
+  op_context_t *ctx, struct io_uring_cqe *cqe, Backend_t *backend
+)
+{
+  if (ctx->result == -ECANCELED) {
+    context_store_release(&backend->store, ctx);
+  }
+  else {
+    int has_more = cqe->flags & IORING_CQE_F_MORE;
+    if (!has_more) {
+      context_store_release(&backend->store, ctx);
+    }
+    if (ctx->fiber) {
+      Fiber_make_runnable(ctx->fiber, has_more ? Qtrue : Qnil);
+    }
   }
 }
 
@@ -172,6 +208,8 @@ static void handle_multishot_completion(op_context_t *ctx, struct io_uring_cqe *
   switch (ctx->type) {
     case OP_MULTISHOT_ACCEPT:
       return handle_multishot_accept_completion(ctx, cqe, backend);
+    case OP_MULTISHOT_TIMEOUT:
+      return handle_multishot_timeout_completion(ctx, cqe, backend);
     default:
       printf("Unexpected multishot completion for op type %d\n", ctx->type);
   }
@@ -181,6 +219,12 @@ static inline void io_uring_backend_handle_completion(struct io_uring_cqe *cqe,
   op_context_t *ctx = io_uring_cqe_get_data(cqe);
   if (!ctx) return;
 
+  // if (ctx->type == OP_TIMEOUT) {
+  //   double now = current_time_ns() / 1e9;
+  //   double elapsed = now - ctx->ts;
+  //   printf("%13.6f CQE timeout %p:%d (elapsed: %9.6f)\n", now, ctx, ctx->id, elapsed);
+  // }
+
   // printf("cqe ctx %p id: %d result: %d (%s, ref_count: %d)\n", ctx, ctx->id, cqe->res, op_type_to_str(ctx->type), ctx->ref_count);
   ctx->result = cqe->res;
   if (ctx->ref_count == MULTISHOT_REFCOUNT) {
@@ -236,7 +280,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 +291,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 +330,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 +378,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 +406,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 +425,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 +440,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 +481,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 +542,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 +591,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 +635,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,9 +686,10 @@ 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) {
+      TRACE_FREE(iov);
       free(iov);
       context_attach_buffers(ctx, argc, argv);
       RAISE_IF_EXCEPTION(resume_value);
@@ -631,6 +698,7 @@ VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
     RB_GC_GUARD(resume_value);
 
     if (result < 0) {
+      TRACE_FREE(iov);
       free(iov);
       rb_syserr_fail(-result, strerror(-result));
     }
@@ -653,6 +721,7 @@ VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
     }
   }
 
+  TRACE_FREE(iov);
   free(iov);
   return INT2FIX(total_written);
 }
@@ -686,7 +755,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 +813,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 +863,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 +911,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 +955,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 +1016,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 +1037,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 +1068,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 +1077,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 +1092,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 +1113,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 +1147,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 +1163,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 +1207,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 +1225,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 +1274,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 +1325,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 +1356,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 +1389,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 +1408,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 +1430,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 +1438,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 +1457,17 @@ 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);
 
+  // double now = current_time_ns() / 1e9;
+  // ctx->ts = now;
+  // printf("%13.6f SQE timeout %p:%d (%g)\n", now, ctx, ctx->id, duration);
+
   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 +1476,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 +1495,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 +1587,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);
@@ -1549,7 +1605,7 @@ VALUE Backend_waitpid(VALUE self, VALUE pid) {
     else
       rb_syserr_fail(e, strerror(e));
   }
-  return rb_ary_new_from_args(2, INT2FIX(ret), INT2FIX(WEXITSTATUS(status)));
+  return rb_ary_new_from_args(2, INT2FIX(ret), INT2FIX(status));
 }
 
 /*
@@ -1586,7 +1642,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 +1775,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 +1859,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 +1867,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 +1879,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 +1923,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 +1958,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 +2046,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);