uringmachine 0.10 → 0.11

data/vendor/liburing/src/queue.c

@@ -47,7 +47,7 @@ static inline bool cq_ring_needs_flush(struct io_uring *ring)
 
 static inline bool cq_ring_needs_enter(struct io_uring *ring)
 {
-	return (ring->flags & IORING_SETUP_IOPOLL) || cq_ring_needs_flush(ring);
+	return (ring->int_flags & INT_FLAG_CQ_ENTER) || cq_ring_needs_flush(ring);
 }
 
 struct get_data {
@@ -151,6 +151,31 @@ int io_uring_get_events(struct io_uring *ring)
 	return __sys_io_uring_enter(ring->enter_ring_fd, 0, 0, flags, NULL);
 }
 
+static inline bool io_uring_peek_batch_cqe_(struct io_uring *ring,
+					    struct io_uring_cqe **cqes,
+					    unsigned *count)
+{
+	unsigned ready = io_uring_cq_ready(ring);
+	unsigned shift;
+	unsigned head;
+	unsigned mask;
+	unsigned last;
+
+	if (!ready)
+		return false;
+
+	shift = io_uring_cqe_shift(ring);
+	head = *ring->cq.khead;
+	mask = ring->cq.ring_mask;
+	if (ready < *count)
+		*count = ready;
+	last = head + *count;
+	for (;head != last; head++)
+		*(cqes++) = &ring->cq.cqes[(head & mask) << shift];
+
+	return true;
+}
+
 /*
  * Fill in an array of IO completions up to count, if any are available.
  * Returns the amount of IO completions filled.
@@ -158,39 +183,17 @@ int io_uring_get_events(struct io_uring *ring)
 unsigned io_uring_peek_batch_cqe(struct io_uring *ring,
 				 struct io_uring_cqe **cqes, unsigned count)
 {
-	unsigned ready;
-	bool overflow_checked = false;
-	int shift = 0;
-
-	if (ring->flags & IORING_SETUP_CQE32)
-		shift = 1;
-
-again:
-	ready = io_uring_cq_ready(ring);
-	if (ready) {
-		unsigned head = *ring->cq.khead;
-		unsigned mask = ring->cq.ring_mask;
-		unsigned last;
-		int i = 0;
-
-		count = count > ready ? ready : count;
-		last = head + count;
-		for (;head != last; head++, i++)
-			cqes[i] = &ring->cq.cqes[(head & mask) << shift];
-
+	if (io_uring_peek_batch_cqe_(ring, cqes, &count))
 		return count;
-	}
 
-	if (overflow_checked)
+	if (!cq_ring_needs_flush(ring))
 		return 0;
 
-	if (cq_ring_needs_flush(ring)) {
-		io_uring_get_events(ring);
-		overflow_checked = true;
-		goto again;
-	}
+	io_uring_get_events(ring);
+	if (!io_uring_peek_batch_cqe_(ring, cqes, &count))
+		return 0;
 
-	return 0;
+	return count;
 }
 
 /*
@@ -324,6 +327,8 @@ int io_uring_submit_and_wait_reg(struct io_uring *ring,
 				 struct io_uring_cqe **cqe_ptr,
 				 unsigned wait_nr, int reg_index)
 {
+	unsigned long offset = reg_index * sizeof(struct io_uring_reg_wait);
+
 	struct get_data data = {
 		.submit		= __io_uring_flush_sq(ring),
 		.wait_nr	= wait_nr,
@@ -331,7 +336,7 @@ int io_uring_submit_and_wait_reg(struct io_uring *ring,
 				  IORING_ENTER_EXT_ARG_REG,
 		.sz		= sizeof(struct io_uring_reg_wait),
 		.has_ts		= true,
-		.arg		= (void *) (uintptr_t) reg_index,
+		.arg		= (void *) (uintptr_t) offset,
 	};
 
 	if (!(ring->features & IORING_FEAT_EXT_ARG))

data/vendor/liburing/src/register.c

@@ -111,9 +111,9 @@ int io_uring_register_files_update(struct io_uring *ring, unsigned off,
 {
 	liburing_sanitize_address(files);
 
-	struct io_uring_files_update up = {
+	struct io_uring_rsrc_update up = {
 		.offset	= off,
-		.fds	= (unsigned long) files,
+		.data	= (unsigned long) files,
 	};
 
 	return do_register(ring, IORING_REGISTER_FILES_UPDATE, &up, nr_files);
@@ -395,9 +395,9 @@ int io_uring_register_clock(struct io_uring *ring,
 	return do_register(ring, IORING_REGISTER_CLOCK, arg, 0);
 }
 
-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)
 {
 	struct io_uring_clone_buffers buf = {
 		.src_fd		= src->ring_fd,
@@ -407,19 +407,40 @@ int io_uring_clone_buffers_offset(struct io_uring *dst, struct io_uring *src,
 		.nr		= nr,
 	};
 
-	if (src->int_flags & INT_FLAG_REG_REG_RING) {
+	if (flags & IORING_REGISTER_SRC_REGISTERED &&
+	    src->int_flags & INT_FLAG_REG_REG_RING) {
 		buf.src_fd = src->enter_ring_fd;
-		buf.flags |= IORING_REGISTER_SRC_REGISTERED;
 	} else {
 		buf.src_fd = src->ring_fd;
+		buf.flags &= ~IORING_REGISTER_SRC_REGISTERED;
 	}
 
 	return do_register(dst, IORING_REGISTER_CLONE_BUFFERS, &buf, 1);
 }
 
+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)
+{
+	return __io_uring_clone_buffers_offset(dst, src, dst_off, src_off, nr,
+						flags | IORING_REGISTER_SRC_REGISTERED);
+}
+
 int io_uring_clone_buffers(struct io_uring *dst, struct io_uring *src)
 {
-	return io_uring_clone_buffers_offset(dst, src, 0, 0, 0, 0);
+	return __io_uring_clone_buffers_offset(dst, src, 0, 0, 0, IORING_REGISTER_SRC_REGISTERED);
+}
+
+int __io_uring_clone_buffers(struct io_uring *dst, struct io_uring *src,
+			     unsigned int flags)
+{
+	return __io_uring_clone_buffers_offset(dst, src, 0, 0, 0, flags);
+}
+
+int io_uring_register_ifq(struct io_uring *ring,
+			  struct io_uring_zcrx_ifq_reg *reg)
+{
+	return do_register(ring, IORING_REGISTER_ZCRX_IFQ, reg, 1);
 }
 
 int io_uring_resize_rings(struct io_uring *ring, struct io_uring_params *p)
@@ -468,12 +489,22 @@ out:
 int io_uring_register_wait_reg(struct io_uring *ring,
 			       struct io_uring_reg_wait *reg, int nr)
 {
-	struct io_uring_cqwait_reg_arg arg = {
-		.flags		= 0,
-		.struct_size	= sizeof(*reg),
-		.nr_entries	= nr,
-		.user_addr	= (unsigned long) (uintptr_t) reg,
-	};
+	return -EINVAL;
+}
 
-	return do_register(ring, IORING_REGISTER_CQWAIT_REG, &arg, 1);
+int io_uring_register_region(struct io_uring *ring,
+			     struct io_uring_mem_region_reg *reg)
+{
+	return do_register(ring, IORING_REGISTER_MEM_REGION, reg, 1);
+}
+
+int io_uring_set_iowait(struct io_uring *ring, bool enable_iowait)
+{
+	if (!(ring->features & IORING_FEAT_NO_IOWAIT))
+		return -EOPNOTSUPP;
+	if (enable_iowait)
+		ring->int_flags &= ~INT_FLAG_NO_IOWAIT;
+	else
+		ring->int_flags |= INT_FLAG_NO_IOWAIT;
+	return 0;
 }

data/vendor/liburing/src/sanitize.c

@@ -115,6 +115,10 @@ static inline void initialize_sanitize_handlers()
 	sanitize_handlers[IORING_OP_FTRUNCATE] = sanitize_sqe_addr;
 	sanitize_handlers[IORING_OP_BIND] = sanitize_sqe_addr;
 	sanitize_handlers[IORING_OP_LISTEN] = sanitize_sqe_addr;
+	sanitize_handlers[IORING_OP_RECV_ZC] = sanitize_sqe_addr,
+	sanitize_handlers[IORING_OP_EPOLL_WAIT] = sanitize_sqe_addr,
+	sanitize_handlers[IORING_OP_READV_FIXED] = sanitize_sqe_addr,
+	sanitize_handlers[IORING_OP_WRITEV_FIXED] = sanitize_sqe_addr,
 	sanitize_handlers_initialized = true;
 }
 
@@ -122,18 +126,11 @@ void liburing_sanitize_ring(struct io_uring *ring)
 {
 	struct io_uring_sq *sq = &ring->sq;
 	struct io_uring_sqe *sqe;
-	unsigned int head;
-	int shift = 0;
+	unsigned head = io_uring_load_sq_head(ring);
+	unsigned shift = io_uring_sqe_shift(ring);
 
 	initialize_sanitize_handlers();
 
-	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);
-
 	while (head != sq->sqe_tail) {
 		sqe = &sq->sqes[(head & sq->ring_mask) << shift];
 		if (sqe->opcode < IORING_OP_LAST)

data/vendor/liburing/src/setup.c

@@ -94,18 +94,25 @@ void io_uring_setup_ring_pointers(struct io_uring_params *p,
 	cq->ring_entries = *cq->kring_entries;
 }
 
+static size_t params_sqes_size(const struct io_uring_params *p, unsigned sqes)
+{
+	sqes <<= io_uring_sqe_shift_from_flags(p->flags);
+	return sqes * sizeof(struct io_uring_sqe);
+}
+
+static size_t params_cq_size(const struct io_uring_params *p, unsigned cqes)
+{
+	cqes <<= io_uring_cqe_shift_from_flags(p->flags);
+	return cqes * sizeof(struct io_uring_cqe);
+}
+
 int io_uring_mmap(int fd, struct io_uring_params *p, struct io_uring_sq *sq,
 		  struct io_uring_cq *cq)
 {
-	size_t size;
 	int ret;
 
-	size = sizeof(struct io_uring_cqe);
-	if (p->flags & IORING_SETUP_CQE32)
-		size += sizeof(struct io_uring_cqe);
-
 	sq->ring_sz = p->sq_off.array + p->sq_entries * sizeof(unsigned);
-	cq->ring_sz = p->cq_off.cqes + p->cq_entries * size;
+	cq->ring_sz = p->cq_off.cqes + params_cq_size(p, p->cq_entries);
 
 	if (p->features & IORING_FEAT_SINGLE_MMAP) {
 		if (cq->ring_sz > sq->ring_sz)
@@ -131,11 +138,9 @@ int io_uring_mmap(int fd, struct io_uring_params *p, struct io_uring_sq *sq,
 		}
 	}
 
-	size = sizeof(struct io_uring_sqe);
-	if (p->flags & IORING_SETUP_SQE128)
-		size += 64;
-	sq->sqes = __sys_mmap(0, size * p->sq_entries, PROT_READ | PROT_WRITE,
-			      MAP_SHARED | MAP_POPULATE, fd, IORING_OFF_SQES);
+	sq->sqes = __sys_mmap(0, params_sqes_size(p, p->sq_entries),
+			      PROT_READ | PROT_WRITE, MAP_SHARED | MAP_POPULATE,
+			      fd, IORING_OFF_SQES);
 	if (IS_ERR(sq->sqes)) {
 		ret = PTR_ERR(sq->sqes);
 err:
@@ -160,6 +165,12 @@ __cold int io_uring_queue_mmap(int fd, struct io_uring_params *p,
 	return io_uring_mmap(fd, p, &ring->sq, &ring->cq);
 }
 
+static size_t io_uring_sqes_size(const struct io_uring *ring)
+{
+	return (ring->sq.ring_entries << io_uring_sqe_shift(ring)) *
+	       sizeof(struct io_uring_sqe);
+}
+
 /*
  * Ensure that the mmap'ed rings aren't available to a child after a fork(2).
  * This uses madvise(..., MADV_DONTFORK) on the mmap'ed ranges.
@@ -172,10 +183,7 @@ __cold int io_uring_ring_dontfork(struct io_uring *ring)
 	if (!ring->sq.ring_ptr || !ring->sq.sqes || !ring->cq.ring_ptr)
 		return -EINVAL;
 
-	len = sizeof(struct io_uring_sqe);
-	if (ring->flags & IORING_SETUP_SQE128)
-		len += 64;
-	len *= ring->sq.ring_entries;
+	len = io_uring_sqes_size(ring);
 	ret = __sys_madvise(ring->sq.sqes, len, MADV_DONTFORK);
 	if (ret < 0)
 		return ret;
@@ -209,7 +217,7 @@ static int io_uring_alloc_huge(unsigned entries, struct io_uring_params *p,
 {
 	unsigned long page_size = get_page_size();
 	unsigned sq_entries, cq_entries;
-	size_t ring_mem, sqes_mem, cqes_mem;
+	size_t ring_mem, sqes_mem;
 	unsigned long mem_used = 0;
 	void *ptr;
 	int ret;
@@ -220,15 +228,12 @@ static int io_uring_alloc_huge(unsigned entries, struct io_uring_params *p,
 
 	ring_mem = KRING_SIZE;
 
-	sqes_mem = sq_entries * sizeof(struct io_uring_sqe);
+	sqes_mem = params_sqes_size(p, sq_entries);
 	if (!(p->flags & IORING_SETUP_NO_SQARRAY))
 		sqes_mem += sq_entries * sizeof(unsigned);
 	sqes_mem = (sqes_mem + page_size - 1) & ~(page_size - 1);
 
-	cqes_mem = cq_entries * sizeof(struct io_uring_cqe);
-	if (p->flags & IORING_SETUP_CQE32)
-		cqes_mem *= 2;
-	ring_mem += sqes_mem + cqes_mem;
+	ring_mem += sqes_mem + params_cq_size(p, cq_entries);
 	mem_used = ring_mem;
 	mem_used = (mem_used + page_size - 1) & ~(page_size - 1);
 
@@ -359,6 +364,13 @@ int __io_uring_queue_init_params(unsigned entries, struct io_uring *ring,
 	} else {
 		ring->ring_fd = fd;
 	}
+	/*
+	 * IOPOLL always needs to enter, except if SQPOLL is set as well.
+	 * Use an internal flag to check for this.
+	 */
+	if ((ring->flags & (IORING_SETUP_IOPOLL|IORING_SETUP_SQPOLL)) ==
+			IORING_SETUP_IOPOLL)
+		ring->int_flags |= INT_FLAG_CQ_ENTER;
 
 	return ret;
 }
@@ -430,20 +442,10 @@ __cold void io_uring_queue_exit(struct io_uring *ring)
 {
 	struct io_uring_sq *sq = &ring->sq;
 	struct io_uring_cq *cq = &ring->cq;
-	size_t sqe_size;
 
-	if (!sq->ring_sz && !(ring->int_flags & INT_FLAG_APP_MEM)) {
-		sqe_size = sizeof(struct io_uring_sqe);
-		if (ring->flags & IORING_SETUP_SQE128)
-			sqe_size += 64;
-		__sys_munmap(sq->sqes, sqe_size * sq->ring_entries);
+	if (!(ring->int_flags & INT_FLAG_APP_MEM)) {
+		__sys_munmap(sq->sqes, io_uring_sqes_size(ring));
 		io_uring_unmap_rings(sq, cq);
-	} else {
-		if (!(ring->int_flags & INT_FLAG_APP_MEM)) {
-			__sys_munmap(sq->sqes,
-				*sq->kring_entries * sizeof(struct io_uring_sqe));
-			io_uring_unmap_rings(sq, cq);
-		}
 	}
 
 	/*
@@ -508,18 +510,11 @@ static size_t rings_size(struct io_uring_params *p, unsigned entries,
 {
 	size_t pages, sq_size, cq_size;
 
-	cq_size = sizeof(struct io_uring_cqe);
-	if (p->flags & IORING_SETUP_CQE32)
-		cq_size += sizeof(struct io_uring_cqe);
-	cq_size *= cq_entries;
-	cq_size += KRING_SIZE;
+	cq_size = KRING_SIZE + params_cq_size(p, cq_entries);
 	cq_size = (cq_size + 63) & ~63UL;
 	pages = (size_t) 1 << npages(cq_size, page_size);
 
-	sq_size = sizeof(struct io_uring_sqe);
-	if (p->flags & IORING_SETUP_SQE128)
-		sq_size += 64;
-	sq_size *= entries;
+	sq_size = params_sqes_size(p, entries);
 	pages += (size_t) 1 << npages(sq_size, page_size);
 	return pages * page_size;
 }
@@ -686,32 +681,3 @@ int io_uring_free_buf_ring(struct io_uring *ring, struct io_uring_buf_ring *br,
 	__sys_munmap(br, nentries * sizeof(struct io_uring_buf));
 	return 0;
 }
-
-void io_uring_free_reg_wait(struct io_uring_reg_wait *reg, unsigned nentries)
-{
-	__sys_munmap(reg, nentries * sizeof(struct io_uring_reg_wait));
-}
-
-struct io_uring_reg_wait *io_uring_setup_reg_wait(struct io_uring *ring,
-						  unsigned nentries, int *err)
-{
-	struct io_uring_reg_wait *reg;
-	size_t size = nentries * sizeof(*reg);
-	int ret;
-
-	reg = __sys_mmap(NULL, size, PROT_READ | PROT_WRITE,
-			MAP_SHARED|MAP_POPULATE|MAP_ANONYMOUS, -1, 0);
-	if (IS_ERR(reg)) {
-		*err = PTR_ERR(reg);
-		return NULL;
-	}
-
-	memset(reg, 0, size);
-	ret = io_uring_register_wait_reg(ring, reg, nentries);
-	if (!ret)
-		return reg;
-
-	__sys_munmap(reg, size);
-	*err = ret;
-	return NULL;
-}

data/vendor/liburing/src/syscall.c

@@ -11,9 +11,9 @@ int io_uring_enter(unsigned int fd, unsigned int to_submit,
 
 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)
 {
-	return __sys_io_uring_enter2(fd, to_submit, min_complete, flags, sig,
+	return __sys_io_uring_enter2(fd, to_submit, min_complete, flags, arg,
 				     sz);
 }
 

data/vendor/liburing/test/232c93d07b74.c

@@ -10,6 +10,7 @@
 #include <stdlib.h>
 #include <stdint.h>
 #include <assert.h>
+#include <string.h>
 
 #include <pthread.h>
 #include <errno.h>

data/vendor/liburing/test/Makefile

@@ -81,6 +81,7 @@ test_srcs := \
 	eeed8b54e0df.c \
 	empty-eownerdead.c \
 	eploop.c \
+	epwait.c \
 	eventfd.c \
 	eventfd-disable.c \
 	eventfd-reg.c \
@@ -106,6 +107,7 @@ test_srcs := \
 	fixed-hugepage.c \
 	fixed-link.c \
 	fixed-reuse.c \
+	fixed-seg.c \
 	fpos.c \
 	fsnotify.c \
 	fsync.c \
@@ -121,6 +123,7 @@ test_srcs := \
 	io_uring_passthrough.c \
 	io_uring_register.c \
 	io_uring_setup.c \
+	iowait.c \
 	kallsyms.c \
 	lfs-openat.c \
 	lfs-openat-write.c \
@@ -165,10 +168,12 @@ test_srcs := \
 	pollfree.c \
 	probe.c \
 	read-before-exit.c \
+	read-inc-file.c \
 	read-mshot.c \
 	read-mshot-empty.c \
 	read-mshot-stdin.c \
 	read-write.c \
+	recv-bundle-short-ooo.c \
 	recv-msgall.c \
 	recv-msgall-stream.c \
 	recv-multishot.c \
@@ -193,6 +198,7 @@ test_srcs := \
 	send_recv.c \
 	send_recvmsg.c \
 	send-zerocopy.c \
+	sendmsg_iov_clean.c \
 	shared-wq.c \
 	short-read.c \
 	shutdown.c \
@@ -202,6 +208,7 @@ test_srcs := \
 	socket.c \
 	socket-io-cmd.c \
 	socket-getsetsock-cmd.c \
+	socket-nb.c \
 	socket-rw.c \
 	socket-rw-eagain.c \
 	socket-rw-offset.c \
@@ -237,6 +244,8 @@ test_srcs := \
 	wakeup-hang.c \
 	wq-aff.c \
 	xattr.c \
+	zcrx.c \
+	vec-regbuf.c \
 	# EOL
 
 # Please keep this list sorted alphabetically.

data/vendor/liburing/test/accept-test.c

@@ -7,6 +7,7 @@
 #include <sys/socket.h>
 #include <sys/un.h>
 #include <assert.h>
+#include <string.h>
 #include "liburing.h"
 #include "helpers.h"
 

data/vendor/liburing/test/cmd-discard.c

@@ -199,7 +199,7 @@ static int basic_cmd_test(struct io_uring *ring, int op)
 
 	fd = open(filename, O_DIRECT | O_RDWR | O_EXCL);
 	if (fd < 0) {
-		if (errno == -EINVAL || errno == -EBUSY)
+		if (errno == EINVAL || errno == EBUSY)
 			return T_EXIT_SKIP;
 		fprintf(stderr, "open failed %i\n", errno);
 		return T_EXIT_FAIL;
@@ -248,6 +248,8 @@ static int test_fail_edge_cases(struct io_uring *ring, int op)
 
 	fd = open(filename, O_DIRECT | O_RDWR | O_EXCL);
 	if (fd < 0) {
+		if (errno == EINVAL || errno == EBUSY)
+			return T_EXIT_SKIP;
 		fprintf(stderr, "open failed %i\n", errno);
 		return T_EXIT_FAIL;
 	}
@@ -302,6 +304,8 @@ static int test_rdonly(struct io_uring *ring, int op)
 
 	fd = open(filename, O_DIRECT | O_RDONLY | O_EXCL);
 	if (fd < 0) {
+		if (errno == EINVAL || errno == EBUSY)
+			return T_EXIT_SKIP;
 		fprintf(stderr, "open failed %i\n", errno);
 		return T_EXIT_FAIL;
 	}
@@ -315,6 +319,8 @@ static int test_rdonly(struct io_uring *ring, int op)
 
 	fd = open(filename, O_DIRECT | O_RDWR | O_EXCL);
 	if (fd < 0) {
+		if (errno == EINVAL || errno == EBUSY)
+			return T_EXIT_SKIP;
 		fprintf(stderr, "open failed %i\n", errno);
 		return T_EXIT_FAIL;
 	}
@@ -354,6 +360,8 @@ int main(int argc, char *argv[])
 
 	fd = open(filename, O_DIRECT | O_RDONLY | O_EXCL);
 	if (fd < 0) {
+		if (errno == EINVAL || errno == EBUSY)
+			return T_EXIT_SKIP;
 		fprintf(stderr, "open failed %i\n", errno);
 		return T_EXIT_FAIL;
 	}
@@ -396,29 +404,29 @@ int main(int argc, char *argv[])
 		if (!opcodes[cmd_op].test)
 			continue;
 		ret = basic_cmd_test(&ring, cmd_op);
-		if (ret) {
-			if (ret == T_EXIT_SKIP)
-				continue;
-
+		if (ret == T_EXIT_FAIL) {
 			fprintf(stderr, "basic_cmd_test() failed, cmd %i\n",
 					cmd_op);
 			return T_EXIT_FAIL;
 		}
 
 		ret = test_rdonly(&ring, cmd_op);
-		if (ret) {
+		if (ret == T_EXIT_FAIL) {
 			fprintf(stderr, "test_rdonly() failed, cmd %i\n",
 					cmd_op);
 			return T_EXIT_FAIL;
 		}
 
 		ret = test_fail_edge_cases(&ring, cmd_op);
-		if (ret) {
+		if (ret == T_EXIT_FAIL) {
 			fprintf(stderr, "test_fail_edge_cases() failed, cmd %i\n",
 					cmd_op);
 			return T_EXIT_FAIL;
 		}
-		fret = T_EXIT_PASS;
+		if (ret == T_EXIT_SKIP)
+			fret = T_EXIT_SKIP;
+		else
+			fret = T_EXIT_PASS;
 	}
 
 	io_uring_queue_exit(&ring);

data/vendor/liburing/test/connect.c

@@ -371,8 +371,10 @@ static int test(int flags)
 	int ret;
 
 	ret = io_uring_queue_init(8, &ring, flags);
+	if (ret == -EINVAL)
+		return T_EXIT_SKIP;
 	if (ret) {
-		fprintf(stderr, "io_uring_queue_setup() = %d\n", ret);
+		fprintf(stderr, "io_uring_queue_init() = %d\n", ret);
 		return T_EXIT_FAIL;
 	}
 
@@ -413,30 +415,32 @@ static int test(int flags)
 
 int main(int argc, char *argv[])
 {
+	bool any_passed = false;
 	int ret;
 
 	if (argc > 1)
 		return T_EXIT_SKIP;
 
 	ret = test(0);
-	if (ret == -1) {
+	any_passed |= ret == T_EXIT_PASS;
+	if (ret == T_EXIT_FAIL) {
 		fprintf(stderr, "test 0 failed\n");
 		return T_EXIT_FAIL;
 	}
-	if (no_connect)
-		return T_EXIT_SKIP;
 
 	ret = test(IORING_SETUP_SQPOLL);
-	if (ret == -1) {
+	any_passed |= ret == T_EXIT_PASS;
+	if (ret == T_EXIT_FAIL) {
 		fprintf(stderr, "test SQPOLL failed\n");
 		return T_EXIT_FAIL;
 	}
 
 	ret = test(IORING_SETUP_SINGLE_ISSUER|IORING_SETUP_DEFER_TASKRUN);
-	if (ret == -1) {
+	any_passed |= ret == T_EXIT_PASS;
+	if (ret == T_EXIT_FAIL) {
 		fprintf(stderr, "test DEFER failed\n");
 		return T_EXIT_FAIL;
 	}
 
-	return T_EXIT_PASS;
+	return any_passed ? T_EXIT_PASS : T_EXIT_SKIP;
 }