uringmachine 0.26.0 → 0.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba017ea6da0eb880e2366157a7f1ff6ea936d32816ed2be45e3b3ca96b3c7408
-  data.tar.gz: 22f556023080078623fd8618122fe6707fa4cfdf6654b6c43e122f524c91c645
+  metadata.gz: 1211434f5b2f4aad1e47d1bd166204cce6792a80e3ef845ae4dee097d8e1ea45
+  data.tar.gz: eff370b4564c88c3daf57cbed3d8b165113ddee697ee1b16aa63ad3452a38c02
 SHA512:
-  metadata.gz: c08b772dd22791c297fc38dab3e8a73453ace1b54ee5c9e7b31ef127598987efd37fdfebf009b9202d3b550674006caf380a0e20fb50e4c2a3bee7e302afa97b
-  data.tar.gz: 1f35f727b26808a0bca4c24c19ee41ef4400766ec1b3b7033dbd39fea635168f93757825c4bf9e38d065c66652cd5120ce1880f8ef484233abdaa8bd9dff3b84
+  metadata.gz: cdb26cf58a41a9f7ad2d025ccc473b0088f4c3e622a65058b1ee6e0aeb95c0eb3775f980cccb60e81b2213ed8fb49263c6500b2c05fbbb71abb156be00dca636
+  data.tar.gz: 06f509928387d2812578c143dfb96ed031be10994c7b43908babfef02d72d149b8f2a3932dee7a4d3577150b5512addb8b7c44d5b7ea2e63dddb7f2b427df604

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 0.27.0 2026-02-15
+
+- Add `.pr_set_child_subreaper` method
+- Add `#send_fd`, `#recv_fd` methods
+
 # 0.26.0 2026-02-13
 
 - Reimplement um_op lifecycle tracking

data/TODO.md

@@ -64,19 +64,6 @@ stream = UM::Stream.new(conn) # io mode
 - select on multiple queues (ala Go)
 - select on mixture of queues and fds
 
-(see also simplified op management below)
-
-## simplified op management
-
-Op lifecycle management can be much much simpler
-
-- make all ops heap-allocated
-- clear up state transitions:
-
-  - kernel-side state: unsubmitted, submitted, completed, done (for multishot ops)
-  - app-side state: unsubmitted, submitted, ...
-
-
 ## ops
 
 - splice / - tee
@@ -104,7 +91,8 @@ We're still missing:
 - ability to supply buffer to `get_line` and `get_string`
 - allow read to eof, maybe with `read_to_eof`
 
-For the sake of performance, simplicity and explicitness, we change the API as follows:
+For the sake of performance, simplicity and explicitness, we change the API as
+follows:
 
 ```ruby
 stream.get_line(buf, limit)

data/ext/um/um.c

@@ -977,6 +977,93 @@ VALUE um_shutdown_async(struct um *machine, int fd, int how) {
   return INT2NUM(fd);
 }
 
+struct send_recv_fd_data {
+  struct msghdr msgh;
+  char iobuf[1];
+  struct iovec iov;
+  union { // Ancillary data buffer, wrapped in a union for alignment 
+    char buf[CMSG_SPACE(sizeof(int))];
+    struct cmsghdr align;
+  } u;
+};
+
+inline void recv_fd_prepare(struct send_recv_fd_data *data) {
+  memset(&data->msgh, 0, sizeof(data->msgh));
+  data->iov.iov_base = data->iobuf;
+  data->iov.iov_len = sizeof(data->iobuf);
+  data->msgh.msg_iov = &data->iov;
+  data->msgh.msg_iovlen = 1;
+  data->msgh.msg_control = data->u.buf;
+  data->msgh.msg_controllen = sizeof(data->u.buf);
+}
+
+inline void send_fd_prepare(struct send_recv_fd_data *data, int fd) {
+  memset(&data->msgh, 0, sizeof(data->msgh));
+  data->iov.iov_base = data->iobuf;
+  data->iov.iov_len = sizeof(data->iobuf);
+  data->msgh.msg_iov = &data->iov;
+  data->msgh.msg_iovlen = 1;
+  data->msgh.msg_control = data->u.buf;
+  data->msgh.msg_controllen = sizeof(data->u.buf);
+
+  struct cmsghdr *cmsgp = CMSG_FIRSTHDR(&data->msgh);
+  cmsgp->cmsg_level = SOL_SOCKET;
+  cmsgp->cmsg_type = SCM_RIGHTS;
+  cmsgp->cmsg_len = CMSG_LEN(sizeof(fd));
+  memcpy(CMSG_DATA(cmsgp), &fd, sizeof(fd));
+}
+
+VALUE um_send_fd(struct um *machine, int sock_fd, int fd) {
+  struct send_recv_fd_data data;
+  send_fd_prepare(&data, fd);
+
+  VALUE ret = Qnil;
+  struct um_op *op = um_op_acquire(machine);
+  um_prep_op(machine, op, OP_SENDMSG, 2, 0);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  io_uring_prep_sendmsg(sqe, sock_fd, &data.msgh, 0);
+
+  ret = um_yield(machine);
+
+  if (likely(um_verify_op_completion(machine, op, true))) ret = INT2NUM(fd);
+  um_op_release(machine, op);
+
+  RAISE_IF_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+  return ret;
+}
+
+inline int recv_fd_get_fd(struct send_recv_fd_data *data) {
+  int fd;
+  struct cmsghdr *cmsgp = CMSG_FIRSTHDR(&data->msgh);
+
+  if (cmsgp == NULL || cmsgp->cmsg_len != CMSG_LEN(sizeof(int)) ||
+      cmsgp->cmsg_level != SOL_SOCKET || cmsgp->cmsg_type != SCM_RIGHTS
+  ) um_raise_on_error_result(-EINVAL);
+
+  memcpy(&fd, CMSG_DATA(cmsgp), sizeof(int));
+  return fd;
+}
+
+VALUE um_recv_fd(struct um *machine, int sock_fd) {
+  struct send_recv_fd_data data;
+  recv_fd_prepare(&data);
+
+  struct um_op *op = um_op_acquire(machine);
+  um_prep_op(machine, op, OP_RECVMSG, 2, 0);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
+  io_uring_prep_recvmsg(sqe, sock_fd, &data.msgh, 0);
+
+  VALUE ret = um_yield(machine);
+
+  if (likely(um_verify_op_completion(machine, op, true))) ret = INT2NUM(recv_fd_get_fd(&data));
+  um_op_release(machine, op);
+
+  RAISE_IF_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+  return ret;
+}
+
 VALUE um_open(struct um *machine, VALUE pathname, int flags, int mode) {
   struct um_op *op = um_op_acquire(machine);
   um_prep_op(machine, op, OP_OPEN, 2, 0);

data/ext/um/um.h

@@ -51,9 +51,11 @@ enum um_op_kind {
 
   OP_ACCEPT,
   OP_RECV,
+  OP_RECVMSG,
   OP_SEND,
-  OP_SENDV,
   OP_SEND_BUNDLE,
+  OP_SENDMSG,
+  OP_SENDV,
   OP_SOCKET,
   OP_CONNECT,
   OP_BIND,
@@ -349,6 +351,8 @@ VALUE um_getsockopt(struct um *machine, int fd, int level, int opt);
 VALUE um_setsockopt(struct um *machine, int fd, int level, int opt, int value);
 VALUE um_shutdown(struct um *machine, int fd, int how);
 VALUE um_shutdown_async(struct um *machine, int fd, int how);
+VALUE um_send_fd(struct um *machine, int sock_fd, int fd);
+VALUE um_recv_fd(struct um *machine, int sock_fd);
 
 void um_async_op_set(VALUE self, struct um *machine, struct um_op *op);
 VALUE um_async_op_await(struct um_async_op *async_op);

data/ext/um/um_class.c

@@ -5,6 +5,8 @@
 #include <unistd.h>
 #include <sys/socket.h>
 #include <sys/inotify.h>
+#include <linux/prctl.h>
+#include <sys/prctl.h>
 
 VALUE cUM;
 VALUE eUMError;
@@ -328,6 +330,8 @@ VALUE UM_schedule(VALUE self, VALUE fiber, VALUE value) {
 /* Runs the given block, interrupting its execution if its runtime exceeds the
  * given timeout interval (in seconds).
  *
+ * - https://www.man7.org/linux/man-pages//man3/io_uring_prep_timeoute.3.html
+ *
  * @param interval [Number] timeout interval in seconds
  * @param exception_class [any] timeout exception class
  * @return [any] block's return value
@@ -340,6 +344,8 @@ VALUE UM_timeout(VALUE self, VALUE interval, VALUE exception_class) {
 /* Puts the current fiber to sleep for the given time duration (in seconds),
  * yielding control to the next fiber in the runqueue.
  *
+ * - https://www.man7.org/linux/man-pages//man3/io_uring_prep_timeoute.3.html
+ *
  * @param duration [Number] sleep duration in seconds
  * @return [void]
  */
@@ -349,6 +355,8 @@ VALUE UM_sleep(VALUE self, VALUE duration) {
 }
 
 /* Runs the given block at regular time intervals in an infinite loop.
+ *
+ * - https://www.man7.org/linux/man-pages//man3/io_uring_prep_timeoute.3.html
  *
  * @param interval [Number] time interval (in seconds) between consecutive invocations
  * @return [void]
@@ -359,21 +367,23 @@ VALUE UM_periodically(VALUE self, VALUE interval) {
 }
 
 /* call-seq:
- *   machine.read(fd, buffer, maxlen[, buffer_offset[, file_offset]]) -> bytes_read
+ *   machine.read(fd, buffer, maxlen, buffer_offset = nil, file_offset = nil) -> bytes_read
  *
  * Reads up to `maxlen` bytes from the given `fd` into the given buffer. The
  * optional `buffer_offset` parameter determines the position in the buffer into
  * which the data will be read. A negative `buffer_offset` denotes a position
  * relative to the end of the buffer, e.g. a value of `-1` means the data will
  * be appended to the buffer.
+ * 
+ * - https://www.man7.org/linux/man-pages/man2/read.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_read.3.html
  *
- * @overload read(fd, buffer, maxlen, buffer_offset: nil, file_offset: nil)
- *   @param fd [Integer] file descriptor
- *   @param buffer [String, IO::Buffer] buffer
- *   @param maxlen [Integer] maximum number of bytes to read
- *   @param buffer_offset [Integer] optional buffer offset to read into
- *   @param file_offset [Integer] optional file offset to read from
- *   @return [Integer] number of bytes read
+ * @param fd [Integer] file descriptor
+ * @param buffer [String, IO::Buffer] buffer
+ * @param maxlen [Integer] maximum number of bytes to read
+ * @param buffer_offset [Integer] optional buffer offset to read into
+ * @param file_offset [Integer] optional file offset to read from
+ * @return [Integer] number of bytes read
  */
 VALUE UM_read(int argc, VALUE *argv, VALUE self) {
   struct um *machine = um_get_machine(self);
@@ -398,6 +408,8 @@ VALUE UM_read(int argc, VALUE *argv, VALUE self) {
  * buffer group should have been previously setup using `#setup_buffer_ring`.
  * Read data is yielded in an infinite loop to the given block.
  *
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_read_multishot.3.html
+ *
  * @param fd [Integer] file descriptor
  * @param bgid [Integer] buffer group id
  * @return [void]
@@ -408,17 +420,19 @@ VALUE UM_read_each(VALUE self, VALUE fd, VALUE bgid) {
 }
 
 /* call-seq:
- *   machine.write(fd, buffer[, len[, file_offset]]) -> bytes_written
+ *   machine.write(fd, buffer, len = nil, file_offset = nil) -> bytes_written
  *
  * Writes up to `len` bytes from the given buffer to the given `fd`. If `len`,
  * is not given, the entire buffer length is used.
  *
- * @overload write(fd, buffer, len: nil, file_offset: nil)
- *   @param fd [Integer] file descriptor
- *   @param buffer [String, IO::Buffer] buffer
- *   @param len [Integer] maximum number of bytes to write
- *   @param file_offset [Integer] optional file offset to write to
- *   @return [Integer] number of bytes written
+ * - https://man7.org/linux/man-pages/man2/write.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_write.3.html
+ *
+ * @param fd [Integer] file descriptor
+ * @param buffer [String, IO::Buffer] buffer
+ * @param len [Integer] maximum number of bytes to write
+ * @param file_offset [Integer] optional file offset to write to
+ * @return [Integer] number of bytes written
  */
 VALUE UM_write(int argc, VALUE *argv, VALUE self) {
   struct um *machine = um_get_machine(self);
@@ -435,7 +449,7 @@ VALUE UM_write(int argc, VALUE *argv, VALUE self) {
 }
 
 /* call-seq:
- *   machine.writev(fd, *buffers[, file_offset]) -> bytes_written
+ *   machine.writev(fd, *buffers, file_offset = nil) -> bytes_written
  *
  * Writes from the given buffers into the given fd. This method does not
  * guarantee that all data will be written. The application code should check
@@ -443,11 +457,13 @@ VALUE UM_write(int argc, VALUE *argv, VALUE self) {
  * repeat the operation after adjusting the buffers accordingly. See also
  * `#sendv`.
  *
- * @overload writev(fd, *buffers, file_offset: nil)
- *   @param fd [Integer] file descriptor
- *   @param *buffers [Array<String, IO::Buffer>] data buffers
- *   @param file_offset [Integer] optional file offset to write to
- *   @return [Integer] number of bytes written
+ * - https://man7.org/linux/man-pages/man2/writev.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_writev.3.html
+ *
+ * @param fd [Integer] file descriptor
+ * @param *buffers [Array<String, IO::Buffer>] data buffers
+ * @param file_offset [Integer] optional file offset to write to
+ * @return [Integer] number of bytes written
  */
 VALUE UM_writev(int argc, VALUE *argv, VALUE self) {
   struct um *machine = um_get_machine(self);
@@ -460,7 +476,7 @@ VALUE UM_writev(int argc, VALUE *argv, VALUE self) {
 }
 
 /* call-seq:
- *   machine.write_async(fd, buffer[, len[, file_offset]]) -> buffer
+ *   machine.write_async(fd, buffer, len = nil, file_offset = nil) -> buffer
  *
  * Writes up to `len` bytes from the given buffer to the given `fd`. If `len`,
  * is not given, the entire buffer length is used. This method submits the
@@ -468,12 +484,14 @@ VALUE UM_writev(int argc, VALUE *argv, VALUE self) {
  * improve performance in situations where the application does not care about
  * whether the I/O operation succeeds or not.
  *
- * @overload write_async(fd, buffer, len: nil, file_offset: nil)
- *   @param fd [Integer] file descriptor
- *   @param buffer [String, IO::Buffer] buffer
- *   @param len [Integer] maximum number of bytes to write
- *   @param file_offset [Integer] optional file offset to write to
- *   @return [String, IO::Buffer] buffer
+ * - https://man7.org/linux/man-pages/man2/write.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_write.3.html
+ *
+ * @param fd [Integer] file descriptor
+ * @param buffer [String, IO::Buffer] buffer
+ * @param len [Integer] maximum number of bytes to write
+ * @param file_offset [Integer] optional file offset to write to
+ * @return [String, IO::Buffer] buffer
  */
 VALUE UM_write_async(int argc, VALUE *argv, VALUE self) {
   struct um *machine = um_get_machine(self);
@@ -496,6 +514,9 @@ VALUE UM_write_async(int argc, VALUE *argv, VALUE self) {
  *
  * Returns information about a file.
  *
+ * - https://www.man7.org/linux/man-pages/man2/statx.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_statx.3.html
+ *
  * @param dirfd [Integer] file or directory descriptor
  * @param path [String, nil] file path
  * @param flags [Integer] flags
@@ -512,6 +533,9 @@ VALUE UM_statx(VALUE self, VALUE dirfd, VALUE path, VALUE flags, VALUE mask) {
  *
  * Closes the given file descriptor.
  *
+ * - https://www.man7.org/linux/man-pages/man2/close.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_close.3.html
+ *
  * @param fd [Integer] file descriptor
  * @return [0] success
  */
@@ -527,6 +551,9 @@ VALUE UM_close(VALUE self, VALUE fd) {
  * not wait for it to complete. This method may be used to improve performance
  * in cases where the application des not care whether it succeeds or not.
  *
+ * - https://www.man7.org/linux/man-pages/man2/close.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_close.3.html
+ *
  * @param fd [Integer] file descriptor
  * @return [Integer] file descriptor
  */
@@ -540,6 +567,9 @@ VALUE UM_close_async(VALUE self, VALUE fd) {
  *
  * Accepts an incoming TCP connection.
  *
+ * - https://www.man7.org/linux/man-pages/man2/accept4.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_accept.3.html
+ *
  * @param server_fd [Integer] listening socket file descriptor
  * @return [Integer] connection file descriptor
  */
@@ -554,6 +584,9 @@ VALUE UM_accept(VALUE self, VALUE server_fd) {
  * Repeatedly accepts incoming TCP connections in a loop, yielding the
  * connection file descriptors to the given block.
  *
+ * - https://www.man7.org/linux/man-pages/man2/accept4.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_accept.3.html
+ *
  * @param server_fd [Integer] listening socket file descriptor
  * @return [void]
  */
@@ -563,11 +596,14 @@ VALUE UM_accept_each(VALUE self, VALUE server_fd) {
 }
 
 /* call-seq:
- *   machine.accept_each(server_fd, queue)
+ *   machine.accept_into_queue(server_fd, queue)
  *
  * Repeatedly accepts incoming TCP connections in a loop, pushing the connection
  * file descriptors into the given queue.
  *
+ * - https://www.man7.org/linux/man-pages/man2/accept4.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_accept.3.html
+ *
  * @param server_fd [Integer] listening socket file descriptor
  * @param queue [UM::Queue] connection queue
  * @return [void]
@@ -582,6 +618,9 @@ VALUE UM_accept_into_queue(VALUE self, VALUE server_fd, VALUE queue) {
  *
  * Creates a socket.
  *
+ * - https://www.man7.org/linux/man-pages/man2/socket.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_socket.3.html
+ *
  * @param domain [Integer] socket domain
  * @param type [Integer] socket type
  * @param protocol [Integer] socket protocol
@@ -598,6 +637,9 @@ VALUE UM_socket(VALUE self, VALUE domain, VALUE type, VALUE protocol, VALUE flag
  *
  * Shuts down a socket for sending and/or receiving.
  *
+ * - https://man7.org/linux/man-pages/man2/shutdown.2.html
+ * - https://man7.org/linux/man-pages/man3/io_uring_prep_shutdown.3.html
+ *
  * @param fd [Integer] file descriptor
  * @param how [Integer] how the socket should be shutdown
  * @return [0] success
@@ -614,6 +656,9 @@ VALUE UM_shutdown(VALUE self, VALUE fd, VALUE how) {
  * improve performance in situations where the application does not care about
  * whether the operation succeeds or not.
  *
+ * - https://man7.org/linux/man-pages/man2/shutdown.2.html
+ * - https://man7.org/linux/man-pages/man3/io_uring_prep_shutdown.3.html
+ *
  * @param fd [Integer] file descriptor
  * @param how [Integer] how the socket should be shutdown
  * @return [0] success
@@ -623,11 +668,47 @@ VALUE UM_shutdown_async(VALUE self, VALUE fd, VALUE how) {
   return um_shutdown_async(machine, NUM2INT(fd), NUM2INT(how));
 }
 
+/* call-seq:
+ *   machine.send_fd(sock_fd, fd) -> fd
+ *
+ * Sends the given file descriptor over the given socket.
+ *
+ * - https://www.man7.org/linux/man-pages/man3/sendmsg.3p.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_sendmsg.3.html
+ *
+ * @param sock_fd [Integer] socket file descriptor
+ * @param fd [Integer] file descriptor to send
+ * @return [Integer] file descriptor to send
+ */
+VALUE UM_send_fd(VALUE self, VALUE sock_fd, VALUE fd) {
+  struct um *machine = um_get_machine(self);
+  return um_send_fd(machine, NUM2INT(sock_fd), NUM2INT(fd));
+}
+
+/* call-seq:
+ *   machine.recv_fd(sock_fd) -> fd
+ *
+ * Receives a file descriptor over the given socket.
+ *
+ * - https://www.man7.org/linux/man-pages/man3/recvmsg.3p.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_recvmsg.3.html
+ *
+ * @param sock_fd [Integer] socket file descriptor
+ * @return [Integer] rececived file descriptor
+ */
+VALUE UM_recv_fd(VALUE self, VALUE sock_fd) {
+  struct um *machine = um_get_machine(self);
+  return um_recv_fd(machine, NUM2INT(sock_fd));
+}
+
 /* call-seq:
  *   machine.connect(fd, host, port) -> 0
  *
  * Connects the given socket to the given host and port.
  *
+ * - https://www.man7.org/linux/man-pages/man2/connect.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_connect.3.html
+ *
  * @param fd [Integer] file descriptor
  * @param host [String] hostname or IP address
  * @param port [Integer] port number
@@ -652,6 +733,9 @@ VALUE UM_connect(VALUE self, VALUE fd, VALUE host, VALUE port) {
  * the data in the buffer, unless `UM::MSG_WAITALL` is specified in the flags
  * mask.
  *
+ * - https://www.man7.org/linux/man-pages/man2/send.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_send.3.html
+ *
  * @param fd [Integer] file descriptor
  * @param buffer [String, IO::Buffer] buffer
  * @param len [Integer] number of bytes to send
@@ -671,6 +755,9 @@ VALUE UM_send(VALUE self, VALUE fd, VALUE buffer, VALUE len, VALUE flags) {
  * Sends data on the given socket from the given buffers. This method is only
  * available on Linux kernel >= 6.17. This method is guaranteed to send
  *
+ * - https://www.man7.org/linux/man-pages/man2/send.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_send.3.html
+ *
  * @overload sendv(fd, *buffers)
  *   @param fd [Integer] file descriptor
  *   @param *buffers [Array<String, IO::Buffer>] buffers
@@ -695,6 +782,9 @@ VALUE UM_sendv(int argc, VALUE *argv, VALUE self) {
  * buffer group. The buffer group should have been previously registered using
  * `#setup_buffer_ring`.
  *
+ * - https://www.man7.org/linux/man-pages/man2/send.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_send.3.html
+ *
  * @overload send_bundle(fd, bgid, *buffers)
  *   @param fd [Integer] file descriptor
  *   @param bgid [Integer] buffer group id
@@ -722,6 +812,9 @@ VALUE UM_send_bundle(int argc, VALUE *argv, VALUE self) {
  *
  * Receives data from the given socket.
  *
+ * - https://www.man7.org/linux/man-pages/man2/recv.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_recv.3.html
+ *
  * @param fd [Integer] file descriptor
  * @param buffer [String, IO::Buffer] buffer
  * @param maxlen [Integer] maximum number of bytes to receive
@@ -740,6 +833,9 @@ VALUE UM_recv(VALUE self, VALUE fd, VALUE buffer, VALUE maxlen, VALUE flags) {
  * given buffer group id. The buffer group should have been previously setup
  * using `#setup_buffer_ring`.
  *
+ * - https://www.man7.org/linux/man-pages/man2/recv.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_recv.3.html
+ *
  * @param fd [Integer] file descriptor
  * @param bgid [Integer] buffer group id
  * @param flags [Integer] flags mask
@@ -755,6 +851,9 @@ VALUE UM_recv_each(VALUE self, VALUE fd, VALUE bgid, VALUE flags) {
  *
  * Binds the given socket to the given host and port.
  *
+ * - https://www.man7.org/linux/man-pages/man2/bind.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_bind.3.html
+ *
  * @param fd [Integer] file descriptor
  * @param host [String] hostname or IP address
  * @param port [Integer] port number
@@ -783,6 +882,9 @@ VALUE UM_bind(VALUE self, VALUE fd, VALUE host, VALUE port) {
  *
  * Starts listening for incoming connections on the given socket.
  *
+ * - https://www.man7.org/linux/man-pages/man2/listen.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_listen.3.html
+ *
  * @param fd [Integer] file descriptor
  * @param backlog [String] pending connection queue length
  * @return [0] success
@@ -815,6 +917,9 @@ static inline int numeric_value(VALUE value) {
  *
  * Returns the value of a socket option.
  *
+ * - https://www.man7.org/linux/man-pages//man2/getsockopt.2.html
+ * - https://www.man7.org/linux/man-pages//man3/io_uring_prep_cmd.3.html
+ *
  * @param fd [Integer] file descriptor
  * @param level [Integer] level
  * @param opt [Integer] level
@@ -826,10 +931,13 @@ VALUE UM_getsockopt(VALUE self, VALUE fd, VALUE level, VALUE opt) {
 }
 
 /* call-seq:
- *   machine.getsockopt(fd, level, opt, value) -> 0
+ *   machine.setsockopt(fd, level, opt, value) -> 0
  *
  * Sets the value of a socket option.
  *
+ * - https://www.man7.org/linux/man-pages//man2/setsockopt.2.html
+ * - https://www.man7.org/linux/man-pages//man3/io_uring_prep_cmd.3.html
+ *
  * @param fd [Integer] file descriptor
  * @param level [Integer] level
  * @param opt [Integer] level
@@ -847,6 +955,9 @@ VALUE UM_setsockopt(VALUE self, VALUE fd, VALUE level, VALUE opt, VALUE value) {
  * Synchronizes access to the given mutex. The mutex is locked, the given block
  * is executed and finally the mutex is unlocked.
  *
+ * - https://www.man7.org/linux/man-pages/man2/futex.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_futex_wait.3.html
+ *
  * @param mutex [UM::Mutex] mutex
  * @return [any] block return value
  */
@@ -861,6 +972,9 @@ VALUE UM_mutex_synchronize(VALUE self, VALUE mutex) {
  *
  * Pushes a value to the tail of the given queue.
  *
+ * - https://www.man7.org/linux/man-pages/man2/futex.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_futex_wait.3.html
+ *
  * @param queue [UM::Queue] queue
  * @param value [any] value
  * @return [UM::Queue] queue
@@ -876,6 +990,9 @@ VALUE UM_queue_push(VALUE self, VALUE queue, VALUE value) {
  *
  * removes a value from the tail of the given queue.
  *
+ * - https://www.man7.org/linux/man-pages/man2/futex.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_futex_wait.3.html
+ *
  * @param queue [UM::Queue] queue
  * @return [any] value
  */
@@ -890,6 +1007,9 @@ VALUE UM_queue_pop(VALUE self, VALUE queue) {
  *
  * Pushes a value to the head of the given queue.
  *
+ * - https://www.man7.org/linux/man-pages/man2/futex.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_futex_wait.3.html
+ *
  * @param queue [UM::Queue] queue
  * @param value [any] value
  * @return [UM::Queue] queue
@@ -905,6 +1025,9 @@ VALUE UM_queue_unshift(VALUE self, VALUE queue, VALUE value) {
  *
  * removes a value from the head of the given queue.
  *
+ * - https://www.man7.org/linux/man-pages/man2/futex.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_futex_wait.3.html
+ *
  * @param queue [UM::Queue] queue
  * @return [any] value
  */
@@ -933,6 +1056,9 @@ VALUE UM_open_complete(VALUE arg) {
  * file descriptor is passed to the block, and the file is automatically closed
  * when the block returns.
  *
+ * - https://www.man7.org/linux/man-pages/man2/open.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_openat.3.html
+ *
  * @param pathname [String] file path
  * @param flags [Integer] flags mask
  * @return [Integer] fd
@@ -955,6 +1081,9 @@ VALUE UM_open(VALUE self, VALUE pathname, VALUE flags) {
  * Waits for readiness of the given file descriptor according to the given event
  * mask.
  *
+ * - https://www.man7.org/linux/man-pages/man2/poll.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_poll_add.3.html
+ *
  * @param fd [Integer] file descriptor
  * @param mask [Integer] events mask
  * @return [Integer] fd
@@ -970,6 +1099,9 @@ VALUE UM_poll(VALUE self, VALUE fd, VALUE mask) {
  * Waits for readyness of at least one fd for read, write or exception condition
  * from the given fds. This method provides a similar interface to `IO#select`.
  *
+ * - https://www.man7.org/linux/man-pages/man2/select.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_poll_add.3.html
+ *
  * @param read_fds [Array<Integer>] file descriptors for reading
  * @param write_fds [Array<Integer>] file descriptors for writing
  * @param except_fds [Array<Integer>] file descriptors for exception
@@ -986,6 +1118,9 @@ VALUE UM_select(VALUE self, VALUE read_fds, VALUE write_fds, VALUE except_fds) {
  * Waits for a process to change state. The process to wait for can be specified
  * as a pid or as a pidfd, according to the given `idtype` and `id`.
  *
+ * - https://www.man7.org/linux/man-pages/man2/waitid.2.html
+ * - https://www.man7.org/linux/man-pages/man3/io_uring_prep_waitid.3.html
+ *
  * @param idtype [Integer] id type
  * @param id [Integer] id
  * @param options [Integer] options
@@ -1077,6 +1212,8 @@ VALUE UM_ssl_write(VALUE self, VALUE ssl, VALUE buf, VALUE len) {
  *
  * Creates a pipe, returning the file descriptors for the read and write ends.
  *
+ * - https://www.man7.org/linux/man-pages/man2/pipe.2.html
+ *
  * @return [Array<Integer>] array containing the read and write file descriptors
  */
 VALUE UM_pipe(VALUE self) {
@@ -1095,6 +1232,8 @@ VALUE UM_pipe(VALUE self) {
  *
  * Creates a pair of connected sockets, returning the two file descriptors.
  *
+ * - https://www.man7.org/linux/man-pages/man2/socketpair.2.html
+ *
  * @param domain [Integer] domain
  * @param type [Integer] type
  * @param protocol [Integer] protocol
@@ -1117,6 +1256,8 @@ VALUE UM_socketpair(VALUE self, VALUE domain, VALUE type, VALUE protocol) {
  * Creates a file descriptor representing the given process pid. The file
  * descriptor can then be used with methods such as `#waitid` or `.pidfd_open`.
  *
+ * - https://www.man7.org/linux/man-pages/man2/pidfd_open.2.html
+ *
  * @param pid [Integer] process pid
  * @return [Integer] file descriptor
  */
@@ -1135,6 +1276,8 @@ VALUE UM_pidfd_open(VALUE self, VALUE pid) {
  *
  * Sends a signal to a pidfd.
  *
+ * - https://www.man7.org/linux/man-pages/man2/pidfd_send_signal.2.html
+ *
  * @param fd [Integer] pidfd
  * @param sig [Integer] signal
  * @return [Integer] pidfd
@@ -1151,38 +1294,6 @@ VALUE UM_pidfd_send_signal(VALUE self, VALUE fd, VALUE sig) {
   return fd;
 }
 
-/* :nodoc:
- */
-VALUE UM_io_nonblock_p(VALUE self, VALUE io) {
-  int fd = rb_io_descriptor(io);
-  int oflags = fcntl(fd, F_GETFL);
-  if (oflags == -1) return Qnil;
-
-  return (oflags & O_NONBLOCK) ? Qtrue : Qfalse;
-}
-
-/* :nodoc:
- */
-VALUE UM_io_set_nonblock(VALUE self, VALUE io, VALUE nonblock) {
-  int fd = rb_io_descriptor(io);
-  int oflags = fcntl(fd, F_GETFL);
-  if (oflags == -1) return Qnil;
-
-  if (RTEST(nonblock)) {
-    if (!(oflags & O_NONBLOCK)) {
-      oflags |= O_NONBLOCK;
-      fcntl(fd, F_SETFL, oflags);
-    }
-  }
-  else {
-    if (oflags & O_NONBLOCK) {
-      oflags &= ~O_NONBLOCK;
-      fcntl(fd, F_SETFL, oflags);
-    }
-  }
-  return nonblock;
-}
-
 /* call-seq:
  *   UringMachine.kernel_version -> version
  *
@@ -1212,6 +1323,8 @@ VALUE UM_debug(VALUE self, VALUE str) {
  *
  * Creates an inotify file descriptor.
  *
+ * - https://www.man7.org/linux/man-pages/man2/inotify_init.2.html
+ *
  * @return [Integer] file descriptor
  */
 VALUE UM_inotify_init(VALUE self) {
@@ -1228,6 +1341,8 @@ VALUE UM_inotify_init(VALUE self) {
  *
  * Adds a watch on the given inotify file descriptor.
  *
+ * - https://www.man7.org/linux/man-pages/man2/inotify_add_watch.2.html
+ *
  * @param fd [Integer] inotify file descriptor
  * @param path [String] file/directory path
  * @param mask [Integer] inotify event mask
@@ -1269,6 +1384,8 @@ static inline VALUE inotify_get_events(char *buf, size_t len) {
  * descriptor. Each event is returned as a hash containing the watch descriptor,
  * the file name, and the event mask.
  *
+ * - https://www.man7.org/linux/man-pages/man7/inotify.7.html
+ *
  * @param fd [Integer] inotify file descriptor
  * @return [Array<Hash>] array of one or more events
  */
@@ -1281,12 +1398,46 @@ VALUE UM_inotify_get_events(VALUE self, VALUE fd) {
   return inotify_get_events(buf, ret);
 }
 
+/* call-seq:
+ *   UringMachine.pr_set_child_subreaper(vaule) -> value
+ *
+ * Sets/unsets the "child subreaper" attribute of the calling process.
+ *
+ * - https://man7.org/linux/man-pages/man2/PR_SET_CHILD_SUBREAPER.2const.html
+ *
+ * @param value [bool] set/unset value
+ * @return [bool] set/unset value
+ */
+VALUE UM_pr_set_child_subreaper(VALUE self, VALUE set) {
+  int ret = prctl(PR_SET_CHILD_SUBREAPER, RTEST(set) ? 1 : 0);
+  if (ret) {
+    int e = errno;
+    rb_syserr_fail(e, strerror(e));
+  }
+
+  return set;
+}
+
 void Init_UM(void) {
   rb_ext_ractor_safe(true);
 
   cUM = rb_define_class("UringMachine", rb_cObject);
   rb_define_alloc_func(cUM, UM_allocate);
 
+  rb_define_singleton_method(cUM, "pipe", UM_pipe, 0);
+  rb_define_singleton_method(cUM, "socketpair", UM_socketpair, 3);
+  rb_define_singleton_method(cUM, "pidfd_open", UM_pidfd_open, 1);
+  rb_define_singleton_method(cUM, "pidfd_send_signal", UM_pidfd_send_signal, 2);
+
+  rb_define_singleton_method(cUM, "kernel_version", UM_kernel_version, 0);
+  rb_define_singleton_method(cUM, "debug", UM_debug, 1);
+
+  rb_define_singleton_method(cUM, "inotify_init", UM_inotify_init, 0);
+  rb_define_singleton_method(cUM, "inotify_add_watch", UM_inotify_add_watch, 3);
+
+  rb_define_singleton_method(cUM, "pr_set_child_subreaper", UM_pr_set_child_subreaper, 1);
+
+
   rb_define_method(cUM, "initialize", UM_initialize, -1);
   rb_define_method(cUM, "size", UM_size, 0);
   rb_define_method(cUM, "mark", UM_mark_m, 1);
@@ -1302,19 +1453,6 @@ void Init_UM(void) {
 
   rb_define_method(cUM, "setup_buffer_ring", UM_setup_buffer_ring, 2);
 
-  rb_define_singleton_method(cUM, "pipe", UM_pipe, 0);
-  rb_define_singleton_method(cUM, "socketpair", UM_socketpair, 3);
-  rb_define_singleton_method(cUM, "pidfd_open", UM_pidfd_open, 1);
-  rb_define_singleton_method(cUM, "pidfd_send_signal", UM_pidfd_send_signal, 2);
-
-  rb_define_singleton_method(cUM, "io_nonblock?", UM_io_nonblock_p, 1);
-  rb_define_singleton_method(cUM, "io_set_nonblock", UM_io_set_nonblock, 2);
-  rb_define_singleton_method(cUM, "kernel_version", UM_kernel_version, 0);
-  rb_define_singleton_method(cUM, "debug", UM_debug, 1);
-
-  rb_define_singleton_method(cUM, "inotify_init", UM_inotify_init, 0);
-  rb_define_singleton_method(cUM, "inotify_add_watch", UM_inotify_add_watch, 3);
-
   rb_define_method(cUM, "schedule", UM_schedule, 2);
   rb_define_method(cUM, "snooze", UM_snooze, 0);
   rb_define_method(cUM, "timeout", UM_timeout, 2);
@@ -1364,6 +1502,8 @@ void Init_UM(void) {
   rb_define_method(cUM, "socket", UM_socket, 4);
   rb_define_method(cUM, "shutdown", UM_shutdown, 2);
   rb_define_method(cUM, "shutdown_async", UM_shutdown_async, 2);
+  rb_define_method(cUM, "send_fd", UM_send_fd, 2);
+  rb_define_method(cUM, "recv_fd", UM_recv_fd, 1);
 
   rb_define_method(cUM, "prep_timeout", UM_prep_timeout, 1);
 

data/ext/um/um_op.c

@@ -18,9 +18,11 @@ const char * um_op_kind_name(enum um_op_kind kind) {
     case OP_STATX:              return "OP_STATX";
     case OP_ACCEPT:             return "OP_ACCEPT";
     case OP_RECV:               return "OP_RECV";
+    case OP_RECVMSG:            return "OP_RECVMSG";
     case OP_SEND:               return "OP_SEND";
-    case OP_SENDV:              return "OP_SENDV";
     case OP_SEND_BUNDLE:        return "OP_SEND_BUNDLE";
+    case OP_SENDMSG:            return "OP_SENDMSG";
+    case OP_SENDV:              return "OP_SENDV";
     case OP_SOCKET:             return "OP_SOCKET";
     case OP_CONNECT:            return "OP_CONNECT";
     case OP_BIND:               return "OP_BIND";

data/grant-2025/tasks.md

@@ -129,10 +129,10 @@
 
     - [v] Postgres test
 
-- [ ] Ruby Fiber::Scheduler interface
+- [v] Ruby Fiber::Scheduler interface
   - [v] Make a PR for resetting the scheduler and resetting the fiber non-blocking flag.
   - [v] hook for close
-  - [ ] hooks for send/recv/sendmsg/recvmsg
+  - [x] hooks for send/recv/sendmsg/recvmsg (Ruby core PR pending for send/recv)
 
 - [v] SSL
   - [v] setup custom BIO

data/lib/uringmachine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class UringMachine
-  VERSION = '0.26.0'
+  VERSION = '0.27.0'
 end

data/test/test_um.rb

@@ -733,7 +733,7 @@ class ReadEachTest < UMBaseTest
   class TOError < StandardError; end
 
   def test_read_each_timeout
-    r, w = IO.pipe
+    r, _w = IO.pipe
     bgid = machine.setup_buffer_ring(4096, 1024)
 
     bufs = []
@@ -1344,7 +1344,7 @@ class AcceptEachTest < UMBaseTest
   def test_accept_each_closed
     count = 0
     done = nil
-    f = @machine.spin do
+    @machine.spin do
       machine.accept_each(@server.fileno) do |fd|
         count += 1
       end
@@ -1816,7 +1816,7 @@ class RecvEachTest < UMBaseTest
 
   def test_recv_each_timeout
     t = Thread.new do
-      conn = @server.accept
+      @server.accept
       sleep
     end
 
@@ -1847,7 +1847,7 @@ class RecvEachTest < UMBaseTest
 
   def test_recv_each_shutdown
     t = Thread.new do
-      conn = @server.accept
+      @server.accept
       sleep
     end
 
@@ -1861,7 +1861,7 @@ class RecvEachTest < UMBaseTest
     bufs = []
     e = nil
 
-    f = machine.spin {
+    machine.spin {
       machine.sleep(0.01)
       machine.shutdown(fd, UM::SHUT_RDWR)
     }
@@ -1881,6 +1881,90 @@ class RecvEachTest < UMBaseTest
   end
 end
 
+class SendRecvFdTest < UMBaseTest
+  def setup
+    @s1_fd, @s2_fd = UM.socketpair(UM::AF_UNIX, UM::SOCK_STREAM, 0)
+    super
+  end
+
+  def teardown
+    [@s1_fd, @s2_fd].each { machine.close(it) rescue nil }
+    super
+  end
+
+  class TOError < StandardError; end
+
+  def test_send_recv_fd
+    r_fd, w_fd = UM.pipe
+
+    res = machine.send_fd(@s1_fd, w_fd)
+    assert_equal w_fd, res
+
+    fd = machine.recv_fd(@s2_fd)
+    assert_kind_of Integer, fd
+    refute_equal w_fd, fd
+
+    machine.close(w_fd)
+    machine.write(fd, 'foobar')
+    machine.close(fd)
+
+    buf = +''
+    res = machine.read(r_fd, buf, 12)
+    assert_equal 6, res
+    assert_equal 'foobar', buf
+  end
+
+  def test_send_recv_fd_fork
+    pid = fork do
+      m = UM.new
+      fd = m.recv_fd(@s2_fd)
+      m.write(fd, 'Hello!')
+    ensure
+      m.close(fd) rescue nil
+    end
+
+    r_fd, w_fd = UM.pipe
+
+    res = machine.send_fd(@s1_fd, w_fd)
+    assert_equal w_fd, res
+    Process.wait(pid)
+    pid = nil
+    machine.close(w_fd)
+
+    buf = +''
+    len = machine.timeout(1, TOError) { machine.read(r_fd, buf, 12) }
+    assert_equal 6, len
+    assert_equal 'Hello!', buf
+  ensure
+    if pid
+      Process.kill('KILL', pid) rescue nil
+      Process.wait(pid) rescue nil
+    end
+    machine.close(r_fd) rescue nil
+    machine.close(w_fd) rescue nil
+  end
+
+  def test_send_fd_bad_sock_fd
+    _r_fd, w_fd = UM.pipe
+    assert_raises(Errno::ENOTSOCK) { machine.send_fd(0, w_fd) }
+  end
+
+  def test_send_fd_bad_fd
+    assert_raises(TypeError) { machine.send_fd(@s1_fd, nil) }
+    assert_raises(Errno::EBADF) { machine.send_fd(@s1_fd, 1111) }
+  end
+
+  def test_recv_fd_bad_msg
+    buf = "\0" * 1000
+    machine.write(@s1_fd, buf)
+    
+    assert_raises(Errno::EINVAL) {
+      res = machine.recv_fd(@s2_fd)
+      p res: res
+    }
+  end
+end
+
 class BindTest < UMBaseTest
   def setup
     super
@@ -2836,23 +2920,6 @@ class SendBundleTest < UMBaseTest
   end
 end
 
-class NonBlockTest < UMBaseTest
-  def test_io_nonblock?
-    assert_equal false, UM.io_nonblock?(STDIN)
-  end
-
-  def test_io_set_nonblock
-    r, _w = IO.pipe
-    assert_equal true, UM.io_nonblock?(r)
-
-    UM.io_set_nonblock(r, false)
-    assert_equal false, UM.io_nonblock?(r)
-
-    UM.io_set_nonblock(r, true)
-    assert_equal true, UM.io_nonblock?(r)
-  end
-end
-
 class MetricsTest < UMBaseTest
   def test_metrics_empty
     assert_equal({
@@ -3159,3 +3226,39 @@ class FileWatchTest < UMBaseTest
     machine.join(f)
   end
 end
+
+class SetChildSubreaperTest < Minitest::Test
+  def test_pr_set_child_subreaper
+    r, w = IO.pipe
+    UM.pr_set_child_subreaper(true)
+    
+    child_pid = fork {
+      r2, w2 = IO.pipe
+      pid = fork {
+        r.close
+        w.close
+        w2.close
+        r2.read
+        r2.close
+        sleep(0.01)
+      }
+      w << pid
+      w.close
+      r2.close
+      w2 << 'done'
+      w2.close
+    }
+    Process.wait(child_pid)
+
+    w.close
+    msg = r.read
+    r.close
+
+    refute msg.empty?
+    grand_child_pid = msg.to_i
+    refute_equal 0, grand_child_pid
+
+    res = Process.wait(grand_child_pid)
+    assert_equal grand_child_pid, res
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uringmachine
 version: !ruby/object:Gem::Version
-  version: 0.26.0
+  version: 0.27.0
 platform: ruby
 authors:
 - Sharon Rosner