Introduce `rb_io_blocking_region` which takes `struct rb_io` argument. (#11795)

This does not change any actual behaviour, but provides a choke point for blocking IO operations.

* Update `IO::Buffer` to use `rb_io_blocking_region`.

* Update `File` to use `rb_io_blocking_region`.

* Update `IO` to use `rb_io_blocking_region`.

1 files changed, 40 insertions, 24 deletions

diff --git a/io.c b/io.c
index 1e5c851f87..b26f71056f 100644
--- a/io.c
+++ b/io.c
@@ -222,6 +222,17 @@ static VALUE sym_HOLE;
 
 static VALUE prep_io(int fd, int fmode, VALUE klass, const char *path);
 
+VALUE
+rb_io_blocking_region_wait(struct rb_io *io, rb_blocking_function_t *function, void *argument, enum rb_io_event events)
+{
+    return rb_thread_io_blocking_call(function, argument, io->fd, events);
+}
+
+VALUE rb_io_blocking_region(struct rb_io *io, rb_blocking_function_t *function, void *argument)
+{
+    return rb_io_blocking_region_wait(io, function, argument, 0);
+}
+
 struct argf {
     VALUE filename, current_file;
     long last_lineno;		/* $. */
@@ -1298,7 +1309,7 @@ rb_io_read_memory(rb_io_t *fptr, void *buf, size_t count)
         iis.timeout = &timeout_storage;
     }
 
-    return (ssize_t)rb_thread_io_blocking_call(internal_read_func, &iis, fptr->fd, RB_WAITFD_IN);
+    return (ssize_t)rb_io_blocking_region_wait(fptr, internal_read_func, &iis, RUBY_IO_READABLE);
 }
 
 static ssize_t
@@ -1331,7 +1342,7 @@ rb_io_write_memory(rb_io_t *fptr, const void *buf, size_t count)
         iis.timeout = &timeout_storage;
     }
 
-    return (ssize_t)rb_thread_io_blocking_call(internal_write_func, &iis, fptr->fd, RB_WAITFD_OUT);
+    return (ssize_t)rb_io_blocking_region_wait(fptr, internal_write_func, &iis, RUBY_IO_WRITABLE);
 }
 
 #ifdef HAVE_WRITEV
@@ -1368,7 +1379,7 @@ rb_writev_internal(rb_io_t *fptr, const struct iovec *iov, int iovcnt)
         iis.timeout = &timeout_storage;
     }
 
-    return (ssize_t)rb_thread_io_blocking_call(internal_writev_func, &iis, fptr->fd, RB_WAITFD_OUT);
+    return (ssize_t)rb_io_blocking_region_wait(fptr, internal_writev_func, &iis, RUBY_IO_WRITABLE);
 }
 #endif
 
@@ -1398,7 +1409,7 @@ static VALUE
 io_flush_buffer_async(VALUE arg)
 {
     rb_io_t *fptr = (rb_io_t *)arg;
-    return rb_thread_io_blocking_call(io_flush_buffer_sync, fptr, fptr->fd, RB_WAITFD_OUT);
+    return rb_io_blocking_region_wait(fptr, io_flush_buffer_sync, fptr, RUBY_IO_WRITABLE);
 }
 
 static inline int
@@ -2788,8 +2799,10 @@ rb_io_fsync(VALUE io)
 
     if (io_fflush(fptr) < 0)
         rb_sys_fail_on_write(fptr);
-    if ((int)rb_thread_io_blocking_region(nogvl_fsync, fptr, fptr->fd) < 0)
+
+    if ((int)rb_io_blocking_region(fptr, nogvl_fsync, fptr))
         rb_sys_fail_path(fptr->pathv);
+
     return INT2FIX(0);
 }
 #else
@@ -2838,7 +2851,7 @@ rb_io_fdatasync(VALUE io)
     if (io_fflush(fptr) < 0)
         rb_sys_fail_on_write(fptr);
 
-    if ((int)rb_thread_io_blocking_region(nogvl_fdatasync, fptr, fptr->fd) == 0)
+    if ((int)rb_io_blocking_region(fptr, nogvl_fdatasync, fptr) == 0)
         return INT2FIX(0);
 
     /* fall back */
@@ -3423,10 +3436,10 @@ io_read_memory_call(VALUE arg)
     }
 
     if (iis->nonblock) {
-        return rb_thread_io_blocking_call(internal_read_func, iis, iis->fptr->fd, 0);
+        return rb_io_blocking_region(iis->fptr, internal_read_func, iis);
     }
     else {
-        return rb_thread_io_blocking_call(internal_read_func, iis, iis->fptr->fd, RB_WAITFD_IN);
+        return rb_io_blocking_region_wait(iis->fptr, internal_read_func, iis, RUBY_IO_READABLE);
     }
 }
 
@@ -6099,7 +6112,7 @@ rb_io_sysread(int argc, VALUE *argv, VALUE io)
 }
 
 struct prdwr_internal_arg {
-    VALUE io;
+    struct rb_io *io;
     int fd;
     void *buf;
     size_t count;
@@ -6121,14 +6134,14 @@ pread_internal_call(VALUE _arg)
 
     VALUE scheduler = rb_fiber_scheduler_current();
     if (scheduler != Qnil) {
-        VALUE result = rb_fiber_scheduler_io_pread_memory(scheduler, arg->io, arg->offset, arg->buf, arg->count, 0);
+        VALUE result = rb_fiber_scheduler_io_pread_memory(scheduler, arg->io->self, arg->offset, arg->buf, arg->count, 0);
 
         if (!UNDEF_P(result)) {
             return rb_fiber_scheduler_io_result_apply(result);
         }
     }
 
-    return rb_thread_io_blocking_call(internal_pread_func, arg, arg->fd, RB_WAITFD_IN);
+    return rb_io_blocking_region_wait(arg->io, internal_pread_func, arg, RUBY_IO_READABLE);
 }
 
 /*
@@ -6165,7 +6178,7 @@ rb_io_pread(int argc, VALUE *argv, VALUE io)
     VALUE len, offset, str;
     rb_io_t *fptr;
     ssize_t n;
-    struct prdwr_internal_arg arg = {.io = io};
+    struct prdwr_internal_arg arg;
     int shrinkable;
 
     rb_scan_args(argc, argv, "21", &len, &offset, &str);
@@ -6179,6 +6192,7 @@ rb_io_pread(int argc, VALUE *argv, VALUE io)
     GetOpenFile(io, fptr);
     rb_io_check_byte_readable(fptr);
 
+    arg.io = fptr;
     arg.fd = fptr->fd;
     rb_io_check_closed(fptr);
 
@@ -6203,7 +6217,7 @@ internal_pwrite_func(void *_arg)
 
     VALUE scheduler = rb_fiber_scheduler_current();
     if (scheduler != Qnil) {
-        VALUE result = rb_fiber_scheduler_io_pwrite_memory(scheduler, arg->io, arg->offset, arg->buf, arg->count, 0);
+        VALUE result = rb_fiber_scheduler_io_pwrite_memory(scheduler, arg->io->self, arg->offset, arg->buf, arg->count, 0);
 
         if (!UNDEF_P(result)) {
             return rb_fiber_scheduler_io_result_apply(result);
@@ -6244,7 +6258,7 @@ rb_io_pwrite(VALUE io, VALUE str, VALUE offset)
 {
     rb_io_t *fptr;
     ssize_t n;
-    struct prdwr_internal_arg arg = {.io = io};
+    struct prdwr_internal_arg arg;
     VALUE tmp;
 
     if (!RB_TYPE_P(str, T_STRING))
@@ -6255,13 +6269,15 @@ rb_io_pwrite(VALUE io, VALUE str, VALUE offset)
     io = GetWriteIO(io);
     GetOpenFile(io, fptr);
     rb_io_check_writable(fptr);
+
+    arg.io = fptr;
     arg.fd = fptr->fd;
 
     tmp = rb_str_tmp_frozen_acquire(str);
     arg.buf = RSTRING_PTR(tmp);
     arg.count = (size_t)RSTRING_LEN(tmp);
 
-    n = (ssize_t)rb_thread_io_blocking_call(internal_pwrite_func, &arg, fptr->fd, RB_WAITFD_OUT);
+    n = (ssize_t)rb_io_blocking_region_wait(fptr, internal_pwrite_func, &arg, RUBY_IO_WRITABLE);
     if (n < 0) rb_sys_fail_path(fptr->pathv);
     rb_str_tmp_frozen_release(str, tmp);
 
@@ -10806,7 +10822,7 @@ do_io_advise(rb_io_t *fptr, VALUE advice, rb_off_t offset, rb_off_t len)
     ias.offset = offset;
     ias.len    = len;
 
-    rv = (int)rb_thread_io_blocking_region(io_advise_internal, &ias, fptr->fd);
+    rv = (int)rb_io_blocking_region(fptr, io_advise_internal, &ias);
     if (rv && rv != ENOSYS) {
         /* posix_fadvise(2) doesn't set errno. On success it returns 0; otherwise
            it returns the error code. */
@@ -11099,16 +11115,16 @@ nogvl_ioctl(void *ptr)
 }
 
 static int
-do_ioctl(int fd, ioctl_req_t cmd, long narg)
+do_ioctl(struct rb_io *io, ioctl_req_t cmd, long narg)
 {
     int retval;
     struct ioctl_arg arg;
 
-    arg.fd = fd;
+    arg.fd = io->fd;
     arg.cmd = cmd;
     arg.narg = narg;
 
-    retval = (int)rb_thread_io_blocking_region(nogvl_ioctl, &arg, fd);
+    retval = (int)rb_io_blocking_region(io, nogvl_ioctl, &arg);
 
     return retval;
 }
@@ -11371,7 +11387,7 @@ rb_ioctl(VALUE io, VALUE req, VALUE arg)
 
     narg = setup_narg(cmd, &arg, ioctl_narg_len);
     GetOpenFile(io, fptr);
-    retval = do_ioctl(fptr->fd, cmd, narg);
+    retval = do_ioctl(fptr, cmd, narg);
     return finish_narg(retval, arg, fptr);
 }
 
@@ -11425,16 +11441,16 @@ nogvl_fcntl(void *ptr)
 }
 
 static int
-do_fcntl(int fd, int cmd, long narg)
+do_fcntl(struct rb_io *io, int cmd, long narg)
 {
     int retval;
     struct fcntl_arg arg;
 
-    arg.fd = fd;
+    arg.fd = io->fd;
     arg.cmd = cmd;
     arg.narg = narg;
 
-    retval = (int)rb_thread_io_blocking_region(nogvl_fcntl, &arg, fd);
+    retval = (int)rb_io_blocking_region(io, nogvl_fcntl, &arg);
     if (retval != -1) {
         switch (cmd) {
 #if defined(F_DUPFD)
@@ -11460,7 +11476,7 @@ rb_fcntl(VALUE io, VALUE req, VALUE arg)
 
     narg = setup_narg(cmd, &arg, fcntl_narg_len);
     GetOpenFile(io, fptr);
-    retval = do_fcntl(fptr->fd, cmd, narg);
+    retval = do_fcntl(fptr, cmd, narg);
     return finish_narg(retval, arg, fptr);
 }