uringmachine 0.3 → 0.5

data/ext/um/um_class.c

@@ -1,16 +1,23 @@
 #include "um.h"
-#include <sys/mman.h>
+#include <arpa/inet.h>
 
 VALUE cUM;
 
 static void UM_mark(void *ptr) {
-  // struct um *machine = ptr;
-  // um_runqueue_mark(machine);
+  struct um *machine = ptr;
+  rb_gc_mark_movable(machine->self);
+
+  um_op_list_mark(machine, machine->transient_head);
+  um_op_list_mark(machine, machine->runqueue_head);
 }
 
 static void UM_compact(void *ptr) {
-  // struct um *machine = ptr;
-  // um_runqueue_compact(machine);
+  struct um *machine = ptr;
+  machine->self = rb_gc_location(machine->self);
+  machine->poll_fiber = rb_gc_location(machine->poll_fiber);
+
+  um_op_list_compact(machine, machine->transient_head);
+  um_op_list_compact(machine, machine->runqueue_head);
 }
 
 static void UM_free(void *ptr) {
@@ -43,63 +50,19 @@ inline struct um *get_machine(VALUE self) {
 
 VALUE UM_initialize(VALUE self) {
   struct um *machine = RTYPEDDATA_DATA(self);
-  um_setup(machine);
+  um_setup(self, machine);
   return self;
 }
 
 VALUE UM_setup_buffer_ring(VALUE self, VALUE size, VALUE count) {
   struct um *machine = get_machine(self);
-
-  if (machine->buffer_ring_count == BUFFER_RING_MAX_COUNT)
-    rb_raise(rb_eRuntimeError, "Cannot setup more than BUFFER_RING_MAX_COUNT buffer rings");
-
-  struct buf_ring_descriptor *desc = machine->buffer_rings + machine->buffer_ring_count;
-  desc->buf_count = NUM2UINT(count);
-  desc->buf_size = NUM2UINT(size);
-
-  desc->br_size = sizeof(struct io_uring_buf) * desc->buf_count;
-	void *mapped = mmap(
-    NULL, desc->br_size, PROT_READ | PROT_WRITE,
-		MAP_ANONYMOUS | MAP_PRIVATE, 0, 0
-  );
-  if (mapped == MAP_FAILED)
-    rb_raise(rb_eRuntimeError, "Failed to allocate buffer ring");
-
-  desc->br = (struct io_uring_buf_ring *)mapped;
-  io_uring_buf_ring_init(desc->br);
-
-  unsigned bg_id = machine->buffer_ring_count;
-  struct io_uring_buf_reg reg = {
-    .ring_addr = (unsigned long)desc->br,
-		.ring_entries = desc->buf_count,
-		.bgid = bg_id
-  };
-	int ret = io_uring_register_buf_ring(&machine->ring, &reg, 0);
-	if (ret) {
-    munmap(desc->br, desc->br_size);
-    rb_syserr_fail(-ret, strerror(-ret));
-	}
-
-  desc->buf_base = malloc(desc->buf_count * desc->buf_size);
-  if (!desc->buf_base) {
-    io_uring_free_buf_ring(&machine->ring, desc->br, desc->buf_count, bg_id);
-    rb_raise(rb_eRuntimeError, "Failed to allocate buffers");
-  }
-
-  int mask = io_uring_buf_ring_mask(desc->buf_count);
-	for (unsigned i = 0; i < desc->buf_count; i++) {
-		io_uring_buf_ring_add(
-      desc->br, desc->buf_base + i * desc->buf_size, desc->buf_size,
-      i, mask, i);
-	}
-	io_uring_buf_ring_advance(desc->br, desc->buf_count);
-  machine->buffer_ring_count++;
-  return UINT2NUM(bg_id);
+  int bgid = um_setup_buffer_ring(machine, NUM2UINT(size), NUM2UINT(count));
+  return INT2NUM(bgid);
 }
 
 VALUE UM_pending_count(VALUE self) {
   struct um *machine = get_machine(self);
-  return INT2FIX(machine->pending_count);
+  return INT2NUM(machine->pending_count);
 }
 
 VALUE UM_snooze(VALUE self) {
@@ -119,12 +82,6 @@ VALUE UM_schedule(VALUE self, VALUE fiber, VALUE value) {
   return self;
 }
 
-VALUE UM_interrupt(VALUE self, VALUE fiber, VALUE value) {
-  struct um *machine = get_machine(self);
-  um_interrupt(machine, fiber, value);
-  return self;
-}
-
 VALUE UM_timeout(VALUE self, VALUE interval, VALUE class) {
   struct um *machine = get_machine(self);
   return um_timeout(machine, interval, class);
@@ -132,8 +89,7 @@ VALUE UM_timeout(VALUE self, VALUE interval, VALUE class) {
 
 VALUE UM_sleep(VALUE self, VALUE duration) {
   struct um *machine = get_machine(self);
-  um_sleep(machine, NUM2DBL(duration));
-  return duration;
+  return um_sleep(machine, NUM2DBL(duration));
 }
 
 VALUE UM_read(int argc, VALUE *argv, VALUE self) {
@@ -151,8 +107,12 @@ VALUE UM_read(int argc, VALUE *argv, VALUE self) {
 }
 
 VALUE UM_read_each(VALUE self, VALUE fd, VALUE bgid) {
+#ifdef HAVE_IO_URING_PREP_READ_MULTISHOT
   struct um *machine = 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) {
@@ -166,6 +126,11 @@ VALUE UM_write(int argc, VALUE *argv, VALUE self) {
   return um_write(machine, NUM2INT(fd), buffer, bytes);
 }
 
+VALUE UM_close(VALUE self, VALUE fd) {
+  struct um *machine = get_machine(self);
+  return um_close(machine, NUM2INT(fd));
+}
+
 VALUE UM_accept(VALUE self, VALUE fd) {
   struct um *machine = get_machine(self);
   return um_accept(machine, NUM2INT(fd));
@@ -176,6 +141,166 @@ VALUE UM_accept_each(VALUE self, VALUE fd) {
   return um_accept_each(machine, NUM2INT(fd));
 }
 
+VALUE UM_socket(VALUE self, VALUE domain, VALUE type, VALUE protocol, VALUE flags) {
+  struct um *machine = get_machine(self);
+  return um_socket(machine, NUM2INT(domain), NUM2INT(type), NUM2INT(protocol), NUM2UINT(flags));
+}
+
+VALUE UM_connect(VALUE self, VALUE fd, VALUE host, VALUE port) {
+  struct um *machine = get_machine(self);
+
+  struct sockaddr_in addr;
+  memset(&addr, 0, sizeof(addr));
+  addr.sin_family = AF_INET;
+  addr.sin_addr.s_addr = inet_addr(StringValueCStr(host));
+  addr.sin_port = htons(NUM2INT(port));
+
+  return um_connect(machine, NUM2INT(fd), (struct sockaddr *)&addr, sizeof(addr));
+}
+
+VALUE UM_send(VALUE self, VALUE fd, VALUE buffer, VALUE len, VALUE flags) {
+  struct um *machine = get_machine(self);
+  return um_send(machine, NUM2INT(fd), buffer, NUM2INT(len), NUM2INT(flags));
+}
+
+VALUE UM_recv(VALUE self, VALUE fd, VALUE buffer, VALUE maxlen, VALUE flags) {
+  struct um *machine = get_machine(self);
+  return um_recv(machine, NUM2INT(fd), buffer, NUM2INT(maxlen), NUM2INT(flags));
+}
+
+VALUE UM_recv_each(VALUE self, VALUE fd, VALUE bgid, VALUE flags) {
+  struct um *machine = get_machine(self);
+  return um_recv_each(machine, NUM2INT(fd), NUM2INT(bgid), NUM2INT(flags));
+}
+
+VALUE UM_bind(VALUE self, VALUE fd, VALUE host, VALUE port) {
+  struct sockaddr_in addr;
+  memset(&addr, 0, sizeof(addr));
+  addr.sin_family = AF_INET;
+  addr.sin_addr.s_addr = inet_addr(StringValueCStr(host));
+  addr.sin_port = htons(NUM2INT(port));
+
+#ifdef HAVE_IO_URING_PREP_BIND
+  struct um *machine = get_machine(self);
+  return um_bind(machine, NUM2INT(fd), (struct sockaddr *)&addr, sizeof(addr));
+#else
+  int res = bind(NUM2INT(fd), (struct sockaddr *)&addr, sizeof(addr));
+  if (res)
+    rb_syserr_fail(errno, strerror(errno));
+  return INT2NUM(0);
+#endif
+}
+
+VALUE UM_listen(VALUE self, VALUE fd, VALUE backlog) {
+#ifdef HAVE_IO_URING_PREP_LISTEN
+  struct um *machine = get_machine(self);
+  return um_listen(machine, NUM2INT(fd), NUM2INT(backlog));
+#else
+  int res = listen(NUM2INT(fd), NUM2INT(backlog));
+  if (res)
+    rb_syserr_fail(errno, strerror(errno));
+  return INT2NUM(0);
+#endif
+}
+
+static inline int numeric_value(VALUE value) {
+  switch (TYPE(value)) {
+    case T_TRUE:
+      return 1;
+    case T_FALSE:
+      return 0;
+    default:
+      return NUM2INT(value);
+  }
+}
+
+VALUE UM_getsockopt(VALUE self, VALUE fd, VALUE level, VALUE opt) {
+  struct um *machine = get_machine(self);
+  return um_getsockopt(machine, NUM2INT(fd), NUM2INT(level), NUM2INT(opt));
+}
+
+VALUE UM_setsockopt(VALUE self, VALUE fd, VALUE level, VALUE opt, VALUE value) {
+  struct um *machine = get_machine(self);
+  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 = get_machine(self);
+  struct um_mutex *mutex_data = Mutex_data(mutex);
+  return um_mutex_synchronize(machine, &mutex_data->state);
+}
+
+VALUE UM_queue_push(VALUE self, VALUE queue, VALUE value) {
+  struct um *machine = get_machine(self);
+  struct um_queue *que = Queue_data(queue);
+  return um_queue_push(machine, que, value);
+}
+
+VALUE UM_queue_pop(VALUE self, VALUE queue) {
+  struct um *machine = get_machine(self);
+  struct um_queue *que = Queue_data(queue);
+  return um_queue_pop(machine, que);
+}
+
+VALUE UM_queue_unshift(VALUE self, VALUE queue, VALUE value) {
+  struct um *machine = get_machine(self);
+  struct um_queue *que = Queue_data(queue);
+  return um_queue_unshift(machine, que, value);
+}
+
+VALUE UM_queue_shift(VALUE self, VALUE queue) {
+  struct um *machine = get_machine(self);
+  struct um_queue *que = Queue_data(queue);
+  return um_queue_shift(machine, que);
+}
+
+#endif
+
+struct um_open_ctx {
+  VALUE self;
+  VALUE fd;
+};
+
+VALUE UM_open_ensure(VALUE arg) {
+  struct um_open_ctx *ctx = (struct um_open_ctx *)arg;
+  UM_close(ctx->self, ctx->fd);
+  return ctx->self;
+}
+
+VALUE UM_open(VALUE self, VALUE pathname, VALUE flags) {
+  struct um *machine = get_machine(self);
+  // TODO: take optional perm (mode) arg
+  VALUE fd = um_open(machine, pathname, NUM2INT(flags), 0666);
+  if (rb_block_given_p()) {
+    struct um_open_ctx ctx = { self, fd };
+    return rb_ensure(rb_yield, fd, UM_open_ensure, (VALUE)&ctx);
+  }
+  else
+    return fd;
+}
+
+VALUE UM_waitpid(VALUE self, VALUE pid, VALUE options) {
+  struct um *machine = get_machine(self);
+  return um_waitpid(machine, NUM2INT(pid), NUM2INT(options));
+}
+
+VALUE UM_pipe(VALUE self) {
+  int fds[2];
+  int ret = pipe(fds);
+  if (ret) {
+    int e = errno;
+    rb_syserr_fail(e, strerror(e));
+  }
+
+  return rb_ary_new_from_args(2, INT2NUM(fds[0]), INT2NUM(fds[1]));
+}
+
+VALUE UM_kernel_version(VALUE self) {
+  return INT2NUM(UM_KERNEL_VERSION);
+}
+
 void Init_UM(void) {
   rb_ext_ractor_safe(true);
 
@@ -183,60 +308,46 @@ void Init_UM(void) {
   rb_define_alloc_func(cUM, UM_allocate);
 
   rb_define_method(cUM, "initialize", UM_initialize, 0);
-  rb_define_method(cUM, "setup_buffer_ring", UM_setup_buffer_ring, 2);
   rb_define_method(cUM, "pending_count", UM_pending_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_method(cUM, "snooze", UM_snooze, 0);
-  rb_define_method(cUM, "yield", UM_yield, 0);
   rb_define_method(cUM, "schedule", UM_schedule, 2);
-  rb_define_method(cUM, "interrupt", UM_interrupt, 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, "sleep", UM_sleep, 1);
+  rb_define_method(cUM, "close", UM_close, 1);
+  rb_define_method(cUM, "open", UM_open, 2);
   rb_define_method(cUM, "read", UM_read, -1);
   rb_define_method(cUM, "read_each", UM_read_each, 2);
+  rb_define_method(cUM, "sleep", UM_sleep, 1);
   rb_define_method(cUM, "write", UM_write, -1);
 
+  rb_define_method(cUM, "waitpid", UM_waitpid, 2);
+
   rb_define_method(cUM, "accept", UM_accept, 1);
   rb_define_method(cUM, "accept_each", UM_accept_each, 1);
-
-  // rb_define_method(cUM, "emit", UM_emit, 1);
-
-  // rb_define_method(cUM, "prep_accept", UM_prep_accept, 1);
-  // rb_define_method(cUM, "prep_cancel", UM_prep_cancel, 1);
-  // rb_define_method(cUM, "prep_close", UM_prep_close, 1);
-  // rb_define_method(cUM, "prep_nop", UM_prep_nop, 0);
-  // rb_define_method(cUM, "prep_read", UM_prep_read, 1);
-  // rb_define_method(cUM, "prep_timeout", UM_prep_timeout, 1);
-  // rb_define_method(cUM, "prep_write", UM_prep_write, 1);
-
-  // rb_define_method(cUM, "submit", UM_submit, 0);
-  // rb_define_method(cUM, "wait_for_completion", UM_wait_for_completion, 0);
-  // rb_define_method(cUM, "process_completions", UM_process_completions, -1);
-  // rb_define_method(cUM, "process_completions_loop", UM_process_completions_loop, 0);
-
-  // SYM_accept        = MAKE_SYM("accept");
-  // SYM_block         = MAKE_SYM("block");
-  // SYM_buffer        = MAKE_SYM("buffer");
-  // SYM_buffer_group  = MAKE_SYM("buffer_group");
-  // SYM_buffer_offset = MAKE_SYM("buffer_offset");
-  // SYM_close         = MAKE_SYM("close");
-  // SYM_count         = MAKE_SYM("count");
-  // SYM_emit          = MAKE_SYM("emit");
-  // SYM_fd            = MAKE_SYM("fd");
-  // SYM_id            = MAKE_SYM("id");
-  // SYM_interval      = MAKE_SYM("interval");
-  // SYM_len           = MAKE_SYM("len");
-  // SYM_link          = MAKE_SYM("link");
-  // SYM_multishot     = MAKE_SYM("multishot");
-  // SYM_op            = MAKE_SYM("op");
-  // SYM_read          = MAKE_SYM("read");
-  // SYM_result        = MAKE_SYM("result");
-  // SYM_signal        = MAKE_SYM("signal");
-  // SYM_size          = MAKE_SYM("size");
-  // SYM_spec_data     = MAKE_SYM("spec_data");
-  // SYM_stop          = MAKE_SYM("stop");
-  // SYM_timeout       = MAKE_SYM("timeout");
-  // SYM_utf8          = MAKE_SYM("utf8");
-  // SYM_write         = MAKE_SYM("write");
+  rb_define_method(cUM, "bind", UM_bind, 3);
+  rb_define_method(cUM, "connect", UM_connect, 3);
+  rb_define_method(cUM, "getsockopt", UM_getsockopt, 3);
+  rb_define_method(cUM, "listen", UM_listen, 2);
+  rb_define_method(cUM, "recv", UM_recv, 4);
+  rb_define_method(cUM, "recv_each", UM_recv_each, 3);
+  rb_define_method(cUM, "send", UM_send, 4);
+  rb_define_method(cUM, "setsockopt", UM_setsockopt, 4);
+  rb_define_method(cUM, "socket", UM_socket, 4);
+
+  #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
+
+  um_define_net_constants(cUM);
 }

data/ext/um/um_const.c

@@ -0,0 +1,213 @@
+#include "ruby.h"
+
+#include <fcntl.h>
+#include <sys/wait.h>
+
+#include <arpa/inet.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <netinet/udp.h>
+#include <netdb.h>
+#include <net/if.h>
+
+
+#define DEF_CONST_INT(mod, v) rb_define_const(mod, #v, INT2NUM(v))
+
+void um_define_net_constants(VALUE mod) {
+  DEF_CONST_INT(mod, O_APPEND);
+  DEF_CONST_INT(mod, O_CLOEXEC);
+  DEF_CONST_INT(mod, O_CREAT);
+  DEF_CONST_INT(mod, O_DIRECT);
+  DEF_CONST_INT(mod, O_DIRECTORY);
+  DEF_CONST_INT(mod, O_DSYNC);
+  DEF_CONST_INT(mod, O_EXCL);
+  DEF_CONST_INT(mod, O_NOCTTY);
+  DEF_CONST_INT(mod, O_NOFOLLOW);
+  DEF_CONST_INT(mod, O_PATH);
+  DEF_CONST_INT(mod, O_RDONLY);
+  DEF_CONST_INT(mod, O_RDWR);
+  DEF_CONST_INT(mod, O_SYNC);
+  DEF_CONST_INT(mod, O_TMPFILE);
+  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, WCONTINUED);
+  DEF_CONST_INT(mod, WNOWAIT);
+
+  DEF_CONST_INT(mod, SOCK_STREAM);
+  DEF_CONST_INT(mod, SOCK_DGRAM);
+  DEF_CONST_INT(mod, SOCK_RAW);
+  DEF_CONST_INT(mod, SOCK_RDM);
+  DEF_CONST_INT(mod, SOCK_SEQPACKET);
+  DEF_CONST_INT(mod, SOCK_PACKET);
+  DEF_CONST_INT(mod, SOCK_CLOEXEC);
+
+  DEF_CONST_INT(mod, AF_UNSPEC);
+  DEF_CONST_INT(mod, PF_UNSPEC);
+  DEF_CONST_INT(mod, AF_INET);
+  DEF_CONST_INT(mod, PF_INET);
+  DEF_CONST_INT(mod, AF_INET6);
+  DEF_CONST_INT(mod, PF_INET6);
+  DEF_CONST_INT(mod, AF_UNIX);
+  DEF_CONST_INT(mod, PF_UNIX);
+  DEF_CONST_INT(mod, AF_LOCAL);
+  DEF_CONST_INT(mod, PF_LOCAL);
+  DEF_CONST_INT(mod, AF_ROUTE);
+  DEF_CONST_INT(mod, PF_ROUTE);
+  DEF_CONST_INT(mod, AF_MAX);
+  DEF_CONST_INT(mod, PF_MAX);
+
+  DEF_CONST_INT(mod, MSG_OOB);
+  DEF_CONST_INT(mod, MSG_PEEK);
+  DEF_CONST_INT(mod, MSG_DONTROUTE);
+  DEF_CONST_INT(mod, MSG_WAITALL);
+  DEF_CONST_INT(mod, MSG_DONTWAIT);
+  DEF_CONST_INT(mod, MSG_MORE);
+
+  DEF_CONST_INT(mod, SOL_SOCKET);
+  DEF_CONST_INT(mod, SOL_IP);
+
+  DEF_CONST_INT(mod, IPPROTO_IP);
+  DEF_CONST_INT(mod, IPPROTO_ICMP);
+  DEF_CONST_INT(mod, IPPROTO_IGMP);
+  DEF_CONST_INT(mod, IPPROTO_TCP);
+  DEF_CONST_INT(mod, IPPROTO_EGP);
+  DEF_CONST_INT(mod, IPPROTO_PUP);
+  DEF_CONST_INT(mod, IPPROTO_UDP);
+  DEF_CONST_INT(mod, IPPROTO_IDP);
+  DEF_CONST_INT(mod, IPPROTO_IPV6);
+  DEF_CONST_INT(mod, IPPROTO_NONE);
+  DEF_CONST_INT(mod, IPPROTO_ROUTING);
+  DEF_CONST_INT(mod, IPPROTO_RAW);
+  DEF_CONST_INT(mod, IPPROTO_MAX);
+
+  DEF_CONST_INT(mod, INADDR_ANY);
+  DEF_CONST_INT(mod, INADDR_BROADCAST);
+  DEF_CONST_INT(mod, INADDR_LOOPBACK);
+  DEF_CONST_INT(mod, INADDR_NONE);
+
+  DEF_CONST_INT(mod, IP_OPTIONS);
+  DEF_CONST_INT(mod, IP_HDRINCL);
+  DEF_CONST_INT(mod, IP_TOS);
+  DEF_CONST_INT(mod, IP_TTL);
+  DEF_CONST_INT(mod, IP_RECVOPTS);
+  DEF_CONST_INT(mod, IP_MINTTL);
+  DEF_CONST_INT(mod, IP_RECVTTL);
+
+  DEF_CONST_INT(mod, SO_DEBUG);
+  DEF_CONST_INT(mod, SO_REUSEADDR);
+  DEF_CONST_INT(mod, SO_REUSEPORT);
+  DEF_CONST_INT(mod, SO_TYPE);
+  DEF_CONST_INT(mod, SO_ERROR);
+  DEF_CONST_INT(mod, SO_DONTROUTE);
+  DEF_CONST_INT(mod, SO_BROADCAST);
+  DEF_CONST_INT(mod, SO_SNDBUF);
+  DEF_CONST_INT(mod, SO_RCVBUF);
+  DEF_CONST_INT(mod, SO_SNDBUFFORCE);
+  DEF_CONST_INT(mod, SO_RCVBUFFORCE);
+  DEF_CONST_INT(mod, SO_KEEPALIVE);
+  DEF_CONST_INT(mod, SO_OOBINLINE);
+  DEF_CONST_INT(mod, SO_PRIORITY);
+  DEF_CONST_INT(mod, SO_LINGER);
+  DEF_CONST_INT(mod, SO_PASSCRED);
+  DEF_CONST_INT(mod, SO_PEERCRED);
+  DEF_CONST_INT(mod, SO_RCVLOWAT);
+  DEF_CONST_INT(mod, SO_SNDLOWAT);
+  DEF_CONST_INT(mod, SO_RCVTIMEO);
+  DEF_CONST_INT(mod, SO_SNDTIMEO);
+  DEF_CONST_INT(mod, SO_ACCEPTCONN);
+  DEF_CONST_INT(mod, SO_PEERNAME);
+  DEF_CONST_INT(mod, SO_TIMESTAMP);
+  DEF_CONST_INT(mod, SO_MARK);
+  DEF_CONST_INT(mod, SO_PROTOCOL);
+  DEF_CONST_INT(mod, SO_DOMAIN);
+  DEF_CONST_INT(mod, SO_PEEK_OFF);
+  DEF_CONST_INT(mod, SO_BUSY_POLL);
+
+  DEF_CONST_INT(mod, TCP_NODELAY);
+  DEF_CONST_INT(mod, TCP_MAXSEG);
+  DEF_CONST_INT(mod, TCP_CORK);
+  DEF_CONST_INT(mod, TCP_DEFER_ACCEPT);
+  DEF_CONST_INT(mod, TCP_INFO);
+  DEF_CONST_INT(mod, TCP_KEEPCNT);
+  DEF_CONST_INT(mod, TCP_KEEPIDLE);
+  DEF_CONST_INT(mod, TCP_KEEPINTVL);
+  DEF_CONST_INT(mod, TCP_LINGER2);
+  DEF_CONST_INT(mod, TCP_MD5SIG);
+  DEF_CONST_INT(mod, TCP_QUICKACK);
+  DEF_CONST_INT(mod, TCP_SYNCNT);
+  DEF_CONST_INT(mod, TCP_WINDOW_CLAMP);
+  DEF_CONST_INT(mod, TCP_FASTOPEN);
+  DEF_CONST_INT(mod, TCP_CONGESTION);
+  DEF_CONST_INT(mod, TCP_COOKIE_TRANSACTIONS);
+  DEF_CONST_INT(mod, TCP_QUEUE_SEQ);
+  DEF_CONST_INT(mod, TCP_REPAIR);
+  DEF_CONST_INT(mod, TCP_REPAIR_OPTIONS);
+  DEF_CONST_INT(mod, TCP_REPAIR_QUEUE);
+  DEF_CONST_INT(mod, TCP_THIN_LINEAR_TIMEOUTS);
+  DEF_CONST_INT(mod, TCP_TIMESTAMP);
+  DEF_CONST_INT(mod, TCP_USER_TIMEOUT);
+  
+  DEF_CONST_INT(mod, UDP_CORK);
+
+  DEF_CONST_INT(mod, AI_PASSIVE);
+  DEF_CONST_INT(mod, AI_CANONNAME);
+  DEF_CONST_INT(mod, AI_NUMERICHOST);
+  DEF_CONST_INT(mod, AI_NUMERICSERV);
+  DEF_CONST_INT(mod, AI_ALL);
+  DEF_CONST_INT(mod, AI_ADDRCONFIG);
+  DEF_CONST_INT(mod, AI_V4MAPPED);
+  
+  DEF_CONST_INT(mod, NI_MAXHOST);
+  DEF_CONST_INT(mod, NI_MAXSERV);
+  DEF_CONST_INT(mod, NI_NOFQDN);
+  DEF_CONST_INT(mod, NI_NUMERICHOST);
+  DEF_CONST_INT(mod, NI_NAMEREQD);
+  DEF_CONST_INT(mod, NI_NUMERICSERV);
+  DEF_CONST_INT(mod, NI_DGRAM);
+  
+  DEF_CONST_INT(mod, SHUT_RD);
+  DEF_CONST_INT(mod, SHUT_WR);
+  DEF_CONST_INT(mod, SHUT_RDWR);
+
+  DEF_CONST_INT(mod, IPV6_JOIN_GROUP);
+  DEF_CONST_INT(mod, IPV6_LEAVE_GROUP);
+  DEF_CONST_INT(mod, IPV6_MULTICAST_HOPS);
+  DEF_CONST_INT(mod, IPV6_MULTICAST_IF);
+  DEF_CONST_INT(mod, IPV6_MULTICAST_LOOP);
+  DEF_CONST_INT(mod, IPV6_UNICAST_HOPS);
+  DEF_CONST_INT(mod, IPV6_V6ONLY);
+  DEF_CONST_INT(mod, IPV6_CHECKSUM);
+  DEF_CONST_INT(mod, IPV6_DONTFRAG);
+  DEF_CONST_INT(mod, IPV6_DSTOPTS);
+  DEF_CONST_INT(mod, IPV6_HOPLIMIT);
+  DEF_CONST_INT(mod, IPV6_HOPOPTS);
+  DEF_CONST_INT(mod, IPV6_NEXTHOP);
+  DEF_CONST_INT(mod, IPV6_PATHMTU);
+  DEF_CONST_INT(mod, IPV6_PKTINFO);
+  DEF_CONST_INT(mod, IPV6_RECVDSTOPTS);
+  DEF_CONST_INT(mod, IPV6_RECVHOPLIMIT);
+  DEF_CONST_INT(mod, IPV6_RECVHOPOPTS);
+  DEF_CONST_INT(mod, IPV6_RECVPKTINFO);
+  DEF_CONST_INT(mod, IPV6_RECVRTHDR);
+  DEF_CONST_INT(mod, IPV6_RECVTCLASS);
+  DEF_CONST_INT(mod, IPV6_RTHDR);
+  DEF_CONST_INT(mod, IPV6_RTHDRDSTOPTS);
+  DEF_CONST_INT(mod, IPV6_RTHDR_TYPE_0);
+  DEF_CONST_INT(mod, IPV6_RECVPATHMTU);
+  DEF_CONST_INT(mod, IPV6_TCLASS);
+
+  DEF_CONST_INT(mod, INET_ADDRSTRLEN);
+  DEF_CONST_INT(mod, INET6_ADDRSTRLEN);
+
+  DEF_CONST_INT(mod, IF_NAMESIZE);
+
+  DEF_CONST_INT(mod, SOMAXCONN);
+}

data/ext/um/um_ext.c

@@ -1,5 +1,9 @@
 void Init_UM();
+void Init_Mutex();
+void Init_Queue();
 
 void Init_um_ext(void) {
   Init_UM();
+  Init_Mutex();
+  Init_Queue();
 }

data/ext/um/um_mutex_class.c

@@ -0,0 +1,47 @@
+#include "um.h"
+#include <stdlib.h>
+
+VALUE cMutex;
+
+static void Mutex_mark(void *ptr) {
+  struct um_mutex *mutex = ptr;
+  rb_gc_mark_movable(mutex->self);
+}
+
+static void Mutex_compact(void *ptr) {
+  struct um_mutex *mutex = ptr;
+  mutex->self = rb_gc_location(mutex->self);
+}
+
+static size_t Mutex_size(const void *ptr) {
+  return sizeof(struct um_mutex);
+}
+
+static const rb_data_type_t Mutex_type = {
+    "UringMachineMutex",
+    {Mutex_mark, free, Mutex_size, Mutex_compact},
+    0, 0, RUBY_TYPED_FREE_IMMEDIATELY | RUBY_TYPED_WB_PROTECTED
+};
+
+static VALUE Mutex_allocate(VALUE klass) {
+  struct um_mutex *mutex = malloc(sizeof(struct um_mutex));
+  return TypedData_Wrap_Struct(klass, &Mutex_type, mutex);
+}
+
+inline struct um_mutex *Mutex_data(VALUE self) {
+  return RTYPEDDATA_DATA(self);
+}
+
+VALUE Mutex_initialize(VALUE self) {
+  struct um_mutex *mutex = Mutex_data(self);
+  mutex->self = self;
+  um_mutex_init(mutex);
+  return self;
+}
+
+void Init_Mutex(void) {
+  cMutex = rb_define_class_under(cUM, "Mutex", rb_cObject);
+  rb_define_alloc_func(cMutex, Mutex_allocate);
+
+  rb_define_method(cMutex, "initialize", Mutex_initialize, 0);
+}