uringmachine 0.19.1 → 0.20.0

data/vendor/liburing/.github/workflows/ci.yml

@@ -46,6 +46,7 @@ jobs:
             cc: x86_64-linux-gnu-gcc
             cxx: x86_64-linux-gnu-g++
             sanitize: 0
+            tsan: 0
 
           # x86-64 gcc asan
           - arch: x86_64
@@ -54,6 +55,7 @@ jobs:
             cc: x86_64-linux-gnu-gcc
             cxx: x86_64-linux-gnu-g++
             sanitize: 1
+            tsan: 0
 
           # x86-64 clang asan
           - arch: x86_64
@@ -62,6 +64,16 @@ jobs:
             cc: clang
             cxx: clang++
             sanitize: 1
+            tsan: 0
+
+          # x86-64 clang tsan
+          - arch: x86_64
+            cc_pkg: clang
+            cxx_pkg: clang
+            cc: clang
+            cxx: clang++
+            sanitize: 0
+            tsan: 1
 
           # x86-64 clang
           - arch: x86_64
@@ -72,6 +84,7 @@ jobs:
             liburing_extra_flags: -Wshorten-64-to-32
             extra_flags: -Wmissing-prototypes -Wstrict-prototypes -Wunreachable-code-loop-increment -Wunreachable-code -Wmissing-variable-declarations -Wextra-semi-stmt
             sanitize: 0
+            tsan: 0
 
           # x86 (32-bit) gcc
           - arch: i686
@@ -80,6 +93,7 @@ jobs:
             cc: i686-linux-gnu-gcc
             cxx: i686-linux-gnu-g++
             sanitize: 0
+            tsan: 0
 
           # aarch64 gcc
           - arch: aarch64
@@ -88,6 +102,7 @@ jobs:
             cc: aarch64-linux-gnu-gcc
             cxx: aarch64-linux-gnu-g++
             sanitize: 0
+            tsan: 0
 
           # arm (32-bit) gcc
           - arch: arm
@@ -96,6 +111,7 @@ jobs:
             cc: arm-linux-gnueabi-gcc
             cxx: arm-linux-gnueabi-g++
             sanitize: 0
+            tsan: 0
 
           # riscv64
           - arch: riscv64
@@ -104,6 +120,7 @@ jobs:
             cc: riscv64-linux-gnu-gcc
             cxx: riscv64-linux-gnu-g++
             sanitize: 0
+            tsan: 0
 
           # powerpc64
           - arch: powerpc64
@@ -112,6 +129,7 @@ jobs:
             cc: powerpc64-linux-gnu-gcc
             cxx: powerpc64-linux-gnu-g++
             sanitize: 0
+            tsan: 0
 
           # powerpc
           - arch: powerpc
@@ -120,6 +138,7 @@ jobs:
             cc: powerpc-linux-gnu-gcc
             cxx: powerpc-linux-gnu-g++
             sanitize: 0
+            tsan: 0
 
           # alpha
           - arch: alpha
@@ -128,6 +147,7 @@ jobs:
             cc: alpha-linux-gnu-gcc
             cxx: alpha-linux-gnu-g++
             sanitize: 0
+            tsan: 0
 
           # mips64
           - arch: mips64
@@ -136,6 +156,7 @@ jobs:
             cc: mips64-linux-gnuabi64-gcc
             cxx: mips64-linux-gnuabi64-g++
             sanitize: 0
+            tsan: 0
 
           # mips
           - arch: mips
@@ -144,6 +165,7 @@ jobs:
             cc: mips-linux-gnu-gcc
             cxx: mips-linux-gnu-g++
             sanitize: 0
+            tsan: 0
 
           # hppa
           - arch: hppa
@@ -152,10 +174,12 @@ jobs:
             cc: hppa-linux-gnu-gcc
             cxx: hppa-linux-gnu-g++
             sanitize: 0
+            tsan: 0
 
     env:
       FLAGS: -g -O3 -Wall -Wextra -Werror -Wno-sign-compare ${{matrix.build_args.extra_flags}}
       SANITIZE: ${{matrix.build_args.sanitize}}
+      THREAD_SANITIZE: ${{matrix.build_args.tsan}}
 
       # Flags for building sources in src/ dir only.
       LIBURING_CFLAGS: ${{matrix.build_args.liburing_extra_flags}}
@@ -181,7 +205,7 @@ jobs:
           ${{matrix.build_args.cxx}} --version;
 
       - name: Build
-        if: ${{matrix.build_args.sanitize == '0'}}
+        if: ${{matrix.build_args.sanitize == '0' && matrix.build_args.tsan == '0'}}
         run: |
           ./configure --cc=${{matrix.build_args.cc}} --cxx=${{matrix.build_args.cxx}};
           make -j$(nproc) V=1 CPPFLAGS="-Werror" CFLAGS="$FLAGS" CXXFLAGS="$FLAGS";
@@ -192,10 +216,79 @@ jobs:
           ./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: Build
+        if: ${{matrix.build_args.tsan == '1'}}
+        run: |
+          ./configure --cc=${{matrix.build_args.cc}} --cxx=${{matrix.build_args.cxx}} --enable-tsan;
+          make -j$(nproc) V=1 CPPFLAGS="-Werror" CFLAGS="$FLAGS" CXXFLAGS="$FLAGS";
+
       - name: Test install command
         run: |
           sudo make install;
 
+      - name: Test build against the installed liburing
+        run: |
+          export TEST_FILE=".github/workflows/test_build.c";
+          if [ "$SANITIZE" -eq "1" ]; then
+            export SANITIZE_FLAGS="-fsanitize=address,undefined";
+          elif [ "$THREAD_SANITIZE" -eq "1" ]; then
+            export SANITIZE_FLAGS="-fsanitize=thread";
+          else
+            export SANITIZE_FLAGS="";
+          fi;
+          ${{matrix.build_args.cc}} -x c -o a.out $TEST_FILE -luring $SANITIZE_FLAGS;
+          ${{matrix.build_args.cxx}} -x c++ -o a.out $TEST_FILE -luring $SANITIZE_FLAGS;
+
+
+  alpine-musl-build:
+    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
+        with:
+          fetch-depth: 0
+
+      - name: Checkout commit
+        run: |
+          git checkout ${{ matrix.commit }};
+
+      - name: Setup Alpine Environment
+        uses: jirutka/setup-alpine@v1
+        with:
+          branch: v3.15
+
+      - name: Display Alpine version
+        shell: alpine.sh {0}
+        run: cat /etc/alpine-release;
+
+      - name: Install build dependencies
+        shell: alpine.sh --root {0}
+        run: |
+          apk add --no-cache build-base musl-dev linux-headers;
+
+      - name: Build
+        shell: alpine.sh {0}
+        run: |
+          ./configure --cc=gcc --cxx=g++;
+          make -j$(nproc) V=1 CPPFLAGS="-Werror" CFLAGS="$FLAGS" CXXFLAGS="$FLAGS";
+
+      - name: Test install command
+        shell: alpine.sh --root {0}
+        run: |
+          make install;
+
+      - name: Test build against the installed liburing
+        shell: alpine.sh {0}
+        run: |
+          export TEST_FILE=".github/workflows/test_build.c";
+          gcc -x c -o a.out $TEST_FILE -luring;
+          g++ -x c++ -o a.out $TEST_FILE -luring;
+
 
   codespell:
     needs: get_commit_list

data/vendor/liburing/.github/workflows/test_build.c

@@ -0,0 +1,9 @@
+#include <liburing.h>
+
+int main(void)
+{
+	struct io_uring ring;
+	io_uring_queue_init(8, &ring, 0);
+	io_uring_queue_exit(&ring);
+	return 0;
+}

data/vendor/liburing/configure

@@ -30,6 +30,8 @@ for opt do
   ;;
   --enable-sanitizer) use_sanitizer=yes
   ;;
+  --enable-tsan) use_tsan=yes
+  ;;
   *)
     echo "ERROR: unknown option $opt"
     echo "Try '$0 --help' for more information"
@@ -379,6 +381,22 @@ if compile_prog "" "" "has_ucontext"; then
 fi
 print_config "has_ucontext" "$has_ucontext"
 
+##########################################
+# check for memfd_create(2)
+has_memfd_create="no"
+cat > $TMPC << EOF
+#include <sys/mman.h>
+int main(int argc, char **argv)
+{
+  int memfd = memfd_create("test", 0);
+  return 0;
+}
+EOF
+if compile_prog "-Werror=implicit-function-declaration" "" "has_memfd_create"; then
+  has_memfd_create="yes"
+fi
+print_config "has_memfd_create" "$has_memfd_create"
+
 ##########################################
 # Check NVME_URING_CMD support
 nvme_uring_cmd="no"
@@ -539,6 +557,9 @@ fi
 if test "$array_bounds" = "yes"; then
   output_sym "CONFIG_HAVE_ARRAY_BOUNDS"
 fi
+if test "$has_memfd_create" = "yes"; then
+  output_sym "CONFIG_HAVE_MEMFD_CREATE"
+fi
 if test "$nvme_uring_cmd" = "yes"; then
   output_sym "CONFIG_HAVE_NVME_URING"
 fi
@@ -557,6 +578,12 @@ if test "$use_sanitizer" = "yes"; then
 else
   print_config "use sanitizer" "no"
 fi
+if test "$use_tsan" = "yes"; then
+  output_sym "CONFIG_USE_TSAN"
+  print_config "use tsan" "yes"
+else
+  print_config "use tsan" "no"
+fi
 
 echo "CC=$cc" >> $config_host_mak
 print_config "CC" "$cc"

data/vendor/liburing/examples/Makefile

@@ -19,6 +19,12 @@ ifeq ($(CONFIG_USE_SANITIZER),y)
 	override LDFLAGS += -fsanitize=address,undefined
 endif
 
+ifeq ($(CONFIG_USE_TSAN),y)
+	override CFLAGS += -fsanitize=thread -fno-omit-frame-pointer -fno-optimize-sibling-calls
+	override CPPFLAGS += -fsanitize=thread -fno-omit-frame-pointer -fno-optimize-sibling-calls
+	override LDFLAGS += -fsanitize=thread -ltsan
+endif
+
 example_srcs := \
 	io_uring-close-test.c \
 	io_uring-cp.c \

data/vendor/liburing/examples/helpers.c

@@ -13,6 +13,14 @@
 
 #include "helpers.h"
 
+#ifndef CONFIG_HAVE_MEMFD_CREATE
+#include <sys/syscall.h>
+int memfd_create(const char *name, unsigned int flags)
+{
+	return (int)syscall(SYS_memfd_create, name, flags);
+}
+#endif
+
 int setup_listening_socket(int port, int ipv6)
 {
 	struct sockaddr_in srv_addr = { };

data/vendor/liburing/examples/helpers.h

@@ -17,4 +17,9 @@ void *t_aligned_alloc(size_t alignment, size_t size);
 
 void t_error(int status, int errnum, const char *format, ...);
 
+#ifndef CONFIG_HAVE_MEMFD_CREATE
+#include <linux/memfd.h>
+#endif
+int memfd_create(const char *name, unsigned int flags);
+
 #endif

data/vendor/liburing/liburing.spec

@@ -1,5 +1,5 @@
 Name: liburing
-Version: 2.11
+Version: 2.13
 Release: 1%{?dist}
 Summary: Linux-native io_uring I/O access library
 License: (GPLv2 with exceptions and LGPLv2+) or MIT

data/vendor/liburing/src/Makefile

@@ -62,6 +62,12 @@ ifeq ($(CONFIG_USE_SANITIZER),y)
 	liburing_srcs += sanitize.c
 endif
 
+ifeq ($(CONFIG_USE_TSAN),y)
+	override CFLAGS += -fsanitize=thread -fno-omit-frame-pointer -fno-optimize-sibling-calls
+	override CPPFLAGS += -fsanitize=thread -fno-omit-frame-pointer -fno-optimize-sibling-calls
+	override LINK_FLAGS += -fsanitize=thread -ltsan
+endif
+
 override CPPFLAGS += -MT "$@" -MMD -MP -MF "$@.d"
 liburing_objs := $(patsubst %.c,%.ol,$(liburing_srcs))
 liburing_sobjs := $(patsubst %.c,%.os,$(liburing_srcs))
@@ -74,9 +80,7 @@ liburing_ffi_sobjs := ffi.os
 %.ol: %.c
 	$(QUIET_CC)$(CC) $(CPPFLAGS) $(L_CFLAGS) -c -o $@ $<
 
-# Include compiler generated dependency files.
--include $(liburing_objs:%=%.d)
--include $(liburing_sobjs:%=%.d)
+-include $(liburing_objs:%=%.d) $(liburing_sobjs:%=%.d) $(liburing_ffi_objs:%=%.d) $(liburing_ffi_sobjs:%=%.d)
 
 AR ?= ar
 RANLIB ?= ranlib
@@ -102,6 +106,7 @@ install: $(all_targets)
 	install -D -m 644 include/liburing/compat.h $(includedir)/liburing/compat.h
 	install -D -m 644 include/liburing/barrier.h $(includedir)/liburing/barrier.h
 	install -D -m 644 include/liburing/io_uring_version.h $(includedir)/liburing/io_uring_version.h
+	install -D -m 644 include/liburing/io_uring/query.h $(includedir)/liburing/io_uring/query.h
 	install -D -m 644 liburing.a $(libdevdir)/liburing.a
 	install -D -m 644 liburing-ffi.a $(libdevdir)/liburing-ffi.a
 ifeq ($(ENABLE_SHARED),1)
@@ -120,6 +125,7 @@ uninstall:
 	@rm -f $(includedir)/liburing/barrier.h
 	@rm -f $(includedir)/liburing/sanitize.h
 	@rm -f $(includedir)/liburing/io_uring_version.h
+	@rm -f $(includedir)/liburing/io_uring/query.h
 	@rm -f $(libdevdir)/liburing.a
 	@rm -f $(libdevdir)/liburing-ffi.a
 ifeq ($(ENABLE_SHARED),1)

data/vendor/liburing/src/include/liburing/barrier.h

@@ -23,15 +23,18 @@ after the acquire operation executes. This is implemented using
 
 #ifdef __cplusplus
 #include <atomic>
+#define LIBURING_NOEXCEPT noexcept
 
 template <typename T>
-static inline void IO_URING_WRITE_ONCE(T &var, T val)
+_LOCAL_INLINE void IO_URING_WRITE_ONCE(T &var, T val)
+	LIBURING_NOEXCEPT
 {
 	std::atomic_store_explicit(reinterpret_cast<std::atomic<T> *>(&var),
 				   val, std::memory_order_relaxed);
 }
 template <typename T>
-static inline T IO_URING_READ_ONCE(const T &var)
+_LOCAL_INLINE T IO_URING_READ_ONCE(const T &var)
+	LIBURING_NOEXCEPT
 {
 	return std::atomic_load_explicit(
 		reinterpret_cast<const std::atomic<T> *>(&var),
@@ -39,21 +42,24 @@ static inline T IO_URING_READ_ONCE(const T &var)
 }
 
 template <typename T>
-static inline void io_uring_smp_store_release(T *p, T v)
+_LOCAL_INLINE void io_uring_smp_store_release(T *p, T v)
+	LIBURING_NOEXCEPT
 {
 	std::atomic_store_explicit(reinterpret_cast<std::atomic<T> *>(p), v,
 				   std::memory_order_release);
 }
 
 template <typename T>
-static inline T io_uring_smp_load_acquire(const T *p)
+_LOCAL_INLINE T io_uring_smp_load_acquire(const T *p)
+	LIBURING_NOEXCEPT
 {
 	return std::atomic_load_explicit(
 		reinterpret_cast<const std::atomic<T> *>(p),
 		std::memory_order_acquire);
 }
 
-static inline void io_uring_smp_mb()
+_LOCAL_INLINE void io_uring_smp_mb()
+	LIBURING_NOEXCEPT
 {
 	std::atomic_thread_fence(std::memory_order_seq_cst);
 }

data/vendor/liburing/src/include/liburing/io_uring/query.h

@@ -0,0 +1,41 @@
+/* SPDX-License-Identifier: (GPL-2.0 WITH Linux-syscall-note) OR MIT */
+/*
+ * Header file for the io_uring query interface.
+ */
+#ifndef LINUX_IO_URING_QUERY_H
+#define LINUX_IO_URING_QUERY_H
+
+#include <linux/types.h>
+
+struct io_uring_query_hdr {
+	__u64 next_entry;
+	__u64 query_data;
+	__u32 query_op;
+	__u32 size;
+	__s32 result;
+	__u32 __resv[3];
+};
+
+enum {
+	IO_URING_QUERY_OPCODES			= 0,
+
+	__IO_URING_QUERY_MAX,
+};
+
+/* Doesn't require a ring */
+struct io_uring_query_opcode {
+	/* The number of supported IORING_OP_* opcodes */
+	__u32	nr_request_opcodes;
+	/* The number of supported IORING_[UN]REGISTER_* opcodes */
+	__u32	nr_register_opcodes;
+	/* Bitmask of all supported IORING_FEAT_* flags */
+	__u64	feature_flags;
+	/* Bitmask of all supported IORING_SETUP_* flags */
+	__u64	ring_setup_flags;
+	/* Bitmask of all supported IORING_ENTER_** flags */
+	__u64	enter_flags;
+	/* Bitmask of all supported IOSQE_* flags */
+	__u64	sqe_flags;
+};
+
+#endif

data/vendor/liburing/src/include/liburing/io_uring.h

@@ -73,6 +73,7 @@ struct io_uring_sqe {
 		__u32		futex_flags;
 		__u32		install_fd_flags;
 		__u32		nop_flags;
+		__u32		pipe_flags;
 	};
 	__u64	user_data;	/* data to be passed back at completion time */
 	/* pack this to avoid bogus arm OABI complaints */
@@ -99,6 +100,10 @@ struct io_uring_sqe {
 			__u64	addr3;
 			__u64	__pad2[1];
 		};
+		struct {
+			__u64   attr_ptr; /* pointer to attribute information */
+			__u64   attr_type_mask; /* bit mask of attributes */
+                };
 		__u64	optval;
 		/*
 		 * If the ring is initialized with IORING_SETUP_SQE128, then
@@ -108,6 +113,18 @@ struct io_uring_sqe {
 	};
 };
 
+/* sqe->attr_type_mask flags */
+#define IORING_RW_ATTR_FLAG_PI  (1U << 0)
+/* PI attribute information */
+struct io_uring_attr_pi {
+		__u16	flags;
+		__u16	app_tag;
+		__u32	len;
+		__u64	addr;
+		__u64	seed;
+		__u64	rsvd;
+};
+
 /*
  * If sqe->file_index is set to this for opcodes that instantiate a new
  * direct descriptor (like openat/openat2/accept), then io_uring will allocate
@@ -204,6 +221,18 @@ enum io_uring_sqe_flags_bit {
 /* Use hybrid poll in iopoll process */
 #define IORING_SETUP_HYBRID_IOPOLL	(1U << 17)
 
+/*
+ * Allow both 16b and 32b CQEs. If a 32b CQE is posted, it will have
+ * IORING_CQE_F_32 set in cqe->flags.
+ */
+#define IORING_SETUP_CQE_MIXED		(1U << 18)
+
+/*
+ *  Allow both 64b and 128b SQEs. If a 128b SQE is posted, it will use a 128b
+ *  opcode.
+ */
+#define IORING_SETUP_SQE_MIXED		(1U << 19)
+
 enum io_uring_op {
 	IORING_OP_NOP,
 	IORING_OP_READV,
@@ -267,6 +296,9 @@ enum io_uring_op {
 	IORING_OP_EPOLL_WAIT,
 	IORING_OP_READV_FIXED,
 	IORING_OP_WRITEV_FIXED,
+	IORING_OP_PIPE,
+	IORING_OP_NOP128,
+	IORING_OP_URING_CMD128,
 
 	/* this goes last, obviously */
 	IORING_OP_LAST,
@@ -370,12 +402,16 @@ enum io_uring_op {
  *				the starting buffer ID in cqe->flags as per
  *				usual for provided buffer usage. The buffers
  *				will be	contiguous from the starting buffer ID.
+ *
+ * IORING_SEND_VECTORIZED	If set, SEND[_ZC] will take a pointer to a io_vec
+ *				to allow vectorized send operations.
  */
 #define IORING_RECVSEND_POLL_FIRST	(1U << 0)
 #define IORING_RECV_MULTISHOT		(1U << 1)
 #define IORING_RECVSEND_FIXED_BUF	(1U << 2)
 #define IORING_SEND_ZC_REPORT_USAGE	(1U << 3)
 #define IORING_RECVSEND_BUNDLE		(1U << 4)
+#define IORING_SEND_VECTORIZED		(1U << 5)
 
 /*
  * cqe.res for IORING_CQE_F_NOTIF if
@@ -424,6 +460,7 @@ enum io_uring_msg_ring_flags {
  * IORING_NOP_INJECT_RESULT	Inject result from sqe->result
  */
 #define IORING_NOP_INJECT_RESULT	(1U << 0)
+#define IORING_NOP_CQE32		(1U << 5)
 
 /*
  * IO completion data structure (Completion Queue Entry)
@@ -457,12 +494,22 @@ struct io_uring_cqe {
  *			other provided buffer type, all completions with a
  *			buffer passed back is automatically returned to the
  *			application.
+ * IORING_CQE_F_SKIP	If set, then the application/liburing must ignore this
+ *			CQE. It's only purpose is to fill a gap in the ring,
+ *			if a large CQE is attempted posted when the ring has
+ *			just a single small CQE worth of space left before
+ *			wrapping.
+ * IORING_CQE_F_32	If set, this is a 32b/big-cqe posting. Use with rings
+ *			setup in a mixed CQE mode, where both 16b and 32b
+ *			CQEs may be posted to the CQ ring.
  */
 #define IORING_CQE_F_BUFFER		(1U << 0)
 #define IORING_CQE_F_MORE		(1U << 1)
 #define IORING_CQE_F_SOCK_NONEMPTY	(1U << 2)
 #define IORING_CQE_F_NOTIF		(1U << 3)
 #define IORING_CQE_F_BUF_MORE		(1U << 4)
+#define IORING_CQE_F_SKIP		(1U << 5)
+#define IORING_CQE_F_32			(1U << 15)
 
 #define IORING_CQE_BUFFER_SHIFT		16
 
@@ -635,6 +682,9 @@ enum io_uring_register_op {
 
 	IORING_REGISTER_MEM_REGION		= 34,
 
+	/* query various aspects of io_uring, see linux/io_uring/query.h */
+	IORING_REGISTER_QUERY			= 35,
+
 	/* this goes last */
 	IORING_REGISTER_LAST,
 

data/vendor/liburing/src/include/liburing/sanitize.h

@@ -2,6 +2,12 @@
 #ifndef LIBURING_SANITIZE_H
 #define LIBURING_SANITIZE_H
 
+#ifdef __cplusplus
+#define LIBURING_NOEXCEPT noexcept
+#else
+#define LIBURING_NOEXCEPT
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -10,24 +16,30 @@ struct io_uring;
 struct iovec;
 
 #if defined(CONFIG_USE_SANITIZER)
-void liburing_sanitize_ring(struct io_uring *ring);
-void liburing_sanitize_address(const void *addr);
-void liburing_sanitize_region(const void *addr, unsigned int len);
-void liburing_sanitize_iovecs(const struct iovec *iovecs, unsigned nr);
+void liburing_sanitize_ring(struct io_uring *ring) LIBURING_NOEXCEPT;
+void liburing_sanitize_address(const void *addr) LIBURING_NOEXCEPT;
+void liburing_sanitize_region(const void *addr, unsigned int len)
+	LIBURING_NOEXCEPT;
+void liburing_sanitize_iovecs(const struct iovec *iovecs, unsigned nr)
+	LIBURING_NOEXCEPT;
 #else
 #define __maybe_unused	__attribute__((__unused__))
 static inline void liburing_sanitize_ring(struct io_uring __maybe_unused *ring)
+   LIBURING_NOEXCEPT
 {
 }
 static inline void liburing_sanitize_address(const void __maybe_unused *addr)
+   LIBURING_NOEXCEPT
 {
 }
 static inline void liburing_sanitize_region(const void __maybe_unused *addr,
 					    unsigned int __maybe_unused len)
+   LIBURING_NOEXCEPT
 {
 }
 static inline void liburing_sanitize_iovecs(const struct iovec __maybe_unused *iovecs,
 					    unsigned __maybe_unused nr)
+   LIBURING_NOEXCEPT
 {
 }
 #endif