polyphony 0.50.0 → 0.53.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2aac80a08ca16498c3ee0044b0ba6de039b179425051cbcee67af4c9b948c349
-  data.tar.gz: bbe016d6b2ad3c5c89129089f9ebb8457a37159e03be2ff84f2572454880b0c2
+  metadata.gz: b769b5e71cbfa8679a639d369817abd8e5870efec8ea21feb60bb1e46ee7ca29
+  data.tar.gz: 0b2ded84eb0e120d20dd17c9973e2cab784cdf61c20bd20fcb6a13c2b6e9f58a
 SHA512:
-  metadata.gz: 2f91d0b40bceb4600e4bbd22f39cdbd6bfd4ac5b5fc038f77deb7d26a464ce3cad177884f9aadde60c78bc48df170ab6909c44d133283af3abf77a090ac58332
-  data.tar.gz: 37dfa412a25f41dd704a203a865817bf273a23db0ccbe1bbec1a3f6017b9cd953301d67077e3b58601485f4dd96db94bef77da3d46cabd57fb563d3652173175
+  metadata.gz: e6d3a3d2c130c31483ead4d8f13cc90a87149ac6c461871a43144111cdc37e6e2544c130dc447af26e39e9519b48e3abe1a10197dd4512a7292968e4939e676b
+  data.tar.gz: dc1b53918032fc74578ca528abb5a96e423ea8e7a070047f7936720cb6553d9f247cbb625e9d82c7b9b58795a4a3a74aae566231a7a4bb8443f5352c00d10b2a

data/.github/workflows/test.yml

@@ -8,7 +8,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest]
-        ruby: [2.6, 2.7]
+        ruby: [2.6, 2.7, 3.0]
 
     name: >-
       ${{matrix.os}}, ${{matrix.ruby}}

data/CHANGELOG.md

@@ -1,3 +1,33 @@
+## 0.53.1
+
+- Remove `splice` methods on libev backend on non-Linux OS (#43)
+
+## 0.53.0
+
+- Implement `Backend#splice`, `Backend#splice_to_eof`, along with `IO#splice`, `IO#splice_to_eof`
+
+## 0.52.0
+
+- Polyphony is now compatible with Ruby 3.0
+- Add `Backend#sendv` method for sending multiple strings
+- Accept flags argument in `Backend#send` (#48)
+- Fix io_uring backend on Ruby 3.0 (#47)
+- Implement C-based public backend API: `Polyphony.backend_XXXX` methods
+- libev backend: Use` pidfd_open` for Linux 5.3+, otherwise use a libev child watcher
+- Use `:call` as default method in `#feed_loop`
+
+## 0.51.0
+
+- Implement `IO#feed_loop`, `Socket#feed_loop`
+- Fix error handling in `Process.kill_and_await`
+
+## 0.50.1
+
+- Set `IOSQE_ASYNC` flag in io_uring backend
+- Fix error handling in `Backend#waitpid`
+- Reimplement libev backend's `#waitpid` by using pidfd_open (in similar manner
+  to the io_uring backend)
+
 ## 0.50.0
 
 - Use `Process::CLOCK_MONOTONIC` in Timer

data/Gemfile.lock

@@ -1,101 +1,50 @@
 PATH
   remote: .
   specs:
-    polyphony (0.50.0)
+    polyphony (0.53.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    addressable (2.7.0)
-      public_suffix (>= 2.0.2, < 5.0)
     ansi (1.5.0)
     ast (2.4.0)
     builder (3.2.4)
     coderay (1.1.3)
-    colorator (1.1.0)
-    concurrent-ruby (1.1.6)
     docile (1.3.2)
-    em-websocket (0.5.1)
-      eventmachine (>= 0.12.9)
-      http_parser.rb (~> 0.6.0)
-    eventmachine (1.2.7)
-    ffi (1.12.1)
-    forwardable-extended (2.6.0)
     hiredis (0.6.3)
     http_parser.rb (0.6.0)
     httparty (0.17.1)
       mime-types (~> 3.0)
       multi_xml (>= 0.5.2)
-    i18n (0.9.5)
-      concurrent-ruby (~> 1.0)
-    jekyll (3.8.6)
-      addressable (~> 2.4)
-      colorator (~> 1.0)
-      em-websocket (~> 0.5)
-      i18n (~> 0.7)
-      jekyll-sass-converter (~> 1.0)
-      jekyll-watch (~> 2.0)
-      kramdown (~> 1.14)
-      liquid (~> 4.0)
-      mercenary (~> 0.3.3)
-      pathutil (~> 0.9)
-      rouge (>= 1.7, < 4)
-      safe_yaml (~> 1.0)
-    jekyll-remote-theme (0.4.1)
-      addressable (~> 2.0)
-      jekyll (>= 3.5, < 5.0)
-      rubyzip (>= 1.3.0)
-    jekyll-sass-converter (1.5.2)
-      sass (~> 3.4)
-    jekyll-seo-tag (2.6.1)
-      jekyll (>= 3.3, < 5.0)
-    jekyll-watch (2.2.1)
-      listen (~> 3.0)
     json (2.3.0)
-    just-the-docs (0.3.0)
-      jekyll (>= 3.8.5)
-      jekyll-seo-tag (~> 2.0)
-      rake (>= 12.3.1, < 13.1.0)
-    kramdown (1.17.0)
-    liquid (4.0.3)
-    listen (3.2.1)
-      rb-fsevent (~> 0.10, >= 0.10.3)
-      rb-inotify (~> 0.9, >= 0.9.10)
-    mercenary (0.3.6)
     method_source (1.0.0)
     mime-types (3.3.1)
       mime-types-data (~> 3.2015)
     mime-types-data (3.2020.0512)
-    minitest (5.13.0)
+    minitest (5.14.4)
     minitest-reporters (1.4.2)
       ansi
       builder
       minitest (>= 5.0)
       ruby-progressbar
+    msgpack (1.4.2)
     multi_xml (0.6.0)
     mysql2 (0.5.3)
     parallel (1.19.1)
     parser (2.7.0.2)
       ast (~> 2.4.0)
-    pathutil (0.16.2)
-      forwardable-extended (~> 2.6)
     pg (1.1.4)
     pry (0.13.1)
       coderay (~> 1.1)
       method_source (~> 1.0)
-    public_suffix (4.0.3)
     rack (2.2.3)
     rainbow (3.0.0)
-    rake (12.3.3)
+    rake (13.0.3)
     rake-compiler (1.1.1)
       rake
-    rb-fsevent (0.10.3)
-    rb-inotify (0.10.1)
-      ffi (~> 1.0)
     redis (4.1.0)
     regexp_parser (1.7.1)
     rexml (3.2.4)
-    rouge (3.15.0)
     rubocop (0.85.1)
       parallel (~> 1.10)
       parser (>= 2.7.0.1)
@@ -108,13 +57,6 @@ GEM
     rubocop-ast (0.0.3)
       parser (>= 2.7.0.1)
     ruby-progressbar (1.10.1)
-    rubyzip (2.0.0)
-    safe_yaml (1.0.5)
-    sass (3.7.4)
-      sass-listen (~> 4.0.0)
-    sass-listen (4.0.0)
-      rb-fsevent (~> 0.9, >= 0.9.4)
-      rb-inotify (~> 0.9, >= 0.9.7)
     sequel (5.34.0)
     simplecov (0.17.1)
       docile (~> 1.1)
@@ -130,12 +72,9 @@ DEPENDENCIES
   hiredis (= 0.6.3)
   http_parser.rb (~> 0.6.0)
   httparty (= 0.17.1)
-  jekyll (~> 3.8.6)
-  jekyll-remote-theme (~> 0.4.1)
-  jekyll-seo-tag (~> 2.6.1)
-  just-the-docs (~> 0.3.0)
-  minitest (= 5.13.0)
+  minitest (= 5.14.4)
   minitest-reporters (= 1.4.2)
+  msgpack (= 1.4.2)
   mysql2 (= 0.5.3)
   pg (= 1.1.4)
   polyphony!
@@ -148,4 +87,4 @@ DEPENDENCIES
   simplecov (= 0.17.1)
 
 BUNDLED WITH
-   2.1.4
+   2.2.3

data/TODO.md

@@ -1,9 +1,11 @@
+- Add support for IPv6:
+  https://www.reddit.com/r/ruby/comments/lyen23/understanding_ipv6_and_why_its_important_to_you/
+
+- Add support for UDP sockets
+
 - Check segfault when resetting a `cancel_after` timeout lots of times at very high rate
 - Check why `throttled_loop` inside of `move_on_after` fails to stop
 
-- Commented out `io_uring_sqe_set_flags(sqe, IOSQE_ASYNC);` in `io_uring_backend_defer_submit_and_await`:
-  - This flag should be set for I/O ops, not for other stuff
-
 - Override stock `::SizedQueue` impl with Queue with capacity
 
 - Add support for `break` and `StopIteration` in all loops (with tests)
@@ -16,17 +18,46 @@
   - `Fiber#receive_loop` (very little effort, should be implemented in C)
 
 
-- Add `Backend#splice`, `Backend#splice_loop` for implementing stuff like proxying:
+- Add `Backend#splice`, `Backend#splice_to_eof` for implementing stuff like proxying:
 
   ```ruby
   def two_way_proxy(socket1, socket2)
     backend = Thread.current.backend
-    f1 = spin { backend.splice_loop(socket1, socket2) }
-    f2 = spin { backend.splice_loop(socket2, socket1) }
+    f1 = spin { backend.splice_to_eof(socket1, socket2) }
+    f2 = spin { backend.splice_to_eof(socket2, socket1) }
     Fiber.await(f1, f2)
   end
   ```
 
+- Add support for `close` to io_uring backend
+
+- Add support for submission of multiple requests to io_uring backend:
+
+  ```ruby
+  Thread.current.backend.submit(
+    [:send, sock, chunk_header(len)],
+    [:splice, file, sock, len]
+  )
+  ```
+
+  Full example (for writing chunks from a file to an HTTP response):
+
+  ```ruby
+  def serve_io(io)
+    i, o = IO.pipe
+    backend = Thread.current.backend
+    while true
+      len = o.splice(io, 8192)
+      break if len == 0
+      
+      backend.submit(
+        [:write, sock, chunk_header(len)],
+        [:splice, i, sock, len]
+      )
+    end
+  end
+  ```
+
 - Graceful shutdown again:
   - What happens to children when doing a graceful shutdown?
   - What are the implications of passing graceful shutdown flag to children?

data/examples/core/forking.rb

@@ -5,7 +5,7 @@ require 'polyphony'
 
 puts "parent pid: #{Process.pid}"
 
-pid = Polyphony.fork do
+pid = fork do
   puts "child pid: #{Process.pid}"
 
   spin do
@@ -20,5 +20,5 @@ end
 puts "got child pid #{pid}"
 
 puts 'parent waiting for child'
-Thread.current.backend.waitpid(pid)
+Polyphony.backend_waitpid(pid)
 puts 'parent done waiting'

data/examples/io/echo_server.rb

@@ -9,6 +9,7 @@ puts 'Echoing on port 1234...'
 while (client = server.accept)
   spin do
     while (data = client.gets)
+      # client.send("you said: #{data.chomp}!\n", 0)
       client.write('you said: ', data.chomp, "!\n")
     end
   rescue Errno::ECONNRESET

data/examples/io/tcp_proxy.rb

@@ -15,7 +15,7 @@ f1 = spin {
   client1 = server1.accept
   loop do
     if client2
-      Thread.current.backend.splice_loop(client1, client2)
+      Thread.current.backend.splice_to_eof(client1, client2)
     end
   end
 }
@@ -24,7 +24,7 @@ f2 = spin {
   client2 = server2.accept
   loop do
     if client1
-      Thread.current.backend.splice_loop(client2, client1)
+      Thread.current.backend.splice_to_eof(client2, client1)
     end
   end
 }

data/ext/polyphony/backend_common.h

@@ -3,6 +3,17 @@
 #include "ruby.h"
 #include "ruby/io.h"
 
+
+#ifdef POLYPHONY_USE_PIDFD_OPEN
+#ifndef __NR_pidfd_open
+#define __NR_pidfd_open 434   /* System call # on most architectures */
+#endif
+
+static int pidfd_open(pid_t pid, unsigned int flags) {
+  return syscall(__NR_pidfd_open, pid, flags);
+}
+#endif
+
 //////////////////////////////////////////////////////////////////////
 //////////////////////////////////////////////////////////////////////
 // the following is copied verbatim from the Ruby source code (io.c)
@@ -15,11 +26,11 @@ struct io_internal_read_struct {
 
 #define StringValue(v) rb_string_value(&(v))
 
-inline int io_setstrbuf(VALUE *str, long len) {
+int io_setstrbuf(VALUE *str, long len) {
   #ifdef _WIN32
     len = (len + 1) & ~1L;	/* round up for wide char */
   #endif
-  if (NIL_P(*str)) {
+  if (*str == Qnil) {
     *str = rb_str_new(0, len);
     return 1;
   }
@@ -44,7 +55,7 @@ inline void io_shrink_read_string(VALUE str, long n) {
   }
 }
 
-inline void io_set_read_length(VALUE str, long n, int shrinkable) {
+void io_set_read_length(VALUE str, long n, int shrinkable) {
   if (RSTRING_LEN(str) != n) {
     rb_str_modify(str);
     rb_str_set_len(str, n);
@@ -59,7 +70,7 @@ inline rb_encoding* io_read_encoding(rb_io_t *fptr) {
     return rb_default_external_encoding();
 }
 
-inline VALUE io_enc_str(VALUE str, rb_io_t *fptr) {
+VALUE io_enc_str(VALUE str, rb_io_t *fptr) {
     OBJ_TAINT(str);
     rb_enc_associate(str, io_read_encoding(fptr));
     return str;
@@ -99,6 +110,13 @@ inline VALUE backend_snooze() {
   READ_LOOP_PREPARE_STR(); \
 }
 
+#define READ_LOOP_PASS_STR_TO_RECEIVER(receiver, method_id) { \
+  io_set_read_length(str, total, shrinkable); \
+  io_enc_str(str, fptr); \
+  rb_funcall_passing_block(receiver, method_id, 1, &str); \
+  READ_LOOP_PREPARE_STR(); \
+}
+
 inline void rectify_io_file_pos(rb_io_t *fptr) {
   // Apparently after reopening a closed file, the file position is not reset,
   // which causes the read to fail. Fortunately we can use fptr->rbuf.len to
@@ -120,10 +138,42 @@ inline double current_time() {
 }
 
 inline VALUE backend_timeout_exception(VALUE exception) {
-  if (RTEST(rb_obj_is_kind_of(exception, rb_cArray)))
+  if (rb_obj_is_kind_of(exception, rb_cArray) == Qtrue)
     return rb_funcall(rb_ary_entry(exception, 0), ID_new, 1, rb_ary_entry(exception, 1));
-  else if (RTEST(rb_obj_is_kind_of(exception, rb_cClass)))
+  else if (rb_obj_is_kind_of(exception, rb_cClass) == Qtrue)
     return rb_funcall(exception, ID_new, 0);
   else
     return rb_funcall(rb_eRuntimeError, ID_new, 1, exception);
-}
+}
+
+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);
+}
+
+static VALUE empty_string = Qnil;
+
+VALUE Backend_sendv(VALUE self, VALUE io, VALUE ary, VALUE flags) {
+  switch (RARRAY_LEN(ary)) {
+  case 0:
+    return Qnil;
+  case 1:
+    return Backend_send(self, io, RARRAY_AREF(ary, 0), flags);
+  default:
+    if (empty_string == Qnil) {
+      empty_string = rb_str_new_literal("");
+      rb_global_variable(&empty_string);
+    }
+    VALUE joined = rb_ary_join(ary, empty_string);
+    VALUE result = Backend_send(self, io, joined, flags);
+    RB_GC_GUARD(joined);
+    return result;
+  }
+}

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
@@ -132,7 +150,7 @@ static inline bool cq_ring_needs_flush(struct io_uring *ring) {
 	return IO_URING_READ_ONCE(*ring->sq.kflags) & IORING_SQ_CQ_OVERFLOW;
 }
 
-void io_uring_backend_handle_completion(struct io_uring_cqe *cqe, Backend_t *backend) {
+static inline void io_uring_backend_handle_completion(struct io_uring_cqe *cqe, Backend_t *backend) {
   op_context_t *ctx = io_uring_cqe_get_data(cqe);
   if (!ctx) return;
 
@@ -151,7 +169,7 @@ void io_uring_backend_handle_completion(struct io_uring_cqe *cqe, Backend_t *bac
 }
 
 // adapted from io_uring_peek_batch_cqe in queue.c 
-// this peeks at cqes and for each one 
+// this peeks at cqes and handles each available cqe
 void io_uring_backend_handle_ready_cqes(Backend_t *backend) {
   struct io_uring *ring = &backend->ring;
 	bool overflow_checked = false;
@@ -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);
@@ -297,8 +315,8 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
   Backend_t *backend;
   rb_io_t *fptr;
   long dynamic_len = length == Qnil;
-  long len = dynamic_len ? 4096 : NUM2INT(length);
-  int shrinkable = io_setstrbuf(&str, len);
+  long buffer_size = dynamic_len ? 4096 : NUM2INT(length);
+  int shrinkable = io_setstrbuf(&str, buffer_size);
   char *buf = RSTRING_PTR(str);
   long total = 0;
   int read_to_eof = RTEST(to_eof);
@@ -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);
 
@@ -315,7 +334,7 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
     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 - total, -1);
+    io_uring_prep_read(sqe, fptr->fd, buf, buffer_size - total, -1);
 
     int result = io_uring_backend_defer_submit_and_await(backend, sqe, ctx, &resume_value);
     OP_CONTEXT_RELEASE(&backend->store, ctx);
@@ -331,14 +350,15 @@ VALUE Backend_read(VALUE self, VALUE io, VALUE str, VALUE length, VALUE to_eof)
       total += result;
       if (!read_to_eof) break;
 
-      if (total == len) {
+      if (total == buffer_size) {
         if (!dynamic_len) break;
 
+        // resize buffer
         rb_str_resize(str, total);
-        rb_str_modify_expand(str, len);
+        rb_str_modify_expand(str, buffer_size);
         buf = RSTRING_PTR(str) + total;
         shrinkable = 0;
-        len += len;
+        buffer_size += buffer_size;
       }
       else buf += result;
     }
@@ -368,6 +388,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 +418,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 +475,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 +519,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 +599,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 +647,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 +676,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 +732,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 +771,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 +826,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));
+
+    total += result;
+    if (result == 0 || !loop) return INT2NUM(total);
+  }
+
+  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 +890,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 +917,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 +989,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 +1027,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 +1044,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 +1092,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 +1101,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"));
 }