From: ciconia@... Date: 2021-06-16T07:10:29+00:00 Subject: [ruby-core:104301] [Ruby master Bug#17664] Behavior of sockets changed in Ruby 3.0 to non-blocking Issue #17664 has been updated by ciconia (Sharon Rosner). > In the uring backend, for read/write operations, set the IO to blocking and then revert it afterwards. Why would you need to revert it? In practically all cases I can think of, you're going to do all I/O for a given fd on the same scheduler. In addition, if you need to make two additional `fcntl` system calls on every I/O operation, it defeats the whole purpose of using io_uring in the first place. I had another solution in mind, similar to [what I mentioned above](https://github.com/digital-fabric/polyphony/blob/d3c9cf3ddc1f414387948fa40e5f6a24f68bf045/ext/polyphony/backend_io_uring.c#L28-L47), but more general: - Cache the blocking/non-blocking state in an instance variable on the `IO`/`Socket` instance. - If the instance variable is not set, call `fcntl` and set the instance variable. - This could be done in order to implement both blocking and non-blocking behavior, according to the type of fiber scheduler. So a libev-based scheduler would be able to set it to non-blocking, and an io_uring-based one would set it to blocking. Pseudo-code: ```ruby def check_blocking_state(io, block) state = io.instance_variable_get(:blocking_state) if block != state flags = fcntl(io.fd, F_GETFL) block ? (flags ~= flags & ~O_NONBLOCK) : (flags |= O_NONBLOCK) fcntl(io.fd, F_SETFL, flags); io.instance_variable_set(:blocking_state, block) end end ``` This solution, called before any I/O operation, keeps the extra system calls to a minimum and lets you implement schedulers for both blocking and non-blocking I/O. It's also fully backwards compatible with the core Ruby IO and Socket implementations. (BTW the current IO implementation, when no fiber scheduler is used, [calls `fcntl` at least once](https://github.com/ruby/ruby/blob/f136c1ec804e1837f006f3abbf2ef90f1ef8134d/io.c#L2993) for basically *every I/O operation*, which is also a waste in practically all cases.) > Change Ruby default IO back to blocking. But it can cause issues for fiber scheduler since non-blocking hooks will never be invoked. I think sockets should be changed back to blocking by default, even if just for the sake of consistency. This change took me by surprise, and it cost me a few hours of looking around trying to figure out why I was getting `EAGAIN` on sockets and not on files. ---------------------------------------- Bug #17664: Behavior of sockets changed in Ruby 3.0 to non-blocking https://bugs.ruby-lang.org/issues/17664#change-92523 * Author: ciconia (Sharon Rosner) * Status: Assigned * Priority: Normal * Assignee: ioquatix (Samuel Williams) * ruby -v: 3.0.0 * Backport: 2.5: UNKNOWN, 2.6: UNKNOWN, 2.7: UNKNOWN, 3.0: UNKNOWN ---------------------------------------- I'm not sure this is a bug, but apparently a change was introduced in Ruby 3.0 that makes sockets non-blocking by default. This change was apparently introduced as part of the work on the [FiberScheduler interface](https://github.com/ruby/ruby/blame/78f188524f551c97b1a7a44ae13514729f1a21c7/ext/socket/init.c#L411-L434). This change of behaviour is not discussed in the Ruby 3.0.0 release notes. This change complicates the implementation of an io_uring-based fiber scheduler, since io_uring SQE's on fd's with `O_NONBLOCK` can return `EAGAIN` just like normal syscalls. Using io_uring with non-blocking fd's defeats the whole purpose of using io_uring in the first place. A workaround I have put in place in the Polyphony [io_uring backend](https://github.com/digital-fabric/polyphony/blob/d3c9cf3ddc1f414387948fa40e5f6a24f68bf045/ext/polyphony/backend_io_uring.c#L28-L47) is to make sure `O_NONBLOCK` is not set before attempting I/O operations on any fd. -- https://bugs.ruby-lang.org/ Unsubscribe: