uringmachine 0.3 → 0.4

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;
@@ -267,19 +294,28 @@ static void *recv_fn(void *data)
 	if (posix_memalign(&buf, 4096, 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))
 		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,14 +49,15 @@ 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);
+			IORING_SETUP_REGISTERED_FD_ONLY | IORING_SETUP_NO_MMAP |
+			ring_flags);
 	if (ret == -EINVAL) {
 		no_mmap = 1;
 		return T_EXIT_SKIP;
@@ -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/regbuf-clone.c

@@ -0,0 +1,187 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: test buffer cloning between rings
+ *
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/uio.h>
+
+#include "liburing.h"
+#include "helpers.h"
+
+#define NR_VECS		64
+#define BUF_SIZE	8192
+
+static int test(int reg_src, int reg_dst)
+{
+	struct iovec vecs[NR_VECS];
+	struct io_uring src, dst;
+	int ret, i;
+
+	ret = io_uring_queue_init(1, &src, 0);
+	if (ret) {
+		fprintf(stderr, "ring_init: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+	ret = io_uring_queue_init(1, &dst, 0);
+	if (ret) {
+		fprintf(stderr, "ring_init: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+	if (reg_src) {
+		ret = io_uring_register_ring_fd(&src);
+		if (ret < 0) {
+			if (ret == -EINVAL)
+				return T_EXIT_SKIP;
+			fprintf(stderr, "register ring: %d\n", ret);
+			return T_EXIT_FAIL;
+		}
+	}
+	if (reg_dst) {
+		ret = io_uring_register_ring_fd(&dst);
+		if (ret < 0) {
+			if (ret == -EINVAL)
+				return T_EXIT_SKIP;
+			fprintf(stderr, "register ring: %d\n", ret);
+			return T_EXIT_FAIL;
+		}
+	}
+
+	/* test fail with no buffers in src */
+	ret = io_uring_clone_buffers(&dst, &src);
+	if (ret == -EINVAL) {
+		/* no buffer copy support */
+		return T_EXIT_SKIP;
+	} else if (ret != -ENXIO) {
+		fprintf(stderr, "empty copy: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	for (i = 0; i < NR_VECS; i++) {
+		if (posix_memalign(&vecs[i].iov_base, 4096, BUF_SIZE))
+			return T_EXIT_FAIL;
+		vecs[i].iov_len = BUF_SIZE;
+	}
+
+	ret = io_uring_register_buffers(&src, vecs, NR_VECS);
+	if (ret < 0) {
+		if (ret == -ENOMEM)
+			return T_EXIT_SKIP;
+		return T_EXIT_FAIL;
+	}
+
+	/* copy should work now */
+	ret = io_uring_clone_buffers(&dst, &src);
+	if (ret) {
+		fprintf(stderr, "buffer copy: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	/* try copy again, should get -EBUSY */
+	ret = io_uring_clone_buffers(&dst, &src);
+	if (ret != -EBUSY) {
+		fprintf(stderr, "busy copy: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	ret = io_uring_unregister_buffers(&dst);
+	if (ret) {
+		fprintf(stderr, "dst unregister buffers: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	ret = io_uring_unregister_buffers(&dst);
+	if (ret != -ENXIO) {
+		fprintf(stderr, "dst unregister empty buffers: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	ret = io_uring_unregister_buffers(&src);
+	if (ret) {
+		fprintf(stderr, "src unregister buffers: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	ret = io_uring_register_buffers(&dst, vecs, NR_VECS);
+	if (ret < 0) {
+		fprintf(stderr, "register buffers dst; %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	ret = io_uring_clone_buffers(&src, &dst);
+	if (ret) {
+		fprintf(stderr, "buffer copy reverse: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	ret = io_uring_unregister_buffers(&dst);
+	if (ret) {
+		fprintf(stderr, "dst unregister buffers: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	ret = io_uring_unregister_buffers(&dst);
+	if (ret != -ENXIO) {
+		fprintf(stderr, "dst unregister empty buffers: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	ret = io_uring_unregister_buffers(&src);
+	if (ret) {
+		fprintf(stderr, "src unregister buffers: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	io_uring_queue_exit(&src);
+	io_uring_queue_exit(&dst);
+
+	for (i = 0; i < NR_VECS; i++)
+		free(vecs[i].iov_base);
+
+	return T_EXIT_PASS;
+}
+
+int main(int argc, char *argv[])
+{
+	int ret;
+
+	if (argc > 1)
+		return T_EXIT_SKIP;
+
+	ret = test(0, 0);
+	if (ret == T_EXIT_SKIP) {
+		return T_EXIT_SKIP;
+	} else if (ret != T_EXIT_PASS) {
+		fprintf(stderr, "test 0 0 failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	ret = test(0, 1);
+	if (ret == T_EXIT_SKIP) {
+		return T_EXIT_SKIP;
+	} else if (ret != T_EXIT_PASS) {
+		fprintf(stderr, "test 0 1 failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	ret = test(1, 0);
+	if (ret == T_EXIT_SKIP) {
+		return T_EXIT_SKIP;
+	} else if (ret != T_EXIT_PASS) {
+		fprintf(stderr, "test 1 0 failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	ret = test(1, 1);
+	if (ret == T_EXIT_SKIP) {
+		return T_EXIT_SKIP;
+	} else if (ret != T_EXIT_PASS) {
+		fprintf(stderr, "test 1 1 failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	return T_EXIT_PASS;
+}

data/vendor/liburing/test/regbuf-merge.c

@@ -13,6 +13,7 @@
 
 #include "helpers.h"
 
+#ifndef CONFIG_USE_SANITIZER
 #ifndef __NR_io_uring_register
 #define __NR_io_uring_register 427
 #endif
@@ -89,3 +90,9 @@ int main(int argc, char *argv[])
 	syscall(__NR_io_uring_register, r[0], 0ul, 0x20002840ul, 2ul);
 	return T_EXIT_PASS;
 }
+#else
+int main(int argc, char *argv[])
+{
+	return T_EXIT_SKIP;
+}
+#endif