uringmachine 0.26.0 → 0.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba017ea6da0eb880e2366157a7f1ff6ea936d32816ed2be45e3b3ca96b3c7408
-  data.tar.gz: 22f556023080078623fd8618122fe6707fa4cfdf6654b6c43e122f524c91c645
+  metadata.gz: c42e434298bf496752efc6fe6a4cc81d04857f28f1151cfc3165ac3c288ec6a2
+  data.tar.gz: ec176b165f129aa7d1b6d0bdbc5f4b7e55d5e553569061d89956d0b1aee68503
 SHA512:
-  metadata.gz: c08b772dd22791c297fc38dab3e8a73453ace1b54ee5c9e7b31ef127598987efd37fdfebf009b9202d3b550674006caf380a0e20fb50e4c2a3bee7e302afa97b
-  data.tar.gz: 1f35f727b26808a0bca4c24c19ee41ef4400766ec1b3b7033dbd39fea635168f93757825c4bf9e38d065c66652cd5120ce1880f8ef484233abdaa8bd9dff3b84
+  metadata.gz: 1760b892d6ae21c7007fd0a109a78d631da4ae9a79667ad85bc4740ac0e339802ca9cb0bc34114570bf7e6113e4dab704a1c9f40513a196e840b759a494a35b9
+  data.tar.gz: 7dfe1426f96ecd1e99af4224c34d3b3173858b5d6c156b949314a0e80c34b836ae738e930ed26662319bc6700401cd0b369028e172ed1b70982cee64fb13f7a1

data/CHANGELOG.md

@@ -1,3 +1,15 @@
+# 0.28.0 2026-02-19
+
+- Add `#terminate`
+- Make `#sendv` available also for older kernels (using `#writev`)
+- Implement `Stream#skip`
+- Inherit exceptions from `StandardError` instead of `RuntimeError`
+
+# 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

@@ -1,9 +1,11 @@
 ## immediate
 
-- Fix all futex value (Queue, Mutex) to be properly aligned
+- Add tests for support for Set in `machine#await_fibers`
+- Add tests for support for Set, Array in `machine#join`
 
-## Buffer rings - automatic management
+- (?) Fix all futex value (Queue, Mutex) to be properly aligned
 
+## Buffer rings - automatic management
 - Take the buffer_pool branch, rewrite it
 - Allow multiple stream modes:
   - :buffer_pool - uses buffer rings
@@ -64,19 +66,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 +93,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,86 @@ VALUE um_shutdown_async(struct um *machine, int fd, int how) {
   return INT2NUM(fd);
 }
 
+struct send_recv_fd_ctx {
+  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 send_recv_fd_setup_ctx(struct send_recv_fd_ctx *ctx, int fd) {
+  ctx->iov.iov_base = ctx->iobuf;
+  ctx->iov.iov_len = sizeof(ctx->iobuf);
+
+  memset(&ctx->msgh, 0, sizeof(ctx->msgh));
+  ctx->msgh.msg_iov = &ctx->iov;
+  ctx->msgh.msg_iovlen = 1;
+  ctx->msgh.msg_control = ctx->u.buf;
+  ctx->msgh.msg_controllen = sizeof(ctx->u.buf);
+
+  if (fd > 0) {
+    struct cmsghdr *cmsgp = CMSG_FIRSTHDR(&ctx->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_ctx ctx;
+  send_recv_fd_setup_ctx(&ctx, 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, &ctx.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_ctx *ctx) {
+  int fd;
+  struct cmsghdr *cmsgp = CMSG_FIRSTHDR(&ctx->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_ctx ctx;
+  send_recv_fd_setup_ctx(&ctx, -1);
+
+  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, &ctx.msgh, 0);
+
+  VALUE ret = um_yield(machine);
+
+  if (likely(um_verify_op_completion(machine, op, true))) ret = INT2NUM(recv_fd_get_fd(&ctx));
+  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);
@@ -373,6 +377,7 @@ VALUE um_queue_shift(struct um *machine, struct um_queue *queue);
 
 VALUE stream_get_line(struct um_stream *stream, VALUE buf, ssize_t maxlen);
 VALUE stream_get_string(struct um_stream *stream, VALUE buf, ssize_t len);
+VALUE stream_skip(struct um_stream *stream, size_t len);
 VALUE resp_decode(struct um_stream *stream, VALUE out_buffer);
 void resp_encode(struct um_write_buffer *buf, VALUE obj);
 void resp_encode_cmd(struct um_write_buffer *buf, int argc, VALUE *argv);