uringmachine 0.16 → 0.19

data/ext/um/um_const.c

@@ -12,7 +12,7 @@
 #include <netinet/udp.h>
 #include <netdb.h>
 #include <net/if.h>
-
+#include <poll.h>
 
 #define DEF_CONST_INT(mod, v) rb_define_const(mod, #v, INT2NUM(v))
 
@@ -258,6 +258,10 @@ void um_define_net_constants(VALUE mod) {
 
   DEF_CONST_INT(mod, SOMAXCONN);
 
+  DEF_CONST_INT(mod, POLLIN);
+  DEF_CONST_INT(mod, POLLOUT);
+  DEF_CONST_INT(mod, POLLERR);
+
   DEF_CONST_INT(mod, EPERM);
   DEF_CONST_INT(mod, ENOENT);
   DEF_CONST_INT(mod, ESRCH);
@@ -387,5 +391,4 @@ void um_define_net_constants(VALUE mod) {
   DEF_CONST_INT(mod, EKEYREJECTED);
   DEF_CONST_INT(mod, EOWNERDEAD);
   DEF_CONST_INT(mod, ENOTRECOVERABLE);
-
 }

data/ext/um/um_stream.c

@@ -26,7 +26,7 @@ int stream_read_more(struct um_stream *stream) {
   size_t capa = rb_str_capacity(stream->buffer);
   if (capa - stream->pos < maxlen)
     rb_str_modify_expand(stream->buffer, maxlen - (capa - stream->pos));
-  
+
   rb_str_modify(stream->buffer);
   char *ptr = RSTRING_PTR(stream->buffer) + stream->pos;
   size_t ret = um_read_raw(stream->machine, stream->fd, ptr, maxlen);
@@ -94,7 +94,7 @@ VALUE stream_get_string(struct um_stream *stream, VALUE buf, ssize_t len) {
 
       abslen = stream->len - stream->pos;
     }
-  
+
   char *start = RSTRING_PTR(stream->buffer) + stream->pos;
   stream->pos += abslen;
 
@@ -137,7 +137,7 @@ VALUE resp_get_string(struct um_stream *stream, ulong len, VALUE out_buffer) {
 
   while (stream->len - stream->pos < read_len)
     if (!stream_read_more(stream)) return Qnil;
-  
+
   char *start = RSTRING_PTR(stream->buffer) + stream->pos;
   stream->pos += read_len;
 
@@ -198,7 +198,7 @@ static inline VALUE resp_decode_string_with_encoding(struct um_stream *stream, V
 
 static inline VALUE resp_decode_integer(char *ptr) {
   long value = strtol(ptr + 1, NULL, 10);
-  return LONG2NUM(value);    
+  return LONG2NUM(value);
 }
 
 static inline VALUE resp_decode_float(char *ptr) {
@@ -234,13 +234,13 @@ VALUE resp_decode(struct um_stream *stream, VALUE out_buffer) {
   ulong len = RSTRING_LEN(msg);
   ulong data_len;
   if (len == 0) return Qnil;
-  
+
   switch (ptr[0]) {
     case '%': // hash
     case '|': // attributes hash
       data_len = resp_parse_length_field(ptr, len);
       return resp_decode_hash(stream, out_buffer, data_len);
-    
+
     case '*': // array
     case '~': // set
     case '>': // pub/sub push
@@ -276,7 +276,7 @@ VALUE resp_decode(struct um_stream *stream, VALUE out_buffer) {
     default:
       rb_raise(rb_eRuntimeError, "Invalid character encountered");
   }
-  
+
   RB_GC_GUARD(msg);
 }
 
@@ -284,7 +284,7 @@ void write_buffer_init(struct um_write_buffer *buf, VALUE str) {
   size_t capa = 1 << 12;
   size_t len = RSTRING_LEN(str);
   while (capa < len) capa += 1 << 12;
-  
+
   rb_str_resize(str, capa);
   rb_str_set_len(str, len);
   buf->str = str;

data/ext/um/um_stream_class.c

@@ -88,7 +88,7 @@ void Init_Stream(void) {
   rb_define_alloc_func(cStream, Stream_allocate);
 
   rb_define_method(cStream, "initialize", Stream_initialize, 2);
-  
+
   rb_define_method(cStream, "get_line", Stream_get_line, 2);
   rb_define_method(cStream, "get_string", Stream_get_string, 2);
 

data/ext/um/um_sync.c

@@ -21,8 +21,8 @@ void um_futex_wait(struct um *machine, uint32_t *futex, uint32_t expect) {
       um_raise_on_error_result(op.result.res);
   }
 
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  raise_if_exception(ret);
 }
 
 void um_futex_wake(struct um *machine, uint32_t *futex, uint32_t num_waiters) {
@@ -38,8 +38,8 @@ void um_futex_wake(struct um *machine, uint32_t *futex, uint32_t num_waiters) {
   VALUE ret = um_fiber_switch(machine);
   um_check_completion(machine, &op);
 
+  RAISE_IF_EXCEPTION(ret);
   RB_GC_GUARD(ret);
-  raise_if_exception(ret);
 }
 
 void um_futex_wake_transient(struct um *machine, uint32_t *futex, uint32_t num_waiters) {

data/ext/um/um_utils.c

@@ -65,11 +65,11 @@ int um_setup_buffer_ring(struct um *machine, unsigned size, unsigned count) {
   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;
+  desc->buf_mask = io_uring_buf_ring_mask(desc->buf_count);
+
 	void *mapped = mmap(
-    NULL, desc->br_size, PROT_READ | PROT_WRITE,
-		MAP_ANONYMOUS | MAP_PRIVATE, 0, 0
+    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");
@@ -82,21 +82,22 @@ int um_setup_buffer_ring(struct um *machine, unsigned size, unsigned count) {
   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));
+    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");
+  if (size > 0) {
+    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");
+    }
+
+    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);
   }
-
-  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;
 }
@@ -120,3 +121,25 @@ inline VALUE um_get_string_from_buffer_ring(struct um *machine, int bgid, __s32
   RB_GC_GUARD(buf);
   return buf;
 }
+
+inline void um_add_strings_to_buffer_ring(struct um *machine, int bgid, VALUE strings) {
+  static ID ID_to_s = 0;
+
+  struct buf_ring_descriptor *desc = machine->buffer_rings + bgid;
+  ulong count = RARRAY_LEN(strings);
+  VALUE str = Qnil;
+  VALUE converted = Qnil;
+
+  for (ulong i = 0; i < count; i++) {
+    str = rb_ary_entry(strings, i);
+    if (TYPE(str) != T_STRING) {
+      if (!ID_to_s) ID_to_s = rb_intern("to_s");
+      if (NIL_P(converted)) converted = rb_ary_new();
+      str = rb_funcall(str, ID_to_s, 0);
+      rb_ary_push(converted, str);
+    }
+    io_uring_buf_ring_add(desc->br, RSTRING_PTR(str), RSTRING_LEN(str), i, desc->buf_mask, i);
+  }
+  RB_GC_GUARD(converted);
+  io_uring_buf_ring_advance(desc->br, count);
+}

data/lib/uringmachine/fiber_scheduler.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+class UringMachine
+  class FiberScheduler
+    def initialize(machine)
+      @machine = machine
+    end
+
+    def p(o)
+      @machine.write(1, "#{o.inspect}\n")
+    rescue Errno::EINTR
+      retry
+    end
+
+    def join(*)
+      @machine.join(*)
+    end
+
+    def block(blocker, timeout)
+      p block: [blocker, timeout]
+
+    end
+
+    def unblock(blocker, fiber)
+      p unblock: [blocker, fiber]
+    end
+
+    def kernel_sleep(duration = nil)
+      # p sleep: [duration]
+      if duration
+        @machine.sleep(duration)
+      else
+        @machine.yield
+      end
+    end
+
+    def io_wait(io, events, timeout = nil)
+      timeout ||= io.timeout
+      p timeout: timeout
+      if timeout
+        p 1
+        @machine.timeout(timeout, Timeout::Error) {
+          p 2
+          @machine.poll(io.fileno, events).tap { p 3 }
+      }.tap { p 4 }
+      else
+        p 5
+        @machine.poll(io.fileno, events).tap { p 6 }
+
+      end
+    rescue => e
+      p e: e
+      raise
+    end
+
+    def fiber(&block)
+      f = @machine.spin(&block)
+      @machine.snooze
+      f
+    end
+
+    def io_write(io, buffer, length, offset)
+      p io_write: [io, buffer.get_string, length, offset]
+      @machine.write(io.fileno, buffer.get_string)
+    end
+
+    def io_read(io, buffer, length, offset)
+      # p io_read: [io, buffer, length, offset]
+      s = +''
+      length = buffer.size if length == 0
+      bytes = @machine.read(io.fileno, s, length)
+      buffer.set_string(s)
+      bytes
+    rescue SystemCallError => e
+      -e.errno
+    end
+
+    def io_pwrite(io, buffer, from, length, offset)
+      p io_pwrite: [io, buffer, from, length, offset]
+    end
+
+    def io_pread(io, buffer, from, length, offset)
+      p io_pread: [io, buffer, from, length, offset]
+    end
+
+    # def fiber(&block)
+    #   fiber = Fiber.new(blocking: false, &block)
+    #   unblock(nil, fiber)
+    #   # fiber.resume
+    #   return fiber
+    # end
+
+    # def kernel_sleep(duration = nil)
+    #   block(:sleep, duration)
+    # end
+
+    # def process_wait(pid, flags)
+    #   # This is a very simple way to implement a non-blocking wait:
+    #   Thread.new do
+    #     Process::Status.wait(pid, flags)
+    #   end.value
+    # end
+  end
+end

data/lib/uringmachine/version.rb

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

data/test/test_stream.rb

@@ -7,7 +7,7 @@ class StreamBaseTest < UMBaseTest
     super
     @rfd, @wfd = UM.pipe
     @stream = UM::Stream.new(@machine, @rfd)
-  end  
+  end
 end
 
 class StreamTest < StreamBaseTest
@@ -166,7 +166,7 @@ class StreamRespTest < StreamBaseTest
   end
 
   def test_resp_encode
-    s = UM::Stream    
+    s = UM::Stream
     assert_equal "_\r\n",             s.resp_encode(+'', nil)
     assert_equal "#t\r\n",            s.resp_encode(+'', true)
     assert_equal "#f\r\n",            s.resp_encode(+'', false)
@@ -174,7 +174,7 @@ class StreamRespTest < StreamBaseTest
     assert_equal ",42.1\r\n",         s.resp_encode(+'', 42.1)
     assert_equal "$6\r\nfoobar\r\n",  s.resp_encode(+'', 'foobar')
     assert_equal "$10\r\nפובאר\r\n",  s.resp_encode(+'', 'פובאר')
-    
+
     assert_equal "*2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n",
       s.resp_encode(+'', ['foo', 'bar'])
 

data/test/test_um.rb

@@ -169,6 +169,17 @@ class ScheduleTest < UMBaseTest
     assert_equal 0, machine.pending_count
   end
 
+  def test_timeout_with_no_timeout
+    _r, w = UM.pipe
+    v = machine.timeout(0.1, TOError) { machine.write(w, 'foo') }
+
+    assert_equal 3, v
+
+    assert_equal 1, machine.pending_count
+    machine.sleep 0.01 # wait for cancelled CQE
+    assert_equal 0, machine.pending_count
+  end
+
   class TO2Error < RuntimeError; end
   class TO3Error < RuntimeError; end
 
@@ -565,6 +576,22 @@ class WriteAsyncTest < UMBaseTest
     assert_equal 'foo', r.readpartial(3)
   end
 
+  def test_write_async_dynamic_string
+    r, w = IO.pipe
+
+    assert_equal 0, machine.pending_count
+    str = "foo#{123}#{'bar' * 48}"
+    len = str.bytesize
+    machine.write_async(w.fileno, str)
+    str = nil
+    GC.start
+    assert_equal 1, machine.pending_count
+
+    machine.snooze
+    assert_equal 0, machine.pending_count
+    assert_equal "foo#{123}#{'bar' * 48}", r.readpartial(len)
+  end
+
   def test_write_async_bad_fd
     r, _w = IO.pipe
 
@@ -1283,6 +1310,37 @@ class PipeTest < UMBaseTest
   end
 end
 
+class PollTest < UMBaseTest
+  def test_poll
+    rfd, wfd = UM.pipe
+
+    events = []
+    f1 = machine.spin do
+      events << :pre
+      events << machine.poll(rfd, UM::POLLIN)
+      events << :post
+    end
+
+    machine.snooze
+    assert_equal [:pre], events
+
+    machine.write(wfd, 'foo')
+    machine.snooze
+    assert_equal [:pre, UM::POLLIN, :post], events
+
+    ret = machine.poll(wfd, UM::POLLOUT)
+    assert_equal UM::POLLOUT, ret
+
+    machine.close(rfd)
+    ret = machine.poll(wfd, UM::POLLOUT | UM::POLLERR)
+    assert_equal UM::POLLOUT | UM::POLLERR, ret
+  end
+
+  def test_poll_bad_fd
+    assert_raises(Errno::EBADF) { machine.poll(9876, POLLIN) }
+  end
+end
+
 class WaitTest < UMBaseTest
   def test_waitpid
     skip if UM.kernel_version < 607
@@ -1380,6 +1438,17 @@ class StatxTest < UMBaseTest
     io.close
   end
 
+  def test_statx_mask
+    fd = @machine.open(__FILE__, UM::O_RDONLY)
+    ustat = machine.statx(fd, nil, UM::AT_EMPTY_PATH, UM::STATX_MTIME | UM::STATX_SIZE)
+    rstat = File.stat(__FILE__)
+
+    assert_equal rstat.size,        ustat[:size]
+    assert_equal rstat.mtime.to_i,  ustat[:mtime].to_i
+  ensure
+    @machine.close_async(fd)
+  end
+
   def test_statx_bad_path
     assert_raises(Errno::ENOENT) { machine.statx(UM::AT_FDCWD, 'foobar', 0, UM::STATX_ALL) }
   end
@@ -1417,5 +1486,65 @@ class ForkTest < UMBaseTest
   ensure
     Process.wait(child_pid) rescue Errno::ECHILD
   end
+end
+
+class SendBundleTest < UMBaseTest
+  def setup
+    super
+    @client_fd, @server_fd = make_socket_pair
+  end
+
+  def test_send_bundle_splat
+    skip if UringMachine.kernel_version < 610
+
+    bgid = machine.setup_buffer_ring(0, 8)
+    assert_equal 0, bgid
+
+    strs = ['foo', 'bar', 'bazzzzz']
+    len = strs.inject(0) { |len, s| len + s.bytesize }
+
+    ret = machine.send_bundle(@client_fd, bgid, *strs)
+    assert_equal len, ret
+
+    buf = +''
+    ret = machine.recv(@server_fd, buf, 8192, 0)
+    assert_equal len, ret
+    assert_equal strs.join, buf
+  end
+
+  def test_send_bundle_array
+    skip if UringMachine.kernel_version < 610
+
+    bgid = machine.setup_buffer_ring(0, 8)
+    assert_equal 0, bgid
+
+    strs = ['foo', 'bar', 'bazzzzz']
+    len = strs.inject(0) { |len, s| len + s.bytesize }
+
+    ret = machine.send_bundle(@client_fd, bgid, strs)
+    assert_equal len, ret
+
+    buf = +''
+    ret = machine.recv(@server_fd, buf, 8192, 0)
+    assert_equal len, ret
+    assert_equal strs.join, buf
+  end
+
+  def test_send_bundle_non_strings
+    skip if UringMachine.kernel_version < 610
+
+    bgid = machine.setup_buffer_ring(0, 8)
+    assert_equal 0, bgid
 
+    strs = [42, 'bar', false]
+    len = strs.inject(0) { |len, s| len + s.to_s.bytesize }
+
+    ret = machine.send_bundle(@client_fd, bgid, strs)
+    assert_equal len, ret
+
+    buf = +''
+    ret = machine.recv(@server_fd, buf, 8192, 0)
+    assert_equal len, ret
+    assert_equal strs.map(&:to_s).join, buf
+  end
 end

data/vendor/libressl/.github/scripts/changelog.sh

@@ -0,0 +1,74 @@
+#!/bin/sh
+# Copyright (c) 2023 Joshua Sing <joshua@hypera.dev>
+#
+# Permission to use, copy, modify, and distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+#
+# Usage: changelog.sh <version>
+#  Reads the changelog for the specified version from the changelog file.
+#  The output will be reformatted for use in GitHub releases.
+#
+#  The changelog file defaults to "ChangeLog", but can be changed by setting
+#  the environment variable $CHANGELOG_FILE
+#
+
+set -e
+
+# Check if the version argument is provided
+if [ "$#" -ne 1 ]; then
+    echo "Usage: $0 <version>" 1>&2
+    exit 1
+fi
+
+version="${1#v}"
+changelog_file="${CHANGELOG_FILE:-ChangeLog}"
+found_version=false
+changelog=""
+
+# Check if the specified changelog file exists
+if [ ! -f "$changelog_file" ]; then
+    echo "Error: Changelog file '$changelog_file' not found" 1>&2
+    exit 1
+fi
+
+# Read the changelog file line by line
+while IFS= read -r line; do
+    # Check for the version line
+    if echo "$line" | grep -Eq "^${version} - "; then
+      found_version=true
+      continue
+    fi
+
+    # Continue reading the changelog until the next version or end of file,
+    # skipping empty lines
+    if $found_version; then
+      echo "$line" | grep -Eq "^\s*$" && continue
+      echo "$line" | grep -Eq "^[0-9]+\.[0-9]+\.[0-9]+ - " && break
+      changelog="${changelog}${line}\n"
+    fi
+done < "$changelog_file"
+
+# If the specified version was not found, print an error
+if ! $found_version; then
+    echo "Error: Version $version was not found in changelog" 1>&2
+    exit 1
+fi
+
+# Tidy up the changelog for displaying on GitHub
+changelog=$(echo "$changelog" | sed -e 's/^\t\*/###/' -e 's/^\t//')
+
+# Print the changelog for the specified version
+echo "$changelog"
+echo
+echo "Full changelog: https://github.com/libressl/portable/blob/master/ChangeLog"
+exit 0

data/vendor/libressl/.github/workflows/android.yml

@@ -0,0 +1,35 @@
+# GitHub Actions workflow to run tests on Android.
+name: "Android"
+
+on: [push, pull_request]
+
+concurrency:
+  group: "${{ github.workflow }}-${{ github.event.number || github.ref }}"
+  cancel-in-progress: true
+
+jobs:
+  test:
+    name: "Test ${{ matrix.name }}"
+    runs-on: ubuntu-24.04
+    permissions:
+      contents: read
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - name: "Android 8-9"
+            min-nal: 26
+            max-nal: 28
+          - name: "Android 10-11"
+            min-nal: 29
+            max-nal: 30
+    steps:
+      - name: "Checkout repository"
+        uses: actions/checkout@v4
+
+      - name: "Run CI script"
+        run: ./scripts/test
+        env:
+          ARCH: "android"
+          MIN_NAL: "${{ matrix.min-nal }}"
+          MAX_NAL: "${{ matrix.max-nal }}"

data/vendor/libressl/.github/workflows/cifuzz.yml

@@ -0,0 +1,33 @@
+name: CIFuzz
+
+on:
+  workflow_dispatch:
+
+concurrency:
+  group: "${{ github.workflow }}-${{ github.event.number || github.ref }}"
+  cancel-in-progress: true
+
+jobs:
+  Fuzzing:
+    runs-on: ubuntu-24.04
+    steps:
+    - name: Build Fuzzers
+      id: build
+      uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'libressl'
+        dry-run: false
+        language: c++
+    - name: Run Fuzzers
+      uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master
+      with:
+        oss-fuzz-project-name: 'libressl'
+        fuzz-seconds: 300
+        dry-run: false
+        language: c++
+    - name: Upload Crash
+      uses: actions/upload-artifact@v4
+      if: failure() && steps.build.outcome == 'success'
+      with:
+        name: artifacts
+        path: ./out/artifacts