@nxtedition/rocksdb 5.2.36 → 5.2.39

package/deps/liburing/liburing/test/personality.c

@@ -0,0 +1,204 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: test if personalities work
+ *
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+
+#include "liburing.h"
+
+#define FNAME	"/tmp/.tmp.access"
+#define USE_UID	1000
+
+static int no_personality;
+
+static int open_file(struct io_uring *ring, int cred_id, int with_link)
+{
+	struct io_uring_cqe *cqe;
+	struct io_uring_sqe *sqe;
+	int ret, i, to_submit = 1;
+
+	if (with_link) {
+		sqe = io_uring_get_sqe(ring);
+		io_uring_prep_nop(sqe);
+		sqe->flags |= IOSQE_IO_LINK;
+		sqe->user_data = 1;
+		to_submit++;
+	}
+
+	sqe = io_uring_get_sqe(ring);
+	io_uring_prep_openat(sqe, -1, FNAME, O_RDONLY, 0);
+	sqe->user_data = 2;
+
+	if (cred_id != -1)
+		sqe->personality = cred_id;
+
+	ret = io_uring_submit(ring);
+	if (ret != to_submit) {
+		fprintf(stderr, "submit got: %d\n", ret);
+		goto err;
+	}
+
+	for (i = 0; i < to_submit; i++) {
+		ret = io_uring_wait_cqe(ring, &cqe);
+		if (ret < 0) {
+			fprintf(stderr, "wait completion %d\n", ret);
+			goto err;
+		}
+
+		ret = cqe->res;
+		io_uring_cqe_seen(ring, cqe);
+	}
+err:
+	return ret;
+}
+
+static int test_personality(struct io_uring *ring)
+{
+	int ret, cred_id;
+
+	ret = io_uring_register_personality(ring);
+	if (ret < 0) {
+		if (ret == -EINVAL) {
+			fprintf(stdout, "Personalities not supported, skipping\n");
+			no_personality = 1;
+			goto out;
+		}
+		fprintf(stderr, "register_personality: %d\n", ret);
+		goto err;
+	}
+	cred_id = ret;
+
+	/* create file only owner can open */
+	ret = open(FNAME, O_RDONLY | O_CREAT, 0600);
+	if (ret < 0) {
+		perror("open");
+		goto err;
+	}
+	close(ret);
+
+	/* verify we can open it */
+	ret = open_file(ring, -1, 0);
+	if (ret < 0) {
+		fprintf(stderr, "current open got: %d\n", ret);
+		goto err;
+	}
+
+	if (seteuid(USE_UID) < 0) {
+		fprintf(stdout, "Can't switch to UID %u, skipping\n", USE_UID);
+		goto out;
+	}
+
+	/* verify we can't open it with current credentials */
+	ret = open_file(ring, -1, 0);
+	if (ret != -EACCES) {
+		fprintf(stderr, "open got: %d\n", ret);
+		goto err;
+	}
+
+	/* verify we can open with registered credentials */
+	ret = open_file(ring, cred_id, 0);
+	if (ret < 0) {
+		fprintf(stderr, "credential open: %d\n", ret);
+		goto err;
+	}
+	close(ret);
+
+	/* verify we can open with registered credentials and as a link */
+	ret = open_file(ring, cred_id, 1);
+	if (ret < 0) {
+		fprintf(stderr, "credential open: %d\n", ret);
+		goto err;
+	}
+
+	if (seteuid(0))
+		perror("seteuid");
+
+	ret = io_uring_unregister_personality(ring, cred_id);
+	if (ret) {
+		fprintf(stderr, "register_personality: %d\n", ret);
+		goto err;
+	}
+
+out:
+	unlink(FNAME);
+	return 0;
+err:
+	unlink(FNAME);
+	return 1;
+}
+
+static int test_invalid_personality(struct io_uring *ring)
+{
+	int ret;
+
+	ret = open_file(ring, 2, 0);
+	if (ret != -EINVAL) {
+		fprintf(stderr, "invalid personality got: %d\n", ret);
+		goto err;
+	}
+	return 0;
+err:
+	return 1;
+}
+
+static int test_invalid_unregister(struct io_uring *ring)
+{
+	int ret;
+
+	ret = io_uring_unregister_personality(ring, 2);
+	if (ret != -EINVAL) {
+		fprintf(stderr, "invalid personality unregister got: %d\n", ret);
+		goto err;
+	}
+	return 0;
+err:
+	return 1;
+}
+
+int main(int argc, char *argv[])
+{
+	struct io_uring ring;
+	int ret;
+
+	if (argc > 1)
+		return 0;
+
+	if (geteuid()) {
+		fprintf(stderr, "Not root, skipping\n");
+		return 0;
+	}
+
+	ret = io_uring_queue_init(8, &ring, 0);
+	if (ret) {
+		fprintf(stderr, "ring setup failed: %d\n", ret);
+		return 1;
+	}
+
+	ret = test_personality(&ring);
+	if (ret) {
+		fprintf(stderr, "test_personality failed\n");
+		return ret;
+	}
+	if (no_personality)
+		return 0;
+
+	ret = test_invalid_personality(&ring);
+	if (ret) {
+		fprintf(stderr, "test_invalid_personality failed\n");
+		return ret;
+	}
+
+	ret = test_invalid_unregister(&ring);
+	if (ret) {
+		fprintf(stderr, "test_invalid_unregister failed\n");
+		return ret;
+	}
+
+	return 0;
+}

package/deps/liburing/liburing/test/pipe-eof.c

@@ -0,0 +1,81 @@
+/*
+ * Test that closed pipe reads returns 0, instead of waiting for more
+ * data.
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <string.h>
+#include "liburing.h"
+
+#define BUFSIZE	512
+
+struct data {
+	char *str;
+	int fds[2];
+};
+
+static void *t(void *data)
+{
+	struct data *d = data;
+	int ret;
+
+	strcpy(d->str, "This is a test string");
+	ret = write(d->fds[1], d->str, strlen(d->str));
+	close(d->fds[1]);
+	if (ret < 0)
+		perror("write");
+
+	return NULL;
+}
+
+int main(int argc, char *argv[])
+{
+	static char buf[BUFSIZE];
+	struct io_uring ring;
+	pthread_t thread;
+	struct data d;
+	int ret;
+
+	if (pipe(d.fds) < 0) {
+		perror("pipe");
+		return 1;
+	}
+	d.str = buf;
+
+	io_uring_queue_init(8, &ring, 0);
+
+	pthread_create(&thread, NULL, t, &d);
+
+	while (1) {
+		struct io_uring_sqe *sqe;
+		struct io_uring_cqe *cqe;
+
+		sqe = io_uring_get_sqe(&ring);
+		io_uring_prep_read(sqe, d.fds[0], buf, BUFSIZE, 0);
+		ret = io_uring_submit(&ring);
+		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;
+		}
+
+		if (cqe->res < 0) {
+			fprintf(stderr, "Read error: %s\n", strerror(-cqe->res));
+			return 1;
+		}
+		if (cqe->res == 0)
+			break;
+		io_uring_cqe_seen(&ring, cqe);
+	}
+
+	pthread_join(thread, NULL);
+	io_uring_queue_exit(&ring);
+	return 0;
+}

package/deps/liburing/liburing/test/pipe-reuse.c

@@ -0,0 +1,105 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Check split up read is handled correctly
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <pthread.h>
+#include <string.h>
+#include "liburing.h"
+
+#define BUFSIZE	16384
+#define BUFFERS	16
+
+int main(int argc, char *argv[])
+{
+	char buf[BUFSIZE], wbuf[BUFSIZE];
+	struct iovec iov[BUFFERS];
+	struct io_uring_params p = { };
+	struct io_uring ring;
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	int ret, i, fds[2];
+	void *ptr;
+
+	if (pipe(fds) < 0) {
+		perror("pipe");
+		return 1;
+	}
+
+	ptr = buf;
+	for (i = 0; i < BUFFERS; i++) {
+		unsigned bsize = BUFSIZE / BUFFERS;
+
+		iov[i].iov_base = ptr;
+		iov[i].iov_len = bsize;
+		ptr += bsize;
+	}
+
+	ret = io_uring_queue_init_params(8, &ring, &p);
+	if (ret) {
+		fprintf(stderr, "queue_init: %d\n", ret);
+		return 1;
+	}
+	if (!(p.features & IORING_FEAT_SUBMIT_STABLE)) {
+		fprintf(stdout, "FEAT_SUBMIT_STABLE not there, skipping\n");
+		return 0;
+	}
+
+	ptr = wbuf;
+	memset(ptr, 0x11, sizeof(wbuf) / 2);
+	ptr += sizeof(wbuf) / 2;
+	memset(ptr, 0x22, sizeof(wbuf) / 2);
+
+	ret = write(fds[1], wbuf, sizeof(wbuf) / 2);
+	if (ret != sizeof(wbuf) / 2) {
+		fprintf(stderr, "Bad write\n");
+		ret = 1;
+		goto err;
+	}
+
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_readv(sqe, fds[0], iov, BUFFERS, 0);
+	ret = io_uring_submit(&ring);
+	if (ret != 1) {
+		fprintf(stderr, "submit: %d\n", ret);
+		return 1;
+	}
+
+	for (i = 0; i < BUFFERS; i++) {
+		iov[i].iov_base = NULL;
+		iov[i].iov_len = 1000000;
+	}
+
+	ret = write(fds[1], ptr, sizeof(wbuf) / 2);
+	if (ret != sizeof(wbuf) / 2) {
+		fprintf(stderr, "Bad write\n");
+		ret = 1;
+		goto err;
+	}
+
+	ret = io_uring_wait_cqe(&ring, &cqe);
+	if (ret) {
+		fprintf(stderr, "wait: %d\n", ret);
+		return 1;
+	}
+
+	if (cqe->res < 0) {
+		fprintf(stderr, "Read error: %s\n", strerror(-cqe->res));
+		return 1;
+	} else if (cqe->res != sizeof(wbuf)) {
+		/* ignore short read, not a failure */
+		goto err;
+	}
+	io_uring_cqe_seen(&ring, cqe);
+
+	ret = memcmp(wbuf, buf, sizeof(wbuf));
+	if (ret)
+		fprintf(stderr, "Read data mismatch\n");
+
+err:
+	io_uring_queue_exit(&ring);
+	return ret;
+}

package/deps/liburing/liburing/test/poll-cancel-ton.c

@@ -0,0 +1,139 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: test massive amounts of poll with cancel
+ *
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+#include <sys/poll.h>
+#include <sys/wait.h>
+#include <sys/signal.h>
+
+#include "liburing.h"
+
+#define POLL_COUNT	30000
+
+static void *sqe_index[POLL_COUNT];
+
+static int reap_events(struct io_uring *ring, unsigned nr_events, int nowait)
+{
+	struct io_uring_cqe *cqe;
+	int i, ret = 0;
+
+	for (i = 0; i < nr_events; i++) {
+		if (!i && !nowait)
+			ret = io_uring_wait_cqe(ring, &cqe);
+		else
+			ret = io_uring_peek_cqe(ring, &cqe);
+		if (ret) {
+			if (ret != -EAGAIN)
+				fprintf(stderr, "cqe peek failed: %d\n", ret);
+			break;
+		}
+		io_uring_cqe_seen(ring, cqe);
+	}
+
+	return i ? i : ret;
+}
+
+static int del_polls(struct io_uring *ring, int fd, int nr)
+{
+	int batch, i, ret;
+	struct io_uring_sqe *sqe;
+
+	while (nr) {
+		batch = 1024;
+		if (batch > nr)
+			batch = nr;
+
+		for (i = 0; i < batch; i++) {
+			void *data;
+
+			sqe = io_uring_get_sqe(ring);
+			data = sqe_index[lrand48() % nr];
+			io_uring_prep_poll_remove(sqe, data);
+		}
+
+		ret = io_uring_submit(ring);
+		if (ret != batch) {
+			fprintf(stderr, "%s: failed submit, %d\n", __FUNCTION__, ret);
+			return 1;
+		}
+		nr -= batch;
+		ret = reap_events(ring, 2 * batch, 0);
+	}
+	return 0;
+}
+
+static int add_polls(struct io_uring *ring, int fd, int nr)
+{
+	int pending, batch, i, count, ret;
+	struct io_uring_sqe *sqe;
+
+	pending = count = 0;
+	while (nr) {
+		batch = 1024;
+		if (batch > nr)
+			batch = nr;
+
+		for (i = 0; i < batch; i++) {
+			sqe = io_uring_get_sqe(ring);
+			io_uring_prep_poll_add(sqe, fd, POLLIN);
+			sqe_index[count++] = sqe;
+			sqe->user_data = (unsigned long) sqe;
+		}
+
+		ret = io_uring_submit(ring);
+		if (ret != batch) {
+			fprintf(stderr, "%s: failed submit, %d\n", __FUNCTION__, ret);
+			return 1;
+		}
+		nr -= batch;
+		pending += batch;
+		reap_events(ring, batch, 1);
+	}
+	return 0;
+}
+
+int main(int argc, char *argv[])
+{
+	struct io_uring ring;
+	struct io_uring_params p = { };
+	int pipe1[2];
+	int ret;
+
+	if (argc > 1)
+		return 0;
+
+	if (pipe(pipe1) != 0) {
+		perror("pipe");
+		return 1;
+	}
+
+	p.flags = IORING_SETUP_CQSIZE;
+	p.cq_entries = 16384;
+	ret = io_uring_queue_init_params(1024, &ring, &p);
+	if (ret) {
+		if (ret == -EINVAL) {
+			fprintf(stdout, "No CQSIZE, trying without\n");
+			ret = io_uring_queue_init(1024, &ring, 0);
+			if (ret) {
+				fprintf(stderr, "ring setup failed: %d\n", ret);
+				return 1;
+			}
+		}
+	}
+
+	add_polls(&ring, pipe1[0], 30000);
+#if 0
+	usleep(1000);
+#endif
+	del_polls(&ring, pipe1[0], 30000);
+
+	io_uring_queue_exit(&ring);
+	return 0;
+}

package/deps/liburing/liburing/test/poll-cancel.c

@@ -0,0 +1,135 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: test io_uring poll cancel handling
+ *
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <inttypes.h>
+#include <sys/poll.h>
+#include <sys/wait.h>
+#include <sys/signal.h>
+
+#include "liburing.h"
+
+struct poll_data {
+	unsigned is_poll;
+	unsigned is_cancel;
+};
+
+static void sig_alrm(int sig)
+{
+	fprintf(stderr, "Timed out!\n");
+	exit(1);
+}
+
+int main(int argc, char *argv[])
+{
+	struct io_uring ring;
+	int pipe1[2];
+	struct io_uring_cqe *cqe;
+	struct io_uring_sqe *sqe;
+	struct poll_data *pd, pds[2];
+	struct sigaction act;
+	int ret;
+
+	if (argc > 1)
+		return 0;
+
+	if (pipe(pipe1) != 0) {
+		perror("pipe");
+		return 1;
+	}
+
+	ret = io_uring_queue_init(2, &ring, 0);
+	if (ret) {
+		fprintf(stderr, "ring setup failed: %d\n", ret);
+		return 1;
+	}
+
+	memset(&act, 0, sizeof(act));
+	act.sa_handler = sig_alrm;
+	act.sa_flags = SA_RESTART;
+	sigaction(SIGALRM, &act, NULL);
+	alarm(1);
+
+	sqe = io_uring_get_sqe(&ring);
+	if (!sqe) {
+		fprintf(stderr, "get sqe failed\n");
+		return 1;
+	}
+
+	io_uring_prep_poll_add(sqe, pipe1[0], POLLIN);
+
+	pds[0].is_poll = 1;
+	pds[0].is_cancel = 0;
+	io_uring_sqe_set_data(sqe, &pds[0]);
+
+	ret = io_uring_submit(&ring);
+	if (ret <= 0) {
+		fprintf(stderr, "sqe submit failed\n");
+		return 1;
+	}
+
+	sqe = io_uring_get_sqe(&ring);
+	if (!sqe) {
+		fprintf(stderr, "get sqe failed\n");
+		return 1;
+	}
+
+	pds[1].is_poll = 0;
+	pds[1].is_cancel = 1;
+	io_uring_prep_poll_remove(sqe, &pds[0]);
+	io_uring_sqe_set_data(sqe, &pds[1]);
+
+	ret = io_uring_submit(&ring);
+	if (ret <= 0) {
+		fprintf(stderr, "sqe submit failed: %d\n", ret);
+		return 1;
+	}
+
+	ret = io_uring_wait_cqe(&ring, &cqe);
+	if (ret < 0) {
+		fprintf(stderr, "wait cqe failed: %d\n", ret);
+		return 1;
+	}
+
+	pd = io_uring_cqe_get_data(cqe);
+	if (pd->is_poll && cqe->res != -ECANCELED) {
+		fprintf(stderr ,"sqe (add=%d/remove=%d) failed with %ld\n",
+					pd->is_poll, pd->is_cancel,
+					(long) cqe->res);
+		return 1;
+	} else if (pd->is_cancel && cqe->res) {
+		fprintf(stderr, "sqe (add=%d/remove=%d) failed with %ld\n",
+					pd->is_poll, pd->is_cancel,
+					(long) cqe->res);
+		return 1;
+	}
+	io_uring_cqe_seen(&ring, cqe);
+
+	ret = io_uring_wait_cqe(&ring, &cqe);
+	if (ret < 0) {
+		fprintf(stderr, "wait_cqe: %d\n", ret);
+		return 1;
+	}
+
+	pd = io_uring_cqe_get_data(cqe);
+	if (pd->is_poll && cqe->res != -ECANCELED) {
+		fprintf(stderr, "sqe (add=%d/remove=%d) failed with %ld\n",
+					pd->is_poll, pd->is_cancel,
+					(long) cqe->res);
+		return 1;
+	} else if (pd->is_cancel && cqe->res) {
+		fprintf(stderr, "sqe (add=%d/remove=%d) failed with %ld\n",
+					pd->is_poll, pd->is_cancel,
+					(long) cqe->res);
+		return 1;
+	}
+
+	io_uring_cqe_seen(&ring, cqe);
+	return 0;
+}