uringmachine 0.19.1 → 0.20.0

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

@@ -244,3 +244,18 @@ LIBURING_2.11 {
 		io_uring_memory_size_params;
 		io_uring_register_sync_msg;
 } LIBURING_2.10;
+
+LIBURING_2.12 {
+	global:
+		io_uring_prep_pipe;
+		io_uring_prep_pipe_direct;
+		io_uring_cqe_nr;
+} LIBURING_2.11;
+
+LIBURING_2.13 {
+	global:
+		io_uring_prep_nop128;
+		io_uring_prep_uring_cmd;
+		io_uring_prep_uring_cmd128;
+		io_uring_get_sqe128;
+} LIBURING_2.12;

data/vendor/liburing/src/liburing.map

@@ -126,3 +126,11 @@ LIBURING_2.11 {
 		io_uring_memory_size_params;
 		io_uring_register_sync_msg;
 } LIBURING_2.10;
+
+LIBURING_2.12 {
+
+} LIBURING_2.11;
+
+LIBURING_2.13 {
+
+} LIBURING_2.12;

data/vendor/liburing/src/sanitize.c

@@ -119,7 +119,10 @@ static inline void initialize_sanitize_handlers()
 	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;
-	_Static_assert(IORING_OP_WRITEV_FIXED + 1 == IORING_OP_LAST, "Need an implementation for all IORING_OP_* codes");
+	sanitize_handlers[IORING_OP_PIPE] = sanitize_sqe_addr;
+	sanitize_handlers[IORING_OP_NOP128] = sanitize_sqe_nop;
+	sanitize_handlers[IORING_OP_URING_CMD128] = sanitize_sqe_optval;
+	_Static_assert(IORING_OP_URING_CMD128 + 1 == IORING_OP_LAST, "Need an implementation for all IORING_OP_* codes");
 	sanitize_handlers_initialized = true;
 }
 

data/vendor/liburing/src/setup.c

@@ -218,7 +218,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;
+	size_t sqes_size = 0, ring_mem, sqes_mem;
 	unsigned long mem_used = 0;
 	void *ptr;
 	int ret;
@@ -260,7 +260,8 @@ static int io_uring_alloc_huge(unsigned entries, struct io_uring_params *p,
 			buf_size = huge_page_size;
 			map_hugetlb = MAP_HUGETLB;
 		}
-		ptr = __sys_mmap(NULL, buf_size, PROT_READ|PROT_WRITE,
+		sqes_size = buf_size;
+		ptr = __sys_mmap(NULL, sqes_size, PROT_READ|PROT_WRITE,
 					MAP_SHARED|MAP_ANONYMOUS|map_hugetlb,
 					-1, 0);
 		if (IS_ERR(ptr))
@@ -285,7 +286,8 @@ static int io_uring_alloc_huge(unsigned entries, struct io_uring_params *p,
 					MAP_SHARED|MAP_ANONYMOUS|map_hugetlb,
 					-1, 0);
 		if (IS_ERR(ptr)) {
-			__sys_munmap(sq->sqes, 1);
+			if (sqes_size)
+				__sys_munmap(sq->sqes, sqes_size);
 			return PTR_ERR(ptr);
 		}
 		sq->ring_ptr = ptr;
@@ -330,7 +332,7 @@ int __io_uring_queue_init_params(unsigned entries, struct io_uring *ring,
 	if (fd < 0) {
 		if ((p->flags & IORING_SETUP_NO_MMAP) &&
 		    !(ring->int_flags & INT_FLAG_APP_MEM)) {
-			__sys_munmap(ring->sq.sqes, 1);
+			__sys_munmap(ring->sq.sqes, ret);
 			io_uring_unmap_rings(&ring->sq, &ring->cq);
 		}
 		return fd;
@@ -630,6 +632,7 @@ static struct io_uring_buf_ring *br_setup(struct io_uring *ring,
 			MAP_SHARED | MAP_POPULATE, ring->ring_fd, off);
 	if (IS_ERR(br)) {
 		*err = PTR_ERR(br);
+		io_uring_unregister_buf_ring(ring, bgid);
 		return NULL;
 	}
 

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

@@ -100,14 +100,8 @@ static void *rcv(void *arg)
 	int s1 = accept(s0, NULL, NULL);
 	assert(s1 != -1);
 
-	if (p->non_blocking) {
-		int flags = fcntl(s1, F_GETFL, 0);
-		assert(flags != -1);
-
-		flags |= O_NONBLOCK;
-		res = fcntl(s1, F_SETFL, flags);
-		assert(res != -1);
-	}
+	if (p->non_blocking)
+		t_set_nonblock(s1);
 
 	struct io_uring m_io_uring;
 	void *ret = NULL;
@@ -208,14 +202,8 @@ static void *snd(void *arg)
 		assert(ret != -1);
 	}
 
-	if (p->non_blocking) {
-		int flags = fcntl(s0, F_GETFL, 0);
-		assert(flags != -1);
-
-		flags |= O_NONBLOCK;
-		ret = fcntl(s0, F_SETFL, flags);
-		assert(ret != -1);
-	}
+	if (p->non_blocking)
+		t_set_nonblock(s0);
 
 	struct io_uring m_io_uring;
 

data/vendor/liburing/test/Makefile

@@ -31,6 +31,10 @@ ifeq ($(CONFIG_USE_SANITIZER),y)
 	XCFLAGS += -fsanitize=address,undefined -fno-omit-frame-pointer -fno-optimize-sibling-calls
 endif
 
+ifeq ($(CONFIG_USE_TSAN),y)
+	XCFLAGS += -fsanitize=thread -fno-omit-frame-pointer -fno-optimize-sibling-calls
+endif
+
 CXXFLAGS ?= $(CFLAGS)
 override CFLAGS += $(XCFLAGS) -DLIBURING_BUILD_TEST
 override CXXFLAGS += $(XCFLAGS) -std=c++11 -DLIBURING_BUILD_TEST
@@ -62,6 +66,7 @@ test_srcs := \
 	buf-ring-put.c \
 	ce593a6c480a.c \
 	close-opath.c \
+	conn-unreach.c \
 	connect.c \
 	connect-rep.c \
 	coredump.c \
@@ -98,6 +103,7 @@ test_srcs := \
 	fdinfo.c \
 	fdinfo-sqpoll.c \
 	fifo-nonblock-read.c \
+	fifo-futex-poll.c \
 	file-exit-unreg.c \
 	file-register.c \
 	files-exit-hang-poll.c \
@@ -147,12 +153,15 @@ test_srcs := \
 	no-mmap-inval.c \
 	nop-all-sizes.c \
 	nop.c \
+	nop32.c \
+	nop32-overflow.c \
 	ooo-file-unreg.c \
 	openat2.c \
 	open-close.c \
 	open-direct-link.c \
 	open-direct-pick.c \
 	personality.c \
+	pipe.c \
 	pipe-bug.c \
 	pipe-eof.c \
 	pipe-reuse.c \
@@ -191,6 +200,7 @@ test_srcs := \
 	register-restrictions.c \
 	rename.c \
 	resize-rings.c \
+	ringbuf-loop.c \
 	ringbuf-read.c \
 	ringbuf-status.c \
 	ring-leak2.c \
@@ -219,7 +229,6 @@ test_srcs := \
 	socket-rw-offset.c \
 	splice.c \
 	sq-full.c \
-	sq-full-cpp.cc \
 	sqpoll-disable-exit.c \
 	sqpoll-exec.c \
 	sq-poll-dup.c \
@@ -228,6 +237,9 @@ test_srcs := \
 	sq-poll-share.c \
 	sqpoll-sleep.c \
 	sq-space_left.c \
+	sqe-mixed-nop.c \
+	sqe-mixed-bad-wrap.c \
+	sqe-mixed-uring_cmd.c \
 	sqwait.c \
 	stdout.c \
 	submit-and-wait.c \
@@ -253,6 +265,8 @@ test_srcs := \
 	zcrx.c \
 	vec-regbuf.c \
 	timestamp.c \
+	ring-query.c \
+	mock_file.c \
 	# EOL
 
 # Please keep this list sorted alphabetically.

data/vendor/liburing/test/accept.c

@@ -218,23 +218,12 @@ static int set_client_fd(struct sockaddr_in *addr)
 	ret = setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val));
 	assert(ret != -1);
 
-	int32_t flags = fcntl(fd, F_GETFL, 0);
-	assert(flags != -1);
-
-	flags |= O_NONBLOCK;
-	ret = fcntl(fd, F_SETFL, flags);
-	assert(ret != -1);
+	t_set_nonblock(fd);
 
 	ret = connect(fd, (struct sockaddr *)addr, sizeof(*addr));
 	assert(ret == -1);
 
-	flags = fcntl(fd, F_GETFL, 0);
-	assert(flags != -1);
-
-	flags &= ~O_NONBLOCK;
-	ret = fcntl(fd, F_SETFL, flags);
-	assert(ret != -1);
-
+	t_clear_nonblock(fd);
 	return fd;
 }
 

data/vendor/liburing/test/conn-unreach.c

@@ -0,0 +1,132 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Check that IORING_OP_CONNECT properly returns -ECONNRESET when
+ * attempting to connect to an unreachable address. See:
+ *
+ * https://github.com/axboe/liburing/discussions/1335
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdint.h>
+#include <string.h>
+#include <assert.h>
+
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <netinet/tcp.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+
+#include "liburing.h"
+#include "helpers.h"
+
+static int check_cqe(struct io_uring *ring, struct io_uring_cqe *cqe)
+{
+	if (cqe->res == -EINVAL)
+		return T_EXIT_SKIP;
+
+	switch (cqe->user_data) {
+	case 1:
+		if (cqe->res != -ECONNRESET) {
+			fprintf(stderr, "Unexpected connect: %d\n", cqe->res);
+			return T_EXIT_FAIL;
+		}
+		break;
+	case 2:
+		if (cqe->res) {
+			fprintf(stderr, "Unexpected shutdown: %d\n", cqe->res);
+			return T_EXIT_FAIL;
+		}
+		break;
+	}
+	io_uring_cqe_seen(ring, cqe);
+	return T_EXIT_PASS;
+}
+
+static int test(struct io_uring *ring, struct sockaddr_in *saddr, int p_fd)
+{
+	struct io_uring_cqe *cqe;
+	struct io_uring_sqe *sqe1, *sqe2;
+	socklen_t val_len;
+	int ret, val;
+
+	sqe1 = io_uring_get_sqe(ring);
+	io_uring_prep_connect(sqe1, p_fd, (struct sockaddr *)saddr, sizeof(*saddr));
+	sqe1->user_data = 1;
+
+	ret = io_uring_submit(ring);
+	assert(ret != -1);
+
+	usleep(200000); // 200ms
+	sqe2 = io_uring_get_sqe(ring);
+	io_uring_prep_shutdown(sqe2, p_fd, SHUT_RDWR);
+	sqe2->user_data = 2;
+
+	ret = io_uring_submit(ring);
+	assert(ret != -1);
+
+	ret = io_uring_wait_cqe(ring, &cqe);
+	if (ret < 0) {
+		fprintf(stderr, "wait: %s\n", strerror(-ret));
+		return T_EXIT_FAIL;
+	}
+
+	ret = check_cqe(ring, cqe);
+	if (ret != T_EXIT_PASS)
+		return ret;
+
+	val = 0;
+	val_len = sizeof(val);
+	ret = getsockopt(p_fd, SOL_SOCKET, SO_ERROR, &val, &val_len);
+	assert(ret != -1);
+
+	ret = io_uring_wait_cqe(ring, &cqe);
+	if (ret < 0) {
+		fprintf(stderr, "wait: %s\n", strerror(-ret));
+		return T_EXIT_FAIL;
+	}
+
+	return check_cqe(ring, cqe);
+}
+
+int main(int argc, char *argv[])
+{
+	struct sockaddr_in addr = { };
+	struct io_uring ring;
+	int val, p_fd, ret;
+
+	if (argc > 1)
+		return T_EXIT_SKIP;
+
+	p_fd = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, IPPROTO_TCP);
+
+	val = 1;
+	ret = setsockopt(p_fd, IPPROTO_TCP, TCP_NODELAY, &val, sizeof(val));
+	assert(ret != -1);
+
+	// NB. these are to make things faster
+	val = 2;
+	ret = setsockopt(p_fd, IPPROTO_TCP, TCP_SYNCNT, &val, sizeof(val));
+	assert(ret != -1);
+
+	val = 500; // 500ms
+	ret = setsockopt(p_fd, IPPROTO_TCP, TCP_USER_TIMEOUT, &val, sizeof(val));
+	assert(ret != -1);
+
+	t_set_nonblock(p_fd);
+
+	addr.sin_family = AF_INET;
+	/* any unreachable address */
+	addr.sin_addr.s_addr = inet_addr("172.31.5.5");
+	addr.sin_port = htons(12345);
+
+	ret = io_uring_queue_init(2, &ring, 0);
+	assert(ret >= 0);
+
+	ret = test(&ring, &addr, p_fd);
+	io_uring_queue_exit(&ring);
+	return ret;
+}

data/vendor/liburing/test/fd-pass.c

@@ -50,14 +50,15 @@ static int verify_fixed_read(struct io_uring *ring, int fixed_fd, int fail)
 	return 0;
 }
 
-static int test(const char *filename, int source_fd, int target_fd)
+static int test(const char *filename, int source_fd, int target_fd,
+		unsigned int ring_flags)
 {
 	struct io_uring sring, dring;
 	struct io_uring_sqe *sqe;
 	struct io_uring_cqe *cqe;
 	int ret;
 
-	ret = io_uring_queue_init(8, &sring, 0);
+	ret = io_uring_queue_init(8, &sring, ring_flags);
 	if (ret) {
 		fprintf(stderr, "ring setup failed: %d\n", ret);
 		return T_EXIT_FAIL;
@@ -202,36 +203,60 @@ int main(int argc, char *argv[])
 	sprintf(fname, ".fd-pass.%d", getpid());
 	t_create_file_pattern(fname, FSIZE, PAT);
 
-	ret = test(fname, 0, 1);
+	ret = test(fname, 0, 1, 0);
 	if (ret == T_EXIT_FAIL) {
 		fprintf(stderr, "test failed 0 1\n");
 		ret = T_EXIT_FAIL;
 	}
 
-	ret = test(fname, 0, 2);
+	ret = test(fname, 0, 2, 0);
 	if (ret == T_EXIT_FAIL) {
 		fprintf(stderr, "test failed 0 2\n");
 		ret = T_EXIT_FAIL;
 	}
 
-	ret = test(fname, 1, 1);
+	ret = test(fname, 1, 1, 0);
 	if (ret == T_EXIT_FAIL) {
 		fprintf(stderr, "test failed 1 1\n");
 		ret = T_EXIT_FAIL;
 	}
 
-	ret = test(fname, 1, 0);
+	ret = test(fname, 1, 0, 0);
 	if (ret == T_EXIT_FAIL) {
 		fprintf(stderr, "test failed 1 0\n");
 		ret = T_EXIT_FAIL;
 	}
 
-	ret = test(fname, 1, IORING_FILE_INDEX_ALLOC);
+	ret = test(fname, 1, IORING_FILE_INDEX_ALLOC, 0);
 	if (ret == T_EXIT_FAIL) {
 		fprintf(stderr, "test failed 1 ALLOC\n");
 		ret = T_EXIT_FAIL;
 	}
 
+	ret = test(fname, 0, 2, IORING_SETUP_DEFER_TASKRUN|IORING_SETUP_SINGLE_ISSUER);
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test failed 0 2 defer\n");
+		ret = T_EXIT_FAIL;
+	}
+
+	ret = test(fname, 1, 1, IORING_SETUP_DEFER_TASKRUN|IORING_SETUP_SINGLE_ISSUER);
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test failed 1 1 defer\n");
+		ret = T_EXIT_FAIL;
+	}
+
+	ret = test(fname, 1, 0, IORING_SETUP_DEFER_TASKRUN|IORING_SETUP_SINGLE_ISSUER);
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test failed 1 0 defer\n");
+		ret = T_EXIT_FAIL;
+	}
+
+	ret = test(fname, 1, IORING_FILE_INDEX_ALLOC, IORING_SETUP_DEFER_TASKRUN|IORING_SETUP_SINGLE_ISSUER);
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test failed 1 ALLOC defer\n");
+		ret = T_EXIT_FAIL;
+	}
+
 	unlink(fname);
 	return ret;
 }

data/vendor/liburing/test/fdinfo.c

@@ -57,7 +57,7 @@ static void fdinfo_read(struct io_uring *ring)
 
 static int __test_io(const char *file, struct io_uring *ring, int write,
 		     int buffered, int sqthread, int fixed, int nonvec,
-		     int buf_select, int seq, int exp_len)
+		     int buf_select, int seq, int exp_len, int mixed)
 {
 	struct io_uring_sqe *sqe;
 	struct io_uring_cqe *cqe;
@@ -66,9 +66,9 @@ static int __test_io(const char *file, struct io_uring *ring, int write,
 	off_t offset;
 
 #ifdef VERBOSE
-	fprintf(stdout, "%s: start %d/%d/%d/%d/%d: ", __FUNCTION__, write,
+	fprintf(stdout, "%s: start %d/%d/%d/%d/%d/%d: ", __FUNCTION__, write,
 							buffered, sqthread,
-							fixed, nonvec);
+							fixed, nonvec, mixed);
 #endif
 	if (write)
 		open_flags = O_WRONLY;
@@ -107,6 +107,17 @@ static int __test_io(const char *file, struct io_uring *ring, int write,
 
 	offset = 0;
 	for (i = 0; i < BUFFERS; i++) {
+		if (mixed && i & 1) {
+			sqe = io_uring_get_sqe128(ring);
+			if (!sqe) {
+				fprintf(stderr, "sqe get failed\n");
+				goto err;
+			}
+			io_uring_prep_nop128(sqe);
+			sqe->user_data = i;
+			continue;
+		}
+
 		sqe = io_uring_get_sqe(ring);
 		if (!sqe) {
 			fprintf(stderr, "sqe get failed\n");
@@ -167,12 +178,17 @@ static int __test_io(const char *file, struct io_uring *ring, int write,
 			offset += BS;
 	}
 
+	__io_uring_flush_sq(ring);
 	fdinfo_read(ring);
 
 	ret = io_uring_submit(ring);
-	if (ret != BUFFERS) {
+	if (!mixed && ret != BUFFERS) {
 		fprintf(stderr, "submit got %d, wanted %d\n", ret, BUFFERS);
 		goto err;
+	} else if (mixed && ret != BUFFERS + (BUFFERS >> 1)) {
+		fprintf(stderr, "submit got %d, wanted %d\n", ret,
+			BUFFERS + (BUFFERS >> 1));
+		goto err;
 	}
 
 	for (i = 0; i < 10; i++) {
@@ -186,7 +202,13 @@ static int __test_io(const char *file, struct io_uring *ring, int write,
 			fprintf(stderr, "wait_cqe=%d\n", ret);
 			goto err;
 		}
-		if (cqe->res == -EINVAL && nonvec) {
+		if (mixed && cqe->user_data & 1) {
+			if (cqe->user_data > 32) {
+				fprintf(stderr, "cqe user data %lld, max expected %d\n",
+					cqe->user_data, BUFFERS - 1);
+				goto err;
+			}
+		} else if (cqe->res == -EINVAL && nonvec) {
 			if (!warned) {
 				fprintf(stdout, "Non-vectored IO not "
 					"supported, skipping\n");
@@ -252,15 +274,19 @@ err:
 	return 1;
 }
 static int test_io(const char *file, int write, int buffered, int sqthread,
-		   int fixed, int nonvec, int exp_len)
+		   int fixed, int nonvec, int exp_len, int mixed)
 {
 	struct io_uring ring;
-	int ret, ring_flags = 0;
+	int ret, ring_flags = 0, entries = 64;
 
 	if (sqthread)
 		ring_flags = IORING_SETUP_SQPOLL;
+	if (mixed) {
+		ring_flags |= IORING_SETUP_SQE_MIXED;
+		entries = 128;
+	}
 
-	ret = t_create_ring(64, &ring, ring_flags);
+	ret = t_create_ring(entries, &ring, ring_flags);
 	if (ret == T_SETUP_SKIP)
 		return 0;
 	if (ret != T_SETUP_OK) {
@@ -269,7 +295,7 @@ static int test_io(const char *file, int write, int buffered, int sqthread,
 	}
 
 	ret = __test_io(file, &ring, write, buffered, sqthread, fixed, nonvec,
-			0, 0, exp_len);
+			0, 0, exp_len, mixed);
 	io_uring_queue_exit(&ring);
 	return ret;
 }
@@ -379,17 +405,18 @@ int main(int argc, char *argv[])
 	vecs = t_create_buffers(BUFFERS, BS);
 
 	/* if we don't have nonvec read, skip testing that */
-	nr = has_nonvec_read() ? 32 : 16;
+	nr = has_nonvec_read() ? 64 : 32;
 
 	for (i = 0; i < nr; i++) {
 		int write = (i & 1) != 0;
 		int buffered = (i & 2) != 0;
 		int sqthread = (i & 4) != 0;
 		int fixed = (i & 8) != 0;
-		int nonvec = (i & 16) != 0;
+		int mixed = (i & 16) != 0;
+		int nonvec = (i & 32) != 0;
 
 		ret = test_io(fname, write, buffered, sqthread, fixed, nonvec,
-			      BS);
+			      BS, mixed);
 		if (ret == T_EXIT_SKIP)
 			continue;
 		if (ret) {

data/vendor/liburing/test/fifo-futex-poll.c

@@ -0,0 +1,114 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: Run a failing futex wait command followed up a POLL_ADD
+ *		on a fifo.
+ *
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <linux/futex.h>
+#include <linux/poll.h>
+#include <unistd.h>
+
+#include "liburing.h"
+#include "helpers.h"
+
+#ifndef FUTEX2_SIZE_U32
+#define FUTEX2_SIZE_U32		0x02
+#endif
+
+int main(int argc, char *argv[])
+{
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	struct io_uring ring;
+	int ret, pipe;
+
+	if (argc > 1)
+		return T_EXIT_SKIP;
+
+	/*
+	 * Setup a FIFO for polling. FIFOs are interesting because they end
+	 * up using two wait queue entries for poll, hitting double poll
+	 * in io_uring.
+	 */
+	ret = mkfifo("fifo", 0644);
+	if (ret < 0) {
+		perror("mkfifo");
+		return 1;
+	}
+	pipe = open("fifo", O_RDWR);
+	if (pipe < 0) {
+		perror("open fifo");
+		ret = T_EXIT_FAIL;
+		goto err;
+	}
+
+	ret = io_uring_queue_init(64, &ring, 0);
+	if (ret) {
+		ret = T_EXIT_FAIL;
+		goto err;
+	}
+
+	/*
+	 * Submit invalid futex wait, will error inline.
+	 */
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_futex_wait(sqe, NULL, 0, FUTEX_BITSET_MATCH_ANY, FUTEX2_SIZE_U32, 0);
+	sqe->user_data = 1;
+	io_uring_submit(&ring);
+
+	ret = io_uring_wait_cqe(&ring, &cqe);
+	if (ret) {
+		fprintf(stderr, "wait %d \n", ret);
+		ret = T_EXIT_FAIL;
+		goto err_ring;
+	}
+	if (cqe->res != -EFAULT) {
+		if (cqe->res == -EINVAL) {
+			ret = T_EXIT_SKIP;
+			goto err_ring;
+		}
+		fprintf(stderr, "Unexpected futex return: %d\n", cqe->res);
+		ret = T_EXIT_FAIL;
+		goto err_ring;
+	}
+	io_uring_cqe_seen(&ring, cqe);
+
+	ret = io_uring_register_files(&ring, &pipe, 1);
+	if (ret < 0) {
+		fprintf(stderr, "io_uring register files failed \n");
+		ret = T_EXIT_FAIL;
+		goto err_ring;
+	}
+
+	/*
+	 * Submit poll request for POLLIN on the fifo
+	 */
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_poll_add(sqe, 0, POLLIN);
+	sqe->flags |= IOSQE_FIXED_FILE;
+	sqe->user_data = 2;
+	io_uring_submit(&ring);
+
+	/*
+	 * Trigger the poll request
+	 */
+	ret = write(pipe, "FIFO test\n", 10);
+	if (ret < 0)
+		perror("fifo write");
+
+	ret = io_uring_wait_cqe(&ring, &cqe);
+	if (ret) {
+		fprintf(stderr, "wait %d \n", ret);
+		ret = T_EXIT_FAIL;
+	}
+	io_uring_cqe_seen(&ring, cqe);
+err_ring:
+	io_uring_queue_exit(&ring);
+err:
+	if (pipe != -1)
+		close(pipe);
+	unlink("fifo");
+	return ret;
+}