uringmachine 0.4 → 0.5.1

data/vendor/liburing/test/file-exit-unreg.c

@@ -0,0 +1,48 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: test that a defer task_work file with tags unregistration
+ *		doesn't trigger a lockdep violation
+ *
+ */
+#include <stdio.h>
+#include <inttypes.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include "liburing.h"
+#include "helpers.h"
+
+int main(int argc, char *argv[])
+{
+	__u64 tags[2] = { 1, 2 };
+	struct io_uring ring;
+	int fds[2], ret;
+
+	if (argc > 1)
+		return T_EXIT_SKIP;
+
+	if (pipe(fds) < 0) {
+		perror("pipe");
+		return 1;
+	}
+
+	ret = io_uring_queue_init(4, &ring, IORING_SETUP_SINGLE_ISSUER|IORING_SETUP_DEFER_TASKRUN);
+	if (ret == -EINVAL) {
+		return T_EXIT_SKIP;
+	} else if (ret < 0) {
+		fprintf(stderr, "queue_init: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	ret = io_uring_register_files_tags(&ring, fds, tags, 2);
+	if (ret == -EINVAL) {
+		return T_EXIT_SKIP;
+	} else if (ret < 0) {
+		fprintf(stderr, "file_register_init: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	io_uring_queue_exit(&ring);
+	sleep(1);
+	return 0;
+}

data/vendor/liburing/test/io_uring_passthrough.c

@@ -167,6 +167,8 @@ static int __test_io(const char *file, struct io_uring *ring, int tc, int read,
 			}
 		}
 		sqe->opcode = IORING_OP_URING_CMD;
+		if (do_fixed)
+			sqe->uring_cmd_flags |= IORING_URING_CMD_FIXED;
 		sqe->user_data = ((uint64_t)offset << 32) | i;
 		if (sqthread)
 			sqe->flags |= IOSQE_FIXED_FILE;

data/vendor/liburing/test/io_uring_register.c

@@ -436,14 +436,14 @@ static int ioring_poll(struct io_uring *ring, int fd, int fixed)
 	return ret;
 }
 
-static int test_poll_ringfd(void)
+static int __test_poll_ringfd(int ring_flags)
 {
 	int status = 0;
 	int ret;
 	int fd;
 	struct io_uring ring;
 
-	ret = io_uring_queue_init(1, &ring, 0);
+	ret = io_uring_queue_init(2, &ring, ring_flags);
 	if (ret) {
 		perror("io_uring_queue_init");
 		return 1;
@@ -466,6 +466,17 @@ static int test_poll_ringfd(void)
 	return status;
 }
 
+static int test_poll_ringfd(void)
+{
+	int ret;
+
+	ret = __test_poll_ringfd(0);
+	if (ret)
+		return ret;
+
+	return __test_poll_ringfd(IORING_SETUP_SQPOLL);
+}
+
 int main(int argc, char **argv)
 {
 	int fd, ret;

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

@@ -147,7 +147,7 @@ static int receiver(int queue_flags)
 		io_uring_prep_recv(sqe, fd, buffer, BUF_SIZE, 0);
 
 		ret = io_uring_submit(&ring);
-		if (ret != 1) {
+		if (ret < 0) {
 			fprintf(stderr, "io_uring_submit: %i\n", ret);
 			return 1;
 		}

data/vendor/liburing/test/no-mmap-inval.c

@@ -30,7 +30,7 @@ int main(int argc, char *argv[])
 	p.cq_off.user_addr = (unsigned long long) (uintptr_t) addr;
 
 	ret = io_uring_queue_init_params(2, &ring, &p);
-	if (ret == -EINVAL) {
+	if (ret == -EINVAL || ret == -ENOENT) {
 		/*  kernel doesn't support SETUP_NO_MMAP */
 		free(addr);
 		return T_EXIT_SKIP;

data/vendor/liburing/test/read-mshot-empty.c

@@ -151,6 +151,8 @@ int main(int argc, char *argv[])
 	}
 
 	pthread_join(thread, &tret);
+	io_uring_free_buf_ring(&ring, br, NR_BUFS, BGID);
+	io_uring_queue_exit(&ring);
 	free(buf);
 	return T_EXIT_PASS;
 }

data/vendor/liburing/test/read-mshot-stdin.c

@@ -0,0 +1,121 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: test multishot read on stdin. Not that this REQUIRES input
+ *		to be received on stdin, and hence if invoked with no
+ *		arguments, or without the single argument being 'stdin',
+ *		the test will just return SKIPPED. Can't be run from the
+ *		standard test harness, as it's interactive.
+ *
+ * To run, do run "test/read-mshot-stdin.t stdin" and then input text on
+ * the console, followed by enter / line feed. If it works as it should,
+ * it'll output the received CQE data. If an error is detected, it'll
+ * abort with an error.
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+#include "liburing.h"
+#include "helpers.h"
+
+#define BUF_SIZE	32
+#define NR_BUFS		64
+#define BUF_BGID	1
+
+#define BR_MASK		(NR_BUFS - 1)
+
+static int test_stdin(void)
+{
+	struct io_uring_buf_ring *br;
+	struct io_uring_params p = { };
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	struct io_uring ring;
+	int ret, i, last_bid;
+	char *buf, *ptr;
+
+	p.flags = IORING_SETUP_CQSIZE;
+	p.cq_entries = NR_BUFS;
+	ret = io_uring_queue_init_params(1, &ring, &p);
+	if (ret) {
+		if (ret == -EINVAL)
+			return T_EXIT_SKIP;
+		fprintf(stderr, "ring setup failed: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	if (posix_memalign((void **) &buf, 4096, NR_BUFS * BUF_SIZE))
+		return T_EXIT_FAIL;
+
+	br = io_uring_setup_buf_ring(&ring, NR_BUFS, BUF_BGID, 0, &ret);
+	if (!br) {
+		if (ret == -EINVAL)
+			return T_EXIT_SKIP;
+		fprintf(stderr, "Buffer ring register failed %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	ptr = buf;
+	for (i = 0; i < NR_BUFS; i++) {
+		io_uring_buf_ring_add(br, ptr, BUF_SIZE, i + 1, BR_MASK, i);
+		ptr += BUF_SIZE;
+	}
+	io_uring_buf_ring_advance(br, NR_BUFS);
+
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_read_multishot(sqe, STDIN_FILENO, 0, 0, BUF_BGID);
+
+	ret = io_uring_submit(&ring);
+	if (ret != 1) {
+		fprintf(stderr, "submit: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	last_bid = -1;
+	do {
+		int bid;
+
+		ret = io_uring_wait_cqe(&ring, &cqe);
+		if (ret) {
+			fprintf(stderr, "wait cqe failed %d\n", ret);
+			return T_EXIT_FAIL;
+		}
+		if (cqe->res && !(cqe->flags & IORING_CQE_F_BUFFER)) {
+			fprintf(stderr, "BUF flag not set %x\n", cqe->flags);
+			return T_EXIT_FAIL;
+		}
+		bid = cqe->flags >> 16;
+		printf("CQE res %d, bid %d, flags %x\n", cqe->res, bid, cqe->flags);
+		if (cqe->res > 0 && last_bid != -1 && last_bid + 1 != bid) {
+			fprintf(stderr, "Got bid %d, wanted %d\n", bid, last_bid + 1);
+			return T_EXIT_FAIL;
+		}
+		if (!(cqe->flags & IORING_CQE_F_MORE)) {
+			io_uring_cqe_seen(&ring, cqe);
+			break;
+		}
+
+		last_bid = bid;
+		io_uring_cqe_seen(&ring, cqe);
+	}while (1);
+
+	io_uring_free_buf_ring(&ring, br, NR_BUFS, BUF_BGID);
+	io_uring_queue_exit(&ring);
+	free(buf);
+	return T_EXIT_PASS;
+}
+
+int main(int argc, char *argv[])
+{
+	if (argc == 1)
+		return T_EXIT_SKIP;
+	else if (argc > 2)
+		return T_EXIT_SKIP;
+	if (!strcmp(argv[1], "stdin"))
+		return test_stdin();
+	return T_EXIT_SKIP;
+}

data/vendor/liburing/test/read-mshot.c

@@ -144,6 +144,8 @@ static int test_inc(int use_mshot, int flags)
 		}
 	}
 
+	io_uring_free_buf_ring(&ring, br, 32, BUF_BGID);
+	io_uring_queue_exit(&ring);
 	free(ptr);
 	close(fds[0]);
 	close(fds[1]);
@@ -254,6 +256,7 @@ static int test_clamp(void)
 		io_uring_cqe_seen(&ring, cqe);
 	}
 
+	io_uring_free_buf_ring(&ring, br, NR_BUFS, BUF_BGID);
 	io_uring_queue_exit(&ring);
 	free(ptr);
 	return 0;
@@ -408,6 +411,8 @@ static int test(int first_good, int async, int overflow, int incremental)
 		io_uring_cqe_seen(&ring, cqe);
 	}
 
+
+	io_uring_free_buf_ring(&ring, br, NR_BUFS, BUF_BGID);
 	io_uring_queue_exit(&ring);
 	if (incremental) {
 		free(ptr[0]);
@@ -483,6 +488,7 @@ static int test_invalid(int async)
 	}
 
 	io_uring_cqe_seen(&ring, cqe);
+	io_uring_free_buf_ring(&ring, br, 1, BUF_BGID);
 	io_uring_queue_exit(&ring);
 	free(buf);
 	return 0;

data/vendor/liburing/test/recvsend_bundle.c

@@ -291,7 +291,7 @@ static void *recv_fn(void *data)
 		goto err;
 	}
 
-	if (posix_memalign(&buf, 4096, MSG_SIZE * RECV_BIDS))
+	if (posix_memalign(&buf, sysconf(_SC_PAGESIZE), MSG_SIZE * RECV_BIDS))
 		goto err;
 
 	if (!classic_buffers) {
@@ -453,7 +453,7 @@ static int do_send(struct recv_data *rd)
 		return 0;
 	}
 
-	if (posix_memalign(&buf, 4096, MSG_SIZE * nr_msgs))
+	if (posix_memalign(&buf, sysconf(_SC_PAGESIZE), MSG_SIZE * nr_msgs))
 		return 1;
 
 	if (!classic_buffers) {

data/vendor/liburing/test/reg-fd-only.c

@@ -58,7 +58,7 @@ static int test(int nentries, int ring_flags)
 	ret = io_uring_queue_init(nentries, &ring,
 			IORING_SETUP_REGISTERED_FD_ONLY | IORING_SETUP_NO_MMAP |
 			ring_flags);
-	if (ret == -EINVAL) {
+	if (ret == -EINVAL || ret == -ENOENT) {
 		no_mmap = 1;
 		return T_EXIT_SKIP;
 	} else if (ret == -ENOMEM) {

data/vendor/liburing/test/reg-wait.c

@@ -0,0 +1,251 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: Test that registered waits work
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/time.h>
+
+#include "liburing.h"
+#include "helpers.h"
+#include "test.h"
+
+static struct io_uring_reg_wait *reg;
+
+static int test_invalid_reg2(void)
+{
+	struct io_uring ring;
+	void *buf, *ptr;
+	int ret;
+
+	io_uring_queue_init(1, &ring, 0);
+
+	if (posix_memalign(&buf, 4096, 4096))
+		return T_EXIT_FAIL;
+	memset(buf, 0, 4096);
+	ptr = buf + 4096 - 32;
+
+	ret = io_uring_register_wait_reg(&ring, ptr, 1);
+	if (ret != -EINVAL) {
+		fprintf(stderr, "register cqwait: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	ptr = buf + (sizeof(struct io_uring_reg_wait) / 2);
+	ret = io_uring_register_wait_reg(&ring, ptr, 1);
+	if (ret != -EINVAL) {
+		fprintf(stderr, "register cqwait: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	free(buf);
+	buf = (void *) 0x1000;
+	ret = io_uring_register_wait_reg(&ring, buf, 1);
+	if (ret != -EFAULT) {
+		fprintf(stderr, "register cqwait: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	buf = (void *) 0x1240;
+	ret = io_uring_register_wait_reg(&ring, buf, 1);
+	if (ret != -EFAULT) {
+		fprintf(stderr, "register cqwait: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	buf = (void *) 0x1241;
+	ret = io_uring_register_wait_reg(&ring, buf, 1);
+	if (ret != -EINVAL) {
+		fprintf(stderr, "register cqwait: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	io_uring_queue_exit(&ring);
+	return T_EXIT_PASS;
+}
+
+static int test_invalid_reg(void)
+{
+	struct io_uring_reg_wait *ireg;
+	struct io_uring_cqe *cqe;
+	struct io_uring ring;
+	struct timeval tv;
+	void *buf, *ptr;
+	int ret;
+
+	io_uring_queue_init(1, &ring, 0);
+
+	if (posix_memalign(&buf, 4096, 4096))
+		return T_EXIT_FAIL;
+	memset(buf, 0, 4096);
+	ptr = buf + 512;
+	ireg = ptr;
+
+	ret = io_uring_register_wait_reg(&ring, ireg, 56);
+	if (ret) {
+		fprintf(stderr, "register cqwait: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	ireg = ptr;
+	memset(ireg, 0, sizeof(*ireg));
+	ireg->ts.tv_sec = 1;
+	ireg->ts.tv_nsec = 0;
+	ireg->flags = IORING_REG_WAIT_TS;
+
+	gettimeofday(&tv, NULL);
+	ret = io_uring_submit_and_wait_reg(&ring, &cqe, 1, 0);
+	if (ret != -ETIME) {
+		fprintf(stderr, "wait_reg failed: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	ret = mtime_since_now(&tv);
+	/* allow some slack, should be around 1.1s */
+	if (ret < 1000 || ret > 1200) {
+		fprintf(stderr, "wait too long or short: %d\n", ret);
+		goto err;
+	}
+
+	memset(ireg, 0, sizeof(*ireg));
+	ireg->ts.tv_sec = 1;
+	ireg->ts.tv_nsec = 0;
+	ireg->flags = IORING_REG_WAIT_TS;
+
+	gettimeofday(&tv, NULL);
+	ret = io_uring_submit_and_wait_reg(&ring, &cqe, 1, 56);
+	if (ret != -EFAULT) {
+		fprintf(stderr, "out-of-range reg_wait failed: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	free(buf);
+	io_uring_queue_exit(&ring);
+	return T_EXIT_PASS;
+err:
+	io_uring_queue_exit(&ring);
+	return T_EXIT_FAIL;
+}
+
+static int test_invalid_sig(struct io_uring *ring)
+{
+	struct io_uring_cqe *cqe;
+	sigset_t sig;
+	int ret;
+
+	memset(reg, 0, sizeof(*reg));
+	reg->ts.tv_sec = 1;
+	reg->ts.tv_nsec = 0;
+	reg->sigmask = (unsigned long) &sig;
+	reg->sigmask_sz = 1;
+
+	ret = io_uring_submit_and_wait_reg(ring, &cqe, 1, 0);
+	if (ret != -EINVAL) {
+		fprintf(stderr, "sigmask_sz failed: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	memset(reg, 0, sizeof(*reg));
+	reg->ts.tv_sec = 1;
+	reg->ts.tv_nsec = 0;
+	reg->sigmask = 100;
+	reg->sigmask_sz = 8;
+
+	ret = io_uring_submit_and_wait_reg(ring, &cqe, 1, 0);
+	if (ret != -EFAULT) {
+		fprintf(stderr, "sigmask invalid failed: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	return T_EXIT_PASS;
+}
+
+static int test_basic(struct io_uring *ring)
+{
+	struct io_uring_cqe *cqe;
+	struct timeval tv;
+	int ret;
+
+	memset(reg, 0, sizeof(*reg));
+	reg->ts.tv_sec = 1;
+	reg->ts.tv_nsec = 100000000ULL;
+	reg->flags = IORING_REG_WAIT_TS;
+
+	gettimeofday(&tv, NULL);
+	ret = io_uring_submit_and_wait_reg(ring, &cqe, 2, 0);
+	if (ret != -ETIME) {
+		fprintf(stderr, "submit_and_wait_reg: %d\n", ret);
+		goto err;
+	}
+	ret = mtime_since_now(&tv);
+	/* allow some slack, should be around 1.1s */
+	if (ret < 1000 || ret > 1200) {
+		fprintf(stderr, "wait too long or short: %d\n", ret);
+		goto err;
+	}
+	return T_EXIT_PASS;
+err:
+	return T_EXIT_FAIL;
+}
+
+static int test_ring(void)
+{
+	struct io_uring ring;
+	struct io_uring_params p = { };
+	int ret;
+
+	p.flags = 0;
+	ret = io_uring_queue_init_params(8, &ring, &p);
+	if (ret) {
+		fprintf(stderr, "ring setup failed: %d\n", ret);
+		return 1;
+	}
+
+	reg = io_uring_setup_reg_wait(&ring, 64, &ret);
+	if (!reg) {
+		if (ret == -EINVAL)
+			return T_EXIT_SKIP;
+		fprintf(stderr, "setup_reg_wait: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	ret = test_basic(&ring);
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test failed\n");
+		goto err;
+	}
+
+	ret = test_invalid_sig(&ring);
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test_invalid sig failed\n");
+		goto err;
+	}
+
+	ret = test_invalid_reg();
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test_invalid_reg failed\n");
+		goto err;
+	}
+
+	ret = test_invalid_reg2();
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test_invalid_reg2 failed\n");
+		goto err;
+	}
+
+err:
+	io_uring_queue_exit(&ring);
+	return ret;
+}
+
+int main(int argc, char *argv[])
+{
+	if (argc > 1)
+		return 0;
+
+	return test_ring();
+}