uringmachine 0.1

data/vendor/liburing/test/waitid.c

@@ -0,0 +1,373 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: test waitid functionality
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+
+#include "liburing.h"
+#include "helpers.h"
+
+static bool no_waitid;
+
+static void child(long usleep_time)
+{
+	if (usleep_time)
+		usleep(usleep_time);
+	exit(0);
+}
+
+/*
+ * Test linked timeout with child not exiting in time
+ */
+static int test_noexit(struct io_uring *ring)
+{
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	struct __kernel_timespec ts;
+	siginfo_t si;
+	pid_t pid;
+	int ret, i;
+
+	pid = fork();
+	if (!pid) {
+		child(200000);
+		exit(0);
+	}
+
+	sqe = io_uring_get_sqe(ring);
+	io_uring_prep_waitid(sqe, P_PID, pid, &si, WEXITED, 0);
+	sqe->flags |= IOSQE_IO_LINK;
+	sqe->user_data = 1;
+
+	ts.tv_sec = 0;
+	ts.tv_nsec = 100 * 1000 * 1000ULL;
+	sqe = io_uring_get_sqe(ring);
+	io_uring_prep_link_timeout(sqe, &ts, 0);
+	sqe->user_data = 2;
+
+	io_uring_submit(ring);
+
+	for (i = 0; i < 2; i++) {
+		ret = io_uring_wait_cqe(ring, &cqe);
+		if (ret) {
+			fprintf(stderr, "cqe wait: %d\n", ret);
+			return T_EXIT_FAIL;
+		}
+		if (cqe->user_data == 2 && cqe->res != 1) {
+			fprintf(stderr, "timeout res: %d\n", cqe->res);
+			return T_EXIT_FAIL;
+		}
+		if (cqe->user_data == 1 && cqe->res != -ECANCELED) {
+			fprintf(stderr, "waitid res: %d\n", cqe->res);
+			return T_EXIT_FAIL;
+		}
+		io_uring_cqe_seen(ring, cqe);
+	}
+
+	return T_EXIT_PASS;
+}
+
+/*
+ * Test one child exiting, but not the one we were looking for
+ */
+static int test_double(struct io_uring *ring)
+{
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	siginfo_t si;
+	pid_t p1, p2;
+	int ret;
+
+	/* p1 will exit shortly */
+	p1 = fork();
+	if (!p1) {
+		child(100000);
+		exit(0);
+	}
+
+	/* p2 will linger */
+	p2 = fork();
+	if (!p2) {
+		child(200000);
+		exit(0);
+	}
+
+	sqe = io_uring_get_sqe(ring);
+	io_uring_prep_waitid(sqe, P_PID, p2, &si, WEXITED, 0);
+
+	io_uring_submit(ring);
+
+	ret = io_uring_wait_cqe(ring, &cqe);
+	if (ret) {
+		fprintf(stderr, "cqe wait: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	if (cqe->res < 0) {
+		fprintf(stderr, "cqe res: %d\n", cqe->res);
+		return T_EXIT_FAIL;
+	}
+	if (si.si_pid != p2) {
+		fprintf(stderr, "expected pid %d, got %d\n", p2, si.si_pid);
+		return T_EXIT_FAIL;
+	}
+
+	io_uring_cqe_seen(ring, cqe);
+	return T_EXIT_PASS;
+}
+
+/*
+ * Test reaping of an already exited task
+ */
+static int test_ready(struct io_uring *ring)
+{
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	siginfo_t si;
+	pid_t pid;
+	int ret;
+
+	pid = fork();
+	if (!pid) {
+		child(0);
+		exit(0);
+	}
+
+	sqe = io_uring_get_sqe(ring);
+	io_uring_prep_waitid(sqe, P_PID, pid, &si, WEXITED, 0);
+
+	io_uring_submit(ring);
+
+	ret = io_uring_wait_cqe(ring, &cqe);
+	if (ret) {
+		fprintf(stderr, "cqe wait: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	if (cqe->res < 0) {
+		fprintf(stderr, "cqe res: %d\n", cqe->res);
+		return T_EXIT_FAIL;
+	}
+	if (si.si_pid != pid) {
+		fprintf(stderr, "expected pid %d, got %d\n", pid, si.si_pid);
+		return T_EXIT_FAIL;
+	}
+
+	io_uring_cqe_seen(ring, cqe);
+	return T_EXIT_PASS;
+}
+
+/*
+ * Test cancelation of pending waitid
+ */
+static int test_cancel(struct io_uring *ring)
+{
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	int ret, i;
+	pid_t pid;
+
+	pid = fork();
+	if (!pid) {
+		child(20000);
+		exit(0);
+	}
+
+	sqe = io_uring_get_sqe(ring);
+	io_uring_prep_waitid(sqe, P_PID, pid, NULL, WEXITED, 0);
+	sqe->user_data = 1;
+
+	io_uring_submit(ring);
+
+	sqe = io_uring_get_sqe(ring);
+	io_uring_prep_cancel64(sqe, 1, 0);
+	sqe->user_data = 2;
+
+	io_uring_submit(ring);
+
+	for (i = 0; i < 2; i++) {
+		ret = io_uring_wait_cqe(ring, &cqe);
+		if (ret) {
+			fprintf(stderr, "cqe wait: %d\n", ret);
+			return T_EXIT_FAIL;
+		}
+		if (cqe->user_data == 1 && cqe->res != -ECANCELED) {
+			fprintf(stderr, "cqe res: %d\n", cqe->res);
+			return T_EXIT_FAIL;
+		}
+		if (cqe->user_data == 2 && cqe->res != 1) {
+			fprintf(stderr, "cqe res: %d\n", cqe->res);
+			return T_EXIT_FAIL;
+		}
+		io_uring_cqe_seen(ring, cqe);
+	}
+
+	return T_EXIT_PASS;
+}
+
+/*
+ * Test cancelation of pending waitid, with expected races that either
+ * waitid trigger or cancelation will win.
+ */
+static int test_cancel_race(struct io_uring *ring, int async)
+{
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	int ret, i;
+	pid_t pid;
+
+	for (i = 0; i < 10; i++) {
+		pid = fork();
+		if (!pid) {
+			child(getpid() & 1);
+			exit(0);
+		}
+	}
+
+	sqe = io_uring_get_sqe(ring);
+	io_uring_prep_waitid(sqe, P_ALL, -1, NULL, WEXITED, 0);
+	if (async)
+		sqe->flags |= IOSQE_ASYNC;
+	sqe->user_data = 1;
+
+	io_uring_submit(ring);
+
+	sqe = io_uring_get_sqe(ring);
+	io_uring_prep_cancel64(sqe, 1, 0);
+	sqe->user_data = 2;
+
+	usleep(1);
+
+	io_uring_submit(ring);
+
+	for (i = 0; i < 2; i++) {
+		ret = io_uring_wait_cqe(ring, &cqe);
+		if (ret) {
+			fprintf(stderr, "cqe wait: %d\n", ret);
+			return T_EXIT_FAIL;
+		}
+		if (cqe->user_data == 1 && !(cqe->res == -ECANCELED ||
+					     cqe->res == 0)) {
+			fprintf(stderr, "cqe1 res: %d\n", cqe->res);
+			return T_EXIT_FAIL;
+		}
+		if (cqe->user_data == 2 &&
+		    !(cqe->res == 1 || cqe->res == 0 || cqe->res == -ENOENT ||
+		      cqe->res == -EALREADY)) {
+			fprintf(stderr, "cqe2 res: %d\n", cqe->res);
+			return T_EXIT_FAIL;
+		}
+		io_uring_cqe_seen(ring, cqe);
+	}
+
+	return T_EXIT_PASS;
+}
+
+/*
+ * Test basic reap of child exit
+ */
+static int test(struct io_uring *ring)
+{
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	siginfo_t si;
+	pid_t pid;
+	int ret;
+
+	pid = fork();
+	if (!pid) {
+		child(100);
+		exit(0);
+	}
+
+	sqe = io_uring_get_sqe(ring);
+	io_uring_prep_waitid(sqe, P_PID, pid, &si, WEXITED, 0);
+
+	io_uring_submit(ring);
+
+	ret = io_uring_wait_cqe(ring, &cqe);
+	if (ret) {
+		fprintf(stderr, "cqe wait: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	/* no waitid support */
+	if (cqe->res == -EINVAL) {
+		no_waitid = true;
+		return T_EXIT_SKIP;
+	}
+	if (cqe->res < 0) {
+		fprintf(stderr, "cqe res: %d\n", cqe->res);
+		return T_EXIT_FAIL;
+	}
+	if (si.si_pid != pid) {
+		fprintf(stderr, "expected pid %d, got %d\n", pid, si.si_pid);
+		return T_EXIT_FAIL;
+	}
+
+	io_uring_cqe_seen(ring, cqe);
+	return T_EXIT_PASS;
+}
+
+int main(int argc, char *argv[])
+{
+	struct io_uring ring;
+	int ret, i;
+
+	if (argc > 1)
+		return T_EXIT_SKIP;
+
+	io_uring_queue_init(8, &ring, 0);
+
+	ret = test(&ring);
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test failed\n");
+		return T_EXIT_FAIL;
+	}
+	if (no_waitid)
+		return T_EXIT_SKIP;
+
+	ret = test_noexit(&ring);
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test_noexit failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	ret = test_noexit(&ring);
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test_noexit failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	ret = test_double(&ring);
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test_double failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	ret = test_ready(&ring);
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test_ready failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	ret = test_cancel(&ring);
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test_cancel failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	for (i = 0; i < 1000; i++) {
+		ret = test_cancel_race(&ring, i & 1);
+		if (ret == T_EXIT_FAIL) {
+			fprintf(stderr, "test_cancel_race failed\n");
+			return T_EXIT_FAIL;
+		}
+	}
+
+	io_uring_queue_exit(&ring);
+	return T_EXIT_PASS;
+}

data/vendor/liburing/test/wakeup-hang.c

@@ -0,0 +1,162 @@
+/* SPDX-License-Identifier: MIT */
+#include <sys/eventfd.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <pthread.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <sys/time.h>
+#include "liburing.h"
+
+struct thread_data {
+	struct io_uring *ring;
+	int write_fd;
+};
+
+static void error_exit(char *message)
+{
+	perror(message);
+	exit(1);
+}
+
+static void *listener_thread(void *data)
+{
+	struct thread_data *td = data;
+	struct io_uring_cqe *cqe;
+	int ret;
+
+        ret = io_uring_wait_cqe(td->ring, &cqe);
+        if (ret < 0) {
+        	fprintf(stderr, "Error waiting for completion: %s\n",
+                	strerror(-ret));
+		goto err;
+        }
+	if (cqe->res < 0) {
+		fprintf(stderr, "Error in async operation: %s\n", strerror(-cqe->res));
+		goto err;
+        }
+	io_uring_cqe_seen(td->ring, cqe);
+	return NULL;
+err:
+	return (void *) 1;
+}
+
+static void *wakeup_io_uring(void *data)
+{
+	struct thread_data *td = data;
+	int res;
+
+	res = eventfd_write(td->write_fd, (eventfd_t) 1L);
+	if (res < 0) {
+		perror("eventfd_write");
+		return (void *) 1;
+	}
+	return NULL;
+}
+
+static int test_pipes(void)
+{
+	struct io_uring_sqe *sqe;
+	struct thread_data td;
+	struct io_uring ring;
+	pthread_t t1, t2;
+	int ret, fds[2];
+	void *pret;
+
+	if (pipe(fds) < 0)
+		error_exit("eventfd");
+
+	ret = io_uring_queue_init(8, &ring, 0);
+	if (ret) {
+		fprintf(stderr, "Unable to setup io_uring: %s\n", strerror(-ret));
+		return 1;
+	}
+
+	td.write_fd = fds[1];
+	td.ring = &ring;
+
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_poll_add(sqe, fds[0], POLLIN);
+	sqe->user_data = 2;
+	ret = io_uring_submit(&ring);
+	if (ret != 1) {
+		fprintf(stderr, "ring_submit=%d\n", ret);
+		return 1;
+	}
+
+	pthread_create(&t1, NULL, listener_thread, &td);
+
+	sleep(1);
+
+	pthread_create(&t2, NULL, wakeup_io_uring, &td);
+	pthread_join(t1, &pret);
+
+	io_uring_queue_exit(&ring);
+	return pret != NULL;
+}
+
+static int test_eventfd(void)
+{
+	struct io_uring_sqe *sqe;
+	struct thread_data td;
+	struct io_uring ring;
+	pthread_t t1, t2;
+	int efd, ret;
+	void *pret;
+
+	efd = eventfd(0, 0);
+	if (efd < 0)
+		error_exit("eventfd");
+
+	ret = io_uring_queue_init(8, &ring, 0);
+	if (ret) {
+		fprintf(stderr, "Unable to setup io_uring: %s\n", strerror(-ret));
+		return 1;
+	}
+
+	td.write_fd = efd;
+	td.ring = &ring;
+
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_poll_add(sqe, efd, POLLIN);
+	sqe->user_data = 2;
+	ret = io_uring_submit(&ring);
+	if (ret != 1) {
+		fprintf(stderr, "ring_submit=%d\n", ret);
+		return 1;
+	}
+
+	pthread_create(&t1, NULL, listener_thread, &td);
+
+	sleep(1);
+
+	pthread_create(&t2, NULL, wakeup_io_uring, &td);
+	pthread_join(t1, &pret);
+
+	io_uring_queue_exit(&ring);
+	return pret != NULL;
+}
+
+int main(int argc, char *argv[])
+{
+	int ret;
+
+	if (argc > 1)
+		return 0;
+
+	ret = test_pipes();
+	if (ret) {
+		fprintf(stderr, "test_pipe failed\n");
+		return ret;
+	}
+
+	ret = test_eventfd();
+	if (ret) {
+		fprintf(stderr, "test_eventfd failed\n");
+		return ret;
+	}
+
+	return 0;
+}

data/vendor/liburing/test/wq-aff.c

@@ -0,0 +1,146 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: test that io-wq affinity is correctly set for SQPOLL
+ */
+#include <stdio.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "liburing.h"
+#include "helpers.h"
+
+#define IOWQ_CPU	0
+#define SQPOLL_CPU	1
+
+static int verify_comm(pid_t pid, const char *name, int cpu)
+{
+	char comm[64], buf[64];
+	cpu_set_t set;
+	int fd, ret;
+
+	sprintf(comm, "/proc/%d/comm", pid);
+	fd = open(comm, O_RDONLY);
+	if (fd < 0) {
+		perror("open");
+		return T_EXIT_SKIP;
+	}
+
+	ret = read(fd, buf, sizeof(buf));
+	if (ret < 0) {
+		close(fd);
+		return T_EXIT_SKIP;
+	}
+
+	if (strncmp(buf, name, strlen(name) - 1)) {
+		close(fd);
+		return T_EXIT_SKIP;
+	}
+
+	close(fd);
+
+	ret = sched_getaffinity(pid, sizeof(set), &set);
+	if (ret < 0) {
+		perror("sched_getaffinity");
+		return T_EXIT_SKIP;
+	}
+
+	if (CPU_COUNT(&set) != 1) {
+		fprintf(stderr, "More than one CPU set in mask\n");
+		return T_EXIT_FAIL;
+	}
+	if (!CPU_ISSET(cpu, &set)) {
+		fprintf(stderr, "Wrong CPU set in mask\n");
+		return T_EXIT_FAIL;
+	}
+
+	return T_EXIT_PASS;
+}
+
+static int verify_affinity(pid_t pid, int sqpoll)
+{
+	pid_t wq_pid, sqpoll_pid = -1;
+	char name[64];
+	int ret;
+
+	wq_pid = pid + 2;
+	if (sqpoll)
+		sqpoll_pid = pid + 1;
+
+	/* verify we had the pids right */
+	sprintf(name, "iou-wrk-%d", pid);
+	ret = verify_comm(wq_pid, name, IOWQ_CPU);
+	if (ret != T_EXIT_PASS)
+		return ret;
+
+	if (sqpoll_pid != -1) {
+		sprintf(name, "iou-sqp-%d", pid);
+		ret = verify_comm(sqpoll_pid, name, SQPOLL_CPU);
+		if (ret != T_EXIT_PASS)
+			return ret;
+	}
+
+	return T_EXIT_PASS;
+}
+
+static int test(int sqpoll)
+{
+	struct io_uring_params p = { };
+	struct io_uring ring;
+	struct io_uring_sqe *sqe;
+	char buf[64];
+	int fds[2], ret;
+	cpu_set_t set;
+
+	if (sqpoll) {
+		p.flags = IORING_SETUP_SQPOLL | IORING_SETUP_SQ_AFF;
+		p.sq_thread_cpu = SQPOLL_CPU;
+	}
+
+	io_uring_queue_init_params(8, &ring, &p);
+
+	CPU_ZERO(&set);
+	CPU_SET(IOWQ_CPU, &set);
+
+	ret = io_uring_register_iowq_aff(&ring, sizeof(set), &set);
+	if (ret) {
+		fprintf(stderr, "register aff: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	if (pipe(fds) < 0) {
+		perror("pipe");
+		return T_EXIT_FAIL;
+	}
+
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_read(sqe, fds[0], buf, sizeof(buf), 0);
+	sqe->flags |= IOSQE_ASYNC;
+
+	io_uring_submit(&ring);
+
+	usleep(10000);
+
+	ret = verify_affinity(getpid(), sqpoll);
+	io_uring_queue_exit(&ring);
+	return ret;
+}
+
+int main(int argc, char *argv[])
+{
+	int ret;
+
+	if (argc > 1)
+		return T_EXIT_SKIP;
+
+	ret = test(1);
+	if (ret == T_EXIT_SKIP) {
+		return T_EXIT_SKIP;
+	} else if (ret != T_EXIT_PASS) {
+		fprintf(stderr, "test sqpoll failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	return T_EXIT_PASS;
+}