uringmachine 0.2 → 0.4

data/ext/um/um_class.c

@@ -1,5 +1,5 @@
 #include "um.h"
-#include <sys/mman.h>
+#include <arpa/inet.h>
 
 VALUE cUM;
 
@@ -14,7 +14,7 @@ static void UM_compact(void *ptr) {
 }
 
 static void UM_free(void *ptr) {
-  um_cleanup((struct um *)ptr);
+  um_teardown((struct um *)ptr);
   free(ptr);
 }
 
@@ -43,90 +43,16 @@ inline struct um *get_machine(VALUE self) {
 
 VALUE UM_initialize(VALUE self) {
   struct um *machine = RTYPEDDATA_DATA(self);
-
-  machine->ring_initialized = 0;
-  machine->unsubmitted_count = 0;
-  machine->buffer_ring_count = 0;
-  machine->pending_count = 0;
-  machine->runqueue_head = NULL;
-  machine->runqueue_tail = NULL;
-  machine->freelist_head = NULL;
-
-  unsigned prepared_limit = 4096;
-  int flags = 0;
-  #ifdef HAVE_IORING_SETUP_SUBMIT_ALL
-  flags |= IORING_SETUP_SUBMIT_ALL;
-  #endif
-  #ifdef HAVE_IORING_SETUP_COOP_TASKRUN
-  flags |= IORING_SETUP_COOP_TASKRUN;
-  #endif
-
-  while (1) {
-    int ret = io_uring_queue_init(prepared_limit, &machine->ring, flags);
-    if (likely(!ret)) break;
-
-    // if ENOMEM is returned, try with half as much entries
-    if (unlikely(ret == -ENOMEM && prepared_limit > 64))
-      prepared_limit = prepared_limit / 2;
-    else
-      rb_syserr_fail(-ret, strerror(-ret));
-  }
-  machine->ring_initialized = 1;
-
+  um_setup(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);
@@ -185,6 +111,89 @@ VALUE UM_read_each(VALUE self, VALUE fd, VALUE bgid) {
   return um_read_each(machine, NUM2INT(fd), NUM2INT(bgid));
 }
 
+VALUE UM_write(int argc, VALUE *argv, VALUE self) {
+  struct um *machine = get_machine(self);
+  VALUE fd;
+  VALUE buffer;
+  VALUE len;
+  rb_scan_args(argc, argv, "21", &fd, &buffer, &len);
+
+  int bytes = NIL_P(len) ? RSTRING_LEN(buffer) : NUM2INT(len);
+  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));
+}
+
+VALUE UM_accept_each(VALUE self, VALUE fd) {
+  struct um *machine = 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);
+  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_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
+}
+
 void Init_UM(void) {
   rb_ext_ractor_safe(true);
 
@@ -204,44 +213,17 @@ void Init_UM(void) {
   rb_define_method(cUM, "sleep", UM_sleep, 1);
   rb_define_method(cUM, "read", UM_read, -1);
   rb_define_method(cUM, "read_each", UM_read_each, 2);
-
-  // 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, "write", UM_write, -1);
+  rb_define_method(cUM, "close", UM_close, 1);
+
+  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, "listen", UM_listen, 2);
+
+  um_define_net_constants(cUM);
 }

data/ext/um/um_const.c

@@ -0,0 +1,184 @@
+#include "ruby.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, 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_op.c

@@ -1,17 +1,33 @@
 #include "um.h"
 
+inline struct um_result_entry *um_result_checkout(struct um *machine) {
+  if (machine->result_freelist) {
+    struct um_result_entry *entry = machine->result_freelist;
+    machine->result_freelist = entry->next;
+    return entry;
+  }
+
+  struct um_result_entry *entry = malloc(sizeof(struct um_result_entry));
+  return entry;
+}
+
+inline void um_result_checkin(struct um *machine, struct um_result_entry *entry) {
+  entry->next = machine->result_freelist;
+  machine->result_freelist = entry;
+}
+
 inline void um_op_result_cleanup(struct um *machine, struct um_op *op) {
   struct um_result_entry *entry = op->results_head;
   while (entry) {
     struct um_result_entry *next = entry->next;
-    free(entry);
+    um_result_checkin(machine, entry);
     entry = next;
   }
   op->results_head = op->results_tail = NULL;
 }
 
-inline void um_op_result_push(struct um *machine, struct um_op *op, int result, int flags) {
-  struct um_result_entry *entry = malloc(sizeof(struct um_result_entry));
+inline void um_op_result_push(struct um *machine, struct um_op *op, __s32 result, __u32 flags) {
+  struct um_result_entry *entry = um_result_checkout(machine);
   entry->next = 0;
   entry->result = result;
   entry->flags = flags;
@@ -24,7 +40,7 @@ inline void um_op_result_push(struct um *machine, struct um_op *op, int result,
   }
 }
 
-inline int um_op_result_shift(struct um *machine, struct um_op *op, int *result, int *flags) {
+inline int um_op_result_shift(struct um *machine, struct um_op *op, __s32 *result, __u32 *flags) {
   if (!op->results_head) return 0;
 
   struct um_result_entry *entry = op->results_head;
@@ -33,7 +49,7 @@ inline int um_op_result_shift(struct um *machine, struct um_op *op, int *result,
   op->results_head = entry->next;
   if (!op->results_head)
     op->results_tail = NULL;
-  free(entry);
+  um_result_checkin(machine, entry);
   return 1;
 }
 
@@ -45,25 +61,22 @@ inline void um_op_clear(struct um_op *op) {
 inline struct um_op *um_op_checkout(struct um *machine) {
   machine->pending_count++;
 
-  if (machine->freelist_head) {
-    struct um_op *op = machine->freelist_head;
-    machine->freelist_head = op->next;
-    um_op_clear(op);
-    return op;
-  }
+  struct um_op *op = machine->op_freelist;
+  if (op)
+    machine->op_freelist = op->next;
+  else
+    op = malloc(sizeof(struct um_op));
 
-  struct um_op *op = malloc(sizeof(struct um_op));
   um_op_clear(op);
   return op;
 }
 
 inline void um_op_checkin(struct um *machine, struct um_op *op) {
-  um_op_result_cleanup(machine, op);
-
   machine->pending_count--;
 
-  op->next = machine->freelist_head;
-  machine->freelist_head = op;
+  um_op_result_cleanup(machine, op);
+  op->next = machine->op_freelist;
+  machine->op_freelist = op;
 }
 
 inline struct um_op *um_runqueue_find_by_fiber(struct um *machine, VALUE fiber) {
@@ -108,7 +121,7 @@ inline struct um_op *um_runqueue_shift(struct um *machine) {
 
   op->prev = NULL;
   if (!op->next) {
-    machine->runqueue_head = machine->runqueue_tail = NULL;    
+    machine->runqueue_head = machine->runqueue_tail = NULL;
   }
   else {
     machine->runqueue_head = op->next;
@@ -117,7 +130,7 @@ inline struct um_op *um_runqueue_shift(struct um *machine) {
   return op;
 }
 
-inline void um_free_linked_list(struct um *machine, struct um_op *op) {
+inline void um_free_op_linked_list(struct um *machine, struct um_op *op) {
   while (op) {
     struct um_op *next = op->next;
     um_op_result_cleanup(machine, op);
@@ -125,3 +138,11 @@ inline void um_free_linked_list(struct um *machine, struct um_op *op) {
     op = next;
   }
 }
+
+inline void um_free_result_linked_list(struct um *machine, struct um_result_entry *entry) {
+  while (entry) {
+    struct um_result_entry *next = entry->next;
+    free(entry);
+    entry = next;
+  }
+}

data/ext/um/um_utils.c

@@ -1,4 +1,6 @@
 #include "um.h"
+#include <sys/mman.h>
+#include <stdlib.h>
 
 inline struct __kernel_timespec um_double_to_timespec(double value) {
   double integral;
@@ -46,13 +48,56 @@ static inline void adjust_read_buffer_len(VALUE buffer, int result, int ofs) {
   rb_str_set_len(buffer, len + (unsigned)ofs);
 }
 
-inline void um_update_read_buffer(struct um *machine, VALUE buffer, int buffer_offset, int result, int flags) {
+inline void um_update_read_buffer(struct um *machine, VALUE buffer, int buffer_offset, __s32 result, __u32 flags) {
   if (!result) return;
 
   adjust_read_buffer_len(buffer, result, buffer_offset);
 }
 
-inline VALUE get_string_from_buffer_ring(struct um *machine, int bgid, int result, int flags) {
+int um_setup_buffer_ring(struct um *machine, unsigned size, unsigned count) {
+  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 = count;
+  desc->buf_size = 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;
+  int ret;
+  desc->br = io_uring_setup_buf_ring(&machine->ring, count, bg_id, 0, &ret);
+  if (!desc->br) {
+    munmap(desc->br, desc->br_size);
+    rb_syserr_fail(ret, strerror(ret));
+  }
+
+  if (posix_memalign(&desc->buf_base, 4096, desc->buf_count * desc->buf_size)) {
+    io_uring_free_buf_ring(&machine->ring, desc->br, desc->buf_count, bg_id);
+    rb_raise(rb_eRuntimeError, "Failed to allocate buffers");
+  }
+
+  desc->buf_mask = io_uring_buf_ring_mask(desc->buf_count);
+  void *ptr = desc->buf_base;
+  for (unsigned i = 0; i < desc->buf_count; i++) {
+		io_uring_buf_ring_add(desc->br, ptr, desc->buf_size, i, desc->buf_mask, i);
+    ptr += desc->buf_size;
+	}
+	io_uring_buf_ring_advance(desc->br, desc->buf_count);
+  machine->buffer_ring_count++;
+  return bg_id;
+}
+
+inline VALUE um_get_string_from_buffer_ring(struct um *machine, int bgid, __s32 result, __u32 flags) {
   if (!result) return Qnil;
 
   unsigned buf_idx = flags >> IORING_CQE_BUFFER_SHIFT;
@@ -64,7 +109,7 @@ inline VALUE get_string_from_buffer_ring(struct um *machine, int bgid, int resul
 
   // add buffer back to buffer ring
   io_uring_buf_ring_add(
-    desc->br, src, desc->buf_size, buf_idx, io_uring_buf_ring_mask(desc->buf_count), 0
+    desc->br, src, desc->buf_size, buf_idx, desc->buf_mask, 0
   );
   io_uring_buf_ring_advance(desc->br, 1);
 

data/lib/uringmachine/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class UringMachine
-  VERSION = '0.2'
+  VERSION = '0.4'
 end

data/lib/uringmachine.rb

@@ -3,3 +3,15 @@
 require_relative './um_ext'
 
 UM = UringMachine
+
+class UringMachine
+  def spin(value = nil, &block)
+    Fiber.new do |resume_value| 
+      block.(resume_value)
+    rescue Exception => e
+      raise RuntimeError, "Unhandled fiber exception: #{e.inspect}"
+    ensure
+      self.yield
+    end.tap { |f| schedule(f, value) }
+  end
+end