iou 0.1

data/vendor/liburing/test/eventfd.c

@@ -0,0 +1,113 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: run various eventfd tests
+ *
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <sys/eventfd.h>
+
+#include "liburing.h"
+#include "helpers.h"
+
+int main(int argc, char *argv[])
+{
+	struct io_uring_params p = {};
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	struct io_uring ring;
+	uint64_t ptr;
+	struct iovec vec = {
+		.iov_base = &ptr,
+		.iov_len = sizeof(ptr)
+	};
+	int ret, evfd, i;
+
+	if (argc > 1)
+		return T_EXIT_SKIP;
+
+	ret = io_uring_queue_init_params(8, &ring, &p);
+	if (ret) {
+		fprintf(stderr, "ring setup failed: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+	if (!(p.features & IORING_FEAT_CUR_PERSONALITY)) {
+		fprintf(stdout, "Skipping\n");
+		return T_EXIT_SKIP;
+	}
+
+	evfd = eventfd(0, EFD_CLOEXEC);
+	if (evfd < 0) {
+		perror("eventfd");
+		return T_EXIT_FAIL;
+	}
+
+	ret = io_uring_register_eventfd(&ring, evfd);
+	if (ret) {
+		fprintf(stderr, "failed to register evfd: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_poll_add(sqe, evfd, POLLIN);
+	sqe->flags |= IOSQE_IO_LINK;
+	sqe->user_data = 1;
+
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_readv(sqe, evfd, &vec, 1, 0);
+	sqe->flags |= IOSQE_IO_LINK;
+	sqe->user_data = 2;
+
+	ret = io_uring_submit(&ring);
+	if (ret != 2) {
+		fprintf(stderr, "submit: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_nop(sqe);
+	sqe->user_data = 3;
+
+	ret = io_uring_submit(&ring);
+	if (ret != 1) {
+		fprintf(stderr, "submit: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	for (i = 0; i < 3; i++) {
+		ret = io_uring_wait_cqe(&ring, &cqe);
+		if (ret) {
+			fprintf(stderr, "wait: %d\n", ret);
+			return T_EXIT_FAIL;
+		}
+		switch (cqe->user_data) {
+		case 1:
+			/* POLLIN */
+			if (cqe->res != 1) {
+				fprintf(stderr, "poll: %d\n", cqe->res);
+				return T_EXIT_FAIL;
+			}
+			break;
+		case 2:
+			if (cqe->res != sizeof(ptr)) {
+				fprintf(stderr, "read: %d\n", cqe->res);
+				return T_EXIT_FAIL;
+			}
+			break;
+		case 3:
+			if (cqe->res) {
+				fprintf(stderr, "nop: %d\n", cqe->res);
+				return T_EXIT_FAIL;
+			}
+			break;
+		}
+		io_uring_cqe_seen(&ring, cqe);
+	}
+
+	return T_EXIT_PASS;
+}

data/vendor/liburing/test/evloop.c

@@ -0,0 +1,73 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Test that we don't recursively generate completion events if an io_uring
+ * has an eventfd registered that triggers on completions, and we add a poll
+ * request with multishot on the eventfd. Older kernels will stop on overflow,
+ * newer kernels will detect this earlier and abort correctly.
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <sys/eventfd.h>
+#include <sys/types.h>
+#include <poll.h>
+#include <assert.h>
+#include "liburing.h"
+#include "helpers.h"
+
+int main(int argc, char *argv[])
+{
+	struct io_uring ring;
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	int ret, efd, i;
+
+	if (argc > 1)
+		return T_EXIT_SKIP;
+
+	ret = io_uring_queue_init(8, &ring, 0);
+	if (ret) {
+		fprintf(stderr, "Ring init failed: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	efd = eventfd(0, 0);
+	if (efd < 0) {
+		perror("eventfd");
+		return T_EXIT_FAIL;
+	}
+
+	ret = io_uring_register_eventfd(&ring, efd);
+	if (ret) {
+		fprintf(stderr, "Ring eventfd register failed: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_poll_multishot(sqe, efd, POLLIN);
+	sqe->user_data = 1;
+	io_uring_submit(&ring);
+
+	sqe = io_uring_get_sqe(&ring);
+	sqe->user_data = 2;
+	io_uring_prep_nop(sqe);
+	io_uring_submit(&ring);
+
+	for (i = 0; i < 2; i++) {
+		ret = io_uring_wait_cqe(&ring, &cqe);
+		if (ret) {
+			fprintf(stderr, "wait_cqe ret = %d\n", ret);
+			break;
+		}
+		io_uring_cqe_seen(&ring, cqe);
+	}
+
+	ret = io_uring_peek_cqe(&ring, &cqe);
+	if (!ret) {
+		fprintf(stderr, "Generated too many events\n");
+		return T_EXIT_FAIL;
+	}
+
+	return T_EXIT_PASS;
+}

data/vendor/liburing/test/exec-target.c

@@ -0,0 +1,6 @@
+/* SPDX-License-Identifier: MIT */
+
+int main(int argc, char *argv[])
+{
+	return 0;
+}

data/vendor/liburing/test/exit-no-cleanup.c

@@ -0,0 +1,117 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Test case testing exit without cleanup and io-wq work pending or queued.
+ *
+ * From Florian Fischer <florian.fl.fischer@fau.de>
+ * Link: https://lore.kernel.org/io-uring/20211202165606.mqryio4yzubl7ms5@pasture/
+ *
+ */
+#include <assert.h>
+#include <err.h>
+#include <errno.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/sysinfo.h>
+#include <unistd.h>
+
+#include "liburing.h"
+#include "helpers.h"
+
+#define IORING_ENTRIES 8
+
+static pthread_t *threads;
+static pthread_barrier_t init_barrier;
+static int sleep_fd, notify_fd;
+static sem_t sem;
+
+static void *thread_func(void *arg)
+{
+	struct io_uring ring;
+	int res;
+
+	res = io_uring_queue_init(IORING_ENTRIES, &ring, 0);
+	if (res)
+		err(EXIT_FAILURE, "io_uring_queue_init failed");
+
+	pthread_barrier_wait(&init_barrier);
+
+	for(;;) {
+		struct io_uring_cqe *cqe;
+		struct io_uring_sqe *sqe;
+		uint64_t buf;
+		int res;
+
+		sqe = io_uring_get_sqe(&ring);
+		assert(sqe);
+
+		io_uring_prep_read(sqe, sleep_fd, &buf, sizeof(buf), 0);
+
+		res = io_uring_submit_and_wait(&ring, 1);
+		if (res < 0)
+			err(EXIT_FAILURE, "io_uring_submit_and_wait failed");
+
+		res = io_uring_peek_cqe(&ring, &cqe);
+		assert(!res);
+		if (cqe->res < 0) {
+			errno = -cqe->res;
+			err(EXIT_FAILURE, "read failed");
+		}
+		assert(cqe->res == sizeof(buf));
+
+		sem_post(&sem);
+
+		io_uring_cqe_seen(&ring, cqe);
+	}
+
+	return NULL;
+}
+
+int main(int argc, char *argv[])
+{
+	int res, fds[2], i, cpus;
+	const uint64_t n = 0x42;
+
+	if (argc > 1)
+		return T_EXIT_SKIP;
+
+	cpus = get_nprocs();
+	res = pthread_barrier_init(&init_barrier, NULL, cpus);
+	if (res)
+		err(EXIT_FAILURE, "pthread_barrier_init failed");
+
+	res = sem_init(&sem, 0, 0);
+	if (res)
+		err(EXIT_FAILURE, "sem_init failed");
+
+	threads = t_malloc(sizeof(pthread_t) * cpus);
+
+	res = pipe(fds);
+	if (res)
+		err(EXIT_FAILURE, "pipe failed");
+
+	sleep_fd = fds[0];
+	notify_fd = fds[1];
+
+	for (i = 0; i < cpus; i++) {
+		errno = pthread_create(&threads[i], NULL, thread_func, NULL);
+		if (errno)
+			err(EXIT_FAILURE, "pthread_create failed");
+	}
+
+	// Write #cpus notifications
+	for (i = 0; i < cpus; i++) {
+		res = write(notify_fd, &n, sizeof(n));
+		if (res < 0)
+			err(EXIT_FAILURE, "write failed");
+		assert(res == sizeof(n));
+	}
+
+	// Await that all notifications were received
+	for (i = 0; i < cpus; i++)
+		sem_wait(&sem);
+
+	// Exit without resource cleanup
+	exit(EXIT_SUCCESS);
+}

data/vendor/liburing/test/fadvise.c

@@ -0,0 +1,202 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: basic fadvise test
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/time.h>
+
+#include "helpers.h"
+#include "liburing.h"
+
+#define FILE_SIZE	(128 * 1024)
+#define LOOPS		100
+#define MIN_LOOPS	10
+
+static unsigned long long utime_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 *= 1000000;
+	return sec + usec;
+}
+
+static unsigned long long utime_since_now(struct timeval *tv)
+{
+	struct timeval end;
+
+	gettimeofday(&end, NULL);
+	return utime_since(tv, &end);
+}
+
+static int do_fadvise(struct io_uring *ring, int fd, off_t offset, off_t len,
+		      int advice)
+{
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	int ret;
+
+	sqe = io_uring_get_sqe(ring);
+	if (!sqe) {
+		fprintf(stderr, "failed to get sqe\n");
+		return 1;
+	}
+
+	io_uring_prep_fadvise(sqe, fd, offset, len, advice);
+	sqe->user_data = advice;
+	ret = io_uring_submit_and_wait(ring, 1);
+	if (ret != 1) {
+		fprintf(stderr, "submit: %d\n", ret);
+		return 1;
+	}
+
+	ret = io_uring_wait_cqe(ring, &cqe);
+	if (ret) {
+		fprintf(stderr, "wait: %d\n", ret);
+		return 1;
+	}
+
+	ret = cqe->res;
+	if (ret == -EINVAL || ret == -EBADF) {
+		fprintf(stdout, "Fadvise not supported, skipping\n");
+		unlink(".fadvise.tmp");
+		exit(T_EXIT_SKIP);
+	} else if (ret) {
+		fprintf(stderr, "cqe->res=%d\n", cqe->res);
+	}
+	io_uring_cqe_seen(ring, cqe);
+	return ret;
+}
+
+static long do_read(int fd, char *buf)
+{
+	struct timeval tv;
+	int ret;
+	long t;
+
+	ret = lseek(fd, 0, SEEK_SET);
+	if (ret) {
+		perror("lseek");
+		return -1;
+	}
+	
+	gettimeofday(&tv, NULL);
+	ret = read(fd, buf, FILE_SIZE);
+	t = utime_since_now(&tv);
+	if (ret < 0) {
+		perror("read");
+		return -1;
+	} else if (ret != FILE_SIZE) {
+		fprintf(stderr, "short read1: %d\n", ret);
+		return -1;
+	}
+
+	return t;
+}
+
+static int test_fadvise(struct io_uring *ring, const char *filename)
+{
+	unsigned long cached_read, uncached_read, cached_read2;
+	int fd, ret;
+	char *buf;
+
+	fd = open(filename, O_RDONLY);
+	if (fd < 0) {
+		perror("open");
+		return 1;
+	}
+
+	buf = t_malloc(FILE_SIZE);
+
+	cached_read = do_read(fd, buf);
+	if (cached_read == -1)
+		return 1;
+
+	ret = do_fadvise(ring, fd, 0, FILE_SIZE, POSIX_FADV_DONTNEED);
+	if (ret)
+		return 1;
+
+	uncached_read = do_read(fd, buf);
+	if (uncached_read == -1)
+		return 1;
+
+	ret = do_fadvise(ring, fd, 0, FILE_SIZE, POSIX_FADV_DONTNEED);
+	if (ret)
+		return 1;
+
+	ret = do_fadvise(ring, fd, 0, FILE_SIZE, POSIX_FADV_WILLNEED);
+	if (ret)
+		return 1;
+
+	fsync(fd);
+
+	cached_read2 = do_read(fd, buf);
+	if (cached_read2 == -1)
+		return 1;
+
+	if (cached_read < uncached_read &&
+	    cached_read2 < uncached_read)
+		return 0;
+
+	return 2;
+}
+
+int main(int argc, char *argv[])
+{
+	struct io_uring ring;
+	int ret, i, good, bad;
+	char *fname;
+
+	if (argc > 1) {
+		fname = argv[1];
+	} else {
+		fname = ".fadvise.tmp";
+		t_create_file(fname, FILE_SIZE);
+	}
+	if (io_uring_queue_init(8, &ring, 0)) {
+		fprintf(stderr, "ring creation failed\n");
+		goto err;
+	}
+
+	good = bad = 0;
+	for (i = 0; i < LOOPS; i++) {
+		ret = test_fadvise(&ring, fname);
+		if (ret == 1) {
+			fprintf(stderr, "read_fadvise failed\n");
+			goto err;
+		} else if (!ret)
+			good++;
+		else if (ret == 2)
+			bad++;
+		if (i >= MIN_LOOPS && !bad)
+			break;
+	}
+
+	/* too hard to reliably test, just ignore */
+	if ((0) && bad > good) {
+		fprintf(stderr, "Suspicious timings\n");
+		goto err;
+	}
+
+	if (fname != argv[1])
+		unlink(fname);
+	io_uring_queue_exit(&ring);
+	return T_EXIT_PASS;
+err:
+	if (fname != argv[1])
+		unlink(fname);
+	return T_EXIT_FAIL;
+}