uringmachine 0.3 → 0.5

data/vendor/liburing/test/recvsend_bundle.c

@@ -19,6 +19,7 @@
 
 static int nr_msgs;
 static int use_tcp;
+static int classic_buffers;
 
 #define RECV_BIDS	8192
 #define RECV_BID_MASK	(RECV_BIDS - 1)
@@ -113,6 +114,9 @@ static int recv_prep(struct io_uring *ring, struct recv_data *rd, int *sock)
 
 		pthread_barrier_wait(&rd->connect);
 
+		if (rd->abort)
+			goto err;
+
 		socklen = sizeof(saddr);
 		use_fd = accept(sockfd, (struct sockaddr *)&saddr, &socklen);
 		if (use_fd < 0) {
@@ -245,13 +249,36 @@ err:
 	return 1;
 }
 
+static int provide_classic_buffers(struct io_uring *ring, void *buf, int nbufs, int bgid)
+{
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	int ret;
+
+	sqe = io_uring_get_sqe(ring);
+	io_uring_prep_provide_buffers(sqe, buf, MSG_SIZE, nbufs, bgid, 0);
+	io_uring_submit(ring);
+
+	ret = io_uring_wait_cqe(ring, &cqe);
+	if (ret) {
+		fprintf(stderr, "provide buffer wait: %d\n", ret);
+		return 1;
+	}
+	if (cqe->res) {
+		fprintf(stderr, "provide buffers fail: %d\n", cqe->res);
+		return 1;
+	}
+	io_uring_cqe_seen(ring, cqe);
+	return 0;
+}
+
 static void *recv_fn(void *data)
 {
 	struct recv_data *rd = data;
 	struct io_uring_params p = { };
 	struct io_uring ring;
 	struct io_uring_buf_ring *br;
-	void *buf, *ptr;
+	void *buf = NULL, *ptr;
 	int ret, sock, i;
 
 	p.cq_entries = 4096;
@@ -264,22 +291,31 @@ 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;
 
-	br = io_uring_setup_buf_ring(&ring, RECV_BIDS, RECV_BGID, 0, &ret);
-	if (!br) {
-		fprintf(stderr, "failed setting up recv ring %d\n", ret);
-		goto err;
-	}
+	if (!classic_buffers) {
+		br = io_uring_setup_buf_ring(&ring, RECV_BIDS, RECV_BGID, 0, &ret);
+		if (!br) {
+			if (ret != -EINVAL)
+				fprintf(stderr, "failed setting up recv ring %d\n", ret);
+			goto err;
+		}
 
-	ptr = buf;
-	for (i = 0; i < RECV_BIDS; i++) {
-		io_uring_buf_ring_add(br, ptr, MSG_SIZE, i, RECV_BID_MASK, i);
-		ptr += MSG_SIZE;
+		ptr = buf;
+		for (i = 0; i < RECV_BIDS; i++) {
+			io_uring_buf_ring_add(br, ptr, MSG_SIZE, i, RECV_BID_MASK, i);
+			ptr += MSG_SIZE;
+		}
+		io_uring_buf_ring_advance(br, RECV_BIDS);
+		rd->recv_buf = buf;
+	} else {
+		ret = provide_classic_buffers(&ring, buf, RECV_BIDS, RECV_BGID);
+		if (ret) {
+			fprintf(stderr, "failed providing classic buffers\n");
+			goto err;
+		}
 	}
-	io_uring_buf_ring_advance(br, RECV_BIDS);
-	rd->recv_buf = buf;
 
 	ret = recv_prep(&ring, rd, &sock);
 	if (ret) {
@@ -293,6 +329,7 @@ static void *recv_fn(void *data)
 	close(rd->accept_fd);
 	io_uring_queue_exit(&ring);
 err:
+	free(buf);
 	return (void *)(intptr_t)ret;
 }
 
@@ -402,7 +439,7 @@ static int do_send(struct recv_data *rd)
 	struct io_uring_buf_ring *br;
 	int sockfd, ret, len, i;
 	socklen_t optlen;
-	void *buf, *ptr;
+	void *buf = NULL, *ptr;
 
 	ret = io_uring_queue_init_params(16, &ring, &p);
 	if (ret) {
@@ -410,29 +447,39 @@ static int do_send(struct recv_data *rd)
 		return 1;
 	}
 	if (!(p.features & IORING_FEAT_RECVSEND_BUNDLE)) {
+		rd->abort = 1;
 		no_send_mshot = 1;
+		pthread_barrier_wait(&rd->connect);
 		return 0;
 	}
 
-	if (posix_memalign(&buf, 4096, MSG_SIZE * nr_msgs))
+	if (posix_memalign(&buf, sysconf(_SC_PAGESIZE), MSG_SIZE * nr_msgs))
 		return 1;
 
-	br = io_uring_setup_buf_ring(&ring, nr_msgs, SEND_BGID, 0, &ret);
-	if (!br) {
-		if (ret == -EINVAL) {
-			fprintf(stderr, "einval on br setup\n");
-			return 0;
+	if (!classic_buffers) {
+		br = io_uring_setup_buf_ring(&ring, nr_msgs, SEND_BGID, 0, &ret);
+		if (!br) {
+			if (ret == -EINVAL) {
+				fprintf(stderr, "einval on br setup\n");
+				return 0;
+			}
+			fprintf(stderr, "failed setting up send ring %d\n", ret);
+			return 1;
 		}
-		fprintf(stderr, "failed setting up send ring %d\n", ret);
-		return 1;
-	}
 
-	ptr = buf;
-	for (i = 0; i < nr_msgs; i++) {
-		io_uring_buf_ring_add(br, ptr, MSG_SIZE, i, nr_msgs - 1, i);
-		ptr += MSG_SIZE;
+		ptr = buf;
+		for (i = 0; i < nr_msgs; i++) {
+			io_uring_buf_ring_add(br, ptr, MSG_SIZE, i, nr_msgs - 1, i);
+			ptr += MSG_SIZE;
+		}
+		io_uring_buf_ring_advance(br, nr_msgs);
+	} else {
+		ret = provide_classic_buffers(&ring, buf, nr_msgs, SEND_BGID);
+		if (ret) {
+			fprintf(stderr, "failed providing classic buffers\n");
+			return ret;
+		}
 	}
-	io_uring_buf_ring_advance(br, nr_msgs);
 
 	memset(&saddr, 0, sizeof(saddr));
 	saddr.sin_family = AF_INET;
@@ -509,6 +556,7 @@ static int do_send(struct recv_data *rd)
 
 	close(sockfd);
 	io_uring_queue_exit(&ring);
+	free(buf);
 	return 0;
 
 err:
@@ -516,6 +564,7 @@ err:
 err2:
 	io_uring_queue_exit(&ring);
 	pthread_barrier_wait(&rd->finish);
+	free(buf);
 	return 1;
 }
 
@@ -550,8 +599,12 @@ static int test(int backlog, unsigned int max_sends, int *to_eagain,
 	}
 
 	ret = do_send(&rd);
-	if (no_send_mshot)
+	if (no_send_mshot) {
+		fprintf(stderr, "no_send_mshot, aborting (ignore other errors)\n");
+		rd.abort = 1;
+		pthread_join(recv_thread, &retval);
 		return 0;
+	}
 
 	if (ret)
 		return ret;
@@ -656,7 +709,7 @@ static int test_tcp(void)
 	use_tcp = 1;
 	ret = run_tests(false);
 	if (ret == T_EXIT_FAIL)
-		fprintf(stderr, "TCP test case failed\n");
+		fprintf(stderr, "TCP test case (classic=%d) failed\n", classic_buffers);
 	return ret;
 }
 
@@ -668,7 +721,7 @@ static int test_udp(void)
 	use_port++;
 	ret = run_tests(true);
 	if (ret == T_EXIT_FAIL)
-		fprintf(stderr, "UDP test case failed\n");
+		fprintf(stderr, "UDP test case (classic=%d) failed\n", classic_buffers);
 	return ret;
 }
 
@@ -679,6 +732,16 @@ int main(int argc, char *argv[])
 	if (argc > 1)
 		return T_EXIT_SKIP;
 
+	ret = test_tcp();
+	if (ret != T_EXIT_PASS)
+		return ret;
+
+	ret = test_udp();
+	if (ret != T_EXIT_PASS)
+		return ret;
+
+	classic_buffers = 1;
+
 	ret = test_tcp();
 	if (ret != T_EXIT_PASS)
 		return ret;

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

@@ -49,15 +49,16 @@ static int test_nops(struct io_uring *ring, int sq_size, int nr_nops)
 	return T_EXIT_PASS;
 }
 
-static int test(int nentries)
+static int test(int nentries, int ring_flags)
 {
 	struct io_uring ring;
 	unsigned values[2];
 	int ret;
 
 	ret = io_uring_queue_init(nentries, &ring,
-			IORING_SETUP_REGISTERED_FD_ONLY | IORING_SETUP_NO_MMAP);
-	if (ret == -EINVAL) {
+			IORING_SETUP_REGISTERED_FD_ONLY | IORING_SETUP_NO_MMAP |
+			ring_flags);
+	if (ret == -EINVAL || ret == -ENOENT) {
 		no_mmap = 1;
 		return T_EXIT_SKIP;
 	} else if (ret == -ENOMEM) {
@@ -110,7 +111,16 @@ int main(int argc, char *argv[])
 		return T_EXIT_SKIP;
 
 	/* test single normal page */
-	ret = test(NORMAL_PAGE_ENTRIES);
+	ret = test(NORMAL_PAGE_ENTRIES, 0);
+	if (ret == T_EXIT_SKIP || no_mmap) {
+		return T_EXIT_SKIP;
+	} else if (ret != T_EXIT_PASS) {
+		fprintf(stderr, "test 8 failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	/* test single normal page */
+	ret = test(NORMAL_PAGE_ENTRIES, IORING_SETUP_SQPOLL);
 	if (ret == T_EXIT_SKIP || no_mmap) {
 		return T_EXIT_SKIP;
 	} else if (ret != T_EXIT_PASS) {
@@ -119,7 +129,7 @@ int main(int argc, char *argv[])
 	}
 
 	/* test with entries requiring a huge page */
-	ret = test(HUGE_PAGE_ENTRIES);
+	ret = test(HUGE_PAGE_ENTRIES, 0);
 	if (ret == T_EXIT_SKIP) {
 		return T_EXIT_SKIP;
 	} else if (ret != T_EXIT_PASS) {

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();
+}