uringmachine 0.8.2 → 0.11

data/vendor/liburing/src/arch/syscall-defs.h

@@ -76,11 +76,11 @@ static inline int __sys_io_uring_setup(unsigned int entries,
 
 static inline int __sys_io_uring_enter2(unsigned int fd, unsigned int to_submit,
 					unsigned int min_complete,
-					unsigned int flags, sigset_t *sig,
+					unsigned int flags, void *arg,
 					size_t sz)
 {
 	return (int) __do_syscall6(__NR_io_uring_enter, fd, to_submit,
-				   min_complete, flags, sig, sz);
+				   min_complete, flags, arg, sz);
 }
 
 static inline int __sys_io_uring_enter(unsigned int fd, unsigned int to_submit,

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

@@ -87,6 +87,7 @@ struct io_uring_sqe {
 	union {
 		__s32	splice_fd_in;
 		__u32	file_index;
+		__u32	zcrx_ifq_idx;
 		__u32	optlen;
 		struct {
 			__u16	addr_len;
@@ -200,6 +201,9 @@ enum io_uring_sqe_flags_bit {
  */
 #define IORING_SETUP_NO_SQARRAY		(1U << 16)
 
+/* Use hybrid poll in iopoll process */
+#define IORING_SETUP_HYBRID_IOPOLL	(1U << 17)
+
 enum io_uring_op {
 	IORING_OP_NOP,
 	IORING_OP_READV,
@@ -259,6 +263,10 @@ enum io_uring_op {
 	IORING_OP_FTRUNCATE,
 	IORING_OP_BIND,
 	IORING_OP_LISTEN,
+	IORING_OP_RECV_ZC,
+	IORING_OP_EPOLL_WAIT,
+	IORING_OP_READV_FIXED,
+	IORING_OP_WRITEV_FIXED,
 
 	/* this goes last, obviously */
 	IORING_OP_LAST,
@@ -361,7 +369,7 @@ enum io_uring_op {
  *				result 	will be the number of buffers send, with
  *				the starting buffer ID in cqe->flags as per
  *				usual for provided buffer usage. The buffers
- *				will be contiguous from the starting buffer ID.
+ *				will be	contiguous from the starting buffer ID.
  */
 #define IORING_RECVSEND_POLL_FIRST	(1U << 0)
 #define IORING_RECV_MULTISHOT		(1U << 1)
@@ -421,7 +429,7 @@ enum io_uring_msg_ring_flags {
  * IO completion data structure (Completion Queue Entry)
  */
 struct io_uring_cqe {
-	__u64	user_data;	/* sqe->user_data submission passed back */
+	__u64	user_data;	/* sqe->user_data value passed back */
 	__s32	res;		/* result code for this event */
 	__u32	flags;
 
@@ -519,6 +527,7 @@ struct io_cqring_offsets {
 #define IORING_ENTER_REGISTERED_RING	(1U << 4)
 #define IORING_ENTER_ABS_TIMER		(1U << 5)
 #define IORING_ENTER_EXT_ARG_REG	(1U << 6)
+#define IORING_ENTER_NO_IOWAIT		(1U << 7)
 
 /*
  * Passed in for io_uring_setup(2). Copied back with updated info on success
@@ -555,6 +564,8 @@ struct io_uring_params {
 #define IORING_FEAT_REG_REG_RING	(1U << 13)
 #define IORING_FEAT_RECVSEND_BUNDLE	(1U << 14)
 #define IORING_FEAT_MIN_TIMEOUT		(1U << 15)
+#define IORING_FEAT_RW_ATTR		(1U << 16)
+#define IORING_FEAT_NO_IOWAIT		(1U << 17)
 
 /*
  * io_uring_register(2) opcodes and arguments
@@ -613,9 +624,16 @@ enum io_uring_register_op {
 	/* clone registered buffers from source ring to current ring */
 	IORING_REGISTER_CLONE_BUFFERS		= 30,
 
+	/* send MSG_RING without having a ring */
+	IORING_REGISTER_SEND_MSG_RING		= 31,
+
+	/* register a netdev hw rx queue for zerocopy */
+	IORING_REGISTER_ZCRX_IFQ		= 32,
+
+	/* resize CQ ring */
 	IORING_REGISTER_RESIZE_RINGS		= 33,
 
-	IORING_REGISTER_CQWAIT_REG		= 34,
+	IORING_REGISTER_MEM_REGION		= 34,
 
 	/* this goes last */
 	IORING_REGISTER_LAST,
@@ -637,6 +655,31 @@ struct io_uring_files_update {
 	__aligned_u64 /* __s32 * */ fds;
 };
 
+enum {
+	/* initialise with user provided memory pointed by user_addr */
+	IORING_MEM_REGION_TYPE_USER		= 1,
+};
+
+struct io_uring_region_desc {
+	__u64 user_addr;
+	__u64 size;
+	__u32 flags;
+	__u32 id;
+	__u64 mmap_offset;
+	__u64 __resv[4];
+};
+
+enum {
+	/* expose the region as registered wait arguments */
+	IORING_MEM_REGION_REG_WAIT_ARG		= 1,
+};
+
+struct io_uring_mem_region_reg {
+	__u64 region_uptr; /* struct io_uring_region_desc * */
+	__u64 flags;
+	__u64 __resv[2];
+};
+
 /*
  * Register a fully sparse file space, rather than pass in an array of all
  * -1 file descriptors.
@@ -808,20 +851,6 @@ enum {
 	IORING_REG_WAIT_TS		= (1U << 0),
 };
 
-/*
- * Argument for IORING_REGISTER_CQWAIT_REG, registering a region of
- * struct io_uring_reg_wait that can be indexed when io_uring_enter(2) is
- * called rather than pass in a wait argument structure separately.
- */
-struct io_uring_cqwait_reg_arg {
-	__u32		flags;
-	__u32		struct_size;
-	__u32		nr_entries;
-	__u32		pad;
-	__u64		user_addr;
-	__u64		pad2[3];
-};
-
 /*
  * Argument for io_uring_enter(2) with
  * IORING_GETEVENTS | IORING_ENTER_EXT_ARG_REG set, where the actual argument
@@ -888,6 +917,61 @@ enum io_uring_socket_op {
 	SOCKET_URING_OP_SETSOCKOPT,
 };
 
+/* Zero copy receive refill queue entry */
+struct io_uring_zcrx_rqe {
+	__u64	off;
+	__u32	len;
+	__u32	__pad;
+};
+
+struct io_uring_zcrx_cqe {
+	__u64	off;
+	__u64	__pad;
+};
+
+/* The bit from which area id is encoded into offsets */
+#define IORING_ZCRX_AREA_SHIFT	48
+#define IORING_ZCRX_AREA_MASK	(~(((__u64)1 << IORING_ZCRX_AREA_SHIFT) - 1))
+
+struct io_uring_zcrx_offsets {
+	__u32	head;
+	__u32	tail;
+	__u32	rqes;
+	__u32	__resv2;
+	__u64	__resv[2];
+};
+
+enum io_uring_zcrx_area_flags {
+	IORING_ZCRX_AREA_DMABUF		= 1,
+};
+
+struct io_uring_zcrx_area_reg {
+	__u64	addr;
+	__u64	len;
+	__u64	rq_area_token;
+	__u32	flags;
+	__u32	dmabuf_fd;
+	__u64	__resv2[2];
+};
+
+/*
+ * Argument for IORING_REGISTER_ZCRX_IFQ
+ */
+struct io_uring_zcrx_ifq_reg {
+	__u32	if_idx;
+	__u32	if_rxq;
+	__u32	rq_entries;
+	__u32	flags;
+
+	__u64	area_ptr; /* pointer to struct io_uring_zcrx_area_reg */
+	__u64	region_ptr; /* struct io_uring_region_desc * */
+
+	struct io_uring_zcrx_offsets offsets;
+	__u32	zcrx_id;
+	__u32	__resv2;
+	__u64	__resv[3];
+};
+
 #ifdef __cplusplus
 }
 #endif

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

@@ -132,6 +132,16 @@ struct io_uring {
 	unsigned pad2;
 };
 
+struct io_uring_zcrx_rq {
+	__u32 *khead;
+	__u32 *ktail;
+	__u32 rq_tail;
+	unsigned ring_entries;
+
+	struct io_uring_zcrx_rqe *rqes;
+	void *ring_ptr;
+};
+
 /*
  * Library interface
  */
@@ -206,7 +216,12 @@ int io_uring_resize_rings(struct io_uring *ring, struct io_uring_params *p);
 int io_uring_clone_buffers_offset(struct io_uring *dst, struct io_uring *src,
 				  unsigned int dst_off, unsigned int src_off,
 				  unsigned int nr, unsigned int flags);
+int __io_uring_clone_buffers_offset(struct io_uring *dst, struct io_uring *src,
+				  unsigned int dst_off, unsigned int src_off,
+				  unsigned int nr, unsigned int flags);
 int io_uring_clone_buffers(struct io_uring *dst, struct io_uring *src);
+int __io_uring_clone_buffers(struct io_uring *dst, struct io_uring *src,
+				unsigned int flags);
 int io_uring_register_buffers(struct io_uring *ring, const struct iovec *iovecs,
 			      unsigned nr_iovecs);
 int io_uring_register_buffers_tags(struct io_uring *ring,
@@ -265,6 +280,8 @@ int io_uring_register_file_alloc_range(struct io_uring *ring,
 
 int io_uring_register_napi(struct io_uring *ring, struct io_uring_napi *napi);
 int io_uring_unregister_napi(struct io_uring *ring, struct io_uring_napi *napi);
+int io_uring_register_ifq(struct io_uring *ring,
+			  struct io_uring_zcrx_ifq_reg *reg);
 
 int io_uring_register_clock(struct io_uring *ring,
 			    struct io_uring_clock_register *arg);
@@ -279,17 +296,16 @@ int io_uring_enter(unsigned int fd, unsigned int to_submit,
 		   unsigned int min_complete, unsigned int flags, sigset_t *sig);
 int io_uring_enter2(unsigned int fd, unsigned int to_submit,
 		    unsigned int min_complete, unsigned int flags,
-		    sigset_t *sig, size_t sz);
+		    void *arg, size_t sz);
 int io_uring_setup(unsigned int entries, struct io_uring_params *p);
 int io_uring_register(unsigned int fd, unsigned int opcode, const void *arg,
 		      unsigned int nr_args);
 
 /*
- * Mapped/registered wait regions
+ * Mapped/registered regions
  */
-struct io_uring_reg_wait *io_uring_setup_reg_wait(struct io_uring *ring,
-						  unsigned nentries, int *err);
-void io_uring_free_reg_wait(struct io_uring_reg_wait *reg, unsigned nentries);
+int io_uring_register_region(struct io_uring *ring,
+			     struct io_uring_mem_region_reg *reg);
 
 /*
  * Mapped buffer ring alloc/register + unregister/free helpers
@@ -309,34 +325,69 @@ int __io_uring_get_cqe(struct io_uring *ring,
 			struct io_uring_cqe **cqe_ptr, unsigned submit,
 			unsigned wait_nr, sigset_t *sigmask);
 
+/*
+ * Enable/disable setting of iowait by the kernel.
+ */
+int io_uring_set_iowait(struct io_uring *ring, bool enable_iowait);
+
 #define LIBURING_UDATA_TIMEOUT	((__u64) -1)
 
 /*
- * Calculates the step size for CQE iteration.
- * 	For standard CQE's its 1, for big CQE's its two.
+ * Returns the bit shift needed to index the CQ.
+ * This shift is 1 for rings with big CQEs, and 0 for rings with normal CQEs.
+ * CQE `index` can be computed as &cq.cqes[(index & cq.ring_mask) << cqe_shift].
  */
-#define io_uring_cqe_shift(ring)					\
-	(!!((ring)->flags & IORING_SETUP_CQE32))
+IOURINGINLINE unsigned io_uring_cqe_shift_from_flags(unsigned flags)
+{
+	return !!(flags & IORING_SETUP_CQE32);
+}
+
+IOURINGINLINE unsigned io_uring_cqe_shift(const struct io_uring *ring)
+{
+	return io_uring_cqe_shift_from_flags(ring->flags);
+}
+
+struct io_uring_cqe_iter {
+	struct io_uring_cqe *cqes;
+	unsigned mask;
+	unsigned shift;
+	unsigned head;
+	unsigned tail;
+};
+
+IOURINGINLINE struct io_uring_cqe_iter
+io_uring_cqe_iter_init(const struct io_uring *ring)
+{
+	return (struct io_uring_cqe_iter) {
+		.cqes = ring->cq.cqes,
+		.mask = ring->cq.ring_mask,
+		.shift = io_uring_cqe_shift(ring),
+		.head = *ring->cq.khead,
+		/* Acquire ordering ensures tail is loaded before any CQEs */
+		.tail = io_uring_smp_load_acquire(ring->cq.ktail),
+	};
+}
 
-#define io_uring_cqe_index(ring,ptr,mask)				\
-	(((ptr) & (mask)) << io_uring_cqe_shift(ring))
+IOURINGINLINE bool io_uring_cqe_iter_next(struct io_uring_cqe_iter *iter,
+					  struct io_uring_cqe **cqe)
+{
+	if (iter->head == iter->tail)
+		return false;
+
+	*cqe = &iter->cqes[(iter->head++ & iter->mask) << iter->shift];
+	return true;
+}
 
 /*
- * NOTE: we should just get rid of the 'head' being passed in here, it doesn't
+ * NOTE: we should just get rid of the '__head__' being passed in here, it doesn't
  * serve a purpose anymore. The below is a bit of a work-around to ensure that
- * the compiler doesn't complain about 'head' being unused (or only written,
+ * the compiler doesn't complain about '__head__' being unused (or only written,
  * never read), as we use a local iterator for both the head and tail tracking.
  */
-#define io_uring_for_each_cqe(ring, head, cqe)				\
-	/*								\
-	 * io_uring_smp_load_acquire() enforces the order of tail	\
-	 * and CQE reads.						\
-	 */								\
-	for (__u32 __HEAD__ = (head) = *(ring)->cq.khead,		\
-	     __TAIL__ = io_uring_smp_load_acquire((ring)->cq.ktail);	\
-	     (cqe = ((head) != __TAIL__ ?				\
-	     &(ring)->cq.cqes[io_uring_cqe_index(ring, __HEAD__, (ring)->cq.ring_mask)] : NULL)); \
-	     (head) = ++__HEAD__)
+#define io_uring_for_each_cqe(ring, __head__, cqe)					\
+	for (struct io_uring_cqe_iter __ITER__ = io_uring_cqe_iter_init(ring);	\
+	     (__head__) = __ITER__.head, io_uring_cqe_iter_next(&__ITER__, &(cqe));	\
+	     (void)(__head__))
 
 /*
  * Must be called after io_uring_for_each_cqe()
@@ -410,6 +461,12 @@ IOURINGINLINE void io_uring_sqe_set_flags(struct io_uring_sqe *sqe,
 	sqe->flags = (__u8) flags;
 }
 
+IOURINGINLINE void io_uring_sqe_set_buf_group(struct io_uring_sqe *sqe,
+					      int bgid)
+{
+	sqe->buf_group = (__u16) bgid;
+}
+
 IOURINGINLINE void __io_uring_set_target_fixed_file(struct io_uring_sqe *sqe,
 						    unsigned int file_index)
 {
@@ -509,6 +566,16 @@ IOURINGINLINE void io_uring_prep_read_fixed(struct io_uring_sqe *sqe, int fd,
 	sqe->buf_index = (__u16) buf_index;
 }
 
+IOURINGINLINE void io_uring_prep_readv_fixed(struct io_uring_sqe *sqe, int fd,
+					     const struct iovec *iovecs,
+					     unsigned nr_vecs, __u64 offset,
+					     int flags, int buf_index)
+{
+	io_uring_prep_readv2(sqe, fd, iovecs, nr_vecs, offset, flags);
+	sqe->opcode = IORING_OP_READV_FIXED;
+	sqe->buf_index = (__u16)buf_index;
+}
+
 IOURINGINLINE void io_uring_prep_writev(struct io_uring_sqe *sqe, int fd,
 					const struct iovec *iovecs,
 					unsigned nr_vecs, __u64 offset)
@@ -533,6 +600,16 @@ IOURINGINLINE void io_uring_prep_write_fixed(struct io_uring_sqe *sqe, int fd,
 	sqe->buf_index = (__u16) buf_index;
 }
 
+IOURINGINLINE void io_uring_prep_writev_fixed(struct io_uring_sqe *sqe, int fd,
+				       const struct iovec *iovecs,
+				       unsigned nr_vecs, __u64 offset,
+				       int flags, int buf_index)
+{
+	io_uring_prep_writev2(sqe, fd, iovecs, nr_vecs, offset, flags);
+	sqe->opcode = IORING_OP_WRITEV_FIXED;
+	sqe->buf_index = (__u16)buf_index;
+}
+
 IOURINGINLINE void io_uring_prep_recvmsg(struct io_uring_sqe *sqe, int fd,
 					 struct msghdr *msg, unsigned flags)
 {
@@ -724,6 +801,15 @@ IOURINGINLINE void io_uring_prep_listen(struct io_uring_sqe *sqe, int fd,
 	io_uring_prep_rw(IORING_OP_LISTEN, sqe, fd, 0, backlog, 0);
 }
 
+struct epoll_event;
+IOURINGINLINE void io_uring_prep_epoll_wait(struct io_uring_sqe *sqe, int fd,
+					    struct epoll_event *events,
+					    int maxevents, unsigned flags)
+{
+	io_uring_prep_rw(IORING_OP_EPOLL_WAIT, sqe, fd, events, maxevents, 0);
+	sqe->rw_flags = flags;
+}
+
 IOURINGINLINE void io_uring_prep_files_update(struct io_uring_sqe *sqe,
 					      int *fds, unsigned nr_fds,
 					      int offset)
@@ -908,6 +994,17 @@ IOURINGINLINE void io_uring_prep_sendmsg_zc(struct io_uring_sqe *sqe, int fd,
 	sqe->opcode = IORING_OP_SENDMSG_ZC;
 }
 
+IOURINGINLINE void io_uring_prep_sendmsg_zc_fixed(struct io_uring_sqe *sqe,
+						int fd,
+						const struct msghdr *msg,
+						unsigned flags,
+						unsigned buf_index)
+{
+	io_uring_prep_sendmsg_zc(sqe, fd, msg, flags);
+	sqe->ioprio |= IORING_RECVSEND_FIXED_BUF;
+	sqe->buf_index = buf_index;
+}
+
 IOURINGINLINE void io_uring_prep_recv(struct io_uring_sqe *sqe, int sockfd,
 				      void *buf, size_t len, int flags)
 {
@@ -1318,26 +1415,28 @@ IOURINGINLINE void io_uring_prep_cmd_discard(struct io_uring_sqe *sqe,
 	sqe->addr3 = nbytes;
 }
 
+/* Read the kernel's SQ head index with appropriate memory ordering */
+IOURINGINLINE unsigned io_uring_load_sq_head(const struct io_uring *ring)
+{
+	/*
+	 * Without acquire ordering, we could overwrite a SQE before the kernel
+	 * finished reading it. We don't need the acquire ordering for
+	 * non-SQPOLL since then we drive updates.
+	 */
+	if (ring->flags & IORING_SETUP_SQPOLL)
+		return io_uring_smp_load_acquire(ring->sq.khead);
+
+	return *ring->sq.khead;
+}
+
 /*
  * Returns number of unconsumed (if SQPOLL) or unsubmitted entries exist in
  * the SQ ring
  */
 IOURINGINLINE unsigned io_uring_sq_ready(const struct io_uring *ring)
 {
-	unsigned khead;
-
-	/*
-	 * Without a barrier, we could miss an update and think the SQ wasn't
-	 * ready. We don't need the load acquire for non-SQPOLL since then we
-	 * drive updates.
-	 */
-	if (ring->flags & IORING_SETUP_SQPOLL)
-		khead = io_uring_smp_load_acquire(ring->sq.khead);
-	else
-		khead = *ring->sq.khead;
-
 	/* always use real head, to avoid losing sync for short submit */
-	return ring->sq.sqe_tail - khead;
+	return ring->sq.sqe_tail - io_uring_load_sq_head(ring);
 }
 
 /*
@@ -1348,6 +1447,21 @@ IOURINGINLINE unsigned io_uring_sq_space_left(const struct io_uring *ring)
 	return ring->sq.ring_entries - io_uring_sq_ready(ring);
 }
 
+/*
+ * Returns the bit shift needed to index the SQ.
+ * This shift is 1 for rings with big SQEs, and 0 for rings with normal SQEs.
+ * SQE `index` can be computed as &sq.sqes[(index & sq.ring_mask) << sqe_shift].
+ */
+IOURINGINLINE unsigned io_uring_sqe_shift_from_flags(unsigned flags)
+{
+	return !!(flags & IORING_SETUP_SQE128);
+}
+
+IOURINGINLINE unsigned io_uring_sqe_shift(const struct io_uring *ring)
+{
+	return io_uring_sqe_shift_from_flags(ring->flags);
+}
+
 /*
  * Only applicable when using SQPOLL - allows the caller to wait for space
  * to free up in the SQ ring, which happens when the kernel side thread has
@@ -1402,7 +1516,7 @@ IOURINGINLINE int io_uring_cq_eventfd_toggle(struct io_uring *ring,
 {
 	uint32_t flags;
 
-	if (!!enabled == io_uring_cq_eventfd_enabled(ring))
+	if (enabled == io_uring_cq_eventfd_enabled(ring))
 		return 0;
 
 	if (!ring->cq.kflags)
@@ -1445,10 +1559,7 @@ IOURINGINLINE int __io_uring_peek_cqe(struct io_uring *ring,
 	int err = 0;
 	unsigned available;
 	unsigned mask = ring->cq.ring_mask;
-	int shift = 0;
-
-	if (ring->flags & IORING_SETUP_CQE32)
-		shift = 1;
+	unsigned shift = io_uring_cqe_shift(ring);
 
 	do {
 		unsigned tail = io_uring_smp_load_acquire(ring->cq.ktail);
@@ -1515,26 +1626,16 @@ IOURINGINLINE int io_uring_wait_cqe(struct io_uring *ring,
 IOURINGINLINE struct io_uring_sqe *_io_uring_get_sqe(struct io_uring *ring)
 {
 	struct io_uring_sq *sq = &ring->sq;
-	unsigned int head, next = sq->sqe_tail + 1;
-	int shift = 0;
-
-	if (ring->flags & IORING_SETUP_SQE128)
-		shift = 1;
-	if (!(ring->flags & IORING_SETUP_SQPOLL))
-		head = *sq->khead;
-	else
-		head = io_uring_smp_load_acquire(sq->khead);
-
-	if (next - head <= sq->ring_entries) {
-		struct io_uring_sqe *sqe;
+	unsigned head = io_uring_load_sq_head(ring), tail = sq->sqe_tail;
+	struct io_uring_sqe *sqe;
 
-		sqe = &sq->sqes[(sq->sqe_tail & sq->ring_mask) << shift];
-		sq->sqe_tail = next;
-		io_uring_initialize_sqe(sqe);
-		return sqe;
-	}
+	if (tail - head >= sq->ring_entries)
+		return NULL;
 
-	return NULL;
+	sqe = &sq->sqes[(tail & sq->ring_mask) << io_uring_sqe_shift(ring)];
+	sq->sqe_tail = tail + 1;
+	io_uring_initialize_sqe(sqe);
+	return sqe;
 }
 
 /*
@@ -1614,6 +1715,25 @@ IOURINGINLINE int io_uring_buf_ring_available(struct io_uring *ring,
 	return (uint16_t) (br->tail - head);
 }
 
+/*
+ * As of liburing-2.2, io_uring_get_sqe() has been converted into a
+ * "static inline" function. However, this change breaks seamless
+ * updates of liburing.so, as applications would need to be recompiled.
+ * To ensure backward compatibility, liburing keeps the original
+ * io_uring_get_sqe() symbol available in the shared library.
+ *
+ * To accomplish this, io_uring_get_sqe() is defined as a non-static
+ * inline function when LIBURING_INTERNAL is set, which only applies
+ * during liburing.so builds.
+ *
+ * This strategy ensures new users adopt the "static inline" version
+ * while preserving compatibility for old applications linked against
+ * the shared library.
+ *
+ * Relevant commits:
+ * 8be8af4afcb4 ("queue: provide io_uring_get_sqe() symbol again")
+ * 52dcdbba35c8 ("src/queue: protect io_uring_get_sqe() with LIBURING_INTERNAL")
+ */
 #ifndef LIBURING_INTERNAL
 IOURINGINLINE struct io_uring_sqe *io_uring_get_sqe(struct io_uring *ring)
 {

data/vendor/liburing/src/int_flags.h

@@ -2,12 +2,15 @@
 #ifndef LIBURING_INT_FLAGS
 #define LIBURING_INT_FLAGS
 
-#define INT_FLAGS_MASK		(IORING_ENTER_REGISTERED_RING)
+#define INT_FLAGS_MASK		(IORING_ENTER_REGISTERED_RING |	\
+				 IORING_ENTER_NO_IOWAIT)
 
 enum {
 	INT_FLAG_REG_RING	= IORING_ENTER_REGISTERED_RING,
+	INT_FLAG_NO_IOWAIT	= IORING_ENTER_NO_IOWAIT,
 	INT_FLAG_REG_REG_RING	= 1,
 	INT_FLAG_APP_MEM	= 2,
+	INT_FLAG_CQ_ENTER	= 4,
 };
 
 static inline int ring_enter_flags(struct io_uring *ring)

data/vendor/liburing/src/liburing-ffi.map

@@ -221,7 +221,19 @@ LIBURING_2.9 {
 		io_uring_resize_rings;
 		io_uring_register_wait_reg;
 		io_uring_submit_and_wait_reg;
-		io_uring_free_reg_wait;
-		io_uring_setup_reg_wait;
 		io_uring_clone_buffers_offset;
+		io_uring_register_region;
+		io_uring_sqe_set_buf_group;
 } LIBURING_2.8;
+
+LIBURING_2.10 {
+	global:
+		io_uring_register_ifq;
+		io_uring_prep_epoll_wait;
+		io_uring_prep_writev_fixed;
+		io_uring_prep_readv_fixed;
+		io_uring_prep_sendmsg_zc_fixed;
+		io_uring_set_iowait;
+		__io_uring_clone_buffers;
+		__io_uring_clone_buffers_offset;
+} LIBURING_2.9;

data/vendor/liburing/src/liburing.map

@@ -108,7 +108,14 @@ LIBURING_2.9 {
 		io_uring_resize_rings;
 		io_uring_register_wait_reg;
 		io_uring_submit_and_wait_reg;
-		io_uring_free_reg_wait;
-		io_uring_setup_reg_wait;
 		io_uring_clone_buffers_offset;
+		io_uring_register_region;
 } LIBURING_2.8;
+
+LIBURING_2.10 {
+	global:
+		io_uring_register_ifq;
+		io_uring_set_iowait;
+		__io_uring_clone_buffers;
+		__io_uring_clone_buffers_offset;
+} LIBURING_2.9;