uringmachine 0.8.2 → 0.11

data/test/test_stream.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require_relative 'helper'
+
+class StreamBaseTest < UMBaseTest
+  def setup
+    super
+    @rfd, @wfd = UM.pipe
+    @stream = UM::Stream.new(@machine, @rfd)
+  end  
+end
+
+class StreamTest < StreamBaseTest
+  def test_get_line
+    machine.write(@wfd, "foo\nbar\r\nbaz")
+    machine.close(@wfd)
+
+    assert_equal 'foo', @stream.get_line
+    assert_equal 'bar', @stream.get_line
+    assert_nil @stream.get_line
+  end
+
+  def test_get_string
+    machine.write(@wfd, "foobarbazblahzzz")
+    machine.close(@wfd)
+
+    assert_equal 'foobar', @stream.get_string(6)
+    assert_equal 'baz', @stream.get_string(3)
+    assert_equal 'blah', @stream.get_string(4)
+    assert_nil @stream.get_string(4)
+  end
+end
+
+class StreamRespTest < StreamBaseTest
+  def test_trdp_get_line
+    machine.write(@wfd, "foo\r\nbarbar\r\nbaz\n")
+    machine.close(@wfd)
+    
+    assert_equal 'foo', @stream.resp_get_line
+    assert_equal 'barbar', @stream.resp_get_line
+    assert_nil @stream.resp_get_line
+  end
+
+  def test_resp_get_string
+    machine.write(@wfd, "foo\r\nbarbar\r\nbaz\n")
+    machine.close(@wfd)
+
+    assert_equal 'foo', @stream.resp_get_string(3)
+    assert_equal 'barbar', @stream.resp_get_string(6)
+    assert_nil @stream.resp_get_string(3)
+  end
+
+  def test_resp_decode
+    machine.write(@wfd, "+foo bar\r\n")
+    assert_equal "foo bar", @stream.resp_decode
+
+    machine.write(@wfd, "+baz\r\n")
+    assert_equal "baz", @stream.resp_decode
+
+    machine.write(@wfd, "-foobar\r\n")
+    o = @stream.resp_decode
+    assert_kind_of RuntimeError, o
+    assert_equal "foobar", o.message
+
+    machine.write(@wfd, "!3\r\nbaz\r\n")
+    o = @stream.resp_decode
+    assert_kind_of RuntimeError, o
+    assert_equal "baz", o.message
+
+    machine.write(@wfd, ":123\r\n")
+    assert_equal 123, @stream.resp_decode
+
+    machine.write(@wfd, ":-123\r\n")
+    assert_equal(-123, @stream.resp_decode)
+
+    machine.write(@wfd, ",123.321\r\n")
+    assert_equal 123.321, @stream.resp_decode
+
+    machine.write(@wfd, "_\r\n")
+    assert_nil @stream.resp_decode
+
+    machine.write(@wfd, "#t\r\n")
+    assert_equal true, @stream.resp_decode
+
+    machine.write(@wfd, "#f\r\n")
+    assert_equal false, @stream.resp_decode
+
+    machine.write(@wfd, "$6\r\nfoobar\r\n")
+    assert_equal "foobar", @stream.resp_decode
+
+    machine.write(@wfd, "$3\r\nbaz\r\n")
+    assert_equal "baz", @stream.resp_decode
+
+    machine.write(@wfd, "=10\r\ntxt:foobar\r\n")
+    assert_equal "foobar", @stream.resp_decode
+
+    machine.write(@wfd, "*3\r\n+foo\r\n:42\r\n$3\r\nbar\r\n")
+    assert_equal ['foo', 42, 'bar'], @stream.resp_decode
+
+    machine.write(@wfd, "~3\r\n+foo\r\n:42\r\n$3\r\nbar\r\n")
+    assert_equal ['foo', 42, 'bar'], @stream.resp_decode
+
+    machine.write(@wfd, ">3\r\n+foo\r\n:42\r\n$3\r\nbar\r\n")
+    assert_equal ['foo', 42, 'bar'], @stream.resp_decode
+
+    machine.write(@wfd, "%2\r\n+a\r\n:42\r\n+b\r\n:43\r\n")
+    assert_equal({ 'a' => 42, 'b' => 43 }, @stream.resp_decode)
+
+    machine.write(@wfd, "|2\r\n+a\r\n:42\r\n+b\r\n:43\r\n")
+    assert_equal({ 'a' => 42, 'b' => 43 }, @stream.resp_decode)
+
+    machine.write(@wfd, "%2\r\n+a\r\n:42\r\n+b\r\n*3\r\n+foo\r\n+bar\r\n+baz\r\n")
+    assert_equal({ 'a' => 42, 'b' => ['foo', 'bar', 'baz'] }, @stream.resp_decode)
+
+  end
+
+  def test_resp_encode
+    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)
+    assert_equal ":42\r\n",           s.resp_encode(+'', 42)
+    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'])
+
+    assert_equal "%2\r\n$3\r\nfoo\r\n$3\r\nbar\r\n$3\r\nbaz\r\n:42\r\n",
+      s.resp_encode(+'', { 'foo' => 'bar', 'baz' => 42 })
+  end
+end

data/test/test_um.rb

@@ -29,7 +29,7 @@ end
 
 class SnoozeTest < UMBaseTest
   def test_snooze_while_sleeping_fiber
-    f = machine.spin do
+    machine.spin do
       machine.sleep(0.1)
     end
 
@@ -655,7 +655,6 @@ class AcceptEachTest < UMBaseTest
   end
 
   def test_accept_each_interrupted
-    conns = []
     count = 0
     terminated = nil
     f = @machine.spin do
@@ -678,6 +677,8 @@ class AcceptEachTest < UMBaseTest
 
     assert f.done?
     assert terminated
+  ensure
+    s.close
   end
 end
 
@@ -1223,6 +1224,34 @@ class WaitTest < UMBaseTest
     ret = machine.read(rfd, buf, 8192)
     assert_equal msg.bytesize, ret
     assert_equal msg, buf
+  ensure
+    Process.wait(pid) rescue Errno::ECHILD
+  end
+
+  def test_waitpid_any
+    skip if UM.kernel_version < 607
+
+    msg = 'hello from child'
+
+    rfd, wfd = UM.pipe
+    pid = fork do
+      m = UM.new
+      m.write(wfd, msg)
+      m.close(wfd)
+      exit 42
+    end
+
+    ret = machine.waitpid(0, UM::WEXITED)
+    assert_kind_of Array, ret
+    assert_equal [pid, 42], ret
+
+    buf = +''
+    ret = machine.read(rfd, buf, 8192)
+    assert_equal msg.bytesize, ret
+    assert_equal msg, buf
+    
+  ensure
+    Process.wait(pid) rescue Errno::ECHILD
   end
 
   def test_waitpid_bad_pid
@@ -1231,3 +1260,81 @@ class WaitTest < UMBaseTest
     assert_raises(Errno::ECHILD) { machine.waitpid(1, UM::WEXITED) }
   end
 end
+
+class StatxTest < UMBaseTest
+  def test_statx
+    io = File.open(__FILE__, 'r')
+    ustat = machine.statx(io.fileno, nil, UM::AT_EMPTY_PATH, UM::STATX_ALL)
+    rstat = File.stat(__FILE__)
+
+    assert_equal rstat.dev,         ustat[:dev]
+    assert_equal rstat.ino,         ustat[:ino]
+    assert_equal rstat.mode,        ustat[:mode]
+    assert_equal rstat.nlink,       ustat[:nlink]
+    assert_equal rstat.uid,         ustat[:uid]
+    assert_equal rstat.gid,         ustat[:gid]
+    assert_equal rstat.rdev,        ustat[:rdev]
+    assert_equal rstat.size,        ustat[:size]
+    assert_equal rstat.blksize,     ustat[:blksize]
+    assert_equal rstat.blocks,      ustat[:blocks]
+    assert_equal rstat.atime.to_i,  ustat[:atime].to_i
+    assert_equal rstat.ctime.to_i,  ustat[:ctime].to_i
+    assert_equal rstat.mtime.to_i,  ustat[:mtime].to_i
+
+    ustat2 = machine.statx(UM::AT_FDCWD, __FILE__, 0, UM::STATX_ALL)
+    assert_equal rstat.dev,         ustat2[:dev]
+    assert_equal rstat.ino,         ustat2[:ino]
+    assert_equal rstat.mode,        ustat2[:mode]
+    assert_equal rstat.nlink,       ustat2[:nlink]
+    assert_equal rstat.uid,         ustat2[:uid]
+    assert_equal rstat.gid,         ustat2[:gid]
+    assert_equal rstat.rdev,        ustat2[:rdev]
+    assert_equal rstat.size,        ustat2[:size]
+    assert_equal rstat.blksize,     ustat2[:blksize]
+    assert_equal rstat.blocks,      ustat2[:blocks]
+    assert_equal rstat.atime.to_i,  ustat2[:atime].to_i
+    assert_equal rstat.ctime.to_i,  ustat2[:ctime].to_i
+    assert_equal rstat.mtime.to_i,  ustat2[:mtime].to_i
+  ensure
+    io.close
+  end
+
+  def test_statx_bad_path
+    assert_raises(Errno::ENOENT) { machine.statx(UM::AT_FDCWD, 'foobar', 0, UM::STATX_ALL) }
+  end
+end
+
+class ForkTest < UMBaseTest
+  def test_fork
+    parent_rfd, child_wfd = UM.pipe
+    child_rfd, parent_wfd = UM.pipe
+
+    child_pid = fork do
+      # we cannot use the same machine after fork
+      m = UM.new
+      buf = +''
+      m.read(child_rfd, buf, 8192)
+      m.write(child_wfd, buf, buf.bytesize)
+      m.close(child_wfd)
+    rescue Exception => e
+      puts 'c' * 40
+      p e
+      puts e.backtrace.join("\n")
+    end
+
+    ret = machine.write(parent_wfd, 'foo')
+    assert_equal 3, ret
+
+    ret = machine.close(parent_wfd)
+    assert_equal parent_wfd, ret
+
+    buf = +''
+    ret = machine.read(parent_rfd, buf, 8192)
+
+    assert_equal 3, ret
+    assert_equal 'foo', buf
+  ensure
+    Process.wait(child_pid) rescue Errno::ECHILD
+  end
+
+end

data/uringmachine.gemspec

@@ -22,7 +22,5 @@ Gem::Specification.new do |s|
 
   s.add_development_dependency  'rake-compiler',        '1.2.9'
   s.add_development_dependency  'minitest',             '5.25.4'
-  s.add_development_dependency  'http_parser.rb',       '0.8.0'
   s.add_development_dependency  'benchmark-ips',        '2.14.0'
-  s.add_development_dependency  'localhost',            '1.3.1'
 end

data/vendor/liburing/.github/workflows/{build.yml → ci.yml}

@@ -1,18 +1,44 @@
-name: Build test
+name: CI
 
 on:
   # Trigger the workflow on push or pull requests.
   push:
   pull_request:
 
+
 jobs:
-  build:
+  get_commit_list:
     runs-on: ubuntu-24.04
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Get commit list
+        id: get_commit_list
+        run: |
+          git config core.abbrev 12;
+          ( \
+            ( \
+              git log --pretty="%h" --reverse ${{github.event.commits[0].id}}^...${{github.sha}} || \
+              (printf "%s" ${{github.sha}} | head -c 12) \
+            ) | awk '{ print "id" NR "=" $1 }' \
+          ) > $GITHUB_OUTPUT;
+          echo "List of tested commits:" > $GITHUB_STEP_SUMMARY;
+          cat $GITHUB_OUTPUT >> $GITHUB_STEP_SUMMARY;
+
+    outputs:
+      commit_list: ${{ toJson(steps.*.outputs.*) }}
 
+
+  build:
+    needs: get_commit_list
+    runs-on: ubuntu-24.04
     strategy:
       fail-fast: false
       matrix:
-        include:
+        commit: ${{ fromJson(needs.get_commit_list.outputs.commit_list) }}
+        build_args:
           # x86-64 gcc
           - arch: x86_64
             cc_pkg: gcc-x86-64-linux-gnu
@@ -120,46 +146,85 @@ jobs:
             sanitize: 0
 
     env:
-      FLAGS: -g -O3 -Wall -Wextra -Werror -Wno-sign-compare ${{matrix.extra_flags}}
-      SANITIZE: ${{matrix.sanitize}}
+      FLAGS: -g -O3 -Wall -Wextra -Werror -Wno-sign-compare ${{matrix.build_args.extra_flags}}
+      SANITIZE: ${{matrix.build_args.sanitize}}
 
       # Flags for building sources in src/ dir only.
-      LIBURING_CFLAGS: ${{matrix.liburing_extra_flags}}
+      LIBURING_CFLAGS: ${{matrix.build_args.liburing_extra_flags}}
 
     steps:
-    - name: Checkout source
-      uses: actions/checkout@v4
-
-    - name: Install Compilers
-      run: |
-        if [[ "${{matrix.cc_pkg}}" == "clang" ]]; then \
-            wget https://apt.llvm.org/llvm.sh -O /tmp/llvm.sh; \
-            sudo apt-get purge --auto-remove llvm python3-lldb-14 llvm-14 -y; \
-            sudo bash /tmp/llvm.sh 17; \
-            sudo update-alternatives --install /usr/bin/clang++ clang++ /usr/bin/clang++-17 400; \
-            sudo update-alternatives --install /usr/bin/clang clang /usr/bin/clang-17 400; \
-        else \
-            sudo apt-get update -y; \
-            sudo apt-get install -y ${{matrix.cc_pkg}} ${{matrix.cxx_pkg}}; \
-        fi;
-
-    - name: Display compiler versions
-      run: |
-        ${{matrix.cc}} --version;
-        ${{matrix.cxx}} --version;
-
-    - name: Build
-      if: ${{matrix.sanitizer == '0'}}
-      run: |
-        ./configure --cc=${{matrix.cc}} --cxx=${{matrix.cxx}};
-        make -j$(nproc) V=1 CPPFLAGS="-Werror" CFLAGS="$FLAGS" CXXFLAGS="$FLAGS";
-
-    - name: Build
-      if: ${{matrix.sanitizer == '1'}}
-      run: |
-        ./configure --cc=${{matrix.cc}} --cxx=${{matrix.cxx}} --enable-sanitizer;
-        make -j$(nproc) V=1 CPPFLAGS="-Werror" CFLAGS="$FLAGS" CXXFLAGS="$FLAGS";
-
-    - name: Test install command
-      run: |
-        sudo make install;
+      - name: Checkout source
+        uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Checkout commit
+        run: |
+          git checkout ${{ matrix.commit }};
+
+      - name: Install Compilers
+        run: |
+          sudo apt-get update -y;
+          sudo apt-get install -y ${{matrix.build_args.cc_pkg}} ${{matrix.build_args.cxx_pkg}};
+
+      - name: Display compiler versions
+        run: |
+          ${{matrix.build_args.cc}} --version;
+          ${{matrix.build_args.cxx}} --version;
+
+      - name: Build
+        if: ${{matrix.build_args.sanitize == '0'}}
+        run: |
+          ./configure --cc=${{matrix.build_args.cc}} --cxx=${{matrix.build_args.cxx}};
+          make -j$(nproc) V=1 CPPFLAGS="-Werror" CFLAGS="$FLAGS" CXXFLAGS="$FLAGS";
+
+      - name: Build
+        if: ${{matrix.build_args.sanitize == '1'}}
+        run: |
+          ./configure --cc=${{matrix.build_args.cc}} --cxx=${{matrix.build_args.cxx}} --enable-sanitizer;
+          make -j$(nproc) V=1 CPPFLAGS="-Werror" CFLAGS="$FLAGS" CXXFLAGS="$FLAGS";
+
+      - name: Test install command
+        run: |
+          sudo make install;
+
+
+  codespell:
+    needs: get_commit_list
+    runs-on: ubuntu-24.04
+    strategy:
+      matrix:
+        commit: ${{ fromJson(needs.get_commit_list.outputs.commit_list) }}
+
+    steps:
+      - name: Checkout source
+        uses: actions/checkout@v4
+
+      - name: Install codespell
+        run: |
+          sudo apt-get update -y
+          sudo apt-get install -y codespell
+
+      - name: Display codespell version
+        run: codespell --version
+
+      - name: Execute codespell
+        run: codespell --ignore-words=.github/actions/codespell/stopwords .
+
+
+  shellcheck:
+    needs: get_commit_list
+    runs-on: ubuntu-24.04
+    strategy:
+      matrix:
+        commit: ${{ fromJson(needs.get_commit_list.outputs.commit_list) }}
+
+    steps:
+      - name: Checkout source
+        uses: actions/checkout@v4
+
+      - name: Display shellcheck version
+        run: shellcheck --version
+
+      - name: Shellcheck execution
+        run: shellcheck test/runtest*.sh

data/vendor/liburing/.gitignore

@@ -28,6 +28,7 @@
 /examples/rsrc-update-bench
 /examples/kdigest
 /examples/reg-wait
+/examples/zcrx
 
 /test/*.t
 /test/*.dmesg

data/vendor/liburing/CHANGELOG

@@ -1,4 +1,14 @@
+liburing-2.9 release
+
+- Add support for ring resizing
+- Add support for registered waits
+- Test additions and improvements
+- Fix bug with certain ring setups with SQE128 set not fully closing
+  the ring after io_uring_queue_exit(3) had been called.
+- Various man page fixes and updates
+
 liburing-2.8 release
+
 - Add support for incrementally/partially consumed provided buffers,
   usable with the provided buffer ring support.
 - Add support for foo_and_wait_min_timeout(), where it's possible to

data/vendor/liburing/README

@@ -63,6 +63,11 @@ Building liburing
     #
     make -j$(nproc);
 
+    #
+    # Build liburing.pc
+    #
+    make liburing.pc
+
     #
     # Install liburing (headers, shared/static libs, and manpage).
     #

data/vendor/liburing/configure

@@ -114,7 +114,7 @@ fatal() {
 
 # Print result for each configuration test
 print_config() {
-  printf "%-30s%s\n" "$1" "$2"
+  printf "%-35s%s\n" "$1" "$2"
 }
 
 # Default CFLAGS

data/vendor/liburing/examples/Makefile

@@ -32,6 +32,7 @@ example_srcs := \
 	send-zerocopy.c \
 	rsrc-update-bench.c \
 	proxy.c \
+	zcrx.c \
 	kdigest.c
 
 all_targets :=

data/vendor/liburing/examples/helpers.c

@@ -9,6 +9,7 @@
 #include <sys/socket.h>
 #include <sys/time.h>
 #include <unistd.h>
+#include <stdarg.h>
 
 #include "helpers.h"
 
@@ -60,3 +61,27 @@ int setup_listening_socket(int port, int ipv6)
 
 	return fd;
 }
+
+void *aligned_alloc(size_t alignment, size_t size)
+{
+	void *ret;
+
+	if (posix_memalign(&ret, alignment, size))
+		return NULL;
+
+	return ret;
+}
+
+void t_error(int status, int errnum, const char *format, ...)
+{
+	va_list args;
+	va_start(args, format);
+
+	vfprintf(stderr, format, args);
+	if (errnum)
+		fprintf(stderr, ": %s", strerror(errnum));
+
+	fprintf(stderr, "\n");
+	va_end(args);
+	exit(status);
+}

data/vendor/liburing/examples/helpers.h

@@ -2,6 +2,19 @@
 #ifndef LIBURING_EX_HELPERS_H
 #define LIBURING_EX_HELPERS_H
 
+#include <stddef.h>
+
+#define T_ALIGN_UP(v, align) (((v) + (align) - 1) & ~((align) - 1))
+
 int setup_listening_socket(int port, int ipv6);
 
+/*
+ * Some Android versions lack aligned_alloc in stdlib.h.
+ * To avoid making large changes in tests, define a helper
+ * function that wraps posix_memalign as our own aligned_alloc.
+ */
+void *aligned_alloc(size_t alignment, size_t size);
+
+void t_error(int status, int errnum, const char *format, ...);
+
 #endif

data/vendor/liburing/examples/io_uring-test.c

@@ -108,5 +108,8 @@ int main(int argc, char *argv[])
 						(unsigned long) fsize);
 	close(fd);
 	io_uring_queue_exit(&ring);
+	for (i = 0; i < QD; i++)
+		free(iovecs[i].iov_base);
+	free(iovecs);
 	return 0;
 }

data/vendor/liburing/examples/proxy.c

@@ -1354,7 +1354,7 @@ start_close:
 		if (recv_done_res(cqe->res))
 			goto start_close;
 		if (is_sink || !ocd->pending_send)
-			__submit_receive(ring, c, &c->cd[0], c->in_fd);
+			__submit_receive(ring, c, cd, cqe_to_fd(cqe));
 	}
 
 	/*

data/vendor/liburing/examples/reg-wait.c

@@ -13,6 +13,8 @@
 #include <sys/time.h>
 #include <liburing.h>
 
+#include "helpers.h"
+
 static unsigned long long mtime_since(const struct timeval *s,
 				      const struct timeval *e)
 {
@@ -38,6 +40,20 @@ static unsigned long long mtime_since_now(struct timeval *tv)
 	return mtime_since(tv, &end);
 }
 
+static int register_memory(struct io_uring *ring, void *ptr, size_t size)
+{
+	struct io_uring_region_desc rd = {};
+	struct io_uring_mem_region_reg mr = {};
+
+	rd.user_addr = (__u64)(unsigned long)ptr;
+	rd.size = size;
+	rd.flags = IORING_MEM_REGION_TYPE_USER;
+	mr.region_uptr = (__u64)(unsigned long)&rd;
+	mr.flags = IORING_MEM_REGION_REG_WAIT_ARG;
+
+	return io_uring_register_region(ring, &mr);
+}
+
 int main(int argc, char *argv[])
 {
 	struct io_uring_reg_wait *reg;
@@ -48,30 +64,43 @@ int main(int argc, char *argv[])
 	unsigned long msec;
 	struct timeval tv;
 	int ret, fds[2];
+	int page_size;
 
 	if (argc > 1) {
 		fprintf(stdout, "%s: takes no arguments\n", argv[0]);
 		return 0;
 	}
 
+	page_size = sysconf(_SC_PAGESIZE);
+	if (page_size < 0) {
+		fprintf(stderr, "sysconf(_SC_PAGESIZE) failed\n");
+		return 1;
+	}
+
 	if (pipe(fds) < 0) {
 		perror("pipe");
 		return 1;
 	}
 
-	ret = io_uring_queue_init(8, &ring, 0);
+	ret = io_uring_queue_init(8, &ring, IORING_SETUP_R_DISABLED);
 	if (ret) {
 		fprintf(stderr, "Queue init: %d\n", ret);
 		return 1;
 	}
 
 	/*
-	 * Setup wait region. We'll use 32 here, but 64 is probably a more
-	 * logical value, as it'll pin a page regardless of size. 64 is the
-	 * max value on a 4k page size architecture.
+	 * Setup a region we'll use to pass wait arguments. It should be
+	 * page aligned, we're using only first two wait entries here and
+	 * the rest of the memory can be reused for other purposes.
 	 */
-	reg = io_uring_setup_reg_wait(&ring, 32, &ret);
+	reg = aligned_alloc(page_size, page_size);
 	if (!reg) {
+		fprintf(stderr, "allocation failed\n");
+		return 1;
+	}
+
+	ret = register_memory(&ring, reg, page_size);
+	if (ret) {
 		if (ret == -EINVAL) {
 			fprintf(stderr, "Kernel doesn't support registered waits\n");
 			return 1;
@@ -80,6 +109,12 @@ int main(int argc, char *argv[])
 		return 1;
 	}
 
+	ret = io_uring_enable_rings(&ring);
+	if (ret) {
+		fprintf(stderr, "io_uring_enable_rings failure %i\n", ret);
+		return 1;
+	}
+
 	/*
 	 * Setup two distinct wait regions. Index 0 will be a 1 second wait,
 	 * and region 2 is a short wait using min_wait_usec as well. Neither
@@ -154,6 +189,6 @@ int main(int argc, char *argv[])
 	 * Cleanup after ourselves
 	 */
 	io_uring_queue_exit(&ring);
-	io_uring_free_reg_wait(reg, 32);
+	free(reg);
 	return 0;
 }