uringmachine 0.19.1 → 0.21.0

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

@@ -244,3 +244,19 @@ 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;
+		io_uring_prep_cmd_getsockname;
+} 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/bind-listen.c

@@ -22,7 +22,7 @@ static void msec_to_ts(struct __kernel_timespec *ts, unsigned int msec)
 }
 
 static const char *magic = "Hello World!";
-static int use_port = 8000;
+static bool no_getsockname = false;
 
 enum {
 	SRV_INDEX = 0,
@@ -74,18 +74,82 @@ static int connect_client(struct io_uring *ring, unsigned short peer_port)
 	return T_SETUP_OK;
 }
 
-static int setup_srv(struct io_uring *ring, struct sockaddr_in *server_addr)
+/*
+ * getsockname was added to the kernel a few releases after bind/listen.
+ * In order to provide a backward-compatible test, fallback to
+ * non-io-uring if we are on an older kernel, allowing the test to
+ * continue.
+ */
+static int do_getsockname(struct io_uring *ring, int direct_socket,
+			  int peer, struct sockaddr *saddr,
+			  socklen_t *saddr_len)
+{
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	int res = 0, fd;
+
+	if (!no_getsockname) {
+		/* attempt io_uring. Command might not exist */
+		sqe = io_uring_get_sqe(ring);
+		io_uring_prep_cmd_getsockname(sqe, direct_socket,
+					      saddr, saddr_len, peer);
+		sqe->flags |= IOSQE_FIXED_FILE | IOSQE_IO_LINK;
+		io_uring_submit(ring);
+		io_uring_wait_cqe(ring, &cqe);
+		res = cqe->res;
+		io_uring_cqe_seen(ring, cqe);
+	}
+
+	if (no_getsockname || res == -ENOTSUP) {
+		/*
+		 * Older kernel.  install the fd and use the getsockname
+		 * syscall.
+		 */
+		no_getsockname = true;
+
+		sqe = io_uring_get_sqe(ring);
+		io_uring_prep_fixed_fd_install(sqe, direct_socket, 0);
+		io_uring_submit(ring);
+		io_uring_wait_cqe(ring, &cqe);
+		fd = cqe->res;
+		io_uring_cqe_seen(ring, cqe);
+
+		if (fd < 0) {
+			fprintf(stderr, "installing direct fd failed. %d\n",
+				cqe->res);
+			return T_EXIT_FAIL;
+		}
+		if (peer)
+			res = getpeername(fd, saddr, saddr_len);
+		else
+			res = getsockname(fd, saddr, saddr_len);
+
+		if (res) {
+			fprintf(stderr, "get%sname syscall failed. %d\n",
+				peer? "peer":"sock", errno);
+			return T_EXIT_FAIL;
+		}
+		close(fd);
+	} else if (res < 0) {
+		fprintf(stderr, "getsockname server failed. %d\n", cqe->res);
+		return T_EXIT_FAIL;
+	}
+	return 0;
+}
+
+static int setup_srv(struct io_uring *ring)
 {
+	struct sockaddr_in server_addr;
 	struct io_uring_sqe *sqe;
 	struct io_uring_cqe *cqe;
 	struct __kernel_timespec ts;
 	int ret, val, submitted;
 	unsigned head;
 
-	memset(server_addr, 0, sizeof(struct sockaddr_in));
-	server_addr->sin_family = AF_INET;
-	server_addr->sin_port = htons(use_port++);
-	server_addr->sin_addr.s_addr = htons(INADDR_ANY);
+	memset(&server_addr, 0, sizeof(struct sockaddr_in));
+	server_addr.sin_family = AF_INET;
+	server_addr.sin_port = htons(0);
+	server_addr.sin_addr.s_addr = htons(INADDR_ANY);
 
 	sqe = io_uring_get_sqe(ring);
 	io_uring_prep_socket_direct(sqe, AF_INET, SOCK_STREAM, 0, SRV_INDEX, 0);
@@ -98,7 +162,7 @@ static int setup_srv(struct io_uring *ring, struct sockaddr_in *server_addr)
 	sqe->flags |= IOSQE_FIXED_FILE | IOSQE_IO_LINK;
 
 	sqe = io_uring_get_sqe(ring);
-	io_uring_prep_bind(sqe, SRV_INDEX, (struct sockaddr *) server_addr,
+	io_uring_prep_bind(sqe, SRV_INDEX, (struct sockaddr *) &server_addr,
 			   sizeof(struct sockaddr_in));
 	sqe->flags |= IOSQE_FIXED_FILE | IOSQE_IO_LINK;
 
@@ -132,12 +196,13 @@ static int setup_srv(struct io_uring *ring, struct sockaddr_in *server_addr)
 
 static int test_good_server(unsigned int ring_flags)
 {
-	struct sockaddr_in server_addr;
+	struct sockaddr_in saddr = {};
+	socklen_t saddr_len = sizeof(saddr);
 	struct __kernel_timespec ts;
 	struct io_uring_sqe *sqe;
 	struct io_uring_cqe *cqe;
 	struct io_uring ring;
-	int ret;
+	int ret, port;
 	int fds[3];
 	char buf[1024];
 
@@ -155,18 +220,22 @@ static int test_good_server(unsigned int ring_flags)
 		return T_SETUP_SKIP;
 	}
 
-	ret = setup_srv(&ring, &server_addr);
+	ret = setup_srv(&ring);
 	if (ret != T_SETUP_OK) {
 		fprintf(stderr, "srv startup failed.\n");
 		return T_EXIT_FAIL;
 	}
 
-	if (connect_client(&ring, server_addr.sin_port) != T_SETUP_OK) {
+	if (do_getsockname(&ring, SRV_INDEX, 0, (struct sockaddr*) &saddr,
+			   &saddr_len))
+		return T_EXIT_FAIL;
+
+	if (connect_client(&ring, saddr.sin_port) != T_SETUP_OK) {
 		fprintf(stderr, "cli startup failed.\n");
 		return T_SETUP_SKIP;
 	}
 
-	/* Wait for a request */
+	/* Wait for a connection */
 	sqe = io_uring_get_sqe(&ring);
 	io_uring_prep_accept_direct(sqe, SRV_INDEX, NULL, NULL, 0, CONN_INDEX);
 	sqe->flags |= IOSQE_FIXED_FILE;
@@ -179,6 +248,22 @@ static int test_good_server(unsigned int ring_flags)
 	}
 	io_uring_cqe_seen(&ring, cqe);
 
+	/* Test that getsockname on the peer (getpeername) yields a
+	 * sane result.
+	 */
+	port = saddr.sin_port;
+	saddr.sin_port = 0;
+	if (do_getsockname(&ring, CLI_INDEX, 1,
+			   (struct sockaddr*)&saddr, &saddr_len))
+		return T_EXIT_FAIL;
+
+	if (saddr.sin_addr.s_addr != htonl(INADDR_LOOPBACK) ||
+	    saddr.sin_port != port) {
+		fprintf(stderr, "getsockname peer got wrong address: %s:%d\n",
+			inet_ntoa(saddr.sin_addr), saddr.sin_port);
+		return T_EXIT_FAIL;
+	}
+
 	sqe = io_uring_get_sqe(&ring);
 	io_uring_prep_recv(sqe, CONN_INDEX, buf, sizeof(buf), 0);
 	sqe->flags |= IOSQE_FIXED_FILE;
@@ -355,6 +440,77 @@ fail:
 	return ret;
 }
 
+static int test_bad_sockname(void)
+{
+	struct sockaddr_in saddr;
+	socklen_t saddr_len;
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	struct io_uring ring;
+	int sock = -1, err;
+	int ret = T_EXIT_FAIL;
+
+	memset(&saddr, 0, sizeof(struct sockaddr_in));
+	saddr.sin_family = AF_INET;
+	saddr.sin_port = htons(8001);
+	saddr.sin_addr.s_addr = htons(INADDR_ANY);
+
+	err = t_create_ring(1, &ring, 0);
+	if (err < 0) {
+		fprintf(stderr, "queue_init: %d\n", err);
+		return T_SETUP_SKIP;
+	}
+
+	sock = socket(AF_INET, SOCK_STREAM, 0);
+	if (sock < 0) {
+		perror("socket");
+		goto fail;
+	}
+
+	err = t_bind_ephemeral_port(sock, &saddr);
+	if (err) {
+		fprintf(stderr, "bind: %s\n", strerror(-err));
+		goto fail;
+	}
+
+	/* getsockname on a !socket fd.  with getsockname(2), this would
+	 * return -ENOTSOCK, but we can't do it in an io_uring_cmd.
+	 */
+	sqe = io_uring_get_sqe(&ring);
+	saddr_len = sizeof(saddr);
+	io_uring_prep_cmd_getsockname(sqe, 1, (struct sockaddr*)&saddr, &saddr_len, 0);
+	err = io_uring_submit(&ring);
+	if (err < 0)
+		goto fail;
+	err = io_uring_wait_cqe(&ring, &cqe);
+	if (err)
+		goto fail;
+	if (cqe->res != -ENOTSUP)
+		goto fail;
+	io_uring_cqe_seen(&ring, cqe);
+
+	/* getsockname with weird parameters */
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_cmd_getsockname(sqe, sock, (struct sockaddr*)&saddr,
+				      &saddr_len, 3);
+	err = io_uring_submit(&ring);
+	if (err < 0)
+		goto fail;
+	err = io_uring_wait_cqe(&ring, &cqe);
+	if (err)
+		goto fail;
+	if (cqe->res != -EINVAL)
+		goto fail;
+	io_uring_cqe_seen(&ring, cqe);
+
+	ret = T_EXIT_PASS;
+fail:
+	io_uring_queue_exit(&ring);
+	if (sock != -1)
+		close(sock);
+	return ret;
+}
+
 int main(int argc, char *argv[])
 {
 	struct io_uring_probe *probe;
@@ -403,6 +559,12 @@ int main(int argc, char *argv[])
 		fprintf(stderr, "bad listen failed\n");
 		return T_EXIT_FAIL;
 	}
-
+	if (!no_getsockname) {
+		ret = test_bad_sockname();
+		if (ret) {
+			fprintf(stderr, "bad sockname failed\n");
+			return T_EXIT_FAIL;
+		}
+	}
 	return T_EXIT_PASS;
 }

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;
 }