uringmachine 0.19.1 → 0.20.0

data/vendor/liburing/test/recvsend_bundle.c

@@ -21,7 +21,7 @@ static int nr_msgs;
 static int use_tcp;
 static int classic_buffers;
 
-#define RECV_BIDS	8192
+#define RECV_BIDS	16384
 #define RECV_BID_MASK	(RECV_BIDS - 1)
 
 #include "liburing.h"

data/vendor/liburing/test/resize-rings.c

@@ -657,6 +657,8 @@ try_defer:
 	ret = test(IORING_SETUP_SINGLE_ISSUER | IORING_SETUP_DEFER_TASKRUN, fd, 0);
 	if (ret == T_EXIT_FAIL)
 		return T_EXIT_FAIL;
+	else if (ret == T_EXIT_SKIP)
+		return T_EXIT_SKIP;
 
 	ret = test(IORING_SETUP_SINGLE_ISSUER | IORING_SETUP_DEFER_TASKRUN, fd, 1);
 	if (ret == T_EXIT_FAIL)

data/vendor/liburing/test/ring-query.c

@@ -0,0 +1,322 @@
+/* SPDX-License-Identifier: MIT */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+
+#include "liburing.h"
+#include "test.h"
+#include "helpers.h"
+
+struct io_uring_query_opcode_short {
+	__u32	nr_request_opcodes;
+	__u32	nr_register_opcodes;
+};
+
+struct io_uring_query_opcode_large {
+	__u32	nr_request_opcodes;
+	__u32	nr_register_opcodes;
+	__u64	feature_flags;
+	__u64	ring_setup_flags;
+	__u64	enter_flags;
+	__u64	sqe_flags;
+	__u64	placeholder[8];
+};
+
+static struct io_uring_query_opcode sys_ops;
+
+static int io_uring_query(struct io_uring *ring, struct io_uring_query_hdr *arg)
+{
+	int fd = ring ? ring->ring_fd : -1;
+
+	return io_uring_register(fd, IORING_REGISTER_QUERY, arg, 0);
+}
+
+static int test_basic_query(void)
+{
+	struct io_uring_query_opcode op;
+	struct io_uring_query_hdr hdr = {
+		.query_op = IO_URING_QUERY_OPCODES,
+		.query_data = uring_ptr_to_u64(&op),
+		.size = sizeof(op),
+	};
+	int ret;
+
+	ret = io_uring_query(NULL, &hdr);
+	if (ret == -EINVAL)
+		return T_EXIT_SKIP;
+
+	if (ret != 0) {
+		fprintf(stderr, "query failed %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	if (hdr.size != sizeof(op)) {
+		fprintf(stderr, "unexpected size %i vs %i\n",
+				(int)hdr.size, (int)sizeof(op));
+		return T_EXIT_FAIL;
+	}
+
+	if (hdr.result) {
+		fprintf(stderr, "unexpected result %i\n", hdr.result);
+		return T_EXIT_FAIL;
+	}
+
+	if (op.nr_register_opcodes <= IORING_REGISTER_QUERY) {
+		fprintf(stderr, "too few opcodes (%i)\n", op.nr_register_opcodes);
+		return T_EXIT_FAIL;
+	}
+
+	memcpy(&sys_ops, &op, sizeof(sys_ops));
+	return T_EXIT_PASS;
+}
+
+static int test_invalid(void)
+{
+	int ret;
+	struct io_uring_query_opcode op;
+	struct io_uring_query_hdr invalid_hdr = {
+		.query_op = -1U,
+		.query_data = uring_ptr_to_u64(&op),
+		.size = sizeof(struct io_uring_query_opcode),
+	};
+	struct io_uring_query_hdr invalid_next_hdr = {
+		.query_op = IO_URING_QUERY_OPCODES,
+		.query_data = uring_ptr_to_u64(&op),
+		.size = sizeof(struct io_uring_query_opcode),
+		.next_entry = 0xdeadbeefUL,
+	};
+	struct io_uring_query_hdr invalid_data_hdr = {
+		.query_op = IO_URING_QUERY_OPCODES,
+		.query_data = 0xdeadbeefUL,
+		.size = sizeof(struct io_uring_query_opcode),
+	};
+
+	ret = io_uring_query(NULL, &invalid_hdr);
+	if (ret || invalid_hdr.result != -EOPNOTSUPP) {
+		fprintf(stderr, "failed invalid opcode %i (%i)\n",
+			ret, invalid_hdr.result);
+		return T_EXIT_FAIL;
+	}
+
+	ret = io_uring_query(NULL, &invalid_next_hdr);
+	if (ret != -EFAULT) {
+		fprintf(stderr, "invalid next %i\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	ret = io_uring_query(NULL, &invalid_data_hdr);
+	if (ret != -EFAULT) {
+		fprintf(stderr, "invalid next %i\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	return T_EXIT_PASS;
+}
+
+static int test_chain(void)
+{
+	int ret;
+	struct io_uring_query_opcode op1, op2, op3;
+	struct io_uring_query_hdr hdr3 = {
+		.query_op = IO_URING_QUERY_OPCODES,
+		.query_data = uring_ptr_to_u64(&op3),
+		.size = sizeof(struct io_uring_query_opcode),
+	};
+	struct io_uring_query_hdr hdr2 = {
+		.query_op = IO_URING_QUERY_OPCODES,
+		.query_data = uring_ptr_to_u64(&op2),
+		.size = sizeof(struct io_uring_query_opcode),
+		.next_entry = uring_ptr_to_u64(&hdr3),
+	};
+	struct io_uring_query_hdr hdr1 = {
+		.query_op = IO_URING_QUERY_OPCODES,
+		.query_data = uring_ptr_to_u64(&op1),
+		.size = sizeof(struct io_uring_query_opcode),
+		.next_entry = uring_ptr_to_u64(&hdr2),
+	};
+
+	ret = io_uring_query(NULL, &hdr1);
+	if (ret) {
+		fprintf(stderr, "chain failed %i\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	if (hdr1.result || hdr2.result || hdr3.result) {
+		fprintf(stderr, "chain invalid result entries %i %i %i\n",
+			hdr1.result, hdr2.result, hdr3.result);
+		return T_EXIT_FAIL;
+	}
+
+	if (op1.nr_register_opcodes != sys_ops.nr_register_opcodes ||
+	    op2.nr_register_opcodes != sys_ops.nr_register_opcodes ||
+	    op3.nr_register_opcodes != sys_ops.nr_register_opcodes) {
+		fprintf(stderr, "chain invalid register opcodes\n");
+		return T_EXIT_FAIL;
+	}
+
+	return T_EXIT_PASS;
+}
+
+static int test_chain_loop(void)
+{
+	int ret;
+	struct io_uring_query_opcode op1, op2;
+	struct io_uring_query_hdr hdr2 = {
+		.query_op = IO_URING_QUERY_OPCODES,
+		.query_data = uring_ptr_to_u64(&op2),
+		.size = sizeof(struct io_uring_query_opcode),
+	};
+	struct io_uring_query_hdr hdr1 = {
+		.query_op = IO_URING_QUERY_OPCODES,
+		.query_data = uring_ptr_to_u64(&op1),
+		.size = sizeof(struct io_uring_query_opcode),
+	};
+	struct io_uring_query_hdr hdr_self_circular = {
+		.query_op = IO_URING_QUERY_OPCODES,
+		.query_data = uring_ptr_to_u64(&op1),
+		.size = sizeof(struct io_uring_query_opcode),
+		.next_entry = uring_ptr_to_u64(&hdr_self_circular),
+	};
+
+	hdr1.next_entry = uring_ptr_to_u64(&hdr2);
+	hdr2.next_entry = uring_ptr_to_u64(&hdr1);
+	ret = io_uring_query(NULL, &hdr1);
+	if (!ret) {
+		fprintf(stderr, "chain loop failed %i\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	ret = io_uring_query(NULL, &hdr_self_circular);
+	if (!ret) {
+		fprintf(stderr, "chain loop failed %i\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	return T_EXIT_PASS;
+}
+
+static int test_compatibile_shorter(void)
+{
+	int ret;
+	struct io_uring_query_opcode_short op;
+	struct io_uring_query_hdr hdr = {
+		.query_op = IO_URING_QUERY_OPCODES,
+		.query_data = uring_ptr_to_u64(&op),
+		.size = sizeof(op),
+	};
+
+	ret = io_uring_query(NULL, &hdr);
+	if (ret || hdr.result) {
+		fprintf(stderr, "failed invalid short result %i (%i)\n",
+			ret, hdr.result);
+		return T_EXIT_FAIL;
+	}
+
+	if (hdr.size != sizeof(struct io_uring_query_opcode_short)) {
+		fprintf(stderr, "unexpected short query size %i %i\n",
+			(int)hdr.size,
+			(int)sizeof(struct io_uring_query_opcode_short));
+		return T_EXIT_FAIL;
+	}
+
+	if (sys_ops.nr_register_opcodes != op.nr_register_opcodes ||
+	    sys_ops.nr_request_opcodes != op.nr_request_opcodes) {
+		fprintf(stderr, "invalid short data\n");
+		return T_EXIT_FAIL;
+	}
+
+	return T_EXIT_PASS;
+}
+
+static int test_compatibile_larger(void)
+{
+	int ret;
+	struct io_uring_query_opcode_large op;
+	struct io_uring_query_hdr hdr = {
+		.query_op = IO_URING_QUERY_OPCODES,
+		.query_data = uring_ptr_to_u64(&op),
+		.size = sizeof(op),
+	};
+
+	ret = io_uring_query(NULL, &hdr);
+	if (ret || hdr.result) {
+		fprintf(stderr, "failed invalid large result %i (%i)\n",
+			ret, hdr.result);
+		return T_EXIT_FAIL;
+	}
+
+	if (hdr.size < sizeof(struct io_uring_query_opcode)) {
+		fprintf(stderr, "unexpected large query size %i %i\n",
+			(int)hdr.size,
+			(int)sizeof(struct io_uring_query_opcode));
+		return T_EXIT_FAIL;
+	}
+
+	if (sys_ops.nr_register_opcodes != op.nr_register_opcodes ||
+	    sys_ops.nr_request_opcodes != op.nr_request_opcodes ||
+	    sys_ops.ring_setup_flags != op.ring_setup_flags ||
+	    sys_ops.feature_flags != op.feature_flags) {
+		fprintf(stderr, "invalid large data\n");
+		return T_EXIT_FAIL;
+	}
+
+	return T_EXIT_PASS;
+}
+
+int main(int argc, char *argv[])
+{
+	struct io_uring ring;
+	int ret;
+
+	if (argc > 1)
+		return T_EXIT_SKIP;
+
+	ret = test_basic_query();
+	if (ret != T_EXIT_PASS) {
+		if (ret == T_EXIT_SKIP)
+			fprintf(stderr, "ring query not supported, skip\n");
+		else
+			fprintf(stderr, "test_basic_query failed\n");
+
+		return T_EXIT_SKIP;
+	}
+
+	ret = io_uring_queue_init(8, &ring, 0);
+	if (ret) {
+		fprintf(stderr, "init failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	ret = test_invalid();
+	if (ret)
+		return T_EXIT_FAIL;
+
+	ret = test_chain();
+	if (ret) {
+		fprintf(stderr, "test_chain failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	ret = test_chain_loop();
+	if (ret) {
+		fprintf(stderr, "test_chain_loop failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	ret = test_compatibile_shorter();
+	if (ret) {
+		fprintf(stderr, "test_compatibile_shorter failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	ret = test_compatibile_larger();
+	if (ret) {
+		fprintf(stderr, "test_compatibile_larger failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	return 0;
+}

data/vendor/liburing/test/ringbuf-loop.c

@@ -0,0 +1,87 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: test that having a command overwrite the provided ring
+ *		buffer itself doesn't impact committing of the received
+ *		length at completion time. Based on a test case posted
+ *		here:
+ *
+ *		https://lore.kernel.org/io-uring/tencent_2DEFFED135071FB225305A65D1688B303A09@qq.com/
+ *
+ */
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <sys/socket.h>
+
+#include "liburing.h"
+#include "helpers.h"
+
+#define BGID		0
+#define RENTRIES	2
+#define RMASK		(RENTRIES - 1)
+
+int main(int argc, char *argv[])
+{
+	struct io_uring_buf_ring *br;
+	struct io_uring_sqe *sqe;
+	struct io_uring ring;
+	void *send_buf;
+	int ret, fds[2];
+
+	if (argc > 1)
+		return T_EXIT_SKIP;
+
+	ret = io_uring_queue_init(1, &ring, IORING_SETUP_NO_SQARRAY);
+	if (ret) {
+		if (ret == -EINVAL)
+			return T_EXIT_SKIP;
+		fprintf(stderr, "ring setup: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	br = io_uring_setup_buf_ring(&ring, RENTRIES, BGID, IOU_PBUF_RING_INC, &ret);
+	if (!br) {
+		if (ret == -EINVAL)
+			return T_EXIT_SKIP;
+		fprintf(stderr, "buf ring setup: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	/*
+	 * Use the buffer ring itself as the provided buffer address. Once the
+	 * recv completes, it will have zero filled the buffer addr/len.
+	 */
+	io_uring_buf_ring_add(br, br, 4096, 0, RMASK, 0);
+	io_uring_buf_ring_advance(br, 1);
+
+	if (socketpair(AF_UNIX, SOCK_DGRAM, 0, fds) < 0) {
+		perror("socketpair");
+		return T_EXIT_FAIL;
+	}
+
+	/*
+	 * Send zeroes, overwriting the buffer ring
+	 */
+	send_buf = calloc(1, 32);
+	ret = send(fds[0], send_buf, 32, MSG_DONTWAIT);
+	if (ret < 0) {
+		perror("send");
+		return T_EXIT_FAIL;
+	}
+
+	/*
+	 * Do recv, picking the first buffer. When buffer is picked,
+	 * it's still fully valid. By the time it needs to get committed,
+	 * it will have invalid addr/len fields (all zeroes from the recv)
+	 */
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_recv(sqe, fds[1], NULL, 0, 0);
+	sqe->flags |= IOSQE_BUFFER_SELECT;
+	sqe->buf_index = BGID;
+	io_uring_submit_and_wait(&ring, 1);
+
+	io_uring_free_buf_ring(&ring, br, RENTRIES, BGID);
+	io_uring_queue_exit(&ring);
+	free(send_buf);
+	return T_EXIT_PASS;
+}

data/vendor/liburing/test/runtests.sh

@@ -1,7 +1,7 @@
 #!/usr/bin/env bash
 
 TESTS=("$@")
-TIMEOUT=60
+: "${TIMEOUT:=60}"
 DMESG_FILTER="cat"
 TEST_DIR=$(dirname "$0")
 FAILED=()
@@ -99,7 +99,7 @@ run_test()
 
 	# Run the test
 	T_START=$(date +%s)
-	timeout -s INT -k $TIMEOUT $TIMEOUT "${test_exec[@]}"
+	timeout -s INT -k "${TIMEOUT}" "${TIMEOUT}" "${test_exec[@]}"
 	local status=$?
 	T_END=$(date +%s)
 

data/vendor/liburing/test/send-zerocopy.c

@@ -74,6 +74,7 @@ static bool has_sendzc;
 static bool has_sendmsg;
 static bool hit_enomem;
 static bool try_hugepages = 1;
+static bool no_send_vec;
 
 static int probe_zc_support(void)
 {
@@ -112,18 +113,34 @@ static bool check_cq_empty(struct io_uring *ring)
 	return ret == -EAGAIN;
 }
 
-static int test_basic_send(struct io_uring *ring, int sock_tx, int sock_rx)
+static int test_basic_send(struct io_uring *ring, int sock_tx, int sock_rx,
+			   int vec)
 {
 	struct io_uring_sqe *sqe;
 	struct io_uring_cqe *cqe;
+	struct iovec vecs[2];
 	int msg_flags = 0;
 	unsigned zc_flags = 0;
 	int payload_size = 100;
 	int ret;
 
+	if (vec && no_send_vec)
+		return 0;
+
 	sqe = io_uring_get_sqe(ring);
-	io_uring_prep_send_zc(sqe, sock_tx, tx_buffer, payload_size,
-			      msg_flags, zc_flags);
+	if (vec) {
+		size_t split = payload_size / 2;
+
+		vecs[0].iov_base = tx_buffer;
+		vecs[0].iov_len = split;
+		vecs[1].iov_base = tx_buffer + split;
+		vecs[1].iov_len = split;
+		io_uring_prep_send_zc(sqe, sock_tx, vecs, 2, msg_flags, zc_flags);
+		sqe->ioprio |= (1U << 5);
+	} else {
+		io_uring_prep_send_zc(sqe, sock_tx, tx_buffer, payload_size,
+				      msg_flags, zc_flags);
+	}
 	sqe->user_data = 1;
 
 	ret = io_uring_submit(ring);
@@ -132,6 +149,21 @@ static int test_basic_send(struct io_uring *ring, int sock_tx, int sock_rx)
 	ret = io_uring_wait_cqe(ring, &cqe);
 	assert(!ret && cqe->user_data == 1);
 	if (cqe->res != payload_size) {
+		if (cqe->res == -EINVAL && vec) {
+			int has_more = cqe->flags & IORING_CQE_F_MORE;
+
+			no_send_vec = 1;
+			io_uring_cqe_seen(ring, cqe);
+			if (has_more) {
+				ret = io_uring_peek_cqe(ring, &cqe);
+				if (ret) {
+					fprintf(stderr, "peek failed\n");
+					return T_EXIT_FAIL;
+				}
+				io_uring_cqe_seen(ring, cqe);
+			}
+			return T_EXIT_PASS;
+		}
 		fprintf(stderr, "send failed %i\n", cqe->res);
 		return T_EXIT_FAIL;
 	}
@@ -773,9 +805,15 @@ static int run_basic_tests(void)
 			return -1;
 		}
 
-		ret = test_basic_send(&ring, sp[0], sp[1]);
+		ret = test_basic_send(&ring, sp[0], sp[1], 0);
+		if (ret) {
+			fprintf(stderr, "test_basic_send() nonvec failed\n");
+			return -1;
+		}
+
+		ret = test_basic_send(&ring, sp[0], sp[1], 1);
 		if (ret) {
-			fprintf(stderr, "test_basic_send() failed\n");
+			fprintf(stderr, "test_basic_send() vec failed\n");
 			return -1;
 		}