uringmachine 0.19 → 0.20.0

data/ext/um/um.c

@@ -1,6 +1,6 @@
 #include <float.h>
 #include "um.h"
-#include "ruby/thread.h"
+#include <ruby/thread.h>
 
 void um_setup(VALUE self, struct um *machine) {
   memset(machine, 0, sizeof(struct um));
@@ -43,7 +43,7 @@ inline struct io_uring_sqe *um_get_sqe(struct um *machine, struct um_op *op) {
   sqe = io_uring_get_sqe(&machine->ring);
   if (likely(sqe)) goto done;
 
-  rb_raise(rb_eRuntimeError, "Failed to get SQE");
+  um_raise_internal_error("Failed to get SQE");
 
   // TODO: retry getting SQE?
 
@@ -194,7 +194,10 @@ inline VALUE process_runqueue_op(struct um *machine, struct um_op *op) {
   if (unlikely(op->flags & OP_F_TRANSIENT))
     um_op_free(machine, op);
 
-  return rb_fiber_transfer(fiber, 1, &value);
+  VALUE ret = rb_fiber_transfer(fiber, 1, &value);
+  RB_GC_GUARD(value);
+  RB_GC_GUARD(ret);
+  return ret;
 }
 
 inline VALUE um_fiber_switch(struct um *machine) {
@@ -266,6 +269,7 @@ inline void um_prep_op(struct um *machine, struct um_op *op, enum op_kind kind,
   VALUE fiber = (flags & OP_F_FREE_ON_COMPLETE) ? Qnil : rb_fiber_current();
   RB_OBJ_WRITE(machine->self, &op->fiber, fiber);
   RB_OBJ_WRITE(machine->self, &op->value, Qnil);
+  RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
 }
 
 inline void um_schedule(struct um *machine, VALUE fiber, VALUE value) {
@@ -275,6 +279,7 @@ inline void um_schedule(struct um *machine, VALUE fiber, VALUE value) {
   op->flags = OP_F_TRANSIENT;
   RB_OBJ_WRITE(machine->self, &op->fiber, fiber);
   RB_OBJ_WRITE(machine->self, &op->value, value);
+  RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
   um_runqueue_push(machine, op);
 }
 
@@ -311,6 +316,7 @@ VALUE um_timeout(struct um *machine, VALUE interval, VALUE class) {
   op->ts = um_double_to_timespec(NUM2DBL(interval));
   RB_OBJ_WRITE(machine->self, &op->fiber, rb_fiber_current());
   RB_OBJ_WRITE(machine->self, &op->value, rb_funcall(class, ID_new, 0));
+  RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
 
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_timeout(sqe, &op->ts, 0, 0);
@@ -347,7 +353,7 @@ VALUE um_sleep(struct um *machine, double duration) {
   return ret;
 }
 
-inline VALUE um_read(struct um *machine, int fd, VALUE buffer, int maxlen, int buffer_offset) {
+VALUE um_read(struct um *machine, int fd, VALUE buffer, size_t maxlen, ssize_t buffer_offset) {
   struct um_op op;
   um_prep_op(machine, &op, OP_READ, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
@@ -360,14 +366,13 @@ inline VALUE um_read(struct um *machine, int fd, VALUE buffer, int maxlen, int b
     ret = INT2NUM(op.result.res);
 
   }
-  RB_GC_GUARD(buffer);
 
   RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
   return ret;
 }
 
-inline size_t um_read_raw(struct um *machine, int fd, char *buffer, int maxlen) {
+size_t um_read_raw(struct um *machine, int fd, char *buffer, size_t maxlen) {
   struct um_op op;
   um_prep_op(machine, &op, OP_READ, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
@@ -384,36 +389,43 @@ inline size_t um_read_raw(struct um *machine, int fd, char *buffer, int maxlen)
   return 0;
 }
 
-VALUE um_write(struct um *machine, int fd, VALUE str, int len) {
+VALUE um_write(struct um *machine, int fd, VALUE buffer, size_t len) {
   struct um_op op;
   um_prep_op(machine, &op, OP_WRITE, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
-  const int str_len = RSTRING_LEN(str);
-  if (len > str_len) len = str_len;
 
-  io_uring_prep_write(sqe, fd, RSTRING_PTR(str), len, -1);
+  const void *base;
+  size_t size;
+  um_get_buffer_bytes_for_writing(buffer, &base, &size);
+  if ((len == (size_t)-1) || (len > size)) len = size;
+
+  io_uring_prep_write(sqe, fd, base, len, -1);
 
   VALUE ret = um_fiber_switch(machine);
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
-  RB_GC_GUARD(str);
-
   RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
   return ret;
 }
 
-VALUE um_write_async(struct um *machine, int fd, VALUE str) {
+VALUE um_write_async(struct um *machine, int fd, VALUE buffer) {
   struct um_op *op = um_op_alloc(machine);
   um_prep_op(machine, op, OP_WRITE_ASYNC, OP_F_TRANSIENT | OP_F_FREE_ON_COMPLETE);
-  RB_OBJ_WRITE(machine->self, &op->value, str);
+  RB_OBJ_WRITE(machine->self, &op->fiber, Qnil);
+  RB_OBJ_WRITE(machine->self, &op->value, buffer);
+  RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
+
+  const void *base;
+  size_t size;
+  um_get_buffer_bytes_for_writing(buffer, &base, &size);
 
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
-  io_uring_prep_write(sqe, fd, RSTRING_PTR(str), RSTRING_LEN(str), -1);
+  io_uring_prep_write(sqe, fd, base, size, -1);
   um_op_transient_add(machine, op);
 
-  return str;
+  return buffer;
 }
 
 VALUE um_close(struct um *machine, int fd) {
@@ -434,6 +446,9 @@ VALUE um_close(struct um *machine, int fd) {
 VALUE um_close_async(struct um *machine, int fd) {
   struct um_op *op = um_op_alloc(machine);
   um_prep_op(machine, op, OP_CLOSE_ASYNC, OP_F_FREE_ON_COMPLETE);
+  RB_OBJ_WRITE(machine->self, &op->fiber, Qnil);
+  RB_OBJ_WRITE(machine->self, &op->value, Qnil);
+  RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
 
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_close(sqe, fd);
@@ -486,18 +501,22 @@ VALUE um_connect(struct um *machine, int fd, const struct sockaddr *addr, sockle
   return ret;
 }
 
-VALUE um_send(struct um *machine, int fd, VALUE buffer, int len, int flags) {
+VALUE um_send(struct um *machine, int fd, VALUE buffer, size_t len, int flags) {
   struct um_op op;
   um_prep_op(machine, &op, OP_SEND, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
-  io_uring_prep_send(sqe, fd, RSTRING_PTR(buffer), len, flags);
+
+  const void *base;
+  size_t size;
+  um_get_buffer_bytes_for_writing(buffer, &base, &size);
+  if ((len == (size_t)-1) || (len > size)) len = size;
+
+  io_uring_prep_send(sqe, fd, base, len, flags);
 
   VALUE ret = um_fiber_switch(machine);
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
 
-  RB_GC_GUARD(buffer);
-
   RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
   return ret;
@@ -523,11 +542,12 @@ VALUE um_send_bundle(struct um *machine, int fd, int bgid, VALUE strings) {
   return ret;
 }
 
-VALUE um_recv(struct um *machine, int fd, VALUE buffer, int maxlen, int flags) {
+VALUE um_recv(struct um *machine, int fd, VALUE buffer, size_t maxlen, int flags) {
   struct um_op op;
   um_prep_op(machine, &op, OP_RECV, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
   void *ptr = um_prepare_read_buffer(buffer, maxlen, 0);
+
   io_uring_prep_recv(sqe, fd, ptr, maxlen, flags);
 
   VALUE ret = um_fiber_switch(machine);
@@ -536,8 +556,6 @@ VALUE um_recv(struct um *machine, int fd, VALUE buffer, int maxlen, int flags) {
     ret = INT2NUM(op.result.res);
   }
 
-  RB_GC_GUARD(buffer);
-
   RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
   return ret;
@@ -577,7 +595,6 @@ VALUE um_getsockopt(struct um *machine, int fd, int level, int opt) {
   VALUE ret = Qnil;
   int value;
 
-#ifdef HAVE_IO_URING_PREP_CMD_SOCK
   struct um_op op;
   um_prep_op(machine, &op, OP_GETSOCKOPT, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
@@ -586,13 +603,6 @@ VALUE um_getsockopt(struct um *machine, int fd, int level, int opt) {
   ret = um_fiber_switch(machine);
   if (um_check_completion(machine, &op))
     ret = INT2NUM(value);
-#else
-  socklen_t nvalue = sizeof(value);
-  int res = getsockopt(fd, level, opt, &value, &nvalue);
-  if (res)
-    rb_syserr_fail(errno, strerror(errno));
-  ret = INT2NUM(value);
-#endif
 
   RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
@@ -602,7 +612,6 @@ 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 ret = Qnil;
 
-#ifdef HAVE_IO_URING_PREP_CMD_SOCK
   struct um_op op;
   um_prep_op(machine, &op, OP_SETSOCKOPT, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
@@ -611,12 +620,6 @@ VALUE um_setsockopt(struct um *machine, int fd, int level, int opt, int value) {
   ret = um_fiber_switch(machine);
   if (um_check_completion(machine, &op))
     ret = INT2NUM(op.result.res);
-#else
-  int res = setsockopt(fd, level, opt, &value, sizeof(value));
-  if (res)
-    rb_syserr_fail(errno, strerror(errno));
-  ret = INT2NUM(0);
-#endif
 
   RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
@@ -643,6 +646,10 @@ VALUE um_shutdown(struct um *machine, int fd, int how) {
 VALUE um_shutdown_async(struct um *machine, int fd, int how) {
   struct um_op *op = um_op_alloc(machine);
   um_prep_op(machine, op, OP_SHUTDOWN_ASYNC, OP_F_FREE_ON_COMPLETE);
+  RB_OBJ_WRITE(machine->self, &op->fiber, Qnil);
+  RB_OBJ_WRITE(machine->self, &op->value, Qnil);
+  RB_OBJ_WRITE(machine->self, &op->async_op, Qnil);
+
   struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_shutdown(sqe, fd, how);
 
@@ -679,13 +686,13 @@ VALUE um_poll(struct um *machine, int fd, unsigned mask) {
   return ret;
 }
 
-VALUE um_waitpid(struct um *machine, int pid, int options) {
+VALUE um_waitid(struct um *machine, int idtype, int id, int options) {
   struct um_op op;
-  um_prep_op(machine, &op, OP_WAITPID, 0);
+  um_prep_op(machine, &op, OP_WAITID, 0);
   struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
 
   siginfo_t infop;
-  io_uring_prep_waitid(sqe, pid == 0 ? P_ALL : P_PID, pid, &infop, options, 0);
+  io_uring_prep_waitid(sqe, idtype, id, &infop, options, 0);
 
   VALUE ret = um_fiber_switch(machine);
   if (um_check_completion(machine, &op))
@@ -694,7 +701,31 @@ VALUE um_waitpid(struct um *machine, int pid, int options) {
   RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
 
-  return rb_ary_new_from_args(2, INT2NUM(infop.si_pid), INT2NUM(infop.si_status));
+  return rb_ary_new_from_args(
+    3, INT2NUM(infop.si_pid), INT2NUM(infop.si_status), INT2NUM(infop.si_code)
+  );
+}
+
+VALUE um_waitid_status(struct um *machine, int idtype, int id, int options) {
+#ifdef HAVE_RB_PROCESS_STATUS_NEW
+  struct um_op op;
+  um_prep_op(machine, &op, OP_WAITID, 0);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
+
+  siginfo_t infop;
+  io_uring_prep_waitid(sqe, idtype, id, &infop, options | WNOWAIT, 0);
+
+  VALUE ret = um_fiber_switch(machine);
+  if (um_check_completion(machine, &op))
+    ret = INT2NUM(op.result.res);
+
+  RAISE_IF_EXCEPTION(ret);
+  RB_GC_GUARD(ret);
+
+  return rb_process_status_new(infop.si_pid, (infop.si_status & 0xff) << 8, 0);
+#else
+  rb_raise(rb_eNotImpError, "Missing rb_process_status_new");
+#endif
 }
 
 #define hash_set(h, sym, v) rb_hash_aset(h, ID2SYM(rb_intern(sym)), v)

data/ext/um/um.h

@@ -20,6 +20,9 @@
 #define likely(cond)	__builtin_expect(!!(cond), 1)
 #endif
 
+#define IO_BUFFER_P(buffer) \
+  (TYPE(buffer) == RUBY_T_DATA) && rb_obj_is_instance_of(buffer, rb_cIOBuffer)
+
 enum op_kind {
   OP_TIMEOUT,
   OP_SCHEDULE,
@@ -47,7 +50,7 @@ enum op_kind {
   OP_SHUTDOWN_ASYNC,
 
   OP_POLL,
-  OP_WAITPID,
+  OP_WAITID,
 
   OP_FUTEX_WAIT,
   OP_FUTEX_WAKE,
@@ -131,6 +134,7 @@ struct um {
 
 struct um_mutex {
   uint32_t state;
+  uint32_t num_waiters;
 };
 
 struct um_queue_entry {
@@ -173,9 +177,11 @@ struct um_write_buffer {
 };
 
 extern VALUE cUM;
+extern VALUE eUMError;
 extern VALUE cMutex;
 extern VALUE cQueue;
 extern VALUE cAsyncOp;
+extern VALUE eStreamRESPError;
 
 struct um *um_get_machine(VALUE self);
 void um_setup(VALUE self, struct um *machine);
@@ -208,8 +214,9 @@ VALUE um_raise_exception(VALUE v);
 
 void um_prep_op(struct um *machine, struct um_op *op, enum op_kind kind, unsigned flags);
 void um_raise_on_error_result(int result);
-void * um_prepare_read_buffer(VALUE buffer, unsigned len, int ofs);
-void um_update_read_buffer(struct um *machine, VALUE buffer, int buffer_offset, __s32 result, __u32 flags);
+void um_get_buffer_bytes_for_writing(VALUE buffer, const void **base, size_t *size);
+void * um_prepare_read_buffer(VALUE buffer, ssize_t len, ssize_t ofs);
+void um_update_read_buffer(struct um *machine, VALUE buffer, ssize_t buffer_offset, __s32 result, __u32 flags);
 int um_setup_buffer_ring(struct um *machine, unsigned size, unsigned count);
 VALUE um_get_string_from_buffer_ring(struct um *machine, int bgid, __s32 result, __u32 flags);
 void um_add_strings_to_buffer_ring(struct um *machine, int bgid, VALUE strings);
@@ -229,25 +236,26 @@ VALUE um_timeout(struct um *machine, VALUE interval, VALUE class);
 
 VALUE um_sleep(struct um *machine, double duration);
 VALUE um_periodically(struct um *machine, double interval);
-VALUE um_read(struct um *machine, int fd, VALUE buffer, int maxlen, int buffer_offset);
-size_t um_read_raw(struct um *machine, int fd, char *buffer, int maxlen);
+VALUE um_read(struct um *machine, int fd, VALUE buffer, size_t maxlen, ssize_t buffer_offset);
+size_t um_read_raw(struct um *machine, int fd, char *buffer, size_t maxlen);
 VALUE um_read_each(struct um *machine, int fd, int bgid);
-VALUE um_write(struct um *machine, int fd, VALUE str, int len);
+VALUE um_write(struct um *machine, int fd, VALUE buffer, size_t len);
+VALUE um_write_async(struct um *machine, int fd, VALUE buffer);
 VALUE um_close(struct um *machine, int fd);
 VALUE um_close_async(struct um *machine, int fd);
 VALUE um_open(struct um *machine, VALUE pathname, int flags, int mode);
 VALUE um_poll(struct um *machine, int fd, unsigned mask);
-VALUE um_waitpid(struct um *machine, int pid, int options);
+VALUE um_waitid(struct um *machine, int idtype, int id, int options);
+VALUE um_waitid_status(struct um *machine, int idtype, int id, int options);
 VALUE um_statx(struct um *machine, int dirfd, VALUE path, int flags, unsigned int mask);
-VALUE um_write_async(struct um *machine, int fd, VALUE str);
 
 VALUE um_accept(struct um *machine, int fd);
 VALUE um_accept_each(struct um *machine, int fd);
 VALUE um_socket(struct um *machine, int domain, int type, int protocol, uint flags);
 VALUE um_connect(struct um *machine, int fd, const struct sockaddr *addr, socklen_t addrlen);
-VALUE um_send(struct um *machine, int fd, VALUE buffer, int len, int flags);
+VALUE um_send(struct um *machine, int fd, VALUE buffer, size_t len, int flags);
 VALUE um_send_bundle(struct um *machine, int fd, int bgid, VALUE strings);
-VALUE um_recv(struct um *machine, int fd, VALUE buffer, int maxlen, int flags);
+VALUE um_recv(struct um *machine, int fd, VALUE buffer, size_t maxlen, int flags);
 VALUE um_recv_each(struct um *machine, int fd, int bgid, int flags);
 VALUE um_bind(struct um *machine, int fd, struct sockaddr *addr, socklen_t addrlen);
 VALUE um_listen(struct um *machine, int fd, int backlog);
@@ -266,7 +274,7 @@ struct um_mutex *Mutex_data(VALUE self);
 struct um_queue *Queue_data(VALUE self);
 
 void um_mutex_init(struct um_mutex *mutex);
-VALUE um_mutex_synchronize(struct um *machine, VALUE mutex, uint32_t *state);
+VALUE um_mutex_synchronize(struct um *machine, struct um_mutex *mutex);
 
 void um_queue_init(struct um_queue *queue);
 void um_queue_free(struct um_queue *queue);
@@ -282,6 +290,8 @@ VALUE stream_get_string(struct um_stream *stream, VALUE buf, ssize_t len);
 VALUE resp_decode(struct um_stream *stream, VALUE out_buffer);
 void resp_encode(struct um_write_buffer *buf, VALUE obj);
 
+__attribute__((noreturn)) void um_raise_internal_error(const char *msg);
+
 void write_buffer_init(struct um_write_buffer *buf, VALUE str);
 void write_buffer_update_len(struct um_write_buffer *buf);
 

data/ext/um/um_async_op_class.c

@@ -52,7 +52,7 @@ void um_async_op_set(VALUE self, struct um *machine, struct um_op *op) {
 
 inline void raise_on_missing_op(struct um_async_op *async_op) {
   if (!async_op->op)
-    rb_raise(rb_eRuntimeError, "Missing op");
+    um_raise_internal_error("Missing op");
 }
 
 inline int async_op_is_done(struct um_async_op *async_op) {
@@ -67,7 +67,7 @@ VALUE AsyncOp_kind(VALUE self) {
     case OP_TIMEOUT:
       return SYM_timeout;
     default:
-      rb_raise(rb_eRuntimeError, "Invalid op kind");
+      um_raise_internal_error("Invalid op kind");
   }
 }
 

data/ext/um/um_buffer.c

@@ -28,7 +28,7 @@ inline struct um_buffer *um_buffer_checkout(struct um *machine, int len) {
 
     buffer->len = buffer_size(len);
     if (posix_memalign(&buffer->ptr, 4096, buffer->len))
-      rb_raise(rb_eRuntimeError, "Failed to allocate buffer");
+      um_raise_internal_error("Failed to allocate buffer");
   }
   return buffer;
 }

data/ext/um/um_class.c

@@ -1,7 +1,13 @@
 #include "um.h"
 #include <arpa/inet.h>
+#include <ruby/io.h>
+#include <sys/syscall.h>
+#include <unistd.h>
 
 VALUE cUM;
+VALUE eUMError;
+
+static ID id_fileno;
 
 static void UM_mark(void *ptr) {
   struct um *machine = ptr;
@@ -43,7 +49,7 @@ static VALUE UM_allocate(VALUE klass) {
 inline struct um *um_get_machine(VALUE self) {
   struct um *um;
   TypedData_Get_Struct(self, struct um, &UringMachine_type, um);
-  if (!um->ring_initialized) rb_raise(rb_eRuntimeError, "Machine not initialized");
+  if (!um->ring_initialized) um_raise_internal_error("Machine not initialized");
 
   return um;
 }
@@ -103,21 +109,17 @@ VALUE UM_read(int argc, VALUE *argv, VALUE self) {
   VALUE buffer;
   VALUE maxlen;
   VALUE buffer_offset;
-  rb_scan_args(argc, argv, "31", &fd, &buffer, &maxlen, &buffer_offset);
+  rb_scan_args(argc, argv, "22", &fd, &buffer, &maxlen, &buffer_offset);
 
-  return um_read(
-    machine, NUM2INT(fd), buffer, NUM2INT(maxlen),
-    NIL_P(buffer_offset) ? 0 : NUM2INT(buffer_offset)
-  );
+  ssize_t maxlen_i = NIL_P(maxlen) ? -1 : NUM2INT(maxlen);
+  ssize_t buffer_offset_i = NIL_P(buffer_offset) ? 0 : NUM2INT(buffer_offset);
+
+  return um_read(machine, NUM2INT(fd), buffer, maxlen_i, buffer_offset_i);
 }
 
 VALUE UM_read_each(VALUE self, VALUE fd, VALUE bgid) {
-#ifdef HAVE_IO_URING_PREP_READ_MULTISHOT
   struct um *machine = um_get_machine(self);
   return um_read_each(machine, NUM2INT(fd), NUM2INT(bgid));
-#else
-  rb_raise(rb_eRuntimeError, "Not supported by kernel");
-#endif
 }
 
 VALUE UM_write(int argc, VALUE *argv, VALUE self) {
@@ -127,13 +129,13 @@ VALUE UM_write(int argc, VALUE *argv, VALUE self) {
   VALUE len;
   rb_scan_args(argc, argv, "21", &fd, &buffer, &len);
 
-  int bytes = NIL_P(len) ? RSTRING_LEN(buffer) : NUM2INT(len);
+  size_t bytes = NIL_P(len) ? (size_t)-1 : NUM2UINT(len);
   return um_write(machine, NUM2INT(fd), buffer, bytes);
 }
 
-VALUE UM_write_async(VALUE self, VALUE fd, VALUE str) {
+VALUE UM_write_async(VALUE self, VALUE fd, VALUE buffer) {
   struct um *machine = um_get_machine(self);
-  return um_write_async(machine, NUM2INT(fd), str);
+  return um_write_async(machine, NUM2INT(fd), buffer);
 }
 
 VALUE UM_statx(VALUE self, VALUE dirfd, VALUE path, VALUE flags, VALUE mask) {
@@ -270,12 +272,10 @@ VALUE UM_setsockopt(VALUE self, VALUE fd, VALUE level, VALUE opt, VALUE value) {
   return um_setsockopt(machine, NUM2INT(fd), NUM2INT(level), NUM2INT(opt), numeric_value(value));
 }
 
-#ifdef HAVE_IO_URING_PREP_FUTEX
-
 VALUE UM_mutex_synchronize(VALUE self, VALUE mutex) {
   struct um *machine = um_get_machine(self);
   struct um_mutex *mutex_data = Mutex_data(mutex);
-  return um_mutex_synchronize(machine, mutex, &mutex_data->state);
+  return um_mutex_synchronize(machine, mutex_data);
 }
 
 VALUE UM_queue_push(VALUE self, VALUE queue, VALUE value) {
@@ -302,8 +302,6 @@ VALUE UM_queue_shift(VALUE self, VALUE queue) {
   return um_queue_shift(machine, que);
 }
 
-#endif
-
 struct um_open_ctx {
   VALUE self;
   VALUE fd;
@@ -332,11 +330,18 @@ VALUE UM_poll(VALUE self, VALUE fd, VALUE mask) {
   return um_poll(machine, NUM2INT(fd), NUM2UINT(mask));
 }
 
-VALUE UM_waitpid(VALUE self, VALUE pid, VALUE options) {
+VALUE UM_waitid(VALUE self, VALUE idtype, VALUE id, VALUE options) {
   struct um *machine = um_get_machine(self);
-  return um_waitpid(machine, NUM2INT(pid), NUM2INT(options));
+  return um_waitid(machine, NUM2INT(idtype), NUM2INT(id), NUM2INT(options));
 }
 
+#ifdef HAVE_RB_PROCESS_STATUS_NEW
+VALUE UM_waitid_status(VALUE self, VALUE idtype, VALUE id, VALUE options) {
+  struct um *machine = um_get_machine(self);
+  return um_waitid_status(machine, NUM2INT(idtype), NUM2INT(id), NUM2INT(options));
+}
+#endif
+
 VALUE UM_prep_timeout(VALUE self, VALUE interval) {
   struct um *machine = um_get_machine(self);
   return um_prep_timeout(machine, NUM2DBL(interval));
@@ -353,10 +358,65 @@ VALUE UM_pipe(VALUE self) {
   return rb_ary_new_from_args(2, INT2NUM(fds[0]), INT2NUM(fds[1]));
 }
 
+VALUE UM_pidfd_open(VALUE self, VALUE pid) {
+  int fd = syscall(SYS_pidfd_open, NUM2INT(pid), 0);
+  if (fd == -1) {
+    int e = errno;
+    rb_syserr_fail(e, strerror(e));
+  }
+
+  return INT2NUM(fd);
+}
+
+VALUE UM_pidfd_send_signal(VALUE self, VALUE fd, VALUE sig) {
+  int ret = syscall(
+    SYS_pidfd_send_signal, NUM2INT(fd), NUM2INT(sig), NULL, 0
+  );
+  if (ret) {
+    int e = errno;
+    rb_syserr_fail(e, strerror(e));
+  }
+
+  return fd;
+}
+
+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;
+}
+
+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;
+}
+
 VALUE UM_kernel_version(VALUE self) {
   return INT2NUM(UM_KERNEL_VERSION);
 }
 
+VALUE UM_debug(VALUE self, VALUE str) {
+  printf("%s\n", StringValueCStr(str));
+  return Qnil;
+}
+
 void Init_UM(void) {
   rb_ext_ractor_safe(true);
 
@@ -368,7 +428,13 @@ 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, "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_method(cUM, "schedule", UM_schedule, 2);
@@ -388,7 +454,10 @@ void Init_UM(void) {
   rb_define_method(cUM, "statx", UM_statx, 4);
 
   rb_define_method(cUM, "poll", UM_poll, 2);
-  rb_define_method(cUM, "waitpid", UM_waitpid, 2);
+  rb_define_method(cUM, "waitid", UM_waitid, 3);
+  #ifdef HAVE_RB_PROCESS_STATUS_NEW
+  rb_define_method(cUM, "waitid_status", UM_waitid_status, 3);
+  #endif
 
   rb_define_method(cUM, "accept", UM_accept, 1);
   rb_define_method(cUM, "accept_each", UM_accept_each, 1);
@@ -407,13 +476,15 @@ void Init_UM(void) {
 
   rb_define_method(cUM, "prep_timeout", UM_prep_timeout, 1);
 
-  #ifdef HAVE_IO_URING_PREP_FUTEX
   rb_define_method(cUM, "pop", UM_queue_pop, 1);
   rb_define_method(cUM, "push", UM_queue_push, 2);
   rb_define_method(cUM, "shift", UM_queue_shift, 1);
   rb_define_method(cUM, "synchronize", UM_mutex_synchronize, 1);
   rb_define_method(cUM, "unshift", UM_queue_unshift, 2);
-  #endif
+
+  eUMError = rb_define_class_under(cUM, "Error", rb_eStandardError);
 
   um_define_net_constants(cUM);
+
+  id_fileno = rb_intern_const("fileno");
 }