uringmachine 0.24.0 → 0.26.0

data/ext/um/um_const.c

@@ -14,10 +14,15 @@
 #include <net/if.h>
 #include <poll.h>
 #include <signal.h>
+#include <sys/inotify.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, STDIN_FILENO);
+  DEF_CONST_INT(mod, STDOUT_FILENO);
+  DEF_CONST_INT(mod, STDERR_FILENO);
+
   DEF_CONST_INT(mod, AT_FDCWD);
   DEF_CONST_INT(mod, AT_EMPTY_PATH);
   DEF_CONST_INT(mod, AT_NO_AUTOMOUNT);
@@ -437,4 +442,30 @@ void um_define_net_constants(VALUE mod) {
   DEF_CONST_INT(mod, SIGUSR2);
   DEF_CONST_INT(mod, SIGPWR);
   DEF_CONST_INT(mod, SIGPOLL);
+
+  DEF_CONST_INT(mod, IN_ACCESS);
+  DEF_CONST_INT(mod, IN_ATTRIB);
+  DEF_CONST_INT(mod, IN_CLOSE_WRITE);
+  DEF_CONST_INT(mod, IN_CLOSE_NOWRITE);
+  DEF_CONST_INT(mod, IN_CREATE);
+  DEF_CONST_INT(mod, IN_DELETE);
+  DEF_CONST_INT(mod, IN_DELETE_SELF);
+  DEF_CONST_INT(mod, IN_MODIFY);
+  DEF_CONST_INT(mod, IN_MOVE_SELF);
+  DEF_CONST_INT(mod, IN_MOVED_FROM);
+  DEF_CONST_INT(mod, IN_MOVED_TO);
+  DEF_CONST_INT(mod, IN_OPEN);
+  DEF_CONST_INT(mod, IN_ALL_EVENTS);
+  DEF_CONST_INT(mod, IN_MOVE);
+  DEF_CONST_INT(mod, IN_CLOSE);
+  DEF_CONST_INT(mod, IN_DONT_FOLLOW);
+  DEF_CONST_INT(mod, IN_EXCL_UNLINK);
+  DEF_CONST_INT(mod, IN_MASK_ADD);
+  DEF_CONST_INT(mod, IN_ONESHOT);
+  DEF_CONST_INT(mod, IN_ONLYDIR);
+  DEF_CONST_INT(mod, IN_MASK_CREATE);
+  DEF_CONST_INT(mod, IN_IGNORED);
+  DEF_CONST_INT(mod, IN_ISDIR);
+  DEF_CONST_INT(mod, IN_Q_OVERFLOW);
+  DEF_CONST_INT(mod, IN_UNMOUNT);
 }

data/ext/um/um_mutex_class.c

@@ -1,6 +1,13 @@
 #include "um.h"
 #include <stdlib.h>
 
+/*
+ * Document-class: UringMachine::Mutex
+ *
+ * A futex-based Mutex implementation for controlling access to a shared
+ * resource. The mutex can be used by calling `UringMachine#synchronize`.
+ */
+
 VALUE cMutex;
 
 static const rb_data_type_t Mutex_type = {
@@ -25,6 +32,11 @@ inline struct um_mutex *Mutex_data(VALUE self) {
   return mutex;
 }
 
+/* Initializes a new mutex instance. The mutex can be used by calling
+`UringMachine#synchronize`.
+ *
+ * @return [void]
+ */
 VALUE Mutex_initialize(VALUE self) {
   struct um_mutex *mutex = Mutex_data(self);
   um_mutex_init(mutex);

data/ext/um/um_op.c

@@ -37,7 +37,6 @@ const char * um_op_kind_name(enum um_op_kind kind) {
     case OP_READ_MULTISHOT:     return "OP_READ_MULTISHOT";
     case OP_RECV_MULTISHOT:     return "OP_RECV_MULTISHOT";
     case OP_TIMEOUT_MULTISHOT:  return "OP_TIMEOUT_MULTISHOT";
-    case OP_SLEEP_MULTISHOT:    return "OP_SLEEP_MULTISHOT";
     default:                    return "UNKNOWN_OP_KIND";
   }
 }
@@ -59,6 +58,7 @@ inline void um_op_transient_add(struct um *machine, struct um_op *op) {
 }
 
 inline void um_op_transient_remove(struct um *machine, struct um_op *op) {
+  op->flags &= ~OP_F_TRANSIENT;
   if (op->prev)
     op->prev->next = op->next;
   if (op->next)
@@ -185,3 +185,17 @@ inline void um_op_free(struct um *machine, struct um_op *op) {
   machine->op_freelist = op;
   machine->metrics.ops_free++;
 }
+
+inline struct um_op *um_op_acquire(struct um *machine) {
+  return um_op_alloc(machine);
+}
+
+inline void um_op_release(struct um *machine, struct um_op *op) {
+  op->ref_count--;
+  if (op->ref_count) return;
+
+  if (op->flags & OP_F_FREE_IOVECS) free(op->iovecs);
+  if (op->flags & OP_F_MULTISHOT)
+    um_op_multishot_results_clear(machine, op);
+  um_op_free(machine, op);
+}

data/ext/um/um_queue_class.c

@@ -1,6 +1,14 @@
 #include "um.h"
 #include <stdlib.h>
 
+/*
+ * Document-class: UringMachine::Queue
+ *
+ * A futex-based Queue implementation. The queue can be manipulated by calling
+ * `UringMachine#push`, `UringMachine#unshift`, `UringMachine#pop` and
+ * `UringMachine#shift`.
+ */
+
 VALUE cQueue;
 
 static void Queue_mark(void *ptr) {
@@ -40,6 +48,10 @@ inline struct um_queue *Queue_data(VALUE self) {
   return queue;
 }
 
+/* Initializes a new queue instance.
+ *
+ * @return [void]
+ */
 VALUE Queue_initialize(VALUE self) {
   struct um_queue *queue = Queue_data(self);
   RB_OBJ_WRITE(self, &queue->self, self);
@@ -47,6 +59,10 @@ VALUE Queue_initialize(VALUE self) {
   return self;
 }
 
+/* Returns the number of items in the queue.
+ *
+ * @return [Integer] number of items in the queue
+ */
 VALUE Queue_count(VALUE self) {
   struct um_queue *queue = Queue_data(self);
   return UINT2NUM(queue->count);

data/ext/um/um_ssl.c

@@ -0,0 +1,109 @@
+#include "um.h"
+#include <openssl/ssl.h>
+#include <openssl/bio.h>
+
+#define IDX_BIO_DATA_MACHINE  1
+#define IDX_BIO_DATA_FD       2
+
+static int um_bio_read(BIO *bio, char *buf, int blen)
+{
+  struct um *machine = (struct um *)BIO_get_ex_data(bio, IDX_BIO_DATA_MACHINE);
+  long fd = (long)BIO_get_ex_data(bio, IDX_BIO_DATA_FD);
+  return (int)um_read_raw(machine, fd, buf, blen);
+}
+
+static int um_bio_write(BIO *bio, const char *buf, int blen)
+{
+  struct um *machine = (struct um *)BIO_get_ex_data(bio, IDX_BIO_DATA_MACHINE);
+  long fd = (long)BIO_get_ex_data(bio, IDX_BIO_DATA_FD);
+  return (int)um_write_raw(machine, fd, buf, blen);
+}
+
+static long um_bio_ctrl(BIO *bio, int cmd, long num, void *ptr)
+{
+  switch(cmd) {
+    case BIO_CTRL_GET_CLOSE:
+      return (long)BIO_get_shutdown(bio);
+    case BIO_CTRL_SET_CLOSE:
+      BIO_set_shutdown(bio, (int)num);
+      return 1;
+    case BIO_CTRL_FLUSH:
+      // we don't buffer writes, so noop
+      return 1;
+    default:
+      return 0;
+  }
+}
+
+BIO_METHOD *um_ssl_create_bio_method(void)
+{
+  BIO_METHOD *m = BIO_meth_new(BIO_TYPE_MEM, "UringMachine BIO");
+  if(m) {
+    BIO_meth_set_write(m, &um_bio_write);
+    BIO_meth_set_read(m, &um_bio_read);
+    BIO_meth_set_ctrl(m, &um_bio_ctrl);
+  }
+  else
+    rb_raise(eUMError, "Failed to set SSL BIO");
+  return m;
+}
+
+
+static BIO_METHOD *um_bio_method = NULL;
+static ID id_ivar_um_bio;
+
+void um_ssl_set_bio(struct um *machine, VALUE ssl_obj)
+{
+  if (!um_bio_method) {
+    um_bio_method = um_ssl_create_bio_method();
+    id_ivar_um_bio = rb_intern_const("@__um_bio__");
+  }
+
+  long fd = NUM2LONG(rb_funcall(ssl_obj, rb_intern_const("fileno"), 0));
+  rb_ivar_set(ssl_obj, id_ivar_um_bio, Qtrue);
+
+  BIO *bio = BIO_new(um_bio_method);
+  if(!bio)
+    rb_raise(eUMError, "Failed to create custom BIO");
+
+  int ret = BIO_set_ex_data(bio, IDX_BIO_DATA_MACHINE, (void *)machine);
+  if (!ret)
+    rb_raise(eUMError, "Failed to set BIO metadata");
+
+  ret = BIO_set_ex_data(bio, IDX_BIO_DATA_FD, (void *)fd);
+  if (!ret)
+    rb_raise(eUMError, "Failed to set BIO metadata");
+
+  SSL *ssl = RTYPEDDATA_GET_DATA(ssl_obj);
+  BIO_up_ref(bio);
+  SSL_set0_rbio(ssl, bio);
+  SSL_set0_wbio(ssl, bio);
+}
+
+int um_ssl_read(struct um *machine, VALUE ssl_obj, VALUE buf, int maxlen) {
+  SSL *ssl = RTYPEDDATA_GET_DATA(ssl_obj);
+  void *ptr = um_prepare_read_buffer(buf, maxlen, 0);
+  int ret = SSL_read(ssl, ptr, maxlen);
+  if (ret > 0) {
+    um_update_read_buffer(buf, 0, ret);
+  }
+  else {
+    rb_raise(eUMError, "Failed to read");
+  }
+  return ret;
+}
+
+int um_ssl_write(struct um *machine, VALUE ssl_obj, VALUE buf, int len) {
+  SSL *ssl = RTYPEDDATA_GET_DATA(ssl_obj);
+  const void *base;
+  size_t size;
+  um_get_buffer_bytes_for_writing(buf, &base, &size, true);
+  if ((len == (int)-1) || (len > (int)size)) len = (int)size;
+  if (unlikely(!len)) return INT2NUM(0);
+
+  int ret = SSL_write(ssl, base, len);
+  if (ret <= 0) {
+    rb_raise(eUMError, "Failed to read");
+  }
+  return ret;
+}

data/ext/um/um_stream.c

@@ -113,7 +113,7 @@ VALUE resp_get_line(struct um_stream *stream, VALUE out_buffer) {
       stream->pos += len + 2;
 
       if (NIL_P(out_buffer)) {
-        VALUE str = rb_str_new(start, len + 1);
+        VALUE str = rb_interned_str(start, len + 1);
         rb_str_set_len(str, len);
         RSTRING_PTR(str)[len] = 0;
         RB_GC_GUARD(str);
@@ -170,7 +170,8 @@ VALUE resp_decode_array(struct um_stream *stream, VALUE out_buffer, ulong len) {
   VALUE array = rb_ary_new2(len);
 
   for (ulong i = 0; i < len; i++) {
-    VALUE value = resp_decode(stream, out_buffer);
+    VALUE buf = rb_str_new(NULL, 100);
+    VALUE value = resp_decode(stream, buf);
     rb_ary_push(array, value);
     RB_GC_GUARD(value);
   }
@@ -180,11 +181,11 @@ VALUE resp_decode_array(struct um_stream *stream, VALUE out_buffer, ulong len) {
 }
 
 static inline VALUE resp_decode_simple_string(char *ptr, ulong len) {
-  return rb_str_new(ptr + 1, len - 1);
+  return rb_interned_str(ptr + 1, len - 1);
 }
 
-static inline VALUE resp_decode_string(struct um_stream *stream, VALUE out_buffer, ulong len) {
-  return resp_get_string(stream, len, out_buffer);
+static inline VALUE resp_decode_string(struct um_stream *stream, ulong len) {
+  return resp_get_string(stream, len, Qnil);
 }
 
 static inline VALUE resp_decode_string_with_encoding(struct um_stream *stream, VALUE out_buffer, ulong len) {
@@ -210,7 +211,7 @@ static inline VALUE resp_decode_simple_error(char *ptr, ulong len) {
   static ID ID_new = 0;
   if (!ID_new) ID_new = rb_intern("new");
 
-  VALUE msg = rb_str_new(ptr + 1, len - 1);
+  VALUE msg = rb_interned_str(ptr + 1, len - 1);
   VALUE err = rb_funcall(eStreamRESPError, ID_new, 1, msg);
   RB_GC_GUARD(msg);
   return err;
@@ -220,7 +221,7 @@ static inline VALUE resp_decode_error(struct um_stream *stream, VALUE out_buffer
   static ID ID_new = 0;
   if (!ID_new) ID_new = rb_intern("new");
 
-  VALUE msg = resp_decode_string(stream, out_buffer, len);
+  VALUE msg = resp_decode_string(stream, len);
   VALUE err = rb_funcall(eStreamRESPError, ID_new, 1, msg);
   RB_GC_GUARD(msg);
   return err;
@@ -251,7 +252,7 @@ VALUE resp_decode(struct um_stream *stream, VALUE out_buffer) {
       return resp_decode_simple_string(ptr, len);
     case '$': // string
       data_len = resp_parse_length_field(ptr, len);
-      return resp_decode_string(stream, out_buffer, data_len);
+      return resp_decode_string(stream, data_len);
     case '=': // string with encoding
       data_len = resp_parse_length_field(ptr, len);
       return resp_decode_string_with_encoding(stream, out_buffer, data_len);

data/ext/um/um_sync.c

@@ -6,35 +6,42 @@
 
 // The value argument is the current (known) futex value.
 void um_futex_wait(struct um *machine, uint32_t *futex, uint32_t value) {
-  struct um_op op;
-  um_prep_op(machine, &op, OP_FUTEX_WAIT, 0);
-  struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
+  struct um_op *op = um_op_acquire(machine);
+  um_prep_op(machine, op, OP_FUTEX_WAIT, 2, 0);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_futex_wait(
     sqe, (uint32_t *)futex, value, FUTEX_BITSET_MATCH_ANY, FUTEX2_SIZE_U32, 0
   );
 
   VALUE ret = um_yield(machine);
-  if (!um_op_completed_p(&op))
-    um_cancel_and_wait(machine, &op);
+
+  if (unlikely(!OP_CQE_DONE_P(op)))
+    um_cancel_op_and_await_cqe(machine, op);
   else {
-    if (op.result.res != -EAGAIN)
-      um_raise_on_error_result(op.result.res);
+    int res = op->result.res;
+    if (res != -EAGAIN) {
+      um_op_release(machine, op);
+      um_raise_on_error_result(res);
+    }
   }
+  um_op_release(machine, op);
 
   RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
 }
 
 void um_futex_wake(struct um *machine, uint32_t *futex, uint32_t num_waiters) {
-  struct um_op op;
-  um_prep_op(machine, &op, OP_FUTEX_WAKE, 0);
-  struct io_uring_sqe *sqe = um_get_sqe(machine, &op);
+  struct um_op *op = um_op_acquire(machine);
+  um_prep_op(machine, op, OP_FUTEX_WAKE, 2, 0);
+  struct io_uring_sqe *sqe = um_get_sqe(machine, op);
   io_uring_prep_futex_wake(
     sqe, (uint32_t *)futex, num_waiters, FUTEX_BITSET_MATCH_ANY, FUTEX2_SIZE_U32, 0
   );
 
   VALUE ret = um_yield(machine);
-  um_check_completion(machine, &op);
+
+  um_verify_op_completion(machine, op, true);
+  um_op_release(machine, op);
 
   RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);

data/ext/um/um_utils.c

@@ -17,21 +17,20 @@ inline double um_timestamp_to_double(__s64 tv_sec, __u32 tv_nsec) {
   return (double)tv_sec + ((double)tv_nsec) / 1000000000;
 }
 
-inline double um_get_time_cpu() {
+inline double um_get_time_cpu(void) {
   struct timespec ts;
   if (clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts)) return -1.0;
 
   return um_timestamp_to_double(ts.tv_sec, ts.tv_nsec);
 }
 
-inline double um_get_time_monotonic() {
+inline double um_get_time_monotonic(void) {
   struct timespec ts;
   if (clock_gettime(CLOCK_MONOTONIC, &ts)) return -1.0;
 
   return um_timestamp_to_double(ts.tv_sec, ts.tv_nsec);
 }
 
-
 #define RAISE_EXCEPTION(e) rb_funcall(e, ID_invoke, 0);
 
 inline int um_value_is_exception_p(VALUE v) {
@@ -93,21 +92,27 @@ static inline void adjust_read_buffer_len(VALUE buffer, int result, ssize_t ofs)
   }
 }
 
-inline void um_update_read_buffer(struct um *machine, VALUE buffer, ssize_t buffer_offset, __s32 result, __u32 flags) {
+inline void um_update_read_buffer(VALUE buffer, ssize_t buffer_offset, __s32 result) {
   if (!result) return;
 
   adjust_read_buffer_len(buffer, result, buffer_offset);
 }
 
-inline void um_get_buffer_bytes_for_writing(VALUE buffer, const void **base, size_t *size) {
+// returns false if buffer is invalid and raise_on_bad_buffer is false
+inline int um_get_buffer_bytes_for_writing(VALUE buffer, const void **base, size_t *size, int raise_on_bad_buffer) {
   if (TYPE(buffer) == T_STRING) {
     *base = RSTRING_PTR(buffer);
     *size = RSTRING_LEN(buffer);
   }
   else if (IO_BUFFER_P(buffer))
     rb_io_buffer_get_bytes_for_reading(buffer, base, size); // reading *from* buffer
-  else
-    um_raise_internal_error("Invalid buffer provided");
+  else {
+    if (raise_on_bad_buffer)
+      um_raise_internal_error("Invalid buffer provided");
+    else
+      return false;
+  }
+  return true;
 }
 
 int um_setup_buffer_ring(struct um *machine, unsigned size, unsigned count) {
@@ -205,7 +210,11 @@ inline struct iovec *um_alloc_iovecs_for_writing(int argc, VALUE *argv, size_t *
   size_t len = 0;
 
   for (int i = 0; i < argc; i++) {
-    um_get_buffer_bytes_for_writing(argv[i], (const void **)&iovecs[i].iov_base, &iovecs[i].iov_len);
+    int ok = um_get_buffer_bytes_for_writing(argv[i], (const void **)&iovecs[i].iov_base, &iovecs[i].iov_len, false);
+    if (unlikely(!ok)) {
+      free(iovecs);
+      um_raise_internal_error("Invalid buffer provided");
+    }
     len += iovecs[i].iov_len;
   }
   if (total_len) *total_len = len;

data/grant-2025/interim-report.md

@@ -1,6 +1,6 @@
 # Interim Report for Ruby Association Grant Program 2025
 
-## Project Summary 
+## Project Summary
 
 Io_uring is a relatively new Linux API, permitting the invocation of Linux
 system calls asynchronously. UringMachine is a gem that brings low-level access

data/grant-2025/journal.md

@@ -574,7 +574,7 @@ Ruby I/O layer. Some interesting warts in the Ruby `IO` implementation:
 - Implemented sidecar mode - the basic idea is that UringMachine starts an
   auxiliary thread that loops entering the kernel with a call to
   `io_uring_enter` in order to make CQEs available. On return from the system
-  call, it signals through a futex that ready CQEs can be processed. 
+  call, it signals through a futex that ready CQEs can be processed.
 
   On fiber switch, the next fiber to run is shifted from the runqueue. If the
   runqueue is empty, the UringMachine will wait for the signal, and then process
@@ -590,7 +590,7 @@ Ruby I/O layer. Some interesting warts in the Ruby `IO` implementation:
 
 # 2026-01-07
 
-- In the last week I've been working on implementing a buffer pool  
+- In the last week I've been working on implementing a buffer pool
   with automatic buffer manangement. I've been contemplating the design for a
   few weeks already, and after the vacation has decided the idea is solid enough
   for me to start writing some code. But let me back up and explain what I'm
@@ -601,7 +601,7 @@ Ruby I/O layer. Some interesting warts in the Ruby `IO` implementation:
   buffers for reading or receiving repeatedly from an fd, letting the
   application know with each CQE which buffer was used and with how much data.
   This is particularly useful when dealing with bursts of incoming data.
-  
+
   The application initiates multishot read/recv operations on each connection,
   and the kernel has at its disposition a pool of application-provided buffers
   it can use whenever a chunk of data is read / received. So the kernel consumes
@@ -631,4 +631,4 @@ Ruby I/O layer. Some interesting warts in the Ruby `IO` implementation:
   ID will continue where the previous one left off. So it's great that buffer
   space can be used fully by the kernel, but the application is required to keep
   track of a "cursor" for each buffer.
-  
+

data/grant-2025/tasks.md

@@ -20,7 +20,7 @@
 
   - [v] Make writev automatically complete partial writes
 
-  - [ ] Add inotify API
+  - [v] Add inotify API
 
     https://www.man7.org/linux/man-pages/man7/inotify.7.html
 
@@ -134,10 +134,12 @@
   - [v] hook for close
   - [ ] hooks for send/recv/sendmsg/recvmsg
 
-- [ ] SSL
-  - [ ] openssl gem: custom BIO?
+- [v] SSL
+  - [v] setup custom BIO
+  - [v] SSL read/write methods
 
-    - curl: https://github.com/curl/curl/blob/5f4cd4c689c822ce957bb415076f0c78e5f474b5/lib/vtls/openssl.c#L786-L803
+- [v] RDoc
+  - [v] Rewrite README to show some examples
 
 - [ ] UringMachine website
   - [ ] domain: uringmachine.dev

data/lib/uringmachine/dns_resolver.rb

@@ -3,7 +3,13 @@
 require 'resolv'
 
 class UringMachine
+  # A basic DNS resolver implementation.
   class DNSResolver
+
+    # Initializes the DNS resolver.
+    #
+    # @param machine [UringMachine] UringMachine instance
+    # @return [void]
     def initialize(machine)
       @machine = machine
       @requests = UM::Queue.new
@@ -12,11 +18,19 @@ class UringMachine
       @last_id = 0
     end
 
+    # Resolves the given hostname.
+    #
+    # @param hostname [String] hostname
+    # @param type [Symbol] DNS record type
+    # @return [String] IP address
     def resolve(hostname, type)
       @machine.push(@requests, [hostname, type, Fiber.current])
       @machine.yield
     end
 
+    private
+
+    # Handles resolve requests as they come.
     def handle_requests_loop
       while true
         hostname, type, fiber = @machine.shift(@requests)
@@ -25,6 +39,9 @@ class UringMachine
       end
     end
 
+    # Returns an array of nameservers.
+    #
+    # @return [Array<String>] name servers
     def get_nameservers
       nameservers = []
       IO.readlines('/etc/resolv.conf').each do |line|
@@ -35,10 +52,16 @@ class UringMachine
       nameservers
     end
 
+    # Returns a DNS socket fd connected to a name server.
+    #
+    # @return [Integer] fd
     def socket_fd
       @socket_fd ||= prepare_socket
     end
 
+    # Prepares a socket fd connected to a name server.
+    #
+    # @return [Integer] fd
     def prepare_socket
       fd = @machine.socket(UM::AF_INET, UM::SOCK_DGRAM, 0, 0)
       @machine.bind(fd, '0.0.0.0', 0)
@@ -46,6 +69,12 @@ class UringMachine
       fd
     end
 
+    # Resolves a DNS query.
+    #
+    # @param hostname [String] hostname
+    # @param type [Symbol] DNS record type
+    # @param try_count [Integer] retry counter
+    # @return [Array<String>] array of addresses
     def do_resolve(hostname, type, try_count = 0)
       fd = socket_fd
       req = prepare_request_packet(hostname, type)
@@ -67,6 +96,11 @@ class UringMachine
       addrs
     end
 
+    # Prepares a request packet.
+    #
+    # @param hostname [String] hostname
+    # @param type [Symbol] DNS record type
+    # @return [Resolv::DNS::Message]
     def prepare_request_packet(hostname, type)
       msg = Resolv::DNS::Message.new
       msg.id = (@last_id += 1)
@@ -75,6 +109,10 @@ class UringMachine
       msg
     end
 
+    # Returns the message type class.
+    #
+    # @param type [Symbol] DNS record type
+    # @return [Class] message type class
     def msg_type(type)
       # TODO: add support for other types
       Resolv::DNS::Resource::IN::A

data/lib/uringmachine/fiber_scheduler.rb

@@ -5,6 +5,7 @@ require 'etc'
 require 'uringmachine'
 
 class UringMachine
+
   # Implements a worker thread pool for running blocking operations. Worker
   # threads are started as needed. Worker thread count is limited to the number
   # of CPU cores available.
@@ -12,6 +13,7 @@ class UringMachine
 
     # Initializes a new worker pool.
     #
+    # @param max_workers [Integer] maximum worker thread count
     # @return [void]
     def initialize(max_workers = Etc.nprocessors)
       @max_workers = max_workers
@@ -71,9 +73,9 @@ class UringMachine
     end
   end
 
-  # UringMachine::FiberScheduler implements the Fiber::Scheduler interface for
-  # creating fiber-based concurrent applications in Ruby, in tight integration
-  # with the standard Ruby I/O and locking APIs.
+  # Implements the `Fiber::Scheduler` interface for creating fiber-based
+  # concurrent applications in Ruby, in tight integration with the standard Ruby
+  # I/O and locking APIs.
   class FiberScheduler
 
     # The blocking operation thread pool is shared by all fiber schedulers.
@@ -198,7 +200,7 @@ class UringMachine
     # @param io [IO] IO object
     # @param events [Number] readiness bitmask
     # @param timeout [Number, nil] optional timeout
-    # @param return
+    # @return [void]
     def io_wait(io, events, timeout = nil)
       timeout ||= io.timeout
       if timeout
@@ -314,7 +316,7 @@ class UringMachine
     #
     # @param io [IO] IO object
     # @param buffer [IO::Buffer] write buffer
-    # @param length [Integer] file offset
+    # @param from [Integer] file offset
     # @param length [Integer] write length
     # @param offset [Integer] buffer offset
     # @return [Integer] bytes written

data/lib/uringmachine/version.rb

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