polyphony 0.85 → 0.86

data/vendor/liburing/test/across-fork.c

@@ -0,0 +1,283 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: test sharing a ring across a fork
+ */
+#include <fcntl.h>
+#include <pthread.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include "liburing.h"
+
+
+struct forktestmem
+{
+	struct io_uring ring;
+	pthread_barrier_t barrier;
+	pthread_barrierattr_t barrierattr;
+};
+
+static int open_tempfile(const char *dir, const char *fname)
+{
+	int fd;
+	char buf[32];
+
+	snprintf(buf, sizeof(buf), "%s/%s",
+		 dir, fname);
+	fd = open(buf, O_RDWR | O_CREAT | O_APPEND, S_IRUSR | S_IWUSR);
+	if (fd < 0) {
+		perror("open");
+		exit(1);
+	}
+
+	return fd;
+}
+
+static int submit_write(struct io_uring *ring, int fd, const char *str,
+			int wait)
+{
+	struct io_uring_sqe *sqe;
+	struct iovec iovec;
+	int ret;
+
+	sqe = io_uring_get_sqe(ring);
+	if (!sqe) {
+		fprintf(stderr, "could not get sqe\n");
+		return 1;
+	}
+
+	iovec.iov_base = (char *) str;
+	iovec.iov_len = strlen(str);
+	io_uring_prep_writev(sqe, fd, &iovec, 1, 0);
+	ret = io_uring_submit_and_wait(ring, wait);
+	if (ret < 0) {
+		fprintf(stderr, "submit failed: %s\n", strerror(-ret));
+		return 1;
+	}
+
+	return 0;
+}
+
+static int wait_cqe(struct io_uring *ring, const char *stage)
+{
+	struct io_uring_cqe *cqe;
+	int ret;
+
+	ret = io_uring_wait_cqe(ring, &cqe);
+	if (ret) {
+		fprintf(stderr, "%s wait_cqe failed %d\n", stage, ret);
+		return 1;
+	}
+	if (cqe->res < 0) {
+		fprintf(stderr, "%s cqe failed %d\n", stage, cqe->res);
+		return 1;
+	}
+
+	io_uring_cqe_seen(ring, cqe);
+	return 0;
+}
+
+static int verify_file(const char *tmpdir, const char *fname, const char* expect)
+{
+	int fd;
+	char buf[512];
+	int err = 0;
+
+	memset(buf, 0, sizeof(buf));
+
+	fd = open_tempfile(tmpdir, fname);
+	if (fd < 0)
+		return 1;
+
+	if (read(fd, buf, sizeof(buf) - 1) < 0)
+		return 1;
+
+	if (strcmp(buf, expect) != 0) {
+		fprintf(stderr, "content mismatch for %s\n"
+			"got:\n%s\n"
+			"expected:\n%s\n",
+			fname, buf, expect);
+		err = 1;
+	}
+
+	close(fd);
+	return err;
+}
+
+static void cleanup(const char *tmpdir)
+{
+	char buf[32];
+
+	/* don't check errors, called during partial runs */
+
+	snprintf(buf, sizeof(buf), "%s/%s", tmpdir, "shared");
+	unlink(buf);
+
+	snprintf(buf, sizeof(buf), "%s/%s", tmpdir, "parent1");
+	unlink(buf);
+
+	snprintf(buf, sizeof(buf), "%s/%s", tmpdir, "parent2");
+	unlink(buf);
+
+	snprintf(buf, sizeof(buf), "%s/%s", tmpdir, "child");
+	unlink(buf);
+
+	rmdir(tmpdir);
+}
+
+int main(int argc, char *argv[])
+{
+	struct forktestmem *shmem;
+	char tmpdir[] = "forktmpXXXXXX";
+	int shared_fd;
+	int ret;
+	pid_t p;
+
+	if (argc > 1)
+		return 0;
+
+	shmem = mmap(0, sizeof(struct forktestmem), PROT_READ|PROT_WRITE,
+		   MAP_SHARED | MAP_ANONYMOUS, 0, 0);
+	if (!shmem) {
+		fprintf(stderr, "mmap failed\n");
+		exit(1);
+	}
+
+	pthread_barrierattr_init(&shmem->barrierattr);
+	pthread_barrierattr_setpshared(&shmem->barrierattr, 1);
+	pthread_barrier_init(&shmem->barrier, &shmem->barrierattr, 2);
+
+	ret = io_uring_queue_init(10, &shmem->ring, 0);
+	if (ret < 0) {
+		fprintf(stderr, "queue init failed\n");
+		exit(1);
+	}
+
+	if (mkdtemp(tmpdir) == NULL) {
+		fprintf(stderr, "temp directory creation failed\n");
+		exit(1);
+	}
+
+	shared_fd = open_tempfile(tmpdir, "shared");
+
+	/*
+	 * First do a write before the fork, to test whether child can
+	 * reap that
+	 */
+	if (submit_write(&shmem->ring, shared_fd, "before fork: write shared fd\n", 0))
+		goto errcleanup;
+
+	p = fork();
+	switch (p) {
+	case -1:
+		fprintf(stderr, "fork failed\n");
+		goto errcleanup;
+
+	default: {
+		/* parent */
+		int parent_fd1;
+		int parent_fd2;
+		int wstatus;
+
+		/* wait till fork is started up */
+		pthread_barrier_wait(&shmem->barrier);
+
+		parent_fd1 = open_tempfile(tmpdir, "parent1");
+		parent_fd2 = open_tempfile(tmpdir, "parent2");
+
+		/* do a parent write to the shared fd */
+		if (submit_write(&shmem->ring, shared_fd, "parent: write shared fd\n", 0))
+			goto errcleanup;
+
+		/* do a parent write to an fd where same numbered fd exists in child */
+		if (submit_write(&shmem->ring, parent_fd1, "parent: write parent fd 1\n", 0))
+			goto errcleanup;
+
+		/* do a parent write to an fd where no same numbered fd exists in child */
+		if (submit_write(&shmem->ring, parent_fd2, "parent: write parent fd 2\n", 0))
+			goto errcleanup;
+
+		/* wait to switch read/writ roles with child */
+		pthread_barrier_wait(&shmem->barrier);
+
+		/* now wait for child to exit, to ensure we still can read completion */
+		waitpid(p, &wstatus, 0);
+		if (WEXITSTATUS(wstatus) != 0) {
+			fprintf(stderr, "child failed\n");
+			goto errcleanup;
+		}
+
+		if (wait_cqe(&shmem->ring, "p cqe 1"))
+			goto errcleanup;
+
+		if (wait_cqe(&shmem->ring, "p cqe 2"))
+			goto errcleanup;
+
+		/* check that IO can still be submitted after child exited */
+		if (submit_write(&shmem->ring, shared_fd, "parent: write shared fd after child exit\n", 0))
+			goto errcleanup;
+
+		if (wait_cqe(&shmem->ring, "p cqe 3"))
+			goto errcleanup;
+
+		break;
+	}
+	case 0: {
+		/* child */
+		int child_fd;
+
+		/* wait till fork is started up */
+		pthread_barrier_wait(&shmem->barrier);
+
+		child_fd = open_tempfile(tmpdir, "child");
+
+		if (wait_cqe(&shmem->ring, "c cqe shared"))
+			exit(1);
+
+		if (wait_cqe(&shmem->ring, "c cqe parent 1"))
+			exit(1);
+
+		if (wait_cqe(&shmem->ring, "c cqe parent 2"))
+			exit(1);
+
+		if (wait_cqe(&shmem->ring, "c cqe parent 3"))
+			exit(1);
+
+		/* wait to switch read/writ roles with parent */
+		pthread_barrier_wait(&shmem->barrier);
+
+		if (submit_write(&shmem->ring, child_fd, "child: write child fd\n", 0))
+			exit(1);
+
+		/* ensure both writes have finished before child exits */
+		if (submit_write(&shmem->ring, shared_fd, "child: write shared fd\n", 2))
+			exit(1);
+
+		exit(0);
+	}
+	}
+
+	if (verify_file(tmpdir, "shared",
+			 "before fork: write shared fd\n"
+			 "parent: write shared fd\n"
+			 "child: write shared fd\n"
+			 "parent: write shared fd after child exit\n") ||
+	    verify_file(tmpdir, "parent1", "parent: write parent fd 1\n") ||
+	    verify_file(tmpdir, "parent2", "parent: write parent fd 2\n") ||
+	    verify_file(tmpdir, "child", "child: write child fd\n"))
+		goto errcleanup;
+
+	cleanup(tmpdir);
+	exit(0);
+
+errcleanup:
+	cleanup(tmpdir);
+	exit(1);
+}

data/vendor/liburing/test/b19062a56726-test.c

@@ -0,0 +1,53 @@
+/* SPDX-License-Identifier: MIT */
+// autogenerated by syzkaller (https://github.com/google/syzkaller)
+
+#include <endian.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+#include "liburing.h"
+#include "../src/syscall.h"
+
+int main(int argc, char *argv[])
+{
+  if (argc > 1)
+    return 0;
+
+  mmap((void *) 0x20000000, 0x1000000, 3, 0x32, -1, 0);
+
+  *(uint32_t*)0x20000200 = 0;
+  *(uint32_t*)0x20000204 = 0;
+  *(uint32_t*)0x20000208 = 5;
+  *(uint32_t*)0x2000020c = 0x400;
+  *(uint32_t*)0x20000210 = 0;
+  *(uint32_t*)0x20000214 = 0;
+  *(uint32_t*)0x20000218 = 0;
+  *(uint32_t*)0x2000021c = 0;
+  *(uint32_t*)0x20000220 = 0;
+  *(uint32_t*)0x20000224 = 0;
+  *(uint32_t*)0x20000228 = 0;
+  *(uint32_t*)0x2000022c = 0;
+  *(uint32_t*)0x20000230 = 0;
+  *(uint32_t*)0x20000234 = 0;
+  *(uint32_t*)0x20000238 = 0;
+  *(uint32_t*)0x2000023c = 0;
+  *(uint32_t*)0x20000240 = 0;
+  *(uint32_t*)0x20000244 = 0;
+  *(uint64_t*)0x20000248 = 0;
+  *(uint32_t*)0x20000250 = 0;
+  *(uint32_t*)0x20000254 = 0;
+  *(uint32_t*)0x20000258 = 0;
+  *(uint32_t*)0x2000025c = 0;
+  *(uint32_t*)0x20000260 = 0;
+  *(uint32_t*)0x20000264 = 0;
+  *(uint32_t*)0x20000268 = 0;
+  *(uint32_t*)0x2000026c = 0;
+  *(uint64_t*)0x20000270 = 0;
+  __sys_io_uring_setup(0xc9f, (struct io_uring_params *) 0x20000200);
+  return 0;
+}

data/vendor/liburing/test/b5837bd5311d-test.c

@@ -0,0 +1,77 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: Check to see if wait_nr is being honored.
+ */
+#include <stdio.h>
+#include "liburing.h"
+
+int main(int argc, char *argv[])
+{
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	struct io_uring ring;
+	int ret;
+	struct __kernel_timespec ts = {
+		.tv_sec = 0,
+		.tv_nsec = 10000000
+	};
+
+	if (argc > 1)
+		return 0;
+
+	if (io_uring_queue_init(4, &ring, 0) != 0) {
+		fprintf(stderr, "ring setup failed\n");
+		return 1;
+	}
+
+	/*
+	 * First, submit the timeout sqe so we can actually finish the test
+	 * if everything is in working order.
+	 */
+	sqe = io_uring_get_sqe(&ring);
+	if (!sqe) {
+		fprintf(stderr, "get sqe failed\n");
+		return 1;
+	}
+	io_uring_prep_timeout(sqe, &ts, (unsigned)-1, 0);
+
+	ret = io_uring_submit(&ring);
+	if (ret != 1) {
+		fprintf(stderr, "Got submit %d, expected 1\n", ret);
+		return 1;
+	}
+
+	/*
+	 * Next, submit a nop and wait for two events. If everything is working
+	 * as it should, we should be waiting for more than a millisecond and we
+	 * should see two cqes. Otherwise, execution continues immediately
+	 * and we see only one cqe.
+	 */
+	sqe = io_uring_get_sqe(&ring);
+	if (!sqe) {
+		fprintf(stderr, "get sqe failed\n");
+		return 1;
+	}
+	io_uring_prep_nop(sqe);
+
+	ret = io_uring_submit_and_wait(&ring, 2);
+	if (ret != 1) {
+		fprintf(stderr, "Got submit %d, expected 1\n", ret);
+		return 1;
+	}
+
+	if (io_uring_peek_cqe(&ring, &cqe) != 0) {
+		fprintf(stderr, "Unable to peek cqe!\n");
+		return 1;
+	}
+
+	io_uring_cqe_seen(&ring, cqe);
+
+	if (io_uring_peek_cqe(&ring, &cqe) != 0) {
+		fprintf(stderr, "Unable to peek cqe!\n");
+		return 1;
+	}
+
+	io_uring_queue_exit(&ring);
+	return 0;
+}

data/vendor/liburing/test/ce593a6c480a-test.c

@@ -0,0 +1,136 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Test 5.7 regression with task_work not being run while a task is
+ * waiting on another event in the kernel.
+ */
+#include <errno.h>
+#include <poll.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <sys/eventfd.h>
+#include <unistd.h>
+#include <pthread.h>
+#include "liburing.h"
+#include "helpers.h"
+
+static int use_sqpoll = 0;
+
+void notify_fd(int fd)
+{
+	char buf[8] = {0, 0, 0, 0, 0, 0, 1};
+	int ret;
+
+	ret = write(fd, &buf, 8);
+	if (ret < 0)
+		perror("write");
+}
+
+void *delay_set_fd_from_thread(void *data)
+{
+	int fd = (intptr_t) data;
+
+	sleep(1);
+	notify_fd(fd);
+	return NULL;
+}
+
+int main(int argc, char *argv[])
+{
+	struct io_uring_params p = {};
+	struct io_uring ring;
+	int loop_fd, other_fd;
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe = NULL;
+	int ret, use_fd;
+	char buf[8] = {0, 0, 0, 0, 0, 0, 1};
+	pthread_t tid;
+
+	if (argc > 1)
+		return 0;
+
+	/* Create an eventfd to be registered with the loop to be
+	 * notified of events being ready
+	 */
+	loop_fd = eventfd(0, EFD_CLOEXEC);
+	if (loop_fd == -1) {
+		fprintf(stderr, "eventfd errno=%d\n", errno);
+		return 1;
+	}
+
+	/* Create an eventfd that can create events */
+	use_fd = other_fd = eventfd(0, EFD_CLOEXEC);
+	if (other_fd == -1) {
+		fprintf(stderr, "eventfd errno=%d\n", errno);
+		return 1;
+	}
+
+	if (use_sqpoll)
+		p.flags = IORING_SETUP_SQPOLL;
+
+	/* Setup the ring with a registered event fd to be notified on events */
+	ret = t_create_ring_params(8, &ring, &p);
+	if (ret == T_SETUP_SKIP)
+		return 0;
+	else if (ret < 0)
+		return ret;
+
+	ret = io_uring_register_eventfd(&ring, loop_fd);
+	if (ret < 0) {
+		fprintf(stderr, "register_eventfd=%d\n", ret);
+		return 1;
+	}
+
+	if (use_sqpoll) {
+		ret = io_uring_register_files(&ring, &other_fd, 1);
+		if (ret < 0) {
+			fprintf(stderr, "register_files=%d\n", ret);
+			return 1;
+		}
+		use_fd = 0;
+	}
+
+	/* Submit a poll operation to wait on an event in other_fd */
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_poll_add(sqe, use_fd, POLLIN);
+	sqe->user_data = 1;
+	if (use_sqpoll)
+		sqe->flags |= IOSQE_FIXED_FILE;
+	ret = io_uring_submit(&ring);
+	if (ret != 1) {
+		fprintf(stderr, "submit=%d\n", ret);
+		return 1;
+	}
+
+	/*
+	 * CASE 3: Hangs forever in Linux 5.7.5; Works in Linux 5.6.0 When this
+	 * code is uncommented, we don't se a notification on other_fd until
+	 * _after_ we have started the read on loop_fd. In that case, the read() on
+	 * loop_fd seems to hang forever.
+	*/
+    	pthread_create(&tid, NULL, delay_set_fd_from_thread,
+			(void*) (intptr_t) other_fd);
+
+	/* Wait on the event fd for an event to be ready */
+	ret = read(loop_fd, buf, 8);
+	if (ret < 0) {
+		perror("read");
+		return 1;
+	} else if (ret != 8) {
+		fprintf(stderr, "Odd-sized eventfd read: %d\n", ret);
+		return 1;
+	}
+
+
+	ret = io_uring_wait_cqe(&ring, &cqe);
+	if (ret) {
+		fprintf(stderr, "wait_cqe=%d\n", 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;
+}

data/vendor/liburing/test/close-opath.c

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: MIT
+
+#define _GNU_SOURCE 1
+#define _FILE_OFFSET_BITS 64
+
+// Test program for io_uring IORING_OP_CLOSE with O_PATH file.
+// Author: Clayton Harris <bugs@claycon.org>, 2020-06-07
+
+// linux                5.6.14-300.fc32.x86_64
+// gcc                  10.1.1-1.fc32
+// liburing.x86_64      0.5-1.fc32
+
+// gcc -O2 -Wall -Wextra -std=c11 -o close_opath close_opath.c -luring
+// ./close_opath testfilepath
+
+#include <errno.h>
+#include <fcntl.h>
+#include <liburing.h>
+#include <sys/stat.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+
+typedef struct
+{
+	const char *const flnames;
+	const int oflags;
+} oflgs_t;
+
+static int test_io_uring_close(struct io_uring *ring, int fd)
+{
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	int ret;
+
+	sqe = io_uring_get_sqe(ring);
+	if (!sqe) {
+		fprintf(stderr, "io_uring_get_sqe() failed\n");
+		return -ENOENT;
+	}
+
+	io_uring_prep_close(sqe, fd);
+
+	ret = io_uring_submit(ring);
+	if (ret < 0) {
+		fprintf(stderr, "io_uring_submit() failed, errno %d: %s\n",
+			-ret, strerror(-ret));
+		return ret;
+	}
+
+	ret = io_uring_wait_cqe(ring, &cqe);
+	if (ret < 0) {
+		fprintf(stderr, "io_uring_wait_cqe() failed, errno %d: %s\n",
+			-ret, strerror(-ret));
+		return ret;
+	}
+
+	ret = cqe->res;
+	io_uring_cqe_seen(ring, cqe);
+
+	if (ret < 0 && ret != -EOPNOTSUPP && ret != -EINVAL && ret != -EBADF) {
+		fprintf(stderr, "io_uring close() failed, errno %d: %s\n",
+			-ret, strerror(-ret));
+		return ret;
+	}
+
+	return 0;
+}
+
+static int open_file(const char *path, const oflgs_t *oflgs)
+{
+	int fd;
+
+	fd = openat(AT_FDCWD, path, oflgs->oflags, 0);
+	if (fd < 0) {
+		int err = errno;
+		fprintf(stderr, "openat(%s, %s) failed, errno %d: %s\n",
+			path, oflgs->flnames, err, strerror(err));
+		return -err;
+	}
+
+	return fd;
+}
+
+int main(int argc, char *argv[])
+{
+	const char *fname = ".";
+	struct io_uring ring;
+	int ret, i;
+	static const oflgs_t oflgs[] = {
+		{ "O_RDONLY", O_RDONLY },
+		{ "O_PATH", O_PATH }
+	};
+
+	ret = io_uring_queue_init(2, &ring, 0);
+	if (ret < 0) {
+		fprintf(stderr, "io_uring_queue_init() failed, errno %d: %s\n",
+			-ret, strerror(-ret));
+		return 0x02;
+	}
+
+#define OFLGS_SIZE (sizeof(oflgs) / sizeof(oflgs[0]))
+
+	ret = 0;
+	for (i = 0; i < OFLGS_SIZE; i++) {
+		int fd;
+
+		fd = open_file(fname, &oflgs[i]);
+		if (fd < 0) {
+			ret |= 0x02;
+			break;
+		}
+
+		/* Should always succeed */
+		if (test_io_uring_close(&ring, fd) < 0)
+			ret |= 0x04 << i;
+	}
+#undef OFLGS_SIZE
+
+	io_uring_queue_exit(&ring);
+	return ret;
+}

data/vendor/liburing/test/config

@@ -0,0 +1,10 @@
+# Copy this to config.local, uncomment and define values
+#
+# Define tests to exclude from running
+# TEST_EXCLUDE=""
+#
+# Define raw test devices (or files) for test cases, if any
+# declare -A TEST_MAP=()
+#
+# If no TEST_MAP entry exists for a test, use the ones given in TEST_FILES
+# TEST_FILES="/dev/somedevice /data/somefile"