uringmachine 0.4 → 0.5.1

data/ext/um/um_class.c

@@ -4,13 +4,19 @@
 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);
+
+  um_op_list_compact(machine, machine->transient_head);
+  um_op_list_compact(machine, machine->runqueue_head);
 }
 
 static void UM_free(void *ptr) {
@@ -34,7 +40,7 @@ static VALUE UM_allocate(VALUE klass) {
   return TypedData_Wrap_Struct(klass, &UM_type, machine);
 }
 
-inline struct um *get_machine(VALUE self) {
+inline struct um *um_get_machine(VALUE self) {
   struct um *machine = RTYPEDDATA_DATA(self);
   if (!machine->ring_initialized)
     rb_raise(rb_eRuntimeError, "Machine not initialized");
@@ -43,57 +49,50 @@ 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);
+  struct um *machine = um_get_machine(self);
   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);
+  struct um *machine = um_get_machine(self);
+  return INT2NUM(machine->pending_count);
 }
 
 VALUE UM_snooze(VALUE self) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   um_schedule(machine, rb_fiber_current(), Qnil);
   return um_await(machine);
 }
 
 VALUE UM_yield(VALUE self) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return um_await(machine);
 }
 
 VALUE UM_schedule(VALUE self, VALUE fiber, VALUE value) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   um_schedule(machine, fiber, 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);
+  struct um *machine = um_get_machine(self);
   return um_timeout(machine, interval, class);
 }
 
 VALUE UM_sleep(VALUE self, VALUE duration) {
-  struct um *machine = get_machine(self);
-  um_sleep(machine, NUM2DBL(duration));
-  return duration;
+  struct um *machine = um_get_machine(self);
+  return um_sleep(machine, NUM2DBL(duration));
 }
 
 VALUE UM_read(int argc, VALUE *argv, VALUE self) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   VALUE fd;
   VALUE buffer;
   VALUE maxlen;
@@ -107,12 +106,16 @@ VALUE UM_read(int argc, VALUE *argv, VALUE self) {
 }
 
 VALUE UM_read_each(VALUE self, VALUE fd, VALUE bgid) {
-  struct um *machine = get_machine(self);
+#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) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   VALUE fd;
   VALUE buffer;
   VALUE len;
@@ -123,27 +126,27 @@ VALUE UM_write(int argc, VALUE *argv, VALUE self) {
 }
 
 VALUE UM_close(VALUE self, VALUE fd) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return um_close(machine, NUM2INT(fd));
 }
 
 VALUE UM_accept(VALUE self, VALUE fd) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return um_accept(machine, NUM2INT(fd));
 }
 
 VALUE UM_accept_each(VALUE self, VALUE fd) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   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);
+  struct um *machine = um_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 um *machine = um_get_machine(self);
 
   struct sockaddr_in addr;
   memset(&addr, 0, sizeof(addr));
@@ -155,15 +158,20 @@ VALUE UM_connect(VALUE self, VALUE fd, VALUE host, VALUE port) {
 }
 
 VALUE UM_send(VALUE self, VALUE fd, VALUE buffer, VALUE len, VALUE flags) {
-  struct um *machine = get_machine(self);
+  struct um *machine = um_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);
+  struct um *machine = um_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 = um_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));
@@ -172,7 +180,7 @@ VALUE UM_bind(VALUE self, VALUE fd, VALUE host, VALUE port) {
   addr.sin_port = htons(NUM2INT(port));
 
 #ifdef HAVE_IO_URING_PREP_BIND
-  struct um *machine = get_machine(self);
+  struct um *machine = um_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));
@@ -184,7 +192,7 @@ VALUE UM_bind(VALUE self, VALUE fd, VALUE host, VALUE port) {
 
 VALUE UM_listen(VALUE self, VALUE fd, VALUE backlog) {
 #ifdef HAVE_IO_URING_PREP_LISTEN
-  struct um *machine = get_machine(self);
+  struct um *machine = um_get_machine(self);
   return um_listen(machine, NUM2INT(fd), NUM2INT(backlog));
 #else
   int res = listen(NUM2INT(fd), NUM2INT(backlog));
@@ -194,6 +202,109 @@ VALUE UM_listen(VALUE self, VALUE fd, VALUE backlog) {
 #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 = um_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 = um_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 = um_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 = um_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 = um_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 = um_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 = um_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 = um_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 = um_get_machine(self);
+  return um_waitpid(machine, NUM2INT(pid), NUM2INT(options));
+}
+
+VALUE UM_prep_timeout(VALUE self, VALUE interval) {
+  struct um *machine = um_get_machine(self);
+  return um_prep_timeout(machine, NUM2DBL(interval));
+}
+
+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);
 
@@ -201,29 +312,50 @@ 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, "close", UM_close, 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, "socket", UM_socket, 4);
-  rb_define_method(cUM, "connect", UM_connect, 3);
-  rb_define_method(cUM, "send", UM_send, 4);
-  rb_define_method(cUM, "recv", UM_recv, 4);
   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);
+
+  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
+
+  // Init_micro_ssl(cUM);
 
   um_define_net_constants(cUM);
 }

data/ext/um/um_const.c

@@ -1,4 +1,8 @@
 #include "ruby.h"
+
+#include <fcntl.h>
+#include <sys/wait.h>
+
 #include <arpa/inet.h>
 #include <sys/types.h>
 #include <sys/socket.h>
@@ -12,6 +16,43 @@
 #define DEF_CONST_INT(mod, v) rb_define_const(mod, #v, INT2NUM(v))
 
 void um_define_net_constants(VALUE mod) {
+  DEF_CONST_INT(mod, MSG_CONFIRM);
+  DEF_CONST_INT(mod, MSG_DONTROUTE);
+  DEF_CONST_INT(mod, MSG_DONTWAIT);
+  DEF_CONST_INT(mod, MSG_EOR);
+  DEF_CONST_INT(mod, MSG_ERRQUEUE);
+  DEF_CONST_INT(mod, MSG_FASTOPEN);
+  DEF_CONST_INT(mod, MSG_MORE);
+  DEF_CONST_INT(mod, MSG_NOSIGNAL);
+  DEF_CONST_INT(mod, MSG_OOB);
+  DEF_CONST_INT(mod, MSG_PEEK);
+  DEF_CONST_INT(mod, MSG_TRUNC);
+  DEF_CONST_INT(mod, MSG_WAITALL);
+
+  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, WNOWAIT);
+
   DEF_CONST_INT(mod, SOCK_STREAM);
   DEF_CONST_INT(mod, SOCK_DGRAM);
   DEF_CONST_INT(mod, SOCK_RAW);
@@ -35,13 +76,6 @@ void um_define_net_constants(VALUE mod) {
   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);
 
@@ -117,7 +151,7 @@ void um_define_net_constants(VALUE mod) {
   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_COOKIE_TRANSACTIONS);
   DEF_CONST_INT(mod, TCP_QUEUE_SEQ);
   DEF_CONST_INT(mod, TCP_REPAIR);
   DEF_CONST_INT(mod, TCP_REPAIR_OPTIONS);
@@ -181,4 +215,135 @@ void um_define_net_constants(VALUE mod) {
   DEF_CONST_INT(mod, IF_NAMESIZE);
 
   DEF_CONST_INT(mod, SOMAXCONN);
-}
+
+  DEF_CONST_INT(mod, EPERM);
+  DEF_CONST_INT(mod, ENOENT);
+  DEF_CONST_INT(mod, ESRCH);
+  DEF_CONST_INT(mod, EINTR);
+  DEF_CONST_INT(mod, EIO);
+  DEF_CONST_INT(mod, ENXIO);
+  DEF_CONST_INT(mod, E2BIG);
+  DEF_CONST_INT(mod, ENOEXEC);
+  DEF_CONST_INT(mod, EBADF);
+  DEF_CONST_INT(mod, ECHILD);
+  DEF_CONST_INT(mod, EAGAIN);
+  DEF_CONST_INT(mod, ENOMEM);
+  DEF_CONST_INT(mod, EACCES);
+  DEF_CONST_INT(mod, EFAULT);
+  DEF_CONST_INT(mod, ENOTBLK);
+  DEF_CONST_INT(mod, EBUSY);
+  DEF_CONST_INT(mod, EEXIST);
+  DEF_CONST_INT(mod, EXDEV);
+  DEF_CONST_INT(mod, ENODEV);
+  DEF_CONST_INT(mod, ENOTDIR);
+  DEF_CONST_INT(mod, EISDIR);
+  DEF_CONST_INT(mod, EINVAL);
+  DEF_CONST_INT(mod, ENFILE);
+  DEF_CONST_INT(mod, EMFILE);
+  DEF_CONST_INT(mod, ENOTTY);
+  DEF_CONST_INT(mod, ETXTBSY);
+  DEF_CONST_INT(mod, EFBIG);
+  DEF_CONST_INT(mod, ENOSPC);
+  DEF_CONST_INT(mod, ESPIPE);
+  DEF_CONST_INT(mod, EROFS);
+  DEF_CONST_INT(mod, EMLINK);
+  DEF_CONST_INT(mod, EPIPE);
+  DEF_CONST_INT(mod, EDOM);
+  DEF_CONST_INT(mod, ERANGE);
+  DEF_CONST_INT(mod, EDEADLK);
+  DEF_CONST_INT(mod, ENAMETOOLONG);
+  DEF_CONST_INT(mod, ENOLCK);
+  DEF_CONST_INT(mod, ENOSYS);
+  DEF_CONST_INT(mod, ENOTEMPTY);
+  DEF_CONST_INT(mod, ELOOP);
+  DEF_CONST_INT(mod, ENOMSG);
+  DEF_CONST_INT(mod, EIDRM);
+  DEF_CONST_INT(mod, ECHRNG);
+  DEF_CONST_INT(mod, EL2NSYNC);
+  DEF_CONST_INT(mod, EL3HLT);
+  DEF_CONST_INT(mod, EL3RST);
+  DEF_CONST_INT(mod, ELNRNG);
+  DEF_CONST_INT(mod, EUNATCH);
+  DEF_CONST_INT(mod, ENOCSI);
+  DEF_CONST_INT(mod, EL2HLT);
+  DEF_CONST_INT(mod, EBADE);
+  DEF_CONST_INT(mod, EBADR);
+  DEF_CONST_INT(mod, EXFULL);
+  DEF_CONST_INT(mod, ENOANO);
+  DEF_CONST_INT(mod, EBADRQC);
+  DEF_CONST_INT(mod, EBADSLT);
+  DEF_CONST_INT(mod, EBFONT);
+  DEF_CONST_INT(mod, ENOSTR);
+  DEF_CONST_INT(mod, ENODATA);
+  DEF_CONST_INT(mod, ETIME);
+  DEF_CONST_INT(mod, ENOSR);
+  DEF_CONST_INT(mod, ENONET);
+  DEF_CONST_INT(mod, ENOPKG);
+  DEF_CONST_INT(mod, EREMOTE);
+  DEF_CONST_INT(mod, ENOLINK);
+  DEF_CONST_INT(mod, EADV);
+  DEF_CONST_INT(mod, ESRMNT);
+  DEF_CONST_INT(mod, ECOMM);
+  DEF_CONST_INT(mod, EPROTO);
+  DEF_CONST_INT(mod, EMULTIHOP);
+  DEF_CONST_INT(mod, EDOTDOT);
+  DEF_CONST_INT(mod, EBADMSG);
+  DEF_CONST_INT(mod, EOVERFLOW);
+  DEF_CONST_INT(mod, ENOTUNIQ);
+  DEF_CONST_INT(mod, EBADFD);
+  DEF_CONST_INT(mod, EREMCHG);
+  DEF_CONST_INT(mod, ELIBACC);
+  DEF_CONST_INT(mod, ELIBBAD);
+  DEF_CONST_INT(mod, ELIBSCN);
+  DEF_CONST_INT(mod, ELIBMAX);
+  DEF_CONST_INT(mod, ELIBEXEC);
+  DEF_CONST_INT(mod, EILSEQ);
+  DEF_CONST_INT(mod, ERESTART);
+  DEF_CONST_INT(mod, ESTRPIPE);
+  DEF_CONST_INT(mod, EUSERS);
+  DEF_CONST_INT(mod, ENOTSOCK);
+  DEF_CONST_INT(mod, EDESTADDRREQ);
+  DEF_CONST_INT(mod, EMSGSIZE);
+  DEF_CONST_INT(mod, EPROTOTYPE);
+  DEF_CONST_INT(mod, ENOPROTOOPT);
+  DEF_CONST_INT(mod, EPROTONOSUPPORT);
+  DEF_CONST_INT(mod, ESOCKTNOSUPPORT);
+  DEF_CONST_INT(mod, EOPNOTSUPP);
+  DEF_CONST_INT(mod, EPFNOSUPPORT);
+  DEF_CONST_INT(mod, EAFNOSUPPORT);
+  DEF_CONST_INT(mod, EADDRINUSE);
+  DEF_CONST_INT(mod, EADDRNOTAVAIL);
+  DEF_CONST_INT(mod, ENETDOWN);
+  DEF_CONST_INT(mod, ENETUNREACH);
+  DEF_CONST_INT(mod, ENETRESET);
+  DEF_CONST_INT(mod, ECONNABORTED);
+  DEF_CONST_INT(mod, ECONNRESET);
+  DEF_CONST_INT(mod, ENOBUFS);
+  DEF_CONST_INT(mod, EISCONN);
+  DEF_CONST_INT(mod, ENOTCONN);
+  DEF_CONST_INT(mod, ESHUTDOWN);
+  DEF_CONST_INT(mod, ETOOMANYREFS);
+  DEF_CONST_INT(mod, ETIMEDOUT);
+  DEF_CONST_INT(mod, ECONNREFUSED);
+  DEF_CONST_INT(mod, EHOSTDOWN);
+  DEF_CONST_INT(mod, EHOSTUNREACH);
+  DEF_CONST_INT(mod, EALREADY);
+  DEF_CONST_INT(mod, EINPROGRESS);
+  DEF_CONST_INT(mod, ESTALE);
+  DEF_CONST_INT(mod, EUCLEAN);
+  DEF_CONST_INT(mod, ENOTNAM);
+  DEF_CONST_INT(mod, ENAVAIL);
+  DEF_CONST_INT(mod, EISNAM);
+  DEF_CONST_INT(mod, EREMOTEIO);
+  DEF_CONST_INT(mod, EDQUOT);
+  DEF_CONST_INT(mod, ENOMEDIUM);
+  DEF_CONST_INT(mod, EMEDIUMTYPE);
+  DEF_CONST_INT(mod, ECANCELED);
+  DEF_CONST_INT(mod, ENOKEY);
+  DEF_CONST_INT(mod, EKEYEXPIRED);
+  DEF_CONST_INT(mod, EKEYREVOKED);
+  DEF_CONST_INT(mod, EKEYREJECTED);
+  DEF_CONST_INT(mod, EOWNERDEAD);
+  DEF_CONST_INT(mod, ENOTRECOVERABLE);
+
+}

data/ext/um/um_ext.c

@@ -1,5 +1,13 @@
 void Init_UM();
+void Init_Mutex();
+void Init_Queue();
+void Init_AsyncOp();
+void Init_SSL();
 
 void Init_um_ext(void) {
   Init_UM();
+  Init_Mutex();
+  Init_Queue();
+  Init_AsyncOp();
+  // Init_SSL();
 }

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);
+}