uringmachine 0.22.1 → 0.23.0

data/test/test_um.rb

@@ -39,7 +39,7 @@ class SQPOLLTest < Minitest::Test
     m.write_async(w, 'foo')
 
     # thread should timeout
-    ret = t.join(0.03)
+    t.join(0.03)
     assert_nil buf
   ensure
     t.kill rescue nil
@@ -220,31 +220,6 @@ class ScheduleTest < UMBaseTest
     assert_kind_of TOError, e
   end
 
-  def test_timeout_stress
-    skip
-    # GC.stress = true
-    c = 0
-    fs = 100.times.map {
-      machine.spin {
-        q = UM::Queue.new
-        1000.times {
-          machine.sleep rand(0.001..0.005)
-          begin
-            machine.timeout(rand(0.001..0.06), TOError) do
-              machine.shift(q)
-            end
-          rescue => _e
-            c += 1
-            STDOUT << '*' if c % 1000 == 0
-          end
-        }
-      }
-    }
-    machine.join(*fs)
-  ensure
-    GC.stress = false
-  end
-
   def test_timeout_with_raising_block
     e = nil
     begin
@@ -580,8 +555,6 @@ end
 
 class ReadEachTest < UMBaseTest
   def test_read_each
-    skip if UringMachine.kernel_version < 607
-
     r, w = IO.pipe
     bufs = []
     bgid = machine.setup_buffer_ring(4096, 1024)
@@ -610,8 +583,6 @@ class ReadEachTest < UMBaseTest
 
   # send once and close write fd
   def test_read_each_raising_1
-    skip if UringMachine.kernel_version < 607
-
     r, w = IO.pipe
     bgid = machine.setup_buffer_ring(4096, 1024)
     assert_equal 0, bgid
@@ -634,8 +605,6 @@ class ReadEachTest < UMBaseTest
 
   # send once and leave write fd open
   def test_read_each_raising_2
-    skip if UringMachine.kernel_version < 607
-
     r, w = IO.pipe
     bgid = machine.setup_buffer_ring(4096, 1024)
     assert_equal 0, bgid
@@ -659,8 +628,6 @@ class ReadEachTest < UMBaseTest
 
   # send twice
   def test_read_each_raising_3
-    skip if UringMachine.kernel_version < 607
-
     r, w = IO.pipe
     bgid = machine.setup_buffer_ring(4096, 1024)
     assert_equal 0, bgid
@@ -684,8 +651,6 @@ class ReadEachTest < UMBaseTest
   end
 
   def test_read_each_break
-    skip if UringMachine.kernel_version < 607
-
     r, w = IO.pipe
     bgid = machine.setup_buffer_ring(4096, 1024)
 
@@ -710,8 +675,6 @@ class ReadEachTest < UMBaseTest
   end
 
   def test_read_each_bad_file
-    skip if UringMachine.kernel_version < 607
-
     _r, w = IO.pipe
     bgid = machine.setup_buffer_ring(4096, 1024)
 
@@ -826,6 +789,163 @@ class WriteTest < UMBaseTest
   end
 end
 
+class WritevTest < UMBaseTest
+  def test_writev
+    r, w = IO.pipe
+
+    assert_equal 0, machine.metrics[:ops_pending]
+    res = machine.writev(w.fileno, 'foo', 'bar', 'baz')
+    assert_equal 9, res
+    assert_equal 0, machine.metrics[:ops_pending]
+    assert_equal 'foobarbaz', r.readpartial(9)
+
+    res = machine.writev(w.fileno, 'oofoof', 'rabrab')
+    assert_equal 12, res
+    assert_equal 'oofoofrabrab', r.readpartial(12)
+  end
+
+  def test_writev_incomplete
+    r, w = UM.pipe
+    strs = ['1' * 256, '2' * 30000, '3' * 256]
+    total_len = strs.map(&:bytesize).reduce(:+)
+
+    prelim_len = (65536 - 3);
+    prelim_msg = '*' * prelim_len
+    machine.write(w, prelim_msg)
+
+    reads = []
+    f = machine.spin {
+      loop {
+        buf = +''
+        res = machine.read(r, buf, 8192)
+        break if res == 0
+        
+        reads << buf
+      }
+    }
+
+    res = machine.writev(w, *strs)
+    assert_equal total_len, res
+
+    machine.close(w)
+    machine.join(f)
+
+    msg_read = reads.join
+    msg_expected = [prelim_msg, *strs].join
+
+    assert_equal msg_expected, msg_read
+  ensure
+    machine.close(w) rescue nil
+    machine.close(r) rescue nil
+    machine.join(f)
+  end
+
+  def test_writev_close_r
+    r, w = UM.pipe
+    strs = ['1' * 256, '2' * 30000, '3' * 256]
+
+    prelim_len = (65536 - 3);
+    prelim_msg = '*' * prelim_len
+    machine.write(w, prelim_msg)
+
+    f = machine.spin {
+      buf = +''
+      3.times { machine.read(r, buf, 8192) }
+      machine.close(w)
+    }
+
+    assert_raises(Errno::EBADF) { machine.writev(w, *strs) }
+  ensure
+    machine.close(w) rescue nil
+    machine.close(r) rescue nil
+    machine.join(f)
+  end
+
+  class TOError < RuntimeError; end
+
+  def test_writev_timeout
+    r, w = UM.pipe
+    strs = ['1' * 256, '2' * 30000, '3' * 256]
+
+    prelim_len = (65536 - 3);
+    prelim_msg = '*' * prelim_len
+    machine.write(w, prelim_msg)
+
+    assert_raises(TOError) {
+      machine.timeout(0.01, TOError) {
+        machine.writev(w, *strs)
+      }
+    }
+  ensure
+    machine.close(w) rescue nil
+    machine.close(r) rescue nil
+  end
+
+  def test_writev_bad_fd
+    r, _w = UM.pipe
+
+    assert_equal 0, machine.metrics[:ops_pending]
+    assert_raises(Errno::EBADF) do
+      machine.writev(r, 'foo', 'bar')
+    end
+    assert_equal 0, machine.metrics[:ops_pending]
+  end
+
+  def test_writev_zero_length
+    r, w = IO.pipe
+
+    res = machine.write(w.fileno, '')
+    assert_equal 0, res
+
+    res = machine.writev(w.fileno, '', '')
+    assert_equal 0, res
+
+    buf1 = IO::Buffer.new(0)
+    buf2 = IO::Buffer.new(0)
+    res = machine.writev(w.fileno, buf1, buf2)
+    assert_equal 0, res
+
+    w.close
+    assert_equal '', r.read
+  end
+
+  def test_writev_io_buffer
+    r, w = UM.pipe
+
+    buf1 = IO::Buffer.new(5)
+    buf1.set_string('Hello')
+    buf2 = IO::Buffer.new(6)
+    buf2.set_string(' world')
+
+    machine.writev(w, buf1, buf2)
+    machine.close(w)
+
+    str = +''
+    machine.read(r, str, 8192)
+    assert_equal 'Hello world', str
+  end
+
+  def test_writev_invalid_buffer
+    _r, w = UM.pipe
+    assert_raises(UM::Error) {
+      machine.writev(w, 'abc', [])
+    }
+  end
+
+  def test_writev_with_file_offset
+    fn = "/tmp/um_#{SecureRandom.hex}"
+    IO.write(fn, 'foobar')
+
+    fd = machine.open(fn, UM::O_WRONLY)
+    result = machine.writev(fd, 'bar', 'baz', 2)
+    assert_equal 6, result
+    assert_equal 'fobarbaz', IO.read(fn)
+  ensure
+    machine.close(fd)
+    FileUtils.rm(fn) rescue nil
+  end
+end
+
 class WriteAsyncTest < UMBaseTest
   def test_write_async
     r, w = IO.pipe
@@ -1100,6 +1220,82 @@ class AcceptEachTest < UMBaseTest
   ensure
     s.close
   end
+
+  def test_accept_each_bad_fd
+    queue = UM::Queue.new
+    assert_raises(Errno::ENOTSOCK) { machine.accept_each(STDOUT.fileno) }
+  end
+end
+
+class AcceptIntoQueueTest < UMBaseTest
+  def setup
+    super
+    @port = assign_port
+    @server = TCPServer.open('127.0.0.1', @port)
+    @server_fd = @server.fileno
+  end
+
+  def teardown
+    @server&.close rescue nil
+    super
+  end
+
+  def test_accept_into_queue
+    conns = []
+    t = Thread.new do
+      sleep 0.05
+      3.times do
+        conns << TCPSocket.new('127.0.0.1', @port)
+      end
+    end
+
+    queue = UM::Queue.new
+    f = machine.spin do
+      machine.accept_into_queue(@server_fd, queue)
+    end
+    t.join
+    machine.sleep(0.01)
+    assert_equal 3, queue.count
+  ensure
+    machine.close(@server_fd)
+    machine.schedule(f, nil)
+    machine.join(f)
+    t&.kill
+  end
+
+  def test_accept_into_queue_interrupted
+    count = 0
+    terminated = nil
+    queue = UM::Queue.new
+    f = @machine.spin do
+      machine.accept_into_queue(@server_fd, queue)
+    rescue UM::Terminate
+      terminated = true
+    end
+
+    s = TCPSocket.new('127.0.0.1', @port)
+    @machine.sleep(0.01)
+
+    assert_equal 1, queue.count
+    refute terminated
+
+    @machine.schedule(f, UM::Terminate.new)
+    @machine.sleep(0.01)
+
+    assert f.done?
+    assert terminated
+  ensure
+    s.close
+  end
+
+  def test_accept_into_queue_bad_fd
+    queue = UM::Queue.new
+    assert_raises(Errno::ENOTSOCK) { machine.accept_into_queue(STDOUT.fileno, queue) }
+  end
+
+  def test_accept_into_queue_bad_queue
+    assert_raises(TypeError) { machine.accept_into_queue(@server_fd, nil) }
+  end
 end
 
 class SocketTest < UMBaseTest
@@ -1190,7 +1386,6 @@ class SendTest < UMBaseTest
     t&.kill
   end
 
-
   def test_send_io_buffer
     @port = assign_port
     @server = TCPServer.open('127.0.0.1', @port)
@@ -1263,6 +1458,55 @@ class SendTest < UMBaseTest
   end
 end
 
+class SendvTest < UMBaseTest
+  def setup
+    super
+    @s1, @s2 = UM.socketpair(UM::AF_UNIX, UM::SOCK_STREAM, 0)
+  end
+
+  def teardown
+    @machine.close(@s1)
+    @machine.close(@s2)
+    super
+  end
+
+  def test_sendv
+    skip "Unavailable on kernel version < 6.17" if UM.kernel_version < 617
+
+    ret = machine.sendv(@s1, 'foo', 'bar', 'baz')
+    assert_equal 9, ret
+
+    buf = +''
+    ret = machine.read(@s2, buf, 8192)
+    assert_equal 9, ret
+    assert_equal 'foobarbaz', buf
+  end
+
+  def test_sendv_io_buffer
+    skip "Unavailable on kernel version < 6.17" if UM.kernel_version < 617
+
+    buf1 = IO::Buffer.new(6)
+    buf1.set_string('foobar')
+
+    buf2 = IO::Buffer.new(3)
+    buf2.set_string('baz')
+
+    ret = machine.sendv(@s1, buf1, buf2)
+    assert_equal 9, ret
+
+    buf = +''
+    ret = machine.read(@s2, buf, 8192)
+    assert_equal 9, ret
+    assert_equal 'foobarbaz', buf
+  end
+
+  def test_sendv_invalid_buffer
+    skip "Unavailable on kernel version < 6.17" if UM.kernel_version < 617
+
+    assert_raises(UM::Error) { machine.sendv(@s1, [], 'abc') }
+  end
+end
+
 class RecvTest < UMBaseTest
   def setup
     super
@@ -1694,7 +1938,6 @@ class QueueTest < UMBaseTest
     }
 
     t1.join
-    q = UM::Queue.new
     machine.push(worker_queue, :STOP)
     t2.join
 
@@ -2019,7 +2262,7 @@ class WaitidTest < UMBaseTest
   end
 
   def test_waitid_status
-    skip if !machine.respond_to?(:waitid_status)
+    skip "waitid_status not available" if !machine.respond_to?(:waitid_status)
 
     msg = 'hello from child'
     _rfd, wfd = UM.pipe
@@ -2039,7 +2282,7 @@ class WaitidTest < UMBaseTest
   end
 
   def test_waitid_status_invalid_pid
-    skip if !machine.respond_to?(:waitid_status)
+    skip "waitid_status not available" if !machine.respond_to?(:waitid_status)
 
     assert_raises(Errno::ECHILD) {
       machine.waitid_status(UM::P_PID, Process.pid + 1, UM::WEXITED)
@@ -2047,7 +2290,7 @@ class WaitidTest < UMBaseTest
   end
 
   def test_waitid_status_invalid_idtype
-    skip if !machine.respond_to?(:waitid_status)
+    skip "waitid_status not available" if !machine.respond_to?(:waitid_status)
 
     assert_raises(Errno::EINVAL) {
       machine.waitid_status(1234, 0, UM::WEXITED)
@@ -2055,7 +2298,7 @@ class WaitidTest < UMBaseTest
   end
 
   def test_waitid_status_invalid_options
-    skip if !machine.respond_to?(:waitid_status)
+    skip "waitid_status not available" if !machine.respond_to?(:waitid_status)
 
     assert_raises(Errno::EINVAL) {
       machine.waitid_status(P_ALL, 0, 1234)
@@ -2063,7 +2306,7 @@ class WaitidTest < UMBaseTest
   end
 
   def test_waitid_status_P_ALL
-    skip if !machine.respond_to?(:waitid_status)
+    skip "waitid_status not available" if !machine.respond_to?(:waitid_status)
 
     msg = 'hello from child'
     _rfd, wfd = UM.pipe
@@ -2083,7 +2326,7 @@ class WaitidTest < UMBaseTest
   end
 
   def test_waitid_status_P_PGID
-    skip if !machine.respond_to?(:waitid_status)
+    skip "waitid_status not available" if !machine.respond_to?(:waitid_status)
 
     msg = 'hello from child'
     _rfd, wfd = UM.pipe
@@ -2198,8 +2441,6 @@ class SendBundleTest < UMBaseTest
   end
 
   def test_send_bundle_splat
-    skip if UringMachine.kernel_version < 610
-
     bgid = machine.setup_buffer_ring(0, 8)
     assert_equal 0, bgid
 
@@ -2216,8 +2457,6 @@ class SendBundleTest < UMBaseTest
   end
 
   def test_send_bundle_array
-    skip if UringMachine.kernel_version < 610
-
     bgid = machine.setup_buffer_ring(0, 8)
     assert_equal 0, bgid
 
@@ -2234,8 +2473,6 @@ class SendBundleTest < UMBaseTest
   end
 
   def test_send_bundle_non_strings
-    skip if UringMachine.kernel_version < 610
-
     bgid = machine.setup_buffer_ring(0, 8)
     assert_equal 0, bgid
 
@@ -2360,28 +2597,28 @@ class MetricsTest < UMBaseTest
   end
 
   def test_metrics_ops
-    r, w = UM.pipe
+    _r, w = UM.pipe
 
     f = machine.spin { machine.sleep(0.001) }
-    assert_equal [0, 0, 1, 0, 0], ops_metrics
+    assert_equal [0, 0, 1, 255, 0], ops_metrics
     machine.snooze
-    assert_equal [1, 1, 0, 2, 0], ops_metrics
+    assert_equal [1, 1, 0, 256, 0], ops_metrics
     machine.submit
-    assert_equal [1, 0, 0, 2, 0], ops_metrics
+    assert_equal [1, 0, 0, 256, 0], ops_metrics
     machine.join(f)
-    assert_equal [0, 0, 0, 2, 0], ops_metrics
+    assert_equal [0, 0, 0, 256, 0], ops_metrics
 
     machine.write_async(w, 'foo')
-    assert_equal [1, 1, 0, 1, 1], ops_metrics
+    assert_equal [1, 1, 0, 255, 1], ops_metrics
     machine.submit
-    assert_equal [1, 0, 0, 1, 1], ops_metrics
+    assert_equal [1, 0, 0, 255, 1], ops_metrics
     machine.snooze
-    assert_equal [0, 0, 0, 2, 0], ops_metrics
+    assert_equal [0, 0, 0, 256, 0], ops_metrics
 
     machine.write_async(w, 'foo')
-    assert_equal [1, 1, 0, 1, 1], ops_metrics
+    assert_equal [1, 1, 0, 255, 1], ops_metrics
     machine.snooze
-    assert_equal [0, 0, 0, 2, 0], ops_metrics
+    assert_equal [0, 0, 0, 256, 0], ops_metrics
   ensure
     machine.join(f)
   end

data/vendor/liburing/configure

@@ -120,8 +120,9 @@ print_config() {
 }
 
 # Default CFLAGS
-CFLAGS="-D_GNU_SOURCE -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -include config-host.h"
-BUILD_CFLAGS=""
+ENV_CFLAGS="${CFLAGS}"
+CFLAGS="${CFLAGS:+$CFLAGS }-D_GNU_SOURCE -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -include config-host.h"
+BUILD_CFLAGS="${ENV_CFLAGS}"
 
 # Print configure header at the top of $config_host_h
 echo "/*" > $config_host_h
@@ -588,6 +589,7 @@ fi
 echo "CC=$cc" >> $config_host_mak
 print_config "CC" "$cc"
 echo "CXX=$cxx" >> $config_host_mak
+echo "BUILD_CFLAGS=$BUILD_CFLAGS" >> $config_host_mak
 print_config "CXX" "$cxx"
 
 # generate io_uring_version.h

data/vendor/liburing/src/Makefile

@@ -13,6 +13,7 @@ override CPPFLAGS += -D_GNU_SOURCE \
 CFLAGS ?= -O3 -Wall -Wextra -fno-stack-protector
 override CFLAGS += -Wno-unused-parameter \
 	-DLIBURING_INTERNAL \
+	$(BUILD_CFLAGS) \
 	$(LIBURING_CFLAGS)
 SO_CFLAGS=-fPIC $(CFLAGS)
 L_CFLAGS=$(CFLAGS)

data/vendor/liburing/test/min-timeout-wait.c

@@ -237,9 +237,9 @@ static int test_min_wait_equal(struct io_uring *ring)
 
 int main(int argc, char *argv[])
 {
-	struct io_uring ring1, ring2;
+	struct io_uring ring1, ring2, ring3;
 	struct io_uring_params p = { };
-	int ret;
+	int ret, no_sq_poll = 0;
 
 	if (argc > 1)
 		return 0;
@@ -259,6 +259,11 @@ int main(int argc, char *argv[])
 	else if (ret != T_SETUP_OK)
 		return ret;
 
+	p.flags = IORING_SETUP_SQPOLL;
+	ret = t_create_ring_params(8, &ring3, &p);
+	if (ret != T_SETUP_OK)
+		no_sq_poll = 1;
+
 	ret = test_already(&ring1);
 	if (ret == T_EXIT_FAIL || ret == T_EXIT_SKIP)
 		return ret;
@@ -267,6 +272,12 @@ int main(int argc, char *argv[])
 	if (ret == T_EXIT_FAIL)
 		return T_EXIT_FAIL;
 
+	if (!no_sq_poll) {
+		ret = test_already(&ring3);
+		if (ret == T_EXIT_FAIL)
+			return T_EXIT_FAIL;
+	}
+
 	ret = test_some(&ring1);
 	if (ret == T_EXIT_FAIL || ret == T_EXIT_SKIP)
 		return ret;
@@ -275,6 +286,12 @@ int main(int argc, char *argv[])
 	if (ret == T_EXIT_FAIL)
 		return T_EXIT_FAIL;
 
+	if (!no_sq_poll) {
+		ret = test_some(&ring3);
+		if (ret == T_EXIT_FAIL)
+			return T_EXIT_FAIL;
+	}
+
 	ret = test_late(&ring1);
 	if (ret == T_EXIT_FAIL || ret == T_EXIT_SKIP)
 		return ret;
@@ -283,6 +300,12 @@ int main(int argc, char *argv[])
 	if (ret == T_EXIT_FAIL)
 		return T_EXIT_FAIL;
 
+	if (!no_sq_poll) {
+		ret = test_late(&ring3);
+		if (ret == T_EXIT_FAIL)
+			return T_EXIT_FAIL;
+	}
+
 	ret = test_post_wait(&ring1);
 	if (ret == T_EXIT_FAIL || ret == T_EXIT_SKIP)
 		return ret;
@@ -291,6 +314,12 @@ int main(int argc, char *argv[])
 	if (ret == T_EXIT_FAIL)
 		return T_EXIT_FAIL;
 
+	if (!no_sq_poll) {
+		ret = test_post_wait(&ring3);
+		if (ret == T_EXIT_FAIL)
+			return T_EXIT_FAIL;
+	}
+
 	ret = test_some_wait(&ring1);
 	if (ret == T_EXIT_FAIL || ret == T_EXIT_SKIP)
 		return ret;
@@ -299,6 +328,12 @@ int main(int argc, char *argv[])
 	if (ret == T_EXIT_FAIL)
 		return T_EXIT_FAIL;
 
+	if (!no_sq_poll) {
+		ret = test_some_wait(&ring3);
+		if (ret == T_EXIT_FAIL)
+			return T_EXIT_FAIL;
+	}
+
 	ret = test_nothing(&ring1);
 	if (ret == T_EXIT_FAIL || ret == T_EXIT_SKIP)
 		return ret;
@@ -307,6 +342,12 @@ int main(int argc, char *argv[])
 	if (ret == T_EXIT_FAIL)
 		return T_EXIT_FAIL;
 
+	if (!no_sq_poll) {
+		ret = test_nothing(&ring3);
+		if (ret == T_EXIT_FAIL)
+			return T_EXIT_FAIL;
+	}
+
 	ret = test_min_wait_biggest(&ring1);
 	if (ret == T_EXIT_FAIL || ret == T_EXIT_SKIP)
 		return ret;
@@ -315,6 +356,12 @@ int main(int argc, char *argv[])
 	if (ret == T_EXIT_FAIL)
 		return T_EXIT_FAIL;
 
+	if (!no_sq_poll) {
+		ret = test_min_wait_biggest(&ring3);
+		if (ret == T_EXIT_FAIL)
+			return T_EXIT_FAIL;
+	}
+
 	ret = test_min_wait_equal(&ring1);
 	if (ret == T_EXIT_FAIL || ret == T_EXIT_SKIP)
 		return ret;
@@ -323,7 +370,15 @@ int main(int argc, char *argv[])
 	if (ret == T_EXIT_FAIL)
 		return T_EXIT_FAIL;
 
+	if (!no_sq_poll) {
+		ret = test_min_wait_equal(&ring3);
+		if (ret == T_EXIT_FAIL)
+			return T_EXIT_FAIL;
+	}
+
 	io_uring_queue_exit(&ring1);
 	io_uring_queue_exit(&ring2);
+	if (!no_sq_poll)
+		io_uring_queue_exit(&ring3);
 	return T_EXIT_PASS;
 }

data/vendor/liburing/test/min-timeout.c

@@ -204,5 +204,27 @@ int main(int argc, char *argv[])
 	if (ret == T_EXIT_FAIL)
 		return T_EXIT_FAIL;
 
+	ret = test(IORING_SETUP_SQPOLL, 1, 0, 2000, NWRITES, WAIT_USEC / 1000);
+	if (ret == T_EXIT_FAIL)
+		return T_EXIT_FAIL;
+
+	ret = test(IORING_SETUP_SQPOLL, 1, 50000, 2000, NWRITES, 50);
+	if (ret == T_EXIT_FAIL)
+		return T_EXIT_FAIL;
+
+	ret = test(IORING_SETUP_SQPOLL, 1, 500000, 2000, NWRITES, 500);
+	if (ret == T_EXIT_FAIL)
+		return T_EXIT_FAIL;
+
+	/* no writes within min timeout, but it's given. expect 1 cqe */
+	ret = test(IORING_SETUP_SQPOLL, 1, 10000, 20000, 1, 20);
+	if (ret == T_EXIT_FAIL)
+		return T_EXIT_FAIL;
+
+	/* same as above, but no min timeout. should time out and we get 6 */
+	ret = test(IORING_SETUP_SQPOLL, 1, 0, 20000, NWRITES, WAIT_USEC / 1000);
+	if (ret == T_EXIT_FAIL)
+		return T_EXIT_FAIL;
+
 	return ret;
 }