@nxtedition/rocksdb 5.2.36 → 5.2.39

package/deps/liburing/liburing/test/a4c0b3decb33-test.c

@@ -0,0 +1,180 @@
+/* SPDX-License-Identifier: MIT */
+// autogenerated by syzkaller (https://github.com/google/syzkaller)
+
+#include <dirent.h>
+#include <endian.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/prctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <sys/mman.h>
+#include <time.h>
+#include <unistd.h>
+
+#include "liburing.h"
+#include "../src/syscall.h"
+
+static void sleep_ms(uint64_t ms)
+{
+	usleep(ms * 1000);
+}
+
+static uint64_t current_time_ms(void)
+{
+	struct timespec ts;
+	if (clock_gettime(CLOCK_MONOTONIC, &ts))
+		exit(1);
+	return (uint64_t)ts.tv_sec * 1000 + (uint64_t)ts.tv_nsec / 1000000;
+}
+
+static bool write_file(const char* file, const char* what, ...)
+{
+	char buf[1024];
+	va_list args;
+	va_start(args, what);
+	vsnprintf(buf, sizeof(buf), what, args);
+	va_end(args);
+	buf[sizeof(buf) - 1] = 0;
+	int len = strlen(buf);
+	int fd = open(file, O_WRONLY | O_CLOEXEC);
+	if (fd == -1)
+		return false;
+	if (write(fd, buf, len) != len) {
+		int err = errno;
+		close(fd);
+		errno = err;
+		return false;
+	}
+	close(fd);
+	return true;
+}
+
+static void kill_and_wait(int pid, int* status)
+{
+	kill(-pid, SIGKILL);
+	kill(pid, SIGKILL);
+	int i;
+	for (i = 0; i < 100; i++) {
+		if (waitpid(-1, status, WNOHANG | __WALL) == pid)
+			return;
+		usleep(1000);
+	}
+	DIR* dir = opendir("/sys/fs/fuse/connections");
+	if (dir) {
+		for (;;) {
+			struct dirent* ent = readdir(dir);
+			if (!ent)
+				break;
+			if (strcmp(ent->d_name, ".") == 0 || strcmp(ent->d_name, "..") == 0)
+				continue;
+			char abort[300];
+			snprintf(abort, sizeof(abort), "/sys/fs/fuse/connections/%s/abort",
+					ent->d_name);
+			int fd = open(abort, O_WRONLY);
+			if (fd == -1) {
+				continue;
+			}
+			if (write(fd, abort, 1) < 0) {
+			}
+			close(fd);
+		}
+		closedir(dir);
+	} else {
+	}
+	while (waitpid(-1, status, __WALL) != pid) {
+	}
+}
+
+static void setup_test()
+{
+	prctl(PR_SET_PDEATHSIG, SIGKILL, 0, 0, 0);
+	setpgrp();
+	write_file("/proc/self/oom_score_adj", "1000");
+}
+
+static void execute_one(void);
+
+#define WAIT_FLAGS __WALL
+
+static void loop(void)
+{
+	int iter;
+	for (iter = 0; iter < 5000; iter++) {
+		int pid = fork();
+		if (pid < 0)
+			exit(1);
+		if (pid == 0) {
+			setup_test();
+			execute_one();
+			exit(0);
+		}
+		int status = 0;
+		uint64_t start = current_time_ms();
+		for (;;) {
+			if (waitpid(-1, &status, WNOHANG | WAIT_FLAGS) == pid)
+				break;
+			sleep_ms(1);
+			if (current_time_ms() - start < 5 * 1000)
+				continue;
+			kill_and_wait(pid, &status);
+			break;
+		}
+	}
+}
+
+void execute_one(void)
+{
+	*(uint32_t*)0x20000080 = 0;
+	*(uint32_t*)0x20000084 = 0;
+	*(uint32_t*)0x20000088 = 3;
+	*(uint32_t*)0x2000008c = 3;
+	*(uint32_t*)0x20000090 = 0x175;
+	*(uint32_t*)0x20000094 = 0;
+	*(uint32_t*)0x20000098 = 0;
+	*(uint32_t*)0x2000009c = 0;
+	*(uint32_t*)0x200000a0 = 0;
+	*(uint32_t*)0x200000a4 = 0;
+	*(uint32_t*)0x200000a8 = 0;
+	*(uint32_t*)0x200000ac = 0;
+	*(uint32_t*)0x200000b0 = 0;
+	*(uint32_t*)0x200000b4 = 0;
+	*(uint32_t*)0x200000b8 = 0;
+	*(uint32_t*)0x200000bc = 0;
+	*(uint32_t*)0x200000c0 = 0;
+	*(uint32_t*)0x200000c4 = 0;
+	*(uint64_t*)0x200000c8 = 0;
+	*(uint32_t*)0x200000d0 = 0;
+	*(uint32_t*)0x200000d4 = 0;
+	*(uint32_t*)0x200000d8 = 0;
+	*(uint32_t*)0x200000dc = 0;
+	*(uint32_t*)0x200000e0 = 0;
+	*(uint32_t*)0x200000e4 = 0;
+	*(uint32_t*)0x200000e8 = 0;
+	*(uint32_t*)0x200000ec = 0;
+	*(uint64_t*)0x200000f0 = 0;
+	__sys_io_uring_setup(0x983, (struct io_uring_params *) 0x20000080);
+}
+
+static void sig_int(int sig)
+{
+	exit(0);
+}
+
+int main(int argc, char *argv[])
+{
+	if (argc > 1)
+		return 0;
+	signal(SIGINT, sig_int);
+	mmap((void *) 0x20000000, 0x1000000, 3, 0x32, -1, 0);
+	loop();
+	return 0;
+}

package/deps/liburing/liburing/test/accept-link.c

@@ -0,0 +1,251 @@
+/* SPDX-License-Identifier: MIT */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <assert.h>
+#include <pthread.h>
+#include <sys/socket.h>
+#include <netinet/tcp.h>
+#include <netinet/in.h>
+#include <poll.h>
+
+#include "liburing.h"
+
+pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+
+static int recv_thread_ready = 0;
+static int recv_thread_done = 0;
+
+static void signal_var(int *var)
+{
+        pthread_mutex_lock(&mutex);
+        *var = 1;
+        pthread_cond_signal(&cond);
+        pthread_mutex_unlock(&mutex);
+}
+
+static void wait_for_var(int *var)
+{
+        pthread_mutex_lock(&mutex);
+
+        while (!*var)
+                pthread_cond_wait(&cond, &mutex);
+
+        pthread_mutex_unlock(&mutex);
+}
+
+struct data {
+	unsigned expected[2];
+	unsigned just_positive[2];
+	unsigned long timeout;
+	int port;
+	int stop;
+};
+
+static void *send_thread(void *arg)
+{
+	struct data *data = arg;
+	int ret;
+
+	wait_for_var(&recv_thread_ready);
+
+	if (data->stop)
+		return NULL;
+
+	int s0 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+	assert(s0 != -1);
+
+	struct sockaddr_in addr;
+
+	addr.sin_family = AF_INET;
+	addr.sin_port = data->port;
+	addr.sin_addr.s_addr = 0x0100007fU;
+
+	ret = connect(s0, (struct sockaddr*)&addr, sizeof(addr));
+	assert(ret != -1);
+
+	wait_for_var(&recv_thread_done);
+
+	close(s0);
+	return NULL;
+}
+
+void *recv_thread(void *arg)
+{
+	struct data *data = arg;
+	struct io_uring ring;
+	int i, ret;
+
+	ret = io_uring_queue_init(8, &ring, 0);
+	assert(ret == 0);
+
+	int s0 = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
+	assert(s0 != -1);
+
+	int32_t val = 1;
+	ret = setsockopt(s0, SOL_SOCKET, SO_REUSEPORT, &val, sizeof(val));
+	assert(ret != -1);
+	ret = setsockopt(s0, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val));
+	assert(ret != -1);
+
+	struct sockaddr_in addr;
+
+	addr.sin_family = AF_INET;
+	addr.sin_addr.s_addr = 0x0100007fU;
+
+	i = 0;
+	do {
+		data->port = 1025 + (rand() % 64510);
+		addr.sin_port = data->port;
+
+		if (bind(s0, (struct sockaddr*)&addr, sizeof(addr)) != -1)
+			break;
+	} while (++i < 100);
+
+	if (i >= 100) {
+		printf("Can't find good port, skipped\n");
+		data->stop = 1;
+		signal_var(&recv_thread_ready);
+		goto out;
+	}
+
+	ret = listen(s0, 128);
+	assert(ret != -1);
+
+	signal_var(&recv_thread_ready);
+
+	struct io_uring_sqe *sqe;
+
+	sqe = io_uring_get_sqe(&ring);
+	assert(sqe != NULL);
+
+	io_uring_prep_accept(sqe, s0, NULL, NULL, 0);
+	sqe->flags |= IOSQE_IO_LINK;
+	sqe->user_data = 1;
+
+	sqe = io_uring_get_sqe(&ring);
+	assert(sqe != NULL);
+
+	struct __kernel_timespec ts;
+	ts.tv_sec = data->timeout / 1000000000;
+	ts.tv_nsec = data->timeout % 1000000000;
+	io_uring_prep_link_timeout(sqe, &ts, 0);
+	sqe->user_data = 2;
+
+	ret = io_uring_submit(&ring);
+	assert(ret == 2);
+
+	for (i = 0; i < 2; i++) {
+		struct io_uring_cqe *cqe;
+		int idx;
+
+		if (io_uring_wait_cqe(&ring, &cqe)) {
+			fprintf(stderr, "wait cqe failed\n");
+			goto err;
+		}
+		idx = cqe->user_data - 1;
+		if (cqe->res != data->expected[idx]) {
+			if (cqe->res > 0 && data->just_positive[idx])
+				goto ok;
+			if (cqe->res == -EBADF) {
+				fprintf(stdout, "Accept not supported, skipping\n");
+				data->stop = 1;
+				goto out;
+			}
+			fprintf(stderr, "cqe %" PRIu64 " got %d, wanted %d\n",
+					(uint64_t) cqe->user_data, cqe->res,
+					data->expected[idx]);
+			goto err;
+		}
+ok:
+		if (cqe->user_data == 1 && cqe->res > 0)
+			close(cqe->res);
+
+		io_uring_cqe_seen(&ring, cqe);
+	}
+
+	signal_var(&recv_thread_done);
+
+out:
+	close(s0);
+	return NULL;
+err:
+	close(s0);
+	return (void *) 1;
+}
+
+static int test_accept_timeout(int do_connect, unsigned long timeout)
+{
+	struct io_uring ring;
+	struct io_uring_params p = {};
+	pthread_t t1, t2;
+	struct data d;
+	void *tret;
+	int ret, fast_poll;
+
+	ret = io_uring_queue_init_params(1, &ring, &p);
+	if (ret) {
+		fprintf(stderr, "queue_init: %d\n", ret);
+		return 1;
+	};
+
+	fast_poll = (p.features & IORING_FEAT_FAST_POLL) != 0;
+	io_uring_queue_exit(&ring);
+
+	recv_thread_ready = 0;
+	recv_thread_done = 0;
+
+	memset(&d, 0, sizeof(d));
+	d.timeout = timeout;
+	if (!do_connect) {
+		if (fast_poll) {
+			d.expected[0] = -ECANCELED;
+			d.expected[1] = -ETIME;
+		} else {
+			d.expected[0] = -EINTR;
+			d.expected[1] = -EALREADY;
+		}
+	} else {
+		d.expected[0] = -1U;
+		d.just_positive[0] = 1;
+		d.expected[1] = -ECANCELED;
+	}
+
+	pthread_create(&t1, NULL, recv_thread, &d);
+
+	if (do_connect)
+		pthread_create(&t2, NULL, send_thread, &d);
+
+	pthread_join(t1, &tret);
+	if (tret)
+		ret++;
+
+	if (do_connect) {
+		pthread_join(t2, &tret);
+		if (tret)
+			ret++;
+	}
+
+	return ret;
+}
+
+int main(int argc, char *argv[])
+{
+	if (argc > 1)
+		return 0;
+	if (test_accept_timeout(0, 200000000)) {
+		fprintf(stderr, "accept timeout 0 failed\n");
+		return 1;
+	}
+
+	if (test_accept_timeout(1, 1000000000)) {
+		fprintf(stderr, "accept and connect timeout 0 failed\n");
+		return 1;
+	}
+
+	return 0;
+}

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

@@ -0,0 +1,164 @@
+/* SPDX-License-Identifier: MIT */
+#include <liburing.h>
+#include <netdb.h>
+#include <string.h>
+#include <sys/socket.h>
+#include <sys/types.h>
+#include <unistd.h>
+#include <stdio.h>
+#include <errno.h>
+#include "liburing.h"
+#include "../src/syscall.h"
+
+struct io_uring io_uring;
+
+int sys_io_uring_enter(const int fd,
+		       const unsigned to_submit,
+		       const unsigned min_complete,
+		       const unsigned flags, sigset_t * const sig)
+{
+	return __sys_io_uring_enter(fd, to_submit, min_complete, flags, sig);
+}
+
+int submit_sqe(void)
+{
+	struct io_uring_sq *sq = &io_uring.sq;
+	const unsigned tail = *sq->ktail;
+
+	sq->array[tail & *sq->kring_mask] = 0;
+	io_uring_smp_store_release(sq->ktail, tail + 1);
+
+	return sys_io_uring_enter(io_uring.ring_fd, 1, 0, 0, NULL);
+}
+
+int main(int argc, char **argv)
+{
+	struct addrinfo *addr_info_list = NULL;
+	struct addrinfo *ai, *addr_info = NULL;
+	struct io_uring_params params;
+	struct io_uring_sqe *sqe;
+	struct addrinfo hints;
+	struct sockaddr sa;
+	socklen_t sa_size = sizeof(sa);
+	int ret, listen_fd, connect_fd, val, i;
+
+	if (argc > 1)
+		return 0;
+
+	memset(&params, 0, sizeof(params));
+	ret = io_uring_queue_init_params(4, &io_uring, &params);
+	if (ret) {
+		fprintf(stderr, "io_uring_init_failed: %d\n", ret);
+		return 1;
+	}
+	if (!(params.features & IORING_FEAT_SUBMIT_STABLE)) {
+		fprintf(stdout, "FEAT_SUBMIT_STABLE not there, skipping\n");
+		return 0;
+	}
+
+	memset(&hints, 0, sizeof(hints));
+	hints.ai_family = AF_UNSPEC;
+	hints.ai_socktype = SOCK_STREAM;
+	hints.ai_flags = AI_PASSIVE | AI_NUMERICSERV;
+
+	ret = getaddrinfo(NULL, "12345", &hints, &addr_info_list);
+	if (ret < 0) {
+		perror("getaddrinfo");
+		return 1;
+	}
+
+	for (ai = addr_info_list; ai; ai = ai->ai_next) {
+		if (ai->ai_family == AF_INET || ai->ai_family == AF_INET6) {
+			addr_info = ai;
+			break;
+		}
+	}
+	if (!addr_info) {
+		fprintf(stderr, "addrinfo not found\n");
+		return 1;
+	}
+
+	sqe = &io_uring.sq.sqes[0];
+	listen_fd = -1;
+
+	ret = socket(addr_info->ai_family, SOCK_STREAM,
+			   addr_info->ai_protocol);
+	if (ret < 0) {
+		perror("socket");
+		return 1;
+	}
+	listen_fd = ret;
+
+	val = 1;
+	setsockopt(listen_fd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(int));
+	setsockopt(listen_fd, SOL_SOCKET, SO_REUSEPORT, &val, sizeof(int));
+
+	ret = bind(listen_fd, addr_info->ai_addr, addr_info->ai_addrlen);
+	if (ret < 0) {
+		perror("bind");
+		return 1;
+	}
+
+	ret = listen(listen_fd, SOMAXCONN);
+	if (ret < 0) {
+		perror("listen");
+		return 1;
+	}
+
+	memset(&sa, 0, sizeof(sa));
+
+	io_uring_prep_accept(sqe, listen_fd, &sa, &sa_size, 0);
+	sqe->user_data = 1;
+	ret = submit_sqe();
+	if (ret != 1) {
+		fprintf(stderr, "submit failed: %d\n", ret);
+		return 1;
+	}
+
+	connect_fd = -1;
+	ret = socket(addr_info->ai_family, SOCK_STREAM, addr_info->ai_protocol);
+	if (ret < 0) {
+		perror("socket");
+		return 1;
+	}
+	connect_fd = ret;
+
+	io_uring_prep_connect(sqe, connect_fd, addr_info->ai_addr,
+				addr_info->ai_addrlen);
+	sqe->user_data = 2;
+	ret = submit_sqe();
+	if (ret != 1) {
+		fprintf(stderr, "submit failed: %d\n", ret);
+		return 1;
+	}
+
+	for (i = 0; i < 2; i++) {
+		struct io_uring_cqe *cqe = NULL;
+
+		ret = io_uring_wait_cqe(&io_uring, &cqe);
+		if (ret) {
+			fprintf(stderr, "io_uring_wait_cqe: %d\n", ret);
+			return 1;
+		}
+
+		switch (cqe->user_data) {
+		case 1:
+			if (cqe->res < 0) {
+				fprintf(stderr, "accept failed: %d\n", cqe->res);
+				return 1;
+			}
+			break;
+		case 2:
+			if (cqe->res) {
+				fprintf(stderr, "connect failed: %d\n", cqe->res);
+				return 1;
+			}
+			break;
+		}
+		io_uring_cq_advance(&io_uring, 1);
+	}
+
+	freeaddrinfo(addr_info_list);
+	io_uring_queue_exit(&io_uring);
+	return 0;
+}

package/deps/liburing/liburing/test/accept-test.c

@@ -0,0 +1,79 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: Check to see if accept handles addr and addrlen
+ */
+#include <stdio.h>
+#include <errno.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <assert.h>
+#include "liburing.h"
+
+int main(int argc, char *argv[])
+{
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	struct io_uring ring;
+	struct sockaddr_un addr;
+	socklen_t addrlen = sizeof(addr);
+	int ret, fd;
+	struct __kernel_timespec ts = {
+		.tv_sec = 0,
+		.tv_nsec = 1000000
+	};
+
+	if (argc > 1)
+		return 0;
+
+	if (io_uring_queue_init(4, &ring, 0) != 0) {
+		fprintf(stderr, "ring setup failed\n");
+		return 1;
+	}
+
+	fd = socket(AF_UNIX, SOCK_STREAM, 0);
+	assert(fd != -1);
+
+	memset(&addr, 0, sizeof(addr));
+	addr.sun_family = AF_UNIX;
+	memcpy(addr.sun_path, "\0sock", 6);
+
+	ret = bind(fd, (struct sockaddr *)&addr, addrlen);
+	assert(ret != -1);
+	ret = listen(fd, 128);
+	assert(ret != -1);
+
+	sqe = io_uring_get_sqe(&ring);
+	if (!sqe) {
+		fprintf(stderr, "get sqe failed\n");
+		return 1;
+	}
+	io_uring_prep_accept(sqe, fd, (struct sockaddr*)&addr, &addrlen, 0);
+	sqe->user_data = 1;
+
+	ret = io_uring_submit(&ring);
+	if (ret != 1) {
+		fprintf(stderr, "Got submit %d, expected 1\n", ret);
+		return 1;
+	}
+
+	ret = io_uring_wait_cqe_timeout(&ring, &cqe, &ts);
+	if (!ret) {
+		if (cqe->res == -EBADF || cqe->res == -EINVAL) {
+			fprintf(stdout, "Accept not supported, skipping\n");
+			goto out;
+		} else if (cqe->res < 0) {
+			fprintf(stderr, "cqe error %d\n", cqe->res);
+			goto err;
+		}
+	} else if (ret != -ETIME) {
+		fprintf(stderr, "accept() failed to use addr & addrlen parameters!\n");
+		return 1;
+	}
+
+out:
+	io_uring_queue_exit(&ring);
+	return 0;
+err:
+	io_uring_queue_exit(&ring);
+	return 1;
+}