polyphony 0.49.2 → 0.53.0

data/ext/polyphony/backend_io_uring.c

@@ -16,18 +16,36 @@
 
 #include "polyphony.h"
 #include "../liburing/liburing.h"
-#include "ruby/thread.h"
 #include "backend_io_uring_context.h"
+#include "ruby/thread.h"
+#include "ruby/io.h"
 
-#ifndef __NR_pidfd_open
-#define __NR_pidfd_open 434   /* System call # on most architectures */
-#endif
+VALUE SYM_io_uring;
 
-static int pidfd_open(pid_t pid, unsigned int flags) {
-  return syscall(__NR_pidfd_open, pid, flags);
+#ifdef POLYPHONY_UNSET_NONBLOCK
+ID ID_ivar_is_nonblocking;
+
+// One of the changes introduced in Ruby 3.0 as part of the work on the
+// FiberScheduler interface is that all created sockets are marked as
+// non-blocking. This prevents the io_uring backend from working correctly,
+// since it will return an EAGAIN error just like a normal syscall. So here
+// instead of setting O_NONBLOCK (which is required for the libev backend), we
+// unset it.
+inline void io_unset_nonblock(rb_io_t *fptr, VALUE io) {
+  VALUE is_nonblocking = rb_ivar_get(io, ID_ivar_is_nonblocking);
+  if (is_nonblocking == Qfalse) return;
+
+  rb_ivar_set(io, ID_ivar_is_nonblocking, Qfalse);
+
+  int oflags = fcntl(fptr->fd, F_GETFL);
+  if ((oflags == -1) && (oflags & O_NONBLOCK)) return;
+  oflags &= !O_NONBLOCK;
+  fcntl(fptr->fd, F_SETFL, oflags);
 }
-
-VALUE SYM_io_uring;
+#else
+// NOP
+#define io_unset_nonblock(fptr, io)
+#endif
 
 typedef struct Backend_t {
   // common fields
@@ -260,7 +278,7 @@ int io_uring_backend_defer_submit_and_await(
   VALUE switchpoint_result = Qnil;
 
   io_uring_sqe_set_data(sqe, ctx);
-  // io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);
+  io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);
   io_uring_backend_defer_submit(backend);
 
   switchpoint_result = backend_await(backend);
@@ -308,6 +326,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
   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);
   OBJ_TAINT(str);
 
@@ -368,6 +387,7 @@ VALUE Backend_read_loop(VALUE self, VALUE io) {
   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);
 
   while (1) {
@@ -397,6 +417,53 @@ VALUE Backend_read_loop(VALUE self, VALUE io) {
   return io;
 }
 
+VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
+  Backend_t *backend;
+  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);
+
+  while (1) {
+    VALUE resume_value = Qnil;
+    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_READ);
+    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    io_uring_prep_read(sqe, fptr->fd, buf, len, -1);
+    
+    ssize_t result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
+    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    RAISE_IF_EXCEPTION(resume_value);
+    if (!ctx->completed) return resume_value;
+    RB_GC_GUARD(resume_value);
+
+    if (result < 0)
+      rb_syserr_fail(-result, strerror(-result));
+    else if (!result)
+      break; // EOF
+    else {
+      total = result;
+      READ_LOOP_PASS_STR_TO_RECEIVER(receiver, method_id);
+    }
+  }
+
+  RB_GC_GUARD(str);
+
+  return io;
+}
+
 VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   Backend_t *backend;
   rb_io_t *fptr;
@@ -407,6 +474,7 @@ VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   GetBackend(self, backend);
   io = rb_io_get_write_io(io);
   GetOpenFile(io, fptr);
+  io_unset_nonblock(fptr, io);
 
   char *buf = StringValuePtr(str);
   long len = RSTRING_LEN(str);
@@ -450,6 +518,7 @@ VALUE Backend_writev(VALUE self, VALUE io, int argc, VALUE *argv) {
   GetBackend(self, backend);
   io = rb_io_get_write_io(io);
   GetOpenFile(io, fptr);
+  io_unset_nonblock(fptr, io);
 
   iov = malloc(iov_count * sizeof(struct iovec));
   for (int i = 0; i < argc; i++) {
@@ -529,6 +598,7 @@ VALUE Backend_recv(VALUE self, VALUE io, VALUE str, VALUE length) {
   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);
   OBJ_TAINT(str);
 
@@ -576,6 +646,7 @@ VALUE Backend_recv_loop(VALUE self, VALUE io) {
   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);
 
   while (1) {
@@ -604,7 +675,53 @@ VALUE Backend_recv_loop(VALUE self, VALUE io) {
   return io;
 }
 
-VALUE Backend_send(VALUE self, VALUE io, VALUE str) {
+VALUE Backend_recv_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
+  Backend_t *backend;
+  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);
+
+  while (1) {
+    VALUE resume_value = Qnil;
+    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_RECV);
+    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    io_uring_prep_recv(sqe, fptr->fd, buf, len, 0);
+    
+    int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
+    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    RAISE_IF_EXCEPTION(resume_value);
+    if (!ctx->completed) return resume_value;
+    RB_GC_GUARD(resume_value);
+
+    if (result < 0)
+      rb_syserr_fail(-result, strerror(-result));
+    else if (!result)
+      break; // EOF
+    else {
+      total = result;
+      READ_LOOP_PASS_STR_TO_RECEIVER(receiver, method_id);
+    }
+  }
+
+  RB_GC_GUARD(str);
+  return io;
+}
+
+VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
   Backend_t *backend;
   rb_io_t *fptr;
   VALUE underlying_io;
@@ -614,16 +731,18 @@ VALUE Backend_send(VALUE self, VALUE io, VALUE str) {
   GetBackend(self, backend);
   io = rb_io_get_write_io(io);
   GetOpenFile(io, fptr);
+  io_unset_nonblock(fptr, io);
 
   char *buf = StringValuePtr(str);
   long len = RSTRING_LEN(str);
   long left = len;
+  int flags_int = NUM2INT(flags);
 
   while (left > 0) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_SEND);
     struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
-    io_uring_prep_send(sqe, fptr->fd, buf, left, 0);
+    io_uring_prep_send(sqe, fptr->fd, buf, left, flags_int);
     
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     OP_CONTEXT_RELEASE(&backend->store, ctx);
@@ -651,6 +770,8 @@ VALUE io_uring_backend_accept(Backend_t *backend, VALUE server_socket, VALUE soc
   if (underlying_sock != Qnil) server_socket = underlying_sock;
 
   GetOpenFile(server_socket, fptr);
+  io_unset_nonblock(fptr, server_socket);
+
   while (1) {
     VALUE resume_value = Qnil;
     op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_ACCEPT);
@@ -704,6 +825,60 @@ VALUE Backend_accept_loop(VALUE self, VALUE server_socket, VALUE socket_class) {
   return self;
 }
 
+VALUE io_uring_backend_splice(Backend_t *backend, VALUE src, VALUE dest, VALUE maxlen, int loop) {
+  rb_io_t *src_fptr;
+  rb_io_t *dest_fptr;
+  VALUE underlying_io;
+  int total = 0;
+
+  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);
+
+  VALUE resume_value = Qnil;
+
+  while (1) {
+    op_context_t *ctx = OP_CONTEXT_ACQUIRE(&backend->store, OP_SPLICE);
+    struct io_uring_sqe *sqe = io_uring_get_sqe(&backend->ring);
+    io_uring_prep_splice(sqe, src_fptr->fd, -1, dest_fptr->fd, -1, NUM2INT(maxlen), 0);
+    
+    int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
+    OP_CONTEXT_RELEASE(&backend->store, ctx);
+    RAISE_IF_EXCEPTION(resume_value);
+    if (!ctx->completed) return resume_value;
+
+    if (result < 0)
+      rb_syserr_fail(-result, strerror(-result));
+
+    if (result == 0 || !loop) return INT2NUM(total);
+    total += result;
+  }
+
+  RB_GC_GUARD(resume_value);
+}
+
+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);
+}
+
+VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE chunksize) {
+  Backend_t *backend;
+  GetBackend(self, backend);
+
+  return io_uring_backend_splice(backend, src, dest, chunksize, 1);
+}
+
+
 VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
   Backend_t *backend;
   rb_io_t *fptr;
@@ -714,6 +889,7 @@ VALUE Backend_connect(VALUE self, VALUE sock, VALUE host, VALUE port) {
 
   GetBackend(self, backend);
   GetOpenFile(sock, fptr);
+  io_unset_nonblock(fptr, sock);
 
   addr.sin_family = AF_INET;
   addr.sin_addr.s_addr = inet_addr(host_buf);
@@ -740,6 +916,7 @@ VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
   if (underlying_io != Qnil) io = underlying_io;
   GetBackend(self, backend);
   GetOpenFile(io, fptr);
+  io_unset_nonblock(fptr, io);
 
   VALUE resume_value = io_uring_backend_wait_fd(backend, fptr->fd, RTEST(write));
   RAISE_IF_EXCEPTION(resume_value);
@@ -811,18 +988,6 @@ VALUE Backend_timer_loop(VALUE self, VALUE interval) {
   }
 }
 
-VALUE Backend_timeout_safe(VALUE arg) {
-  return rb_yield(arg);
-}
-
-VALUE Backend_timeout_rescue(VALUE arg, VALUE exception) {
-  return exception;
-}
-
-VALUE Backend_timeout_ensure_safe(VALUE arg) {
-  return rb_rescue2(Backend_timeout_safe, Qnil, Backend_timeout_rescue, Qnil, rb_eException, (VALUE)0);
-}
-
 struct Backend_timeout_ctx {
   Backend_t *backend;
   op_context_t *ctx;
@@ -861,7 +1026,6 @@ VALUE Backend_timeout(int argc, VALUE *argv, VALUE self) {
   ctx->resume_value = timeout;
   io_uring_prep_timeout(sqe, &ts, 0, 0);
   io_uring_sqe_set_data(sqe, ctx);
-  io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);
   io_uring_backend_defer_submit(backend);
 
   struct Backend_timeout_ctx timeout_ctx = {backend, ctx};
@@ -879,19 +1043,28 @@ VALUE Backend_timeout(int argc, VALUE *argv, VALUE self) {
 }
 
 VALUE Backend_waitpid(VALUE self, VALUE pid) {
-  Backend_t *backend;
   int pid_int = NUM2INT(pid);
   int fd = pidfd_open(pid_int, 0);
-  GetBackend(self, backend);
-  
-  VALUE resume_value = io_uring_backend_wait_fd(backend, fd, 0);
-  close(fd);
 
-  RAISE_IF_EXCEPTION(resume_value);
-  RB_GC_GUARD(resume_value);
+  if (fd >= 0) {
+    Backend_t *backend;
+    GetBackend(self, backend);
 
+    VALUE resume_value = io_uring_backend_wait_fd(backend, fd, 0);
+    close(fd);
+    RAISE_IF_EXCEPTION(resume_value);
+    RB_GC_GUARD(resume_value);
+  }
+  
   int status;
   pid_t ret = waitpid(pid_int, &status, WNOHANG);
+  if (ret < 0) {
+    int e = errno;
+    if (e == ECHILD)
+      ret = pid_int;
+    else
+      rb_syserr_fail(e, strerror(e));
+  }
   return rb_ary_new_from_args(2, INT2NUM(ret), INT2NUM(WEXITSTATUS(status)));
 }
 
@@ -918,7 +1091,7 @@ VALUE Backend_kind(VALUE self) {
 }
 
 void Init_Backend() {
-  VALUE cBackend = rb_define_class_under(mPolyphony, "Backend", rb_cData);
+  VALUE cBackend = rb_define_class_under(mPolyphony, "Backend", rb_cObject);
   rb_define_alloc_func(cBackend, Backend_allocate);
 
   rb_define_method(cBackend, "initialize", Backend_initialize, 0);
@@ -927,24 +1100,33 @@ void Init_Backend() {
 
   rb_define_method(cBackend, "poll", Backend_poll, 3);
   rb_define_method(cBackend, "break", Backend_wakeup, 0);
+  rb_define_method(cBackend, "kind", Backend_kind, 0);
 
+  rb_define_method(cBackend, "accept", Backend_accept, 2);
+  rb_define_method(cBackend, "accept_loop", Backend_accept_loop, 2);
+  rb_define_method(cBackend, "connect", Backend_connect, 3);
+  rb_define_method(cBackend, "feed_loop", Backend_feed_loop, 3);
   rb_define_method(cBackend, "read", Backend_read, 4);
   rb_define_method(cBackend, "read_loop", Backend_read_loop, 1);
-  rb_define_method(cBackend, "write", Backend_write_m, -1);
   rb_define_method(cBackend, "recv", Backend_recv, 3);
+  rb_define_method(cBackend, "recv_feed_loop", Backend_recv_feed_loop, 3);
   rb_define_method(cBackend, "recv_loop", Backend_recv_loop, 1);
-  rb_define_method(cBackend, "send", Backend_send, 2);
-  rb_define_method(cBackend, "accept", Backend_accept, 2);
-  rb_define_method(cBackend, "accept_loop", Backend_accept_loop, 2);
-  rb_define_method(cBackend, "connect", Backend_connect, 3);
-  rb_define_method(cBackend, "wait_io", Backend_wait_io, 2);
+  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, "timer_loop", Backend_timer_loop, 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, "timeout", Backend_timeout, -1);
-  rb_define_method(cBackend, "waitpid", Backend_waitpid, 1);
+  rb_define_method(cBackend, "timer_loop", Backend_timer_loop, 1);
   rb_define_method(cBackend, "wait_event", Backend_wait_event, 1);
+  rb_define_method(cBackend, "wait_io", Backend_wait_io, 2);
+  rb_define_method(cBackend, "waitpid", Backend_waitpid, 1);
+  rb_define_method(cBackend, "write", Backend_write_m, -1);
 
-  rb_define_method(cBackend, "kind", Backend_kind, 0);
+
+  #ifdef POLYPHONY_UNSET_NONBLOCK
+  ID_ivar_is_nonblocking = rb_intern("@is_nonblocking");
+  #endif
 
   SYM_io_uring = ID2SYM(rb_intern("io_uring"));
 }

data/ext/polyphony/backend_io_uring_context.c

@@ -10,6 +10,7 @@ const char *op_type_to_str(enum op_type type) {
   case OP_WRITE: return "WRITE";
   case OP_RECV: return "RECV";
   case OP_SEND: return "SEND";
+  case OP_SPLICE: return "SPLICE";
   case OP_TIMEOUT: return "TIMEOUT";
   case OP_POLL: return "POLL";
   case OP_ACCEPT: return "ACCEPT";

data/ext/polyphony/backend_io_uring_context.h

@@ -10,6 +10,7 @@ enum op_type {
   OP_WRITE,
   OP_RECV,
   OP_SEND,
+  OP_SPLICE,
   OP_TIMEOUT,
   OP_POLL,
   OP_ACCEPT,

data/ext/polyphony/backend_libev.c

@@ -1,13 +1,57 @@
+/*
+# Libev-based blocking ops backend for Polyphony
+
+## Backend initialization
+
+The backend is initialized by creating an event loop. For the main thread the
+default event loop is used, but we since we don't need to handle any signals
+(see the waitpid implementation below) we might as well use a non-default event
+loop for the main thread at some time in the future.
+
+In addition, we create an async watcher that is used for interrupting the #poll
+method from another thread.
+
+## Blocking operations
+
+I/O operations start by making sure the io has been set to non-blocking
+operation (O_NONBLOCK). That way, if the syscall would block, we'd get an
+EWOULDBLOCK or EAGAIN instead of blocking.
+
+Once the OS has indicated that the operation would block, we start a watcher
+(its type corresponding to the desired operation), and call ev_xxxx_start. in We
+then call Thread_switch_fiber and switch to another fiber while waiting for the
+watcher to be triggered.
+
+## Polling for events
+
+Backend_poll is called either once the corresponding thread has no more work to
+do (no runnable fibers) or periodically while the thread is scheduling fibers in
+order to prevent event starvation.
+
+## Behaviour of waitpid
+
+On Linux 5.3+, pidfd_open will be used, otherwise a libev child watcher will be
+used. Note that if a child watcher is used, waitpid will only work from the main
+thread.
+
+*/
+
 #ifdef POLYPHONY_BACKEND_LIBEV
 
+#ifdef POLYPHONY_LINUX
+#define _GNU_SOURCE 1
+#endif
+
+#include <fcntl.h>
 #include <netdb.h>
 #include <sys/socket.h>
 #include <sys/uio.h>
 #include <unistd.h>
-#include <fcntl.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <stdnoreturn.h>
+#include <sys/types.h>
+#include <sys/wait.h>
 
 #include "polyphony.h"
 #include "../libev/ev.h"
@@ -74,17 +118,27 @@ void break_async_callback(struct ev_loop *ev_loop, struct ev_async *ev_async, in
   // of a *blocking* event loop (waking it up) in a thread-safe, signal-safe manner
 }
 
+inline struct ev_loop *libev_new_loop() {
+  #ifdef POLYPHONY_USE_PIDFD_OPEN
+    return ev_loop_new(EVFLAG_NOSIGMASK);
+  #else
+    int is_main_thread = (rb_thread_current() == rb_thread_main());
+    return is_main_thread ? EV_DEFAULT : ev_loop_new(EVFLAG_NOSIGMASK);
+  #endif
+}
+
 static VALUE Backend_initialize(VALUE self) {
   Backend_t *backend;
-  VALUE thread = rb_thread_current();
-  int is_main_thread = (thread == rb_thread_main());
-
+  
   GetBackend(self, backend);
-  backend->ev_loop = is_main_thread ? EV_DEFAULT : ev_loop_new(EVFLAG_NOSIGMASK);
+  backend->ev_loop = libev_new_loop();
 
+  // start async watcher used for breaking a poll op (from another thread)
   ev_async_init(&backend->break_async, break_async_callback);
   ev_async_start(backend->ev_loop, &backend->break_async);
-  ev_unref(backend->ev_loop); // don't count the break_async watcher
+  // the break_async watcher is unreferenced, in order for Backend_poll to not
+  // block when no other watcher is active
+  ev_unref(backend->ev_loop);
 
   backend->currently_polling = 0;
   backend->pending_count = 0;
@@ -332,6 +386,58 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
+VALUE Backend_feed_loop(VALUE self, VALUE io, VALUE receiver, VALUE method) {
+  Backend_t *backend;
+  struct libev_io watcher;
+  rb_io_t *fptr;
+  VALUE str;
+  long total;
+  long len = 8192;
+  int shrinkable;
+  char *buf;
+  VALUE switchpoint_result = Qnil;
+  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_set_nonblock(fptr, io);
+  rectify_io_file_pos(fptr);
+  watcher.fiber = Qnil;
+
+  while (1) {
+    ssize_t n = read(fptr->fd, buf, len);
+    if (n < 0) {
+      int e = errno;
+      if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
+
+      switchpoint_result = libev_wait_fd_with_watcher(backend, fptr->fd, &watcher, EV_READ);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    }
+    else {
+      switchpoint_result = backend_snooze();
+
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+
+      if (n == 0) break; // EOF
+      total = n;
+      READ_LOOP_PASS_STR_TO_RECEIVER(receiver, method_id);
+    }
+  }
+
+  RB_GC_GUARD(str);
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+
+  return io;
+error:
+  return RAISE_EXCEPTION(switchpoint_result);
+}
+
 VALUE Backend_write(VALUE self, VALUE io, VALUE str) {
   Backend_t *backend;
   struct libev_io watcher;
@@ -618,6 +724,173 @@ error:
   return RAISE_EXCEPTION(switchpoint_result);
 }
 
+VALUE Backend_send(VALUE self, VALUE io, VALUE str, VALUE flags) {
+  Backend_t *backend;
+  struct libev_io watcher;
+  rb_io_t *fptr;
+  VALUE switchpoint_result = Qnil;
+  VALUE underlying_io;
+  char *buf = StringValuePtr(str);
+  long len = RSTRING_LEN(str);
+  long left = 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_set_nonblock(fptr, io);
+  watcher.fiber = Qnil;
+
+  while (left > 0) {
+    ssize_t n = send(fptr->fd, buf, left, flags_int);
+    if (n < 0) {
+      int e = errno;
+      if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
+
+      switchpoint_result = libev_wait_fd_with_watcher(backend, fptr->fd, &watcher, EV_WRITE);
+
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    }
+    else {
+      buf += n;
+      left -= n;
+    }
+  }
+
+  if (watcher.fiber == Qnil) {
+    switchpoint_result = backend_snooze();
+
+    if (TEST_EXCEPTION(switchpoint_result)) goto error;
+  }
+
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+
+  return INT2NUM(len);
+error:
+  return RAISE_EXCEPTION(switchpoint_result);
+}
+
+VALUE Backend_splice(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
+  Backend_t *backend;
+  struct libev_io watcher;
+  VALUE switchpoint_result = Qnil;
+  VALUE underlying_io;
+  rb_io_t *src_fptr;
+  rb_io_t *dest_fptr;
+  int len;
+
+  #ifndef POLYPHONY_LINUX
+  rb_raise(rb_eRuntimeError, "splice not supported");
+  #endif
+
+  GetBackend(self, backend);
+
+  underlying_io = rb_ivar_get(src, ID_ivar_io);
+  if (underlying_io != Qnil) src = underlying_io;
+  GetOpenFile(src, src_fptr);
+  io_set_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_set_nonblock(dest_fptr, dest);
+
+  watcher.fiber = Qnil;
+  while (1) {
+    len = splice(src_fptr->fd, 0, dest_fptr->fd, 0, NUM2INT(maxlen), 0);
+    if (len < 0) {
+      int e = errno;
+      if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
+
+      switchpoint_result = libev_wait_fd_with_watcher(backend, src_fptr->fd, &watcher, EV_READ);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+
+      switchpoint_result = libev_wait_fd_with_watcher(backend, dest_fptr->fd, &watcher, EV_WRITE);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    }
+    else {
+      break;
+    }
+  }
+
+  if (watcher.fiber == Qnil) {
+    switchpoint_result = backend_snooze();
+    if (TEST_EXCEPTION(switchpoint_result)) goto error;
+  }
+
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+
+  return INT2NUM(len);
+error:
+  return RAISE_EXCEPTION(switchpoint_result);
+}
+
+VALUE Backend_splice_to_eof(VALUE self, VALUE src, VALUE dest, VALUE maxlen) {
+  Backend_t *backend;
+  struct libev_io watcher;
+  VALUE switchpoint_result = Qnil;
+  VALUE underlying_io;
+  rb_io_t *src_fptr;
+  rb_io_t *dest_fptr;
+  int len;
+  int total = 0;
+
+  #ifndef POLYPHONY_LINUX
+  rb_raise(rb_eRuntimeError, "splice not supported");
+  #endif
+
+  GetBackend(self, backend);
+
+  underlying_io = rb_ivar_get(src, ID_ivar_io);
+  if (underlying_io != Qnil) src = underlying_io;
+  GetOpenFile(src, src_fptr);
+  io_set_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_set_nonblock(dest_fptr, dest);
+
+  watcher.fiber = Qnil;
+  while (1) {
+    len = splice(src_fptr->fd, 0, dest_fptr->fd, 0, NUM2INT(maxlen), 0);
+    if (len < 0) {
+      int e = errno;
+      if ((e != EWOULDBLOCK && e != EAGAIN)) rb_syserr_fail(e, strerror(e));
+
+      switchpoint_result = libev_wait_fd_with_watcher(backend, src_fptr->fd, &watcher, EV_READ);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+
+      switchpoint_result = libev_wait_fd_with_watcher(backend, dest_fptr->fd, &watcher, EV_WRITE);
+      if (TEST_EXCEPTION(switchpoint_result)) goto error;
+    }
+    else if (len == 0) {
+      break;
+    }
+    else {
+      total += len;
+    }
+  }
+
+  if (watcher.fiber == Qnil) {
+    switchpoint_result = backend_snooze();
+    if (TEST_EXCEPTION(switchpoint_result)) goto error;
+  }
+
+  RB_GC_GUARD(watcher.fiber);
+  RB_GC_GUARD(switchpoint_result);
+
+  return INT2NUM(total);
+error:
+  return RAISE_EXCEPTION(switchpoint_result);
+}
+
 VALUE Backend_wait_io(VALUE self, VALUE io, VALUE write) {
   Backend_t *backend;
   rb_io_t *fptr;
@@ -685,26 +958,12 @@ noreturn VALUE Backend_timer_loop(VALUE self, VALUE interval) {
     RB_GC_GUARD(switchpoint_result);
 
     rb_yield(Qnil);
-
-    while (1) {
+    do {
       next_time += interval_d;
-      if (next_time > now) break;
-    }
+    } while (next_time <= now);
   }
 }
 
-VALUE Backend_timeout_safe(VALUE arg) {
-  return rb_yield(arg);
-}
-
-VALUE Backend_timeout_rescue(VALUE arg, VALUE exception) {
-  return exception;
-}
-
-VALUE Backend_timeout_ensure_safe(VALUE arg) {
-  return rb_rescue2(Backend_timeout_safe, Qnil, Backend_timeout_rescue, Qnil, rb_eException, (VALUE)0);
-}
-
 struct libev_timeout {
   struct ev_timer timer;
   VALUE fiber;
@@ -759,13 +1018,39 @@ VALUE Backend_timeout(int argc,VALUE *argv, VALUE self) {
   return result;
 }
 
+#ifdef POLYPHONY_USE_PIDFD_OPEN
+VALUE Backend_waitpid(VALUE self, VALUE pid) {
+  int pid_int = NUM2INT(pid);
+  int fd = pidfd_open(pid_int, 0);
+  if (fd >= 0) {
+    Backend_t *backend;
+    GetBackend(self, backend);
+
+    VALUE resume_value = libev_wait_fd(backend, fd, EV_READ, 0);
+    close(fd);
+    RAISE_IF_EXCEPTION(resume_value);
+    RB_GC_GUARD(resume_value);
+  }
+  else {
+    int e = errno;
+    rb_syserr_fail(e, strerror(e));
+  }
+
+  int status = 0;
+  pid_t ret = waitpid(pid_int, &status, WNOHANG);
+  if (ret < 0) {
+    int e = errno;
+    rb_syserr_fail(e, strerror(e));
+  }
+  return rb_ary_new_from_args(2, INT2NUM(ret), INT2NUM(WEXITSTATUS(status)));
+}
+#else
 struct libev_child {
   struct ev_child child;
   VALUE fiber;
 };
 
-void Backend_child_callback(EV_P_ ev_child *w, int revents)
-{
+void Backend_child_callback(EV_P_ ev_child *w, int revents) {
   struct libev_child *watcher = (struct libev_child *)w;
   int exit_status = WEXITSTATUS(w->rstatus);
   VALUE status;
@@ -792,6 +1077,7 @@ VALUE Backend_waitpid(VALUE self, VALUE pid) {
   RB_GC_GUARD(switchpoint_result);
   return switchpoint_result;
 }
+#endif
 
 void Backend_async_callback(EV_P_ ev_async *w, int revents) { }
 
@@ -820,7 +1106,7 @@ VALUE Backend_kind(VALUE self) {
 void Init_Backend() {
   ev_set_allocator(xrealloc);
 
-  VALUE cBackend = rb_define_class_under(mPolyphony, "Backend", rb_cData);
+  VALUE cBackend = rb_define_class_under(mPolyphony, "Backend", rb_cObject);
   rb_define_alloc_func(cBackend, Backend_allocate);
 
   rb_define_method(cBackend, "initialize", Backend_initialize, 0);
@@ -829,24 +1115,26 @@ void Init_Backend() {
 
   rb_define_method(cBackend, "poll", Backend_poll, 3);
   rb_define_method(cBackend, "break", Backend_wakeup, 0);
+  rb_define_method(cBackend, "kind", Backend_kind, 0);
 
-  rb_define_method(cBackend, "read", Backend_read, 4);
-  rb_define_method(cBackend, "read_loop", Backend_read_loop, 1);
-  rb_define_method(cBackend, "write", Backend_write_m, -1);
   rb_define_method(cBackend, "accept", Backend_accept, 2);
   rb_define_method(cBackend, "accept_loop", Backend_accept_loop, 2);
   rb_define_method(cBackend, "connect", Backend_connect, 3);
+  rb_define_method(cBackend, "feed_loop", Backend_feed_loop, 3);
+  rb_define_method(cBackend, "read", Backend_read, 4);
+  rb_define_method(cBackend, "read_loop", Backend_read_loop, 1);
   rb_define_method(cBackend, "recv", Backend_recv, 3);
   rb_define_method(cBackend, "recv_loop", Backend_read_loop, 1);
-  rb_define_method(cBackend, "send", Backend_write, 2);
-  rb_define_method(cBackend, "wait_io", Backend_wait_io, 2);
+  rb_define_method(cBackend, "recv_feed_loop", Backend_feed_loop, 3);
+  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, "timer_loop", Backend_timer_loop, 1);
   rb_define_method(cBackend, "timeout", Backend_timeout, -1);
-  rb_define_method(cBackend, "waitpid", Backend_waitpid, 1);
+  rb_define_method(cBackend, "timer_loop", Backend_timer_loop, 1);
   rb_define_method(cBackend, "wait_event", Backend_wait_event, 1);
-
-  rb_define_method(cBackend, "kind", Backend_kind, 0);
+  rb_define_method(cBackend, "wait_io", Backend_wait_io, 2);
+  rb_define_method(cBackend, "waitpid", Backend_waitpid, 1);
+  rb_define_method(cBackend, "write", Backend_write_m, -1);
 
   ID_ivar_is_nonblocking = rb_intern("@is_nonblocking");
   SYM_libev = ID2SYM(rb_intern("libev"));