polyphony 0.85 → 0.86

data/vendor/liburing/test/io_uring_setup.c

@@ -0,0 +1,192 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * io_uring_setup.c
+ *
+ * Description: Unit tests for the io_uring_setup system call.
+ *
+ * Copyright 2019, Red Hat, Inc.
+ * Author: Jeff Moyer <jmoyer@redhat.com>
+ */
+#include <stdio.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/sysinfo.h>
+#include "liburing.h"
+
+#include "../syscall.h"
+
+char *features_string(struct io_uring_params *p)
+{
+	static char flagstr[64];
+
+	if (!p || !p->features)
+		return "none";
+
+	if (p->features & ~IORING_FEAT_SINGLE_MMAP) {
+		snprintf(flagstr, 64, "0x%.8x", p->features);
+		return flagstr;
+	}
+
+	if (p->features & IORING_FEAT_SINGLE_MMAP)
+		strncat(flagstr, "IORING_FEAT_SINGLE_MMAP", 64 - strlen(flagstr));
+
+	return flagstr;
+}
+
+/*
+ * Attempt the call with the given args.  Return 0 when expect matches
+ * the return value of the system call, 1 otherwise.
+ */
+char *
+flags_string(struct io_uring_params *p)
+{
+	static char flagstr[64];
+	int add_pipe = 0;
+
+	memset(flagstr, 0, sizeof(flagstr));
+
+	if (!p || p->flags == 0)
+		return "none";
+
+	/*
+	 * If unsupported flags are present, just print the bitmask.
+	 */
+	if (p->flags & ~(IORING_SETUP_IOPOLL | IORING_SETUP_SQPOLL |
+			 IORING_SETUP_SQ_AFF)) {
+		snprintf(flagstr, 64, "0x%.8x", p->flags);
+		return flagstr;
+	}
+
+	if (p->flags & IORING_SETUP_IOPOLL) {
+		strncat(flagstr, "IORING_SETUP_IOPOLL", 64 - strlen(flagstr));
+		add_pipe = 1;
+	}
+	if (p->flags & IORING_SETUP_SQPOLL) {
+		if (add_pipe)
+			strncat(flagstr, "|", 64 - strlen(flagstr));
+		else
+			add_pipe = 1;
+		strncat(flagstr, "IORING_SETUP_SQPOLL", 64 - strlen(flagstr));
+	}
+	if (p->flags & IORING_SETUP_SQ_AFF) {
+		if (add_pipe)
+			strncat(flagstr, "|", 64 - strlen(flagstr));
+		strncat(flagstr, "IORING_SETUP_SQ_AFF", 64 - strlen(flagstr));
+	}
+
+	return flagstr;
+}
+
+char *
+dump_resv(struct io_uring_params *p)
+{
+	static char resvstr[4096];
+
+	if (!p)
+		return "";
+
+	sprintf(resvstr, "0x%.8x 0x%.8x 0x%.8x", p->resv[0],
+		p->resv[1], p->resv[2]);
+
+	return resvstr;
+}
+
+/* bogus: setup returns a valid fd on success... expect can't predict the
+   fd we'll get, so this really only takes 1 parameter: error */
+int
+try_io_uring_setup(unsigned entries, struct io_uring_params *p, int expect, int error)
+{
+	int ret, err;
+
+	printf("io_uring_setup(%u, %p), flags: %s, feat: %s, resv: %s, sq_thread_cpu: %u\n",
+	       entries, p, flags_string(p), features_string(p), dump_resv(p),
+	       p ? p->sq_thread_cpu : 0);
+
+	ret = __sys_io_uring_setup(entries, p);
+	if (ret != expect) {
+		printf("expected %d, got %d\n", expect, ret);
+		/* if we got a valid uring, close it */
+		if (ret > 0)
+			close(ret);
+		return 1;
+	}
+	err = errno;
+	if (expect == -1 && error != err) {
+		if (err == EPERM && geteuid() != 0) {
+			printf("Needs root, not flagging as an error\n");
+			return 0;
+		}
+		printf("expected errno %d, got %d\n", error, err);
+		return 1;
+	}
+
+	return 0;
+}
+
+int
+main(int argc, char **argv)
+{
+	int fd;
+	unsigned int status = 0;
+	struct io_uring_params p;
+
+	if (argc > 1)
+		return 0;
+
+	memset(&p, 0, sizeof(p));
+	status |= try_io_uring_setup(0, &p, -1, EINVAL);
+	status |= try_io_uring_setup(1, NULL, -1, EFAULT);
+
+	/* resv array is non-zero */
+	memset(&p, 0, sizeof(p));
+	p.resv[0] = p.resv[1] = p.resv[2] = 1;
+	status |= try_io_uring_setup(1, &p, -1, EINVAL);
+
+	/* invalid flags */
+	memset(&p, 0, sizeof(p));
+	p.flags = ~0U;
+	status |= try_io_uring_setup(1, &p, -1, EINVAL);
+
+	/* IORING_SETUP_SQ_AFF set but not IORING_SETUP_SQPOLL */
+	memset(&p, 0, sizeof(p));
+	p.flags = IORING_SETUP_SQ_AFF;
+	status |= try_io_uring_setup(1, &p, -1, EINVAL);
+
+	/* attempt to bind to invalid cpu */
+	memset(&p, 0, sizeof(p));
+	p.flags = IORING_SETUP_SQPOLL | IORING_SETUP_SQ_AFF;
+	p.sq_thread_cpu = get_nprocs_conf();
+	status |= try_io_uring_setup(1, &p, -1, EINVAL);
+
+	/* I think we can limit a process to a set of cpus.  I assume
+	 * we shouldn't be able to setup a kernel thread outside of that.
+	 * try to do that. (task->cpus_allowed) */
+
+	/* read/write on io_uring_fd */
+	memset(&p, 0, sizeof(p));
+	fd = __sys_io_uring_setup(1, &p);
+	if (fd < 0) {
+		printf("io_uring_setup failed with %d, expected success\n",
+		       errno);
+		status = 1;
+	} else {
+		char buf[4096];
+		int ret;
+		ret = read(fd, buf, 4096);
+		if (ret >= 0) {
+			printf("read from io_uring fd succeeded.  expected fail\n");
+			status = 1;
+		}
+	}
+
+	if (!status) {
+		printf("PASS\n");
+		return 0;
+	}
+
+	printf("FAIL\n");
+	return -1;
+}

data/vendor/liburing/test/iopoll.c

@@ -0,0 +1,372 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: basic read/write tests with polled IO
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <poll.h>
+#include <sys/eventfd.h>
+#include <sys/resource.h>
+#include "helpers.h"
+#include "liburing.h"
+#include "../src/syscall.h"
+
+#define FILE_SIZE	(128 * 1024)
+#define BS		4096
+#define BUFFERS		(FILE_SIZE / BS)
+
+static struct iovec *vecs;
+static int no_buf_select;
+static int no_iopoll;
+
+static int provide_buffers(struct io_uring *ring)
+{
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	int ret, i;
+
+	for (i = 0; i < BUFFERS; i++) {
+		sqe = io_uring_get_sqe(ring);
+		io_uring_prep_provide_buffers(sqe, vecs[i].iov_base,
+						vecs[i].iov_len, 1, 1, i);
+	}
+
+	ret = io_uring_submit(ring);
+	if (ret != BUFFERS) {
+		fprintf(stderr, "submit: %d\n", ret);
+		return 1;
+	}
+
+	for (i = 0; i < BUFFERS; i++) {
+		ret = io_uring_wait_cqe(ring, &cqe);
+		if (cqe->res < 0) {
+			fprintf(stderr, "cqe->res=%d\n", cqe->res);
+			return 1;
+		}
+		io_uring_cqe_seen(ring, cqe);
+	}
+
+	return 0;
+}
+
+static int __test_io(const char *file, struct io_uring *ring, int write, int sqthread,
+		     int fixed, int buf_select)
+{
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	int open_flags;
+	int i, fd = -1, ret;
+	off_t offset;
+
+	if (buf_select) {
+		write = 0;
+		fixed = 0;
+	}
+	if (buf_select && provide_buffers(ring))
+		return 1;
+
+	if (write)
+		open_flags = O_WRONLY;
+	else
+		open_flags = O_RDONLY;
+	open_flags |= O_DIRECT;
+
+	if (fixed) {
+		ret = t_register_buffers(ring, vecs, BUFFERS);
+		if (ret == T_SETUP_SKIP)
+			return 0;
+		if (ret != T_SETUP_OK) {
+			fprintf(stderr, "buffer reg failed: %d\n", ret);
+			goto err;
+		}
+	}
+	fd = open(file, open_flags);
+	if (fd < 0) {
+		perror("file open");
+		goto err;
+	}
+	if (sqthread) {
+		ret = io_uring_register_files(ring, &fd, 1);
+		if (ret) {
+			fprintf(stderr, "file reg failed: %d\n", ret);
+			goto err;
+		}
+	}
+
+	offset = 0;
+	for (i = 0; i < BUFFERS; i++) {
+		sqe = io_uring_get_sqe(ring);
+		if (!sqe) {
+			fprintf(stderr, "sqe get failed\n");
+			goto err;
+		}
+		offset = BS * (rand() % BUFFERS);
+		if (write) {
+			int do_fixed = fixed;
+			int use_fd = fd;
+
+			if (sqthread)
+				use_fd = 0;
+			if (fixed && (i & 1))
+				do_fixed = 0;
+			if (do_fixed) {
+				io_uring_prep_write_fixed(sqe, use_fd, vecs[i].iov_base,
+								vecs[i].iov_len,
+								offset, i);
+			} else {
+				io_uring_prep_writev(sqe, use_fd, &vecs[i], 1,
+								offset);
+			}
+		} else {
+			int do_fixed = fixed;
+			int use_fd = fd;
+
+			if (sqthread)
+				use_fd = 0;
+			if (fixed && (i & 1))
+				do_fixed = 0;
+			if (do_fixed) {
+				io_uring_prep_read_fixed(sqe, use_fd, vecs[i].iov_base,
+								vecs[i].iov_len,
+								offset, i);
+			} else {
+				io_uring_prep_readv(sqe, use_fd, &vecs[i], 1,
+								offset);
+			}
+
+		}
+		if (sqthread)
+			sqe->flags |= IOSQE_FIXED_FILE;
+		if (buf_select) {
+			sqe->flags |= IOSQE_BUFFER_SELECT;
+			sqe->buf_group = buf_select;
+			sqe->user_data = i;
+		}
+	}
+
+	ret = io_uring_submit(ring);
+	if (ret != BUFFERS) {
+		ret = io_uring_peek_cqe(ring, &cqe);
+		if (!ret && cqe->res == -EOPNOTSUPP) {
+			no_iopoll = 1;
+			io_uring_cqe_seen(ring, cqe);
+			goto out;
+		}
+		fprintf(stderr, "submit got %d, wanted %d\n", ret, BUFFERS);
+		goto err;
+	}
+
+	for (i = 0; i < BUFFERS; i++) {
+		ret = io_uring_wait_cqe(ring, &cqe);
+		if (ret) {
+			fprintf(stderr, "wait_cqe=%d\n", ret);
+			goto err;
+		} else if (cqe->res == -EOPNOTSUPP) {
+			fprintf(stdout, "File/device/fs doesn't support polled IO\n");
+			no_iopoll = 1;
+			goto out;
+		} else if (cqe->res != BS) {
+			fprintf(stderr, "cqe res %d, wanted %d\n", cqe->res, BS);
+			goto err;
+		}
+		io_uring_cqe_seen(ring, cqe);
+	}
+
+	if (fixed) {
+		ret = io_uring_unregister_buffers(ring);
+		if (ret) {
+			fprintf(stderr, "buffer unreg failed: %d\n", ret);
+			goto err;
+		}
+	}
+	if (sqthread) {
+		ret = io_uring_unregister_files(ring);
+		if (ret) {
+			fprintf(stderr, "file unreg failed: %d\n", ret);
+			goto err;
+		}
+	}
+
+out:
+	close(fd);
+	return 0;
+err:
+	if (fd != -1)
+		close(fd);
+	return 1;
+}
+
+extern int __io_uring_flush_sq(struct io_uring *ring);
+
+/*
+ * if we are polling io_uring_submit needs to always enter the
+ * kernel to fetch events
+ */
+static int test_io_uring_submit_enters(const char *file)
+{
+	struct io_uring ring;
+	int fd, i, ret, ring_flags, open_flags;
+	unsigned head;
+	struct io_uring_cqe *cqe;
+
+	if (no_iopoll)
+		return 0;
+
+	ring_flags = IORING_SETUP_IOPOLL;
+	ret = io_uring_queue_init(64, &ring, ring_flags);
+	if (ret) {
+		fprintf(stderr, "ring create failed: %d\n", ret);
+		return 1;
+	}
+
+	open_flags = O_WRONLY | O_DIRECT;
+	fd = open(file, open_flags);
+	if (fd < 0) {
+		perror("file open");
+		goto err;
+	}
+
+	for (i = 0; i < BUFFERS; i++) {
+		struct io_uring_sqe *sqe;
+		off_t offset = BS * (rand() % BUFFERS);
+
+		sqe = io_uring_get_sqe(&ring);
+		io_uring_prep_writev(sqe, fd, &vecs[i], 1, offset);
+		sqe->user_data = 1;
+	}
+
+	/* submit manually to avoid adding IORING_ENTER_GETEVENTS */
+	ret = __sys_io_uring_enter(ring.ring_fd, __io_uring_flush_sq(&ring), 0,
+						0, NULL);
+	if (ret < 0)
+		goto err;
+
+	for (i = 0; i < 500; i++) {
+		ret = io_uring_submit(&ring);
+		if (ret != 0) {
+			fprintf(stderr, "still had %d sqes to submit, this is unexpected", ret);
+			goto err;
+		}
+
+		io_uring_for_each_cqe(&ring, head, cqe) {
+			/* runs after test_io so should not have happened */
+			if (cqe->res == -EOPNOTSUPP) {
+				fprintf(stdout, "File/device/fs doesn't support polled IO\n");
+				goto err;
+			}
+			goto ok;
+		}
+		usleep(10000);
+	}
+err:
+	ret = 1;
+	if (fd != -1)
+		close(fd);
+
+ok:
+	io_uring_queue_exit(&ring);
+	return ret;
+}
+
+static int test_io(const char *file, int write, int sqthread, int fixed,
+		   int buf_select)
+{
+	struct io_uring ring;
+	int ret, ring_flags = IORING_SETUP_IOPOLL;
+
+	if (no_iopoll)
+		return 0;
+
+	ret = t_create_ring(64, &ring, ring_flags);
+	if (ret == T_SETUP_SKIP)
+		return 0;
+	if (ret != T_SETUP_OK) {
+		fprintf(stderr, "ring create failed: %d\n", ret);
+		return 1;
+	}
+	ret = __test_io(file, &ring, write, sqthread, fixed, buf_select);
+	io_uring_queue_exit(&ring);
+	return ret;
+}
+
+static int probe_buf_select(void)
+{
+	struct io_uring_probe *p;
+	struct io_uring ring;
+	int ret;
+
+	ret = io_uring_queue_init(1, &ring, 0);
+	if (ret) {
+		fprintf(stderr, "ring create failed: %d\n", ret);
+		return 1;
+	}
+
+	p = io_uring_get_probe_ring(&ring);
+	if (!p || !io_uring_opcode_supported(p, IORING_OP_PROVIDE_BUFFERS)) {
+		no_buf_select = 1;
+		fprintf(stdout, "Buffer select not supported, skipping\n");
+		return 0;
+	}
+	io_uring_free_probe(p);
+	return 0;
+}
+
+int main(int argc, char *argv[])
+{
+	int i, ret, nr;
+	char buf[256];
+	char *fname;
+
+	if (probe_buf_select())
+		return 1;
+
+	if (argc > 1) {
+		fname = argv[1];
+	} else {
+		srand((unsigned)time(NULL));
+		snprintf(buf, sizeof(buf), ".basic-rw-%u-%u",
+			(unsigned)rand(), (unsigned)getpid());
+		fname = buf;
+		t_create_file(fname, FILE_SIZE);
+	}
+
+	vecs = t_create_buffers(BUFFERS, BS);
+
+	nr = 16;
+	if (no_buf_select)
+		nr = 8;
+	for (i = 0; i < nr; i++) {
+		int write = (i & 1) != 0;
+		int sqthread = (i & 2) != 0;
+		int fixed = (i & 4) != 0;
+		int buf_select = (i & 8) != 0;
+
+		ret = test_io(fname, write, sqthread, fixed, buf_select);
+		if (ret) {
+			fprintf(stderr, "test_io failed %d/%d/%d/%d\n",
+				write, sqthread, fixed, buf_select);
+			goto err;
+		}
+		if (no_iopoll)
+			break;
+	}
+
+	ret = test_io_uring_submit_enters(fname);
+	if (ret) {
+	    fprintf(stderr, "test_io_uring_submit_enters failed\n");
+	    goto err;
+	}
+
+	if (fname != argv[1])
+		unlink(fname);
+	return 0;
+err:
+	if (fname != argv[1])
+		unlink(fname);
+	return 1;
+}

data/vendor/liburing/test/lfs-openat-write.c

@@ -0,0 +1,119 @@
+/* SPDX-License-Identifier: MIT */
+
+#define _LARGEFILE_SOURCE
+#define _FILE_OFFSET_BITS 64
+
+#include <liburing.h>
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <sys/resource.h>
+#include <unistd.h>
+
+static const int RSIZE = 2;
+static const int OPEN_FLAGS = O_RDWR | O_CREAT;
+static const mode_t OPEN_MODE = S_IRUSR | S_IWUSR;
+
+#define DIE(...) do {\
+		fprintf(stderr, __VA_ARGS__);\
+		abort();\
+	} while(0);
+
+static int do_write(struct io_uring *ring, int fd, off_t offset)
+{
+	char buf[] = "some test write buf";
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	int res, ret;
+
+	sqe = io_uring_get_sqe(ring);
+	if (!sqe) {
+		fprintf(stderr, "failed to get sqe\n");
+		return 1;
+	}
+	io_uring_prep_write(sqe, fd, buf, sizeof(buf), offset);
+
+	ret = io_uring_submit(ring);
+	if (ret < 0) {
+		fprintf(stderr, "failed to submit write: %s\n", strerror(-ret));
+		return 1;
+	}
+
+	ret = io_uring_wait_cqe(ring, &cqe);
+	if (ret < 0) {
+		fprintf(stderr, "wait_cqe failed: %s\n", strerror(-ret));
+		return 1;
+	}
+
+	res = cqe->res;
+	io_uring_cqe_seen(ring, cqe);
+	if (res < 0) {
+		fprintf(stderr, "write failed: %s\n", strerror(-res));
+		return 1;
+	}
+
+	return 0;
+}
+
+static int test_open_write(struct io_uring *ring, int dfd, const char *fn)
+{
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	int ret, fd = -1;
+
+	sqe = io_uring_get_sqe(ring);
+	if (!sqe) {
+		fprintf(stderr, "failed to get sqe\n");
+		return 1;
+	}
+	io_uring_prep_openat(sqe, dfd, fn, OPEN_FLAGS, OPEN_MODE);
+
+	ret = io_uring_submit(ring);
+	if (ret < 0) {
+		fprintf(stderr, "failed to submit openat: %s\n", strerror(-ret));
+		return 1;
+	}
+
+	ret = io_uring_wait_cqe(ring, &cqe);
+	if (ret < 0) {
+		fprintf(stderr, "wait_cqe failed: %s\n", strerror(-ret));
+		return 1;
+	}
+
+	fd = cqe->res;
+	io_uring_cqe_seen(ring, cqe);
+	if (fd < 0) {
+		fprintf(stderr, "openat failed: %s\n", strerror(-fd));
+		return 1;
+	}
+
+	return do_write(ring, fd, 1ULL << 32);
+}
+
+int main(int argc, char *argv[])
+{
+	struct io_uring ring;
+	int dfd, ret;
+
+	if (argc > 1)
+		return 0;
+
+	dfd = open("/tmp", O_RDONLY | O_DIRECTORY);
+	if (dfd < 0)
+		DIE("open /tmp: %s\n", strerror(errno));
+
+	ret = io_uring_queue_init(RSIZE, &ring, 0);
+	if (ret < 0)
+		DIE("failed to init io_uring: %s\n", strerror(-ret));
+
+	ret = test_open_write(&ring, dfd, "io_uring_openat_write_test1");
+
+	io_uring_queue_exit(&ring);
+	close(dfd);
+	unlink("/tmp/io_uring_openat_write_test1");
+	return ret;
+}