iou 0.1

data/vendor/liburing/test/poll-cancel.c

@@ -0,0 +1,228 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: test io_uring poll cancel handling
+ *
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+#include <poll.h>
+#include <sys/wait.h>
+#include <signal.h>
+
+#include "liburing.h"
+
+struct poll_data {
+	unsigned is_poll;
+	unsigned is_cancel;
+};
+
+static void sig_alrm(int sig)
+{
+	fprintf(stderr, "Timed out!\n");
+	exit(1);
+}
+
+static int test_poll_cancel(void)
+{
+	struct io_uring ring;
+	int pipe1[2];
+	struct io_uring_cqe *cqe;
+	struct io_uring_sqe *sqe;
+	struct poll_data *pd, pds[2];
+	struct sigaction act;
+	int ret;
+
+	if (pipe(pipe1) != 0) {
+		perror("pipe");
+		return 1;
+	}
+
+	ret = io_uring_queue_init(2, &ring, 0);
+	if (ret) {
+		fprintf(stderr, "ring setup failed: %d\n", ret);
+		return 1;
+	}
+
+	memset(&act, 0, sizeof(act));
+	act.sa_handler = sig_alrm;
+	act.sa_flags = SA_RESTART;
+	sigaction(SIGALRM, &act, NULL);
+	alarm(1);
+
+	sqe = io_uring_get_sqe(&ring);
+	if (!sqe) {
+		fprintf(stderr, "get sqe failed\n");
+		return 1;
+	}
+
+	io_uring_prep_poll_add(sqe, pipe1[0], POLLIN);
+
+	pds[0].is_poll = 1;
+	pds[0].is_cancel = 0;
+	io_uring_sqe_set_data(sqe, &pds[0]);
+
+	ret = io_uring_submit(&ring);
+	if (ret <= 0) {
+		fprintf(stderr, "sqe submit failed\n");
+		return 1;
+	}
+
+	sqe = io_uring_get_sqe(&ring);
+	if (!sqe) {
+		fprintf(stderr, "get sqe failed\n");
+		return 1;
+	}
+
+	pds[1].is_poll = 0;
+	pds[1].is_cancel = 1;
+	io_uring_prep_poll_remove(sqe, (__u64)(uintptr_t)&pds[0]);
+	io_uring_sqe_set_data(sqe, &pds[1]);
+
+	ret = io_uring_submit(&ring);
+	if (ret <= 0) {
+		fprintf(stderr, "sqe submit failed: %d\n", ret);
+		return 1;
+	}
+
+	ret = io_uring_wait_cqe(&ring, &cqe);
+	if (ret < 0) {
+		fprintf(stderr, "wait cqe failed: %d\n", ret);
+		return 1;
+	}
+
+	pd = io_uring_cqe_get_data(cqe);
+	if (pd->is_poll && cqe->res != -ECANCELED) {
+		fprintf(stderr ,"sqe (add=%d/remove=%d) failed with %ld\n",
+					pd->is_poll, pd->is_cancel,
+					(long) cqe->res);
+		return 1;
+	} else if (pd->is_cancel && cqe->res) {
+		fprintf(stderr, "sqe (add=%d/remove=%d) failed with %ld\n",
+					pd->is_poll, pd->is_cancel,
+					(long) cqe->res);
+		return 1;
+	}
+	io_uring_cqe_seen(&ring, cqe);
+
+	ret = io_uring_wait_cqe(&ring, &cqe);
+	if (ret < 0) {
+		fprintf(stderr, "wait_cqe: %d\n", ret);
+		return 1;
+	}
+
+	pd = io_uring_cqe_get_data(cqe);
+	if (pd->is_poll && cqe->res != -ECANCELED) {
+		fprintf(stderr, "sqe (add=%d/remove=%d) failed with %ld\n",
+					pd->is_poll, pd->is_cancel,
+					(long) cqe->res);
+		return 1;
+	} else if (pd->is_cancel && cqe->res) {
+		fprintf(stderr, "sqe (add=%d/remove=%d) failed with %ld\n",
+					pd->is_poll, pd->is_cancel,
+					(long) cqe->res);
+		return 1;
+	}
+
+	close(pipe1[0]);
+	close(pipe1[1]);
+	io_uring_cqe_seen(&ring, cqe);
+	io_uring_queue_exit(&ring);
+	return 0;
+}
+
+
+static int __test_poll_cancel_with_timeouts(void)
+{
+	struct __kernel_timespec ts = { .tv_sec = 10, };
+	struct io_uring ring, ring2;
+	struct io_uring_sqe *sqe;
+	int ret, off_nr = 1000;
+
+	ret = io_uring_queue_init(8, &ring, 0);
+	if (ret) {
+		fprintf(stderr, "ring setup failed: %d\n", ret);
+		return 1;
+	}
+
+	ret = io_uring_queue_init(1, &ring2, 0);
+	if (ret) {
+		fprintf(stderr, "ring setup failed: %d\n", ret);
+		return 1;
+	}
+
+	/* test timeout-offset triggering path during cancelation */
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_timeout(sqe, &ts, off_nr, 0);
+
+	/* poll ring2 to trigger cancelation on exit() */
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_poll_add(sqe, ring2.ring_fd, POLLIN);
+	sqe->flags |= IOSQE_IO_LINK;
+
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_link_timeout(sqe, &ts, 0);
+
+	ret = io_uring_submit(&ring);
+	if (ret != 3) {
+		fprintf(stderr, "sqe submit failed\n");
+		return 1;
+	}
+
+	/* just drop all rings/etc. intact, exit() will clean them up */
+	return 0;
+}
+
+static int test_poll_cancel_with_timeouts(void)
+{
+	int ret;
+	pid_t p;
+
+	p = fork();
+	if (p == -1) {
+		fprintf(stderr, "fork() failed\n");
+		return 1;
+	}
+
+	if (p == 0) {
+		ret = __test_poll_cancel_with_timeouts();
+		exit(ret);
+	} else {
+		int wstatus;
+
+		if (waitpid(p, &wstatus, 0) == (pid_t)-1) {
+			perror("waitpid()");
+			return 1;
+		}
+		if (!WIFEXITED(wstatus) || WEXITSTATUS(wstatus)) {
+			fprintf(stderr, "child failed %i\n", WEXITSTATUS(wstatus));
+			return 1;
+		}
+	}
+	return 0;
+}
+
+int main(int argc, char *argv[])
+{
+	int ret;
+
+	if (argc > 1)
+		return 0;
+
+	ret = test_poll_cancel();
+	if (ret) {
+		fprintf(stderr, "test_poll_cancel failed\n");
+		return -1;
+	}
+
+	ret = test_poll_cancel_with_timeouts();
+	if (ret) {
+		fprintf(stderr, "test_poll_cancel_with_timeouts failed\n");
+		return -1;
+	}
+
+	return 0;
+}

data/vendor/liburing/test/poll-link.c

@@ -0,0 +1,221 @@
+/* SPDX-License-Identifier: MIT */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <assert.h>
+#include <pthread.h>
+#include <sys/socket.h>
+#include <netinet/tcp.h>
+#include <netinet/in.h>
+#include <poll.h>
+#include <arpa/inet.h>
+
+#include "helpers.h"
+#include "liburing.h"
+
+static pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+
+static int recv_thread_ready = 0;
+static int recv_thread_done = 0;
+
+static void signal_var(int *var)
+{
+        pthread_mutex_lock(&mutex);
+        *var = 1;
+        pthread_cond_signal(&cond);
+        pthread_mutex_unlock(&mutex);
+}
+
+static void wait_for_var(int *var)
+{
+        pthread_mutex_lock(&mutex);
+
+        while (!*var)
+                pthread_cond_wait(&cond, &mutex);
+
+        pthread_mutex_unlock(&mutex);
+}
+
+struct data {
+	unsigned expected[2];
+	unsigned is_mask[2];
+	unsigned long timeout;
+	unsigned short port;
+	unsigned int addr;
+	int stop;
+};
+
+static void *send_thread(void *arg)
+{
+	struct sockaddr_in addr;
+	struct data *data = arg;
+	int s0;
+
+	wait_for_var(&recv_thread_ready);
+
+	s0 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+	assert(s0 != -1);
+
+	addr.sin_family = AF_INET;
+	addr.sin_port = data->port;
+	addr.sin_addr.s_addr = data->addr;
+
+	if (connect(s0, (struct sockaddr*)&addr, sizeof(addr)) != -1)
+		wait_for_var(&recv_thread_done);
+
+	close(s0);
+	return 0;
+}
+
+static void *recv_thread(void *arg)
+{
+	struct sockaddr_in addr = { };
+	struct data *data = arg;
+	struct io_uring_sqe *sqe;
+	struct io_uring ring;
+	int i, ret;
+
+	ret = io_uring_queue_init(8, &ring, 0);
+	assert(ret == 0);
+
+	int s0 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+	assert(s0 != -1);
+
+	int32_t val = 1;
+	ret = setsockopt(s0, SOL_SOCKET, SO_REUSEPORT, &val, sizeof(val));
+	assert(ret != -1);
+	ret = setsockopt(s0, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
+	assert(ret != -1);
+
+	addr.sin_family = AF_INET;
+	data->addr = inet_addr("127.0.0.1");
+	addr.sin_addr.s_addr = data->addr;
+
+	if (t_bind_ephemeral_port(s0, &addr)) {
+		perror("bind");
+		data->stop = 1;
+		signal_var(&recv_thread_ready);
+		goto err;
+	}
+	data->port = addr.sin_port;
+
+	ret = listen(s0, 128);
+	assert(ret != -1);
+
+	signal_var(&recv_thread_ready);
+
+	sqe = io_uring_get_sqe(&ring);
+	assert(sqe != NULL);
+
+	io_uring_prep_poll_add(sqe, s0, POLLIN | POLLHUP | POLLERR);
+	sqe->flags |= IOSQE_IO_LINK;
+	sqe->user_data = 1;
+
+	sqe = io_uring_get_sqe(&ring);
+	assert(sqe != NULL);
+
+	struct __kernel_timespec ts;
+	ts.tv_sec = data->timeout / 1000000000;
+	ts.tv_nsec = data->timeout % 1000000000;
+	io_uring_prep_link_timeout(sqe, &ts, 0);
+	sqe->user_data = 2;
+
+	ret = io_uring_submit(&ring);
+	assert(ret == 2);
+
+	for (i = 0; i < 2; i++) {
+		struct io_uring_cqe *cqe;
+		int idx;
+
+		if (io_uring_wait_cqe(&ring, &cqe)) {
+			fprintf(stderr, "wait cqe failed\n");
+			goto err;
+		}
+		idx = cqe->user_data - 1;
+		if (data->is_mask[idx] && !(data->expected[idx] & cqe->res)) {
+			fprintf(stderr, "cqe %" PRIu64 " got %x, wanted mask %x\n",
+					(uint64_t) cqe->user_data, cqe->res,
+					data->expected[idx]);
+			goto err;
+		} else if (!data->is_mask[idx] && cqe->res != data->expected[idx]) {
+			fprintf(stderr, "cqe %" PRIu64 " got %d, wanted %d\n",
+					(uint64_t) cqe->user_data, cqe->res,
+					data->expected[idx]);
+			goto err;
+		}
+		io_uring_cqe_seen(&ring, cqe);
+	}
+
+	signal_var(&recv_thread_done);
+	close(s0);
+	io_uring_queue_exit(&ring);
+	return NULL;
+err:
+	signal_var(&recv_thread_done);
+	close(s0);
+	io_uring_queue_exit(&ring);
+	return (void *) 1;
+}
+
+static int test_poll_timeout(int do_connect, unsigned long timeout)
+{
+	pthread_t t1, t2;
+	struct data d;
+	void *tret;
+	int ret = 0;
+
+	recv_thread_ready = 0;
+	recv_thread_done = 0;
+
+	memset(&d, 0, sizeof(d));
+	d.timeout = timeout;
+	if (!do_connect) {
+		d.expected[0] = -ECANCELED;
+		d.expected[1] = -ETIME;
+	} else {
+		d.expected[0] = POLLIN;
+		d.is_mask[0] = 1;
+		d.expected[1] = -ECANCELED;
+	}
+
+	pthread_create(&t1, NULL, recv_thread, &d);
+
+	if (do_connect)
+		pthread_create(&t2, NULL, send_thread, &d);
+
+	pthread_join(t1, &tret);
+	if (tret)
+		ret++;
+
+	if (do_connect) {
+		pthread_join(t2, &tret);
+		if (tret)
+			ret++;
+	}
+
+	return ret;
+}
+
+int main(int argc, char *argv[])
+{
+	if (argc > 1)
+		return 0;
+
+	srand(getpid());
+
+	if (test_poll_timeout(0, 200000000)) {
+		fprintf(stderr, "poll timeout 0 failed\n");
+		return 1;
+	}
+
+	if (test_poll_timeout(1, 1000000000)) {
+		fprintf(stderr, "poll timeout 1 failed\n");
+		return 1;
+	}
+
+	return 0;
+}

data/vendor/liburing/test/poll-many.c

@@ -0,0 +1,230 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: test many files being polled for
+ *
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <signal.h>
+#include <poll.h>
+#include <sys/resource.h>
+#include <fcntl.h>
+
+#include "liburing.h"
+#include "helpers.h"
+
+#define	NFILES	5000
+#define BATCH	500
+#define NLOOPS	1000
+
+#define RING_SIZE	512
+
+struct p {
+	int fd[2];
+	int triggered;
+};
+
+static struct p p[NFILES];
+
+static int arm_poll(struct io_uring *ring, int off)
+{
+	struct io_uring_sqe *sqe;
+
+	sqe = io_uring_get_sqe(ring);
+	if (!sqe) {
+		fprintf(stderr, "failed getting sqe\n");
+		return 1;
+	}
+
+	io_uring_prep_poll_add(sqe, p[off].fd[0], POLLIN);
+	sqe->user_data = off;
+	return 0;
+}
+
+static int reap_polls(struct io_uring *ring)
+{
+	struct io_uring_cqe *cqe;
+	int i, ret, off;
+	char c;
+
+	for (i = 0; i < BATCH; i++) {
+		ret = io_uring_wait_cqe(ring, &cqe);
+		if (ret) {
+			fprintf(stderr, "wait cqe %d\n", ret);
+			return ret;
+		}
+		off = cqe->user_data;
+		p[off].triggered = 0;
+		ret = read(p[off].fd[0], &c, 1);
+		if (ret != 1) {
+			fprintf(stderr, "read got %d/%d\n", ret, errno);
+			break;
+		}
+		if (arm_poll(ring, off))
+			break;
+		io_uring_cqe_seen(ring, cqe);
+	}
+
+	if (i != BATCH) {
+		fprintf(stderr, "gave up at %d\n", i);
+		return 1;
+	}
+
+	ret = io_uring_submit(ring);
+	if (ret != BATCH) {
+		fprintf(stderr, "submitted %d, %d\n", ret, BATCH);
+		return 1;
+	}
+
+	return 0;
+}
+
+static int trigger_polls(void)
+{
+	char c = 89;
+	int i, ret;
+
+	for (i = 0; i < BATCH; i++) {
+		int off;
+
+		do {
+			off = rand() % NFILES;
+			if (!p[off].triggered)
+				break;
+		} while (1);
+
+		p[off].triggered = 1;
+		ret = write(p[off].fd[1], &c, 1);
+		if (ret != 1) {
+			fprintf(stderr, "write got %d/%d\n", ret, errno);
+			return 1;
+		}
+	}
+
+	return 0;
+}
+
+static int arm_polls(struct io_uring *ring)
+{
+	int ret, to_arm = NFILES, i, off;
+
+	off = 0;
+	while (to_arm) {
+		int this_arm;
+
+		this_arm = to_arm;
+		if (this_arm > RING_SIZE)
+			this_arm = RING_SIZE;
+
+		for (i = 0; i < this_arm; i++) {
+			if (arm_poll(ring, off)) {
+				fprintf(stderr, "arm failed at %d\n", off);
+				return 1;
+			}
+			off++;
+		}
+
+		ret = io_uring_submit(ring);
+		if (ret != this_arm) {
+			fprintf(stderr, "submitted %d, %d\n", ret, this_arm);
+			return 1;
+		}
+		to_arm -= this_arm;
+	}
+
+	return 0;
+}
+
+static int do_test(struct io_uring *ring)
+{
+	int i;
+
+	if (arm_polls(ring))
+		return 1;
+
+	for (i = 0; i < NLOOPS; i++) {
+		trigger_polls();
+		if (reap_polls(ring))
+			return 1;
+	}
+	return 0;
+}
+
+int main(int argc, char *argv[])
+{
+	struct io_uring ring;
+	struct io_uring_params params = { };
+	struct rlimit rlim;
+	int i, ret;
+
+	if (argc > 1)
+		return 0;
+
+	if (getrlimit(RLIMIT_NOFILE, &rlim) < 0) {
+		perror("getrlimit");
+		return T_EXIT_FAIL;
+	}
+
+	if (rlim.rlim_cur < (2 * NFILES + 5)) {
+		rlim.rlim_cur = (2 * NFILES + 5);
+		rlim.rlim_max = rlim.rlim_cur;
+		if (setrlimit(RLIMIT_NOFILE, &rlim) < 0) {
+			if (errno == EPERM)
+				goto err_nofail;
+			perror("setrlimit");
+			return T_EXIT_FAIL;
+		}
+	}
+
+	for (i = 0; i < NFILES; i++) {
+		if (pipe(p[i].fd) < 0) {
+			perror("pipe");
+			return T_EXIT_FAIL;
+		}
+	}
+
+	params.flags = IORING_SETUP_CQSIZE;
+	params.cq_entries = 4096;
+	ret = io_uring_queue_init_params(RING_SIZE, &ring, &params);
+	if (ret) {
+		if (ret == -EINVAL) {
+			fprintf(stdout, "No CQSIZE, trying without\n");
+
+			params.flags &= ~IORING_SETUP_CQSIZE;
+			params.cq_entries = 0;
+			ret = io_uring_queue_init_params(RING_SIZE, &ring, &params);
+			if (ret) {
+				fprintf(stderr, "ring setup failed: %d\n", ret);
+				return T_EXIT_FAIL;
+			}
+		}
+	}
+
+	if (do_test(&ring)) {
+		fprintf(stderr, "test (normal) failed\n");
+		return T_EXIT_FAIL;
+	}
+	io_uring_queue_exit(&ring);
+
+	if (t_probe_defer_taskrun()) {
+		params.flags |= IORING_SETUP_SINGLE_ISSUER | IORING_SETUP_DEFER_TASKRUN;
+		ret = io_uring_queue_init_params(RING_SIZE, &ring, &params);
+		if (ret) {
+			fprintf(stderr, "ring DEFER setup failed: %d\n", ret);
+			return T_EXIT_FAIL;
+		}
+		if (do_test(&ring)) {
+			fprintf(stderr, "test (DEFER) failed\n");
+			return T_EXIT_FAIL;
+		}
+		io_uring_queue_exit(&ring);
+	}
+	return 0;
+err_nofail:
+	fprintf(stderr, "poll-many: not enough files available (and not root), "
+			"skipped\n");
+	return 0;
+}