uringmachine 0.19.1 → 0.21.0

data/ext/um/um.h

@@ -4,12 +4,20 @@
 #include <ruby.h>
 #include <liburing.h>
 
+
 // debugging
+enum {
+  // set to 1 to enable debug logging
+  DEBUG = 0
+};
+
 #define OBJ_ID(obj) (NUM2LONG(rb_funcall(obj, rb_intern("object_id"), 0)))
 #define INSPECT(str, obj) { printf(str); VALUE s = rb_funcall(obj, rb_intern("inspect"), 0); printf(": %s\n", StringValueCStr(s)); }
 #define CALLER() rb_funcall(rb_mKernel, rb_intern("caller"), 0)
 #define TRACE_CALLER() INSPECT("caller: ", CALLER())
 #define TRACE_FREE(ptr) //printf("Free %p %s:%d\n", ptr, __FILE__, __LINE__)
+#define DEBUG_MARK(machine, markv, msg) \
+  if (machine->mark == markv) printf("%s\n", msg);
 
 // branching
 #ifndef unlikely
@@ -20,7 +28,10 @@
 #define likely(cond)	__builtin_expect(!!(cond), 1)
 #endif
 
-enum op_kind {
+#define IO_BUFFER_P(buffer) \
+  (TYPE(buffer) == RUBY_T_DATA) && rb_obj_is_instance_of(buffer, rb_cIOBuffer)
+
+enum um_op_kind {
   OP_TIMEOUT,
   OP_SCHEDULE,
 
@@ -47,7 +58,7 @@ enum op_kind {
   OP_SHUTDOWN_ASYNC,
 
   OP_POLL,
-  OP_WAITPID,
+  OP_WAITID,
 
   OP_FUTEX_WAIT,
   OP_FUTEX_WAKE,
@@ -59,12 +70,17 @@ enum op_kind {
   OP_SLEEP_MULTISHOT
 };
 
-#define OP_F_COMPLETED        (1U << 0) // op is completed (set on each CQE for multishot ops)
-#define OP_F_TRANSIENT        (1U << 1) // op is heap allocated
-#define OP_F_ASYNC            (1U << 2) // op belongs to an AsyncOp
-#define OP_F_IGNORE_CANCELED  (1U << 3) // CQE with -ECANCEL should be ignored
-#define OP_F_MULTISHOT        (1U << 4) // op is multishot
-#define OP_F_FREE_ON_COMPLETE (1U << 5) // op should be freed on receiving CQE
+#define OP_F_COMPLETED        (1U <<  0) // op is completed (set on each CQE for multishot ops)
+#define OP_F_TRANSIENT        (1U <<  1) // op is heap allocated
+#define OP_F_ASYNC            (1U <<  2) // op belongs to an AsyncOp
+#define OP_F_CANCELED         (1U <<  3) // op is cancelled
+#define OP_F_IGNORE_CANCELED  (1U <<  4) // CQE with -ECANCEL should be ignored
+#define OP_F_MULTISHOT        (1U <<  5) // op is multishot
+#define OP_F_FREE_ON_COMPLETE (1U <<  6) // op should be freed on receiving CQE
+#define OP_F_RUNQUEUE_SKIP    (1U <<  7) // runqueue entry should be skipped
+#define OP_F_SELECT_POLLIN    (1U <<  8) // select POLLIN
+#define OP_F_SELECT_POLLOUT   (1U <<  9) // select POLLOUT
+#define OP_F_SELECT_POLLPRI   (1U << 10) // select POLLPRI
 
 struct um_op_result {
   __s32 res;
@@ -76,8 +92,8 @@ struct um_op {
   struct um_op *prev;
   struct um_op *next;
 
-  enum op_kind kind;
-  unsigned flags;
+  enum um_op_kind kind;
+  uint flags;
 
   VALUE fiber;
   VALUE value;
@@ -85,7 +101,7 @@ struct um_op {
 
   struct um_op_result result;
   struct um_op_result *multishot_result_tail;
-  unsigned multishot_result_count;
+  uint multishot_result_count;
 
   struct __kernel_timespec ts; // used for timeout operation
 };
@@ -114,12 +130,18 @@ struct um {
 
   struct io_uring ring;
 
-  unsigned int    ring_initialized;
-  unsigned int    unsubmitted_count;
-  unsigned int    pending_count;
+  uint ring_initialized; // is the ring initialized successfully
+  uint mark; // used to mark instances for debugging
+
+  uint unsubmitted_count; // number of unsubmitted SQEs pending
+  uint pending_count; // number of pending operations (i.e. not yet completed)
+  uint buffer_ring_count; // number of registered buffer rings
+  ulong total_op_count; // total number of operations submitted since ring was initialized
+  
+  uint entries; // number of entries in SQ
+  uint sqpoll_mode; // SQPOLL mode enabled
 
   struct buf_ring_descriptor buffer_rings[BUFFER_RING_MAX_COUNT];
-  unsigned int buffer_ring_count;
 
   struct um_op *transient_head;
   struct um_op *runqueue_head;
@@ -131,6 +153,7 @@ struct um {
 
 struct um_mutex {
   uint32_t state;
+  uint32_t num_waiters;
 };
 
 struct um_queue_entry {
@@ -173,14 +196,17 @@ 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);
+void um_setup(VALUE self, struct um *machine, uint entries, uint sqpoll_timeout_msec);
 void um_teardown(struct um *machine);
 
+const char * um_op_kind_name(enum um_op_kind kind);
 struct um_op *um_op_alloc(struct um *machine);
 void um_op_free(struct um *machine, struct um_op *op);
 void um_op_clear(struct um *machine, struct um_op *op);
@@ -204,21 +230,24 @@ double um_timestamp_to_double(__s64 tv_sec, __u32 tv_nsec);
 int um_value_is_exception_p(VALUE v);
 VALUE um_raise_exception(VALUE v);
 
-#define RAISE_IF_EXCEPTION(v) if (um_value_is_exception_p(v)) { um_raise_exception(v); }
+#define RAISE_IF_EXCEPTION(v) if (unlikely(um_value_is_exception_p(v))) { um_raise_exception(v); }
 
-void um_prep_op(struct um *machine, struct um_op *op, enum op_kind kind, unsigned flags);
+void um_prep_op(struct um *machine, struct um_op *op, enum um_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);
 
 struct io_uring_sqe *um_get_sqe(struct um *machine, struct um_op *op);
 
+uint um_submit(struct um *machine);
 VALUE um_fiber_switch(struct um *machine);
 VALUE um_await(struct um *machine);
-void um_submit_cancel_op(struct um *machine, struct um_op *op);
+VALUE um_wakeup(struct um *machine);
+void um_cancel_op(struct um *machine, struct um_op *op);
 void um_cancel_and_wait(struct um *machine, struct um_op *op);
 int um_check_completion(struct um *machine, struct um_op *op);
 
@@ -229,25 +258,31 @@ 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, __u64 file_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, __u64 file_offset);
+VALUE um_write_async(struct um *machine, int fd, VALUE buffer, size_t len, __u64 file_offset);
 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_select(struct um *machine, VALUE rfds, VALUE wfds, VALUE efds);
+VALUE um_waitid(struct um *machine, int idtype, int id, int options);
+
+#ifdef HAVE_RB_PROCESS_STATUS_NEW
+VALUE um_waitid_status(struct um *machine, int idtype, int id, int options);
+#endif
+
 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 +301,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 +317,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.c

@@ -36,5 +36,5 @@ VALUE um_async_op_await(struct um_async_op *async_op) {
 }
 
 void um_async_op_cancel(struct um_async_op *async_op) {
-  um_submit_cancel_op(async_op->machine, async_op->op);
+  um_cancel_op(async_op->machine, async_op->op);
 }

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,14 +49,38 @@ 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;
 }
 
-VALUE UM_initialize(VALUE self) {
+static inline uint get_sqpoll_timeout_msec(VALUE sqpoll_timeout) {
+  switch (TYPE(sqpoll_timeout)) {
+    case T_NIL:
+    case T_FALSE:
+      return 0;
+    case T_FLOAT:
+      return (uint)(NUM2DBL(sqpoll_timeout) * 1000);
+    case T_FIXNUM:
+      return NUM2UINT(sqpoll_timeout) * 1000;
+    case T_TRUE:
+      return 1000;
+    default:
+      rb_raise(eUMError, "Invalid sqpoll_timeout value");
+  }
+}
+
+VALUE UM_initialize(int argc, VALUE *argv, VALUE self) {
   struct um *machine = RTYPEDDATA_DATA(self);
-  um_setup(self, machine);
+  VALUE entries;
+  VALUE sqpoll_timeout;
+  rb_scan_args(argc, argv, "02", &entries, &sqpoll_timeout);
+
+  uint entries_i = NIL_P(entries) ? 0 : NUM2UINT(entries);
+  uint sqpoll_timeout_msec = get_sqpoll_timeout_msec(sqpoll_timeout);
+
+
+  um_setup(self, machine, entries_i, sqpoll_timeout_msec);
   return self;
 }
 
@@ -60,9 +90,25 @@ VALUE UM_setup_buffer_ring(VALUE self, VALUE size, VALUE count) {
   return INT2NUM(bgid);
 }
 
+VALUE UM_entries(VALUE self) {
+  struct um *machine = um_get_machine(self);
+  return UINT2NUM(machine->entries);
+}
+
+VALUE UM_mark_m(VALUE self, VALUE mark) {
+  struct um *machine = um_get_machine(self);
+  machine->mark = NUM2UINT(mark);
+  return self;
+}
+
 VALUE UM_pending_count(VALUE self) {
   struct um *machine = um_get_machine(self);
-  return INT2NUM(machine->pending_count);
+  return UINT2NUM(machine->pending_count);
+}
+
+VALUE UM_total_op_count(VALUE self) {
+  struct um *machine = um_get_machine(self);
+  return UINT2NUM(machine->total_op_count);
 }
 
 VALUE UM_snooze(VALUE self) {
@@ -76,6 +122,17 @@ VALUE UM_yield(VALUE self) {
   return um_await(machine);
 }
 
+VALUE UM_wakeup(VALUE self) {
+  struct um *machine = um_get_machine(self);
+  return um_wakeup(machine);
+}
+
+VALUE UM_submit(VALUE self) {
+  struct um *machine = um_get_machine(self);
+  uint ret = um_submit(machine);
+  return UINT2NUM(ret);
+}
+
 VALUE UM_schedule(VALUE self, VALUE fiber, VALUE value) {
   struct um *machine = um_get_machine(self);
   um_schedule(machine, fiber, value);
@@ -103,21 +160,19 @@ 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);
+  VALUE file_offset;
+  rb_scan_args(argc, argv, "23", &fd, &buffer, &maxlen, &buffer_offset, &file_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);
+  __u64 file_offset_i = NIL_P(file_offset) ? (__u64)-1 : NUM2UINT(file_offset);
+
+  return um_read(machine, NUM2INT(fd), buffer, maxlen_i, buffer_offset_i, file_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) {
@@ -125,15 +180,27 @@ VALUE UM_write(int argc, VALUE *argv, VALUE self) {
   VALUE fd;
   VALUE buffer;
   VALUE len;
-  rb_scan_args(argc, argv, "21", &fd, &buffer, &len);
+  VALUE file_offset;
+  rb_scan_args(argc, argv, "22", &fd, &buffer, &len, &file_offset);
+
+  size_t len_i = NIL_P(len) ? (size_t)-1 : NUM2UINT(len);
+  __u64 file_offset_i = NIL_P(file_offset) ? (__u64)-1 : NUM2UINT(file_offset);
 
-  int bytes = NIL_P(len) ? RSTRING_LEN(buffer) : NUM2INT(len);
-  return um_write(machine, NUM2INT(fd), buffer, bytes);
+  return um_write(machine, NUM2INT(fd), buffer, len_i, file_offset_i);
 }
 
-VALUE UM_write_async(VALUE self, VALUE fd, VALUE str) {
+VALUE UM_write_async(int argc, VALUE *argv, VALUE self) {
   struct um *machine = um_get_machine(self);
-  return um_write_async(machine, NUM2INT(fd), str);
+  VALUE fd;
+  VALUE buffer;
+  VALUE len;
+  VALUE file_offset;
+  rb_scan_args(argc, argv, "22", &fd, &buffer, &len, &file_offset);
+
+  size_t len_i = NIL_P(len) ? (size_t)-1 : NUM2UINT(len);
+  __u64 file_offset_i = NIL_P(file_offset) ? (__u64)-1 : NUM2UINT(file_offset);
+
+  return um_write_async(machine, NUM2INT(fd), buffer, len_i, file_offset_i);
 }
 
 VALUE UM_statx(VALUE self, VALUE dirfd, VALUE path, VALUE flags, VALUE mask) {
@@ -270,12 +337,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 +367,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,10 +395,22 @@ 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_select(VALUE self, VALUE rfds, VALUE wfds, VALUE efds) {
+  struct um *machine = um_get_machine(self);
+  return um_select(machine, rfds, wfds, efds);
+}
+
+VALUE UM_waitid(VALUE self, VALUE idtype, VALUE id, VALUE options) {
+  struct um *machine = um_get_machine(self);
+  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_waitpid(machine, NUM2INT(pid), NUM2INT(options));
+  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);
@@ -353,28 +428,93 @@ 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);
 
   cUM = rb_define_class("UringMachine", rb_cObject);
   rb_define_alloc_func(cUM, UM_allocate);
 
-  rb_define_method(cUM, "initialize", UM_initialize, 0);
+  rb_define_method(cUM, "initialize", UM_initialize, -1);
+  rb_define_method(cUM, "entries", UM_entries, 0);
+  rb_define_method(cUM, "mark", UM_mark_m, 1);
   rb_define_method(cUM, "pending_count", UM_pending_count, 0);
+  rb_define_method(cUM, "total_op_count", UM_total_op_count, 0);
   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, "kernel_version", UM_kernel_version, 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);
   rb_define_method(cUM, "snooze", UM_snooze, 0);
   rb_define_method(cUM, "timeout", UM_timeout, 2);
   rb_define_method(cUM, "yield", UM_yield, 0);
+  rb_define_method(cUM, "wakeup", UM_wakeup, 0);
+  rb_define_method(cUM, "submit", UM_submit, 0);
 
   rb_define_method(cUM, "close", UM_close, 1);
   rb_define_method(cUM, "close_async", UM_close_async, 1);
@@ -384,11 +524,16 @@ void Init_UM(void) {
   rb_define_method(cUM, "sleep", UM_sleep, 1);
   rb_define_method(cUM, "periodically", UM_periodically, 1);
   rb_define_method(cUM, "write", UM_write, -1);
-  rb_define_method(cUM, "write_async", UM_write_async, 2);
+  rb_define_method(cUM, "write_async", UM_write_async, -1);
   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, "select", UM_select, 3);
+  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 +552,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");
 }

data/ext/um/um_const.c

@@ -13,6 +13,7 @@
 #include <netdb.h>
 #include <net/if.h>
 #include <poll.h>
+#include <signal.h>
 
 #define DEF_CONST_INT(mod, v) rb_define_const(mod, #v, INT2NUM(v))
 
@@ -88,12 +89,12 @@ void um_define_net_constants(VALUE mod) {
   DEF_CONST_INT(mod, O_TRUNC);
   DEF_CONST_INT(mod, O_WRONLY);
 
-  DEF_CONST_INT(mod, WNOHANG);
-  DEF_CONST_INT(mod, WUNTRACED);
   DEF_CONST_INT(mod, WCONTINUED);
   DEF_CONST_INT(mod, WEXITED);
-  DEF_CONST_INT(mod, WSTOPPED);
+  DEF_CONST_INT(mod, WNOHANG);
   DEF_CONST_INT(mod, WNOWAIT);
+  DEF_CONST_INT(mod, WSTOPPED);
+  DEF_CONST_INT(mod, WUNTRACED);
 
   DEF_CONST_INT(mod, SOCK_STREAM);
   DEF_CONST_INT(mod, SOCK_DGRAM);
@@ -391,4 +392,51 @@ void um_define_net_constants(VALUE mod) {
   DEF_CONST_INT(mod, EKEYREJECTED);
   DEF_CONST_INT(mod, EOWNERDEAD);
   DEF_CONST_INT(mod, ENOTRECOVERABLE);
+
+  DEF_CONST_INT(mod, P_PID);
+  DEF_CONST_INT(mod, P_PIDFD);
+  DEF_CONST_INT(mod, P_PGID);
+  DEF_CONST_INT(mod, P_ALL);
+
+  DEF_CONST_INT(mod, CLD_EXITED);
+  DEF_CONST_INT(mod, CLD_KILLED);
+  DEF_CONST_INT(mod, CLD_DUMPED);
+  DEF_CONST_INT(mod, CLD_STOPPED);
+  DEF_CONST_INT(mod, CLD_TRAPPED);
+  DEF_CONST_INT(mod, CLD_CONTINUED);
+
+  DEF_CONST_INT(mod, SIGHUP);
+  DEF_CONST_INT(mod, SIGINT);
+  DEF_CONST_INT(mod, SIGQUIT);
+  DEF_CONST_INT(mod, SIGILL);
+  DEF_CONST_INT(mod, SIGTRAP);
+  DEF_CONST_INT(mod, SIGABRT);
+  DEF_CONST_INT(mod, SIGIOT);
+  DEF_CONST_INT(mod, SIGFPE);
+  DEF_CONST_INT(mod, SIGKILL);
+  DEF_CONST_INT(mod, SIGBUS);
+  DEF_CONST_INT(mod, SIGSEGV);
+  DEF_CONST_INT(mod, SIGSYS);
+  DEF_CONST_INT(mod, SIGPIPE);
+  DEF_CONST_INT(mod, SIGALRM);
+  DEF_CONST_INT(mod, SIGTERM);
+  DEF_CONST_INT(mod, SIGURG);
+  DEF_CONST_INT(mod, SIGSTOP);
+  DEF_CONST_INT(mod, SIGTSTP);
+  DEF_CONST_INT(mod, SIGCONT);
+  DEF_CONST_INT(mod, SIGCHLD);
+  DEF_CONST_INT(mod, SIGCLD);
+  DEF_CONST_INT(mod, SIGTTIN);
+  DEF_CONST_INT(mod, SIGTTOU);
+  DEF_CONST_INT(mod, SIGIO);
+  DEF_CONST_INT(mod, SIGXCPU);
+  DEF_CONST_INT(mod, SIGXFSZ);
+  DEF_CONST_INT(mod, SIGVTALRM);
+  DEF_CONST_INT(mod, SIGPROF);
+  DEF_CONST_INT(mod, SIGWINCH);
+  DEF_CONST_INT(mod, SIGUSR1);
+  DEF_CONST_INT(mod, SIGUSR2);
+  DEF_CONST_INT(mod, SIGPWR);
+  DEF_CONST_INT(mod, SIGPOLL);
+
 }

data/ext/um/um_mutex_class.c

@@ -11,7 +11,7 @@ static const rb_data_type_t Mutex_type = {
     .dsize = NULL,
     .dcompact = NULL
   },
-  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED | RUBY_TYPED_EMBEDDABLE
+  .flags = RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
 };
 
 static VALUE Mutex_allocate(VALUE klass) {