uringmachine 0.1

data/vendor/liburing/test/stdout.c

@@ -0,0 +1,232 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: check that STDOUT write works
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+
+#include "helpers.h"
+#include "liburing.h"
+
+static int test_pipe_io_fixed(struct io_uring *ring)
+{
+	const char str[] = "This is a fixed pipe test\n";
+	struct io_uring_cqe *cqe;
+	struct io_uring_sqe *sqe;
+	struct iovec vecs[2];
+	char buffer[128];
+	int i, ret, fds[2];
+
+	t_posix_memalign(&vecs[0].iov_base, 4096, 4096);
+	memcpy(vecs[0].iov_base, str, strlen(str));
+	vecs[0].iov_len = strlen(str);
+
+	if (pipe(fds) < 0) {
+		perror("pipe");
+		return 1;
+	}
+
+	ret = io_uring_register_buffers(ring, vecs, 1);
+	if (ret) {
+		fprintf(stderr, "Failed to register buffers: %d\n", ret);
+		return 1;
+	}
+
+	sqe = io_uring_get_sqe(ring);
+	if (!sqe) {
+		fprintf(stderr, "get sqe failed\n");
+		goto err;
+	}
+	io_uring_prep_write_fixed(sqe, fds[1], vecs[0].iov_base,
+					vecs[0].iov_len, 0, 0);
+	sqe->user_data = 1;
+
+	sqe = io_uring_get_sqe(ring);
+	if (!sqe) {
+		fprintf(stderr, "get sqe failed\n");
+		goto err;
+	}
+	vecs[1].iov_base = buffer;
+	vecs[1].iov_len = sizeof(buffer);
+	io_uring_prep_readv(sqe, fds[0], &vecs[1], 1, 0);
+	sqe->user_data = 2;
+
+	ret = io_uring_submit(ring);
+	if (ret < 0) {
+		fprintf(stderr, "sqe submit failed: %d\n", ret);
+		goto err;
+	} else if (ret != 2) {
+		fprintf(stderr, "Submitted only %d\n", ret);
+		goto err;
+	}
+
+	for (i = 0; i < 2; i++) {
+		ret = io_uring_wait_cqe(ring, &cqe);
+		if (ret < 0) {
+			fprintf(stderr, "wait completion %d\n", ret);
+			goto err;
+		}
+		if (cqe->res < 0) {
+			fprintf(stderr, "I/O write error on %lu: %s\n",
+					(unsigned long) cqe->user_data,
+					 strerror(-cqe->res));
+			goto err;
+		}
+		if (cqe->res != strlen(str)) {
+			fprintf(stderr, "Got %d bytes, wanted %d on %lu\n",
+					cqe->res, (int)strlen(str),
+					(unsigned long) cqe->user_data);
+			goto err;
+		}
+		if (cqe->user_data == 2 && memcmp(str, buffer, strlen(str))) {
+			fprintf(stderr, "read data mismatch\n");
+			goto err;
+		}
+		io_uring_cqe_seen(ring, cqe);
+	}
+	io_uring_unregister_buffers(ring);
+	return 0;
+err:
+	return 1;
+}
+
+static int test_stdout_io_fixed(struct io_uring *ring)
+{
+	const char str[] = "This is a fixed pipe test\n";
+	struct io_uring_cqe *cqe;
+	struct io_uring_sqe *sqe;
+	struct iovec vecs;
+	int ret;
+
+	t_posix_memalign(&vecs.iov_base, 4096, 4096);
+	memcpy(vecs.iov_base, str, strlen(str));
+	vecs.iov_len = strlen(str);
+
+	ret = io_uring_register_buffers(ring, &vecs, 1);
+	if (ret) {
+		fprintf(stderr, "Failed to register buffers: %d\n", ret);
+		return 1;
+	}
+
+	sqe = io_uring_get_sqe(ring);
+	if (!sqe) {
+		fprintf(stderr, "get sqe failed\n");
+		goto err;
+	}
+	io_uring_prep_write_fixed(sqe, STDOUT_FILENO, vecs.iov_base, vecs.iov_len, 0, 0);
+
+	ret = io_uring_submit(ring);
+	if (ret < 0) {
+		fprintf(stderr, "sqe submit failed: %d\n", ret);
+		goto err;
+	} else if (ret < 1) {
+		fprintf(stderr, "Submitted only %d\n", ret);
+		goto err;
+	}
+
+	ret = io_uring_wait_cqe(ring, &cqe);
+	if (ret < 0) {
+		fprintf(stderr, "wait completion %d\n", ret);
+		goto err;
+	}
+	if (cqe->res < 0) {
+		fprintf(stderr, "STDOUT write error: %s\n", strerror(-cqe->res));
+		goto err;
+	}
+	if (cqe->res != vecs.iov_len) {
+		fprintf(stderr, "Got %d write, wanted %d\n", cqe->res, (int)vecs.iov_len);
+		goto err;
+	}
+	io_uring_cqe_seen(ring, cqe);
+	io_uring_unregister_buffers(ring);
+	return 0;
+err:
+	return 1;
+}
+
+static int test_stdout_io(struct io_uring *ring)
+{
+	struct io_uring_cqe *cqe;
+	struct io_uring_sqe *sqe;
+	struct iovec vecs;
+	int ret;
+
+	vecs.iov_base = "This is a pipe test\n";
+	vecs.iov_len = strlen(vecs.iov_base);
+
+	sqe = io_uring_get_sqe(ring);
+	if (!sqe) {
+		fprintf(stderr, "get sqe failed\n");
+		goto err;
+	}
+	io_uring_prep_writev(sqe, STDOUT_FILENO, &vecs, 1, 0);
+
+	ret = io_uring_submit(ring);
+	if (ret < 0) {
+		fprintf(stderr, "sqe submit failed: %d\n", ret);
+		goto err;
+	} else if (ret < 1) {
+		fprintf(stderr, "Submitted only %d\n", ret);
+		goto err;
+	}
+
+	ret = io_uring_wait_cqe(ring, &cqe);
+	if (ret < 0) {
+		fprintf(stderr, "wait completion %d\n", ret);
+		goto err;
+	}
+	if (cqe->res < 0) {
+		fprintf(stderr, "STDOUT write error: %s\n",
+				strerror(-cqe->res));
+		goto err;
+	}
+	if (cqe->res != vecs.iov_len) {
+		fprintf(stderr, "Got %d write, wanted %d\n", cqe->res,
+				(int)vecs.iov_len);
+		goto err;
+	}
+	io_uring_cqe_seen(ring, cqe);
+
+	return 0;
+err:
+	return 1;
+}
+
+int main(int argc, char *argv[])
+{
+	struct io_uring ring;
+	int ret;
+
+	if (argc > 1)
+		return 0;
+
+	ret = io_uring_queue_init(8, &ring, 0);
+	if (ret) {
+		fprintf(stderr, "ring setup failed\n");
+		return 1;
+	}
+
+	ret = test_stdout_io(&ring);
+	if (ret) {
+		fprintf(stderr, "test_pipe_io failed\n");
+		return ret;
+	}
+
+	ret = test_stdout_io_fixed(&ring);
+	if (ret) {
+		fprintf(stderr, "test_pipe_io_fixed failed\n");
+		return ret;
+	}
+
+	ret = test_pipe_io_fixed(&ring);
+	if (ret) {
+		fprintf(stderr, "test_pipe_io_fixed failed\n");
+		return ret;
+	}
+
+	return 0;
+}

data/vendor/liburing/test/submit-and-wait.c

@@ -0,0 +1,108 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: Test that io_uring_submit_and_wait_timeout() returns the
+ * right value (submit count) and that it doesn't end up waiting twice.
+ *
+ */
+#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 "test.h"
+
+static unsigned long long mtime_since(const struct timeval *s,
+				      const struct timeval *e)
+{
+	long long sec, usec;
+
+	sec = e->tv_sec - s->tv_sec;
+	usec = (e->tv_usec - s->tv_usec);
+	if (sec > 0 && usec < 0) {
+		sec--;
+		usec += 1000000;
+	}
+
+	sec *= 1000;
+	usec /= 1000;
+	return sec + usec;
+}
+
+static unsigned long long mtime_since_now(struct timeval *tv)
+{
+	struct timeval end;
+
+	gettimeofday(&end, NULL);
+	return mtime_since(tv, &end);
+}
+
+static int test(struct io_uring *ring)
+{
+	struct io_uring_cqe *cqe;
+	struct io_uring_sqe *sqe;
+	struct __kernel_timespec ts;
+	struct timeval tv;
+	int ret, i;
+
+	for (i = 0; i < 1; i++) {
+		sqe = io_uring_get_sqe(ring);
+		if (!sqe) {
+			fprintf(stderr, "get sqe failed at %d\n", i);
+			goto err;
+		}
+		io_uring_prep_nop(sqe);
+	}
+
+	ts.tv_sec = 1;
+	ts.tv_nsec = 0;
+	gettimeofday(&tv, NULL);
+	ret = io_uring_submit_and_wait_timeout(ring, &cqe, 2, &ts, NULL);
+	if (ret < 0) {
+		fprintf(stderr, "submit_and_wait_timeout: %d\n", ret);
+		goto err;
+	}
+	ret = mtime_since_now(&tv);
+	/* allow some slack, should be around 1s */
+	if (ret > 1200) {
+		fprintf(stderr, "wait took too long: %d\n", ret);
+		goto err;
+	}
+	return 0;
+err:
+	return 1;
+}
+
+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;
+	}
+
+	ret = test(&ring);
+	if (ret) {
+		fprintf(stderr, "test 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();
+}

data/vendor/liburing/test/submit-link-fail.c

@@ -0,0 +1,156 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: tests linked requests failing during submission
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <assert.h>
+
+#include "liburing.h"
+
+#define DRAIN_USER_DATA 42
+
+static int test_underprep_fail(bool hardlink, bool drain, bool link_last,
+			       int link_size, int fail_idx)
+{
+	const int invalid_fd = 42;
+	int link_flags = IOSQE_IO_LINK;
+	int total_submit = link_size;
+	struct io_uring ring;
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	char buffer[1] = { };
+	int i, ret, fds[2];
+
+	if (drain)
+		link_flags |= IOSQE_IO_DRAIN;
+	if (hardlink)
+		link_flags |= IOSQE_IO_HARDLINK;
+
+	assert(fail_idx < link_size);
+	assert(link_size < 40);
+
+	/* create a new ring as it leaves it dirty */
+	ret = io_uring_queue_init(8, &ring, 0);
+	if (ret) {
+		printf("ring setup failed\n");
+		return -1;
+	}
+	if (pipe(fds)) {
+		perror("pipe");
+		return -1;
+	}
+
+	if (drain) {
+		/* clog drain, so following reqs sent to draining */
+		sqe = io_uring_get_sqe(&ring);
+		io_uring_prep_read(sqe, fds[0], buffer, sizeof(buffer), 0);
+		sqe->user_data = DRAIN_USER_DATA;
+		sqe->flags |= IOSQE_IO_DRAIN;
+		total_submit++;
+	}
+
+	for (i = 0; i < link_size; i++) {
+		sqe = io_uring_get_sqe(&ring);
+		if (i == fail_idx) {
+			io_uring_prep_read(sqe, invalid_fd, buffer, 1, 0);
+			sqe->ioprio = (short) -1;
+		} else {
+			io_uring_prep_nop(sqe);
+		}
+
+		if (i != link_size - 1 || !link_last)
+			sqe->flags |= link_flags;
+		sqe->user_data = i;
+	}
+
+	ret = io_uring_submit(&ring);
+	if (ret != total_submit) {
+		/* Old behaviour, failed early and under-submitted */
+		if (ret == fail_idx + 1 + drain)
+			goto out;
+		fprintf(stderr, "submit failed: %d\n", ret);
+		return -1;
+	}
+
+	if (drain) {
+		/* unclog drain */
+		ret = write(fds[1], buffer, sizeof(buffer));
+		if (ret < 0) {
+			perror("write");
+			return 1;
+		}
+	}
+
+	for (i = 0; i < total_submit; i++) {
+		ret = io_uring_wait_cqe(&ring, &cqe);
+		if (ret) {
+			fprintf(stderr, "wait_cqe=%d\n", ret);
+			return 1;
+		}
+
+		ret = cqe->res;
+		if (cqe->user_data == DRAIN_USER_DATA) {
+			if (ret != 1) {
+				fprintf(stderr, "drain failed %d\n", ret);
+				return 1;
+			}
+		} else if (cqe->user_data == fail_idx) {
+			if (ret == 0 || ret == -ECANCELED) {
+				fprintf(stderr, "half-prep req unexpected return %d\n", ret);
+				return 1;
+			}
+		} else {
+			if (ret != -ECANCELED) {
+				fprintf(stderr, "cancel failed %d, ud %d\n", ret, (int)cqe->user_data);
+				return 1;
+			}
+		}
+		io_uring_cqe_seen(&ring, cqe);
+	}
+out:
+	close(fds[0]);
+	close(fds[1]);
+	io_uring_queue_exit(&ring);
+	return 0;
+}
+
+int main(int argc, char *argv[])
+{
+	int ret, link_size, fail_idx, i;
+
+	if (argc > 1)
+		return 0;
+
+	/*
+	 * hardlink, size=3, fail_idx=1, drain=false -- kernel fault
+	 * link, size=3, fail_idx=0, drain=true -- kernel fault
+	 * link, size=3, fail_idx=1, drain=true -- invalid cqe->res
+	 */
+	for (link_size = 0; link_size < 3; link_size++) {
+		for (fail_idx = 0; fail_idx < link_size; fail_idx++) {
+			for (i = 0; i < 8; i++) {
+				bool hardlink = (i & 1) != 0;
+				bool drain = (i & 2) != 0;
+				bool link_last = (i & 4) != 0;
+
+				ret = test_underprep_fail(hardlink, drain, link_last,
+							  link_size, fail_idx);
+				if (!ret)
+					continue;
+
+				fprintf(stderr, "failed %d, hard %d, drain %d,"
+						"link_last %d, size %d, idx %d\n",
+						ret, hardlink, drain, link_last,
+						link_size, fail_idx);
+				return 1;
+			}
+		}
+	}
+
+	return 0;
+}

data/vendor/liburing/test/submit-reuse.c

@@ -0,0 +1,237 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Test reads that will punt to blocking context, with immediate overwrite
+ * of iovec->iov_base to NULL. If the kernel doesn't properly handle
+ * reuse of the iovec, we should get -EFAULT.
+ */
+#include <unistd.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <pthread.h>
+#include <sys/time.h>
+
+#include "helpers.h"
+#include "liburing.h"
+
+#define STR_SIZE	32768
+#define FILE_SIZE	65536
+
+struct thread_data {
+	int fd1, fd2;
+	volatile int do_exit;
+};
+
+static void *flusher(void *__data)
+{
+	struct thread_data *data = __data;
+
+	while (!data->do_exit) {
+		posix_fadvise(data->fd1, 0, FILE_SIZE, POSIX_FADV_DONTNEED);
+		posix_fadvise(data->fd2, 0, FILE_SIZE, POSIX_FADV_DONTNEED);
+		usleep(10);
+	}
+
+	return NULL;
+}
+
+static char str1[STR_SIZE];
+static char str2[STR_SIZE];
+
+static struct io_uring ring;
+
+static int no_stable;
+
+static int prep(int fd, char *str, int split, int async)
+{
+	struct io_uring_sqe *sqe;
+	struct iovec iovs[16];
+	int ret, i;
+
+	if (split) {
+		int vsize = STR_SIZE / 16;
+		void *ptr = str;
+
+		for (i = 0; i < 16; i++) {
+			iovs[i].iov_base = ptr;
+			iovs[i].iov_len = vsize;
+			ptr += vsize;
+		}
+	} else {
+		iovs[0].iov_base = str;
+		iovs[0].iov_len = STR_SIZE;
+	}
+
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_readv(sqe, fd, iovs, split ? 16 : 1, 0);
+	sqe->user_data = fd;
+	if (async)
+		sqe->flags = IOSQE_ASYNC;
+	ret = io_uring_submit(&ring);
+	if (ret != 1) {
+		fprintf(stderr, "submit got %d\n", ret);
+		return 1;
+	}
+	if (split) {
+		for (i = 0; i < 16; i++)
+			iovs[i].iov_base = NULL;
+	} else {
+		iovs[0].iov_base = NULL;
+	}
+	return 0;
+}
+
+static int wait_nr(int nr)
+{
+	int i, ret;
+
+	for (i = 0; i < nr; i++) {
+		struct io_uring_cqe *cqe;
+
+		ret = io_uring_wait_cqe(&ring, &cqe);
+		if (ret)
+			return ret;
+		if (cqe->res < 0) {
+			fprintf(stderr, "cqe->res=%d\n", cqe->res);
+			return 1;
+		}
+		io_uring_cqe_seen(&ring, cqe);
+	}
+
+	return 0;
+}
+
+static unsigned long long mtime_since(const struct timeval *s,
+				      const struct timeval *e)
+{
+	long long sec, usec;
+
+	sec = e->tv_sec - s->tv_sec;
+	usec = (e->tv_usec - s->tv_usec);
+	if (sec > 0 && usec < 0) {
+		sec--;
+		usec += 1000000;
+	}
+
+	sec *= 1000;
+	usec /= 1000;
+	return sec + usec;
+}
+
+static unsigned long long mtime_since_now(struct timeval *tv)
+{
+	struct timeval end;
+
+	gettimeofday(&end, NULL);
+	return mtime_since(tv, &end);
+}
+
+static int test_reuse(int argc, char *argv[], int split, int async)
+{
+	struct thread_data data;
+	struct io_uring_params p = { };
+	int fd1, fd2, ret, i;
+	struct timeval tv;
+	pthread_t thread;
+	char *fname1 = ".reuse.1";
+	int do_unlink = 1;
+	void *tret;
+
+	ret = io_uring_queue_init_params(32, &ring, &p);
+	if (ret) {
+		fprintf(stderr, "io_uring_queue_init: %d\n", ret);
+		return 1;
+	}
+
+	if (!(p.features & IORING_FEAT_SUBMIT_STABLE)) {
+		fprintf(stdout, "FEAT_SUBMIT_STABLE not there, skipping\n");
+		io_uring_queue_exit(&ring);
+		no_stable = 1;
+		return 0;
+	}
+
+	if (argc > 1) {
+		fname1 = argv[1];
+		do_unlink = 0;
+	} else {
+		t_create_file(fname1, FILE_SIZE);
+	}
+
+	fd1 = open(fname1, O_RDONLY);
+	if (do_unlink)
+		unlink(fname1);
+	if (fd1 < 0) {
+		perror("open fname1");
+		goto err;
+	}
+
+	t_create_file(".reuse.2", FILE_SIZE);
+	fd2 = open(".reuse.2", O_RDONLY);
+	unlink(".reuse.2");
+	if (fd2 < 0) {
+		perror("open .reuse.2");
+		goto err;
+	}
+
+	data.fd1 = fd1;
+	data.fd2 = fd2;
+	data.do_exit = 0;
+	pthread_create(&thread, NULL, flusher, &data);
+	usleep(10000);
+
+	gettimeofday(&tv, NULL);
+	for (i = 0; i < 1000; i++) {
+		ret = prep(fd1, str1, split, async);
+		if (ret) {
+			fprintf(stderr, "prep1 failed: %d\n", ret);
+			goto err;
+		}
+		ret = prep(fd2, str2, split, async);
+		if (ret) {
+			fprintf(stderr, "prep1 failed: %d\n", ret);
+			goto err;
+		}
+		ret = wait_nr(2);
+		if (ret) {
+			fprintf(stderr, "wait_nr: %d\n", ret);
+			goto err;
+		}
+		if (mtime_since_now(&tv) > 5000)
+			break;
+	}
+
+	data.do_exit = 1;
+	pthread_join(thread, &tret);
+
+	close(fd2);
+	close(fd1);
+	io_uring_queue_exit(&ring);
+	return 0;
+err:
+	io_uring_queue_exit(&ring);
+	return 1;
+
+}
+
+int main(int argc, char *argv[])
+{
+	int ret, i;
+
+	for (i = 0; i < 4; i++) {
+		int split, async;
+
+		split = (i & 1) != 0;
+		async = (i & 2) != 0;
+
+		ret = test_reuse(argc, argv, split, async);
+		if (ret) {
+			fprintf(stderr, "test_reuse %d %d failed\n", split, async);
+			return ret;
+		}
+		if (no_stable)
+			break;
+	}
+
+	return 0;
+}