@nxtedition/rocksdb 5.2.36 → 5.2.39

package/deps/liburing/liburing/test/500f9fbadef8-test.c

@@ -0,0 +1,89 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: Single depth submit+wait poll hang test
+ *
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+
+#include "helpers.h"
+#include "liburing.h"
+
+#define BLOCKS	4096
+
+int main(int argc, char *argv[])
+{
+	struct io_uring ring;
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	struct iovec iov;
+	char buf[32];
+	off_t offset;
+	unsigned blocks;
+	int ret, fd;
+
+	if (argc > 1)
+		return 0;
+
+	t_posix_memalign(&iov.iov_base, 4096, 4096);
+	iov.iov_len = 4096;
+
+	ret = io_uring_queue_init(1, &ring, IORING_SETUP_IOPOLL);
+	if (ret) {
+		fprintf(stderr, "ring setup failed\n");
+		return 1;
+
+	}
+
+	sprintf(buf, "./XXXXXX");
+	fd = mkostemp(buf, O_WRONLY | O_DIRECT | O_CREAT);
+	if (fd < 0) {
+		perror("mkostemp");
+		return 1;
+	}
+
+	offset = 0;
+	blocks = BLOCKS;
+	do {
+		sqe = io_uring_get_sqe(&ring);
+		if (!sqe) {
+			fprintf(stderr, "get sqe failed\n");
+			goto err;
+		}
+		io_uring_prep_writev(sqe, fd, &iov, 1, offset);
+		ret = io_uring_submit_and_wait(&ring, 1);
+		if (ret < 0) {
+			fprintf(stderr, "submit_and_wait: %d\n", ret);
+			goto err;
+		}
+		ret = io_uring_wait_cqe(&ring, &cqe);
+		if (ret < 0) {
+			fprintf(stderr, "wait completion: %d\n", ret);
+			goto err;
+		}
+		if (cqe->res != 4096) {
+			if (cqe->res == -EOPNOTSUPP)
+				goto skipped;
+			goto err;
+		}
+		io_uring_cqe_seen(&ring, cqe);
+		offset += 4096;
+	} while (--blocks);
+		
+	close(fd);
+	unlink(buf);
+	return 0;
+err:
+	close(fd);
+	unlink(buf);
+	return 1;
+skipped:
+	fprintf(stderr, "Polling not supported in current dir, test skipped\n");
+	close(fd);
+	unlink(buf);
+	return 0;
+}

package/deps/liburing/liburing/test/7ad0e4b2f83c-test.c

@@ -0,0 +1,93 @@
+/* SPDX-License-Identifier: MIT */
+#include <stdio.h>
+#include <time.h>
+#include <sys/time.h>
+#include "liburing.h"
+
+static unsigned long long mtime_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 *= 1000;
+	usec /= 1000;
+	return sec + usec;
+}
+
+static unsigned long long mtime_since_now(struct timeval *tv)
+{
+	struct timeval end;
+
+	gettimeofday(&end, NULL);
+	return mtime_since(tv, &end);
+}
+
+int main(int argc, char *argv[])
+{
+	struct __kernel_timespec ts1, ts2;
+	struct io_uring_cqe *cqe;
+	struct io_uring_sqe *sqe;
+	struct io_uring ring;
+	unsigned long msec;
+	struct timeval tv;
+	int ret;
+
+	if (argc > 1)
+		return 0;
+
+	ret = io_uring_queue_init(32, &ring, 0);
+	if (ret) {
+		fprintf(stderr, "io_uring_queue_init=%d\n", ret);
+		return 1;
+	}
+
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_nop(sqe);
+	ret = io_uring_submit(&ring);
+	if (ret != 1) {
+		fprintf(stderr, "io_uring_submit1=%d\n", ret);
+		return 1;
+	}
+
+
+	ts1.tv_sec = 5,
+	ts1.tv_nsec = 0;
+	ret = io_uring_wait_cqe_timeout(&ring, &cqe, &ts1);
+	if (ret) {
+		fprintf(stderr, "io_uring_wait_cqe_timeout=%d\n", ret);
+		return 1;
+	}
+	io_uring_cqe_seen(&ring, cqe);
+	gettimeofday(&tv, NULL);
+
+	ts2.tv_sec = 1;
+	ts2.tv_nsec = 0;
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_timeout(sqe, &ts2, 0, 0);
+	sqe->user_data = 89;
+	ret = io_uring_submit(&ring);
+	if (ret != 1) {
+		fprintf(stderr, "io_uring_submit2=%d\n", ret);
+		return 1;
+	}
+
+	io_uring_wait_cqe(&ring, &cqe);
+	io_uring_cqe_seen(&ring, cqe);
+	msec = mtime_since_now(&tv);
+	if (msec >= 900 && msec <= 1100) {
+		io_uring_queue_exit(&ring);
+		return 0;
+	}
+
+	fprintf(stderr, "%s: Timeout seems wonky (got %lu)\n", __FUNCTION__,
+								msec);
+	io_uring_queue_exit(&ring);
+	return 1;
+}

package/deps/liburing/liburing/test/8a9973408177-test.c

@@ -0,0 +1,106 @@
+/* SPDX-License-Identifier: MIT */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+
+#include "liburing.h"
+
+static int register_file(struct io_uring *ring)
+{
+	char buf[32];
+	int ret, fd;
+
+	sprintf(buf, "./XXXXXX");
+	fd = mkstemp(buf);
+	if (fd < 0) {
+		perror("open");
+		return 1;
+	}
+
+	ret = io_uring_register_files(ring, &fd, 1);
+	if (ret) {
+		fprintf(stderr, "file register %d\n", ret);
+		return 1;
+	}
+
+	ret = io_uring_unregister_files(ring);
+	if (ret) {
+		fprintf(stderr, "file register %d\n", ret);
+		return 1;
+	}
+
+	unlink(buf);
+	close(fd);
+	return 0;
+}
+
+static int test_single_fsync(struct io_uring *ring)
+{
+	struct io_uring_cqe *cqe;
+	struct io_uring_sqe *sqe;
+	char buf[32];
+	int fd, ret;
+
+	sprintf(buf, "./XXXXXX");
+	fd = mkstemp(buf);
+	if (fd < 0) {
+		perror("open");
+		return 1;
+	}
+
+	sqe = io_uring_get_sqe(ring);
+	if (!sqe) {
+		printf("get sqe failed\n");
+		goto err;
+	}
+
+	io_uring_prep_fsync(sqe, fd, 0);
+
+	ret = io_uring_submit(ring);
+	if (ret <= 0) {
+		printf("sqe submit failed: %d\n", ret);
+		goto err;
+	}
+
+	ret = io_uring_wait_cqe(ring, &cqe);
+	if (ret < 0) {
+		printf("wait completion %d\n", ret);
+		goto err;
+	}
+
+	io_uring_cqe_seen(ring, cqe);
+	unlink(buf);
+	return 0;
+err:
+	unlink(buf);
+	return 1;
+}
+
+int main(int argc, char *argv[])
+{
+	struct io_uring ring;
+	int ret;
+
+	if (argc > 1)
+		return 0;
+
+	ret = io_uring_queue_init(8, &ring, 0);
+	if (ret) {
+		printf("ring setup failed\n");
+		return 1;
+	}
+
+	ret = register_file(&ring);
+	if (ret)
+		return ret;
+	ret = test_single_fsync(&ring);
+	if (ret) {
+		printf("test_single_fsync failed\n");
+		return ret;
+	}
+
+	return 0;
+}

package/deps/liburing/liburing/test/917257daa0fe-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*)0x20000000 = 0;
+  *(uint32_t*)0x20000004 = 0;
+  *(uint32_t*)0x20000008 = 6;
+  *(uint32_t*)0x2000000c = 0;
+  *(uint32_t*)0x20000010 = 0x3af;
+  *(uint32_t*)0x20000014 = 0;
+  *(uint32_t*)0x20000018 = 0;
+  *(uint32_t*)0x2000001c = 0;
+  *(uint32_t*)0x20000020 = 0;
+  *(uint32_t*)0x20000024 = 0;
+  *(uint32_t*)0x20000028 = 0;
+  *(uint32_t*)0x2000002c = 0;
+  *(uint32_t*)0x20000030 = 0;
+  *(uint32_t*)0x20000034 = 0;
+  *(uint32_t*)0x20000038 = 0;
+  *(uint32_t*)0x2000003c = 0;
+  *(uint32_t*)0x20000040 = 0;
+  *(uint32_t*)0x20000044 = 0;
+  *(uint64_t*)0x20000048 = 0;
+  *(uint32_t*)0x20000050 = 0;
+  *(uint32_t*)0x20000054 = 0;
+  *(uint32_t*)0x20000058 = 0;
+  *(uint32_t*)0x2000005c = 0;
+  *(uint32_t*)0x20000060 = 0;
+  *(uint32_t*)0x20000064 = 0;
+  *(uint32_t*)0x20000068 = 0;
+  *(uint32_t*)0x2000006c = 0;
+  *(uint64_t*)0x20000070 = 0;
+  __sys_io_uring_setup(0x7a6, (struct io_uring_params *) 0x20000000UL);
+  return 0;
+}

package/deps/liburing/liburing/test/Makefile

@@ -0,0 +1,312 @@
+prefix ?= /usr
+datadir ?= $(prefix)/share
+
+INSTALL=install
+
+ifneq ($(MAKECMDGOALS),clean)
+include ../config-host.mak
+endif
+
+CPPFLAGS ?=
+override CPPFLAGS += -D_GNU_SOURCE -D__SANE_USERSPACE_TYPES__ \
+	-I../src/include/ -include ../config-host.h
+CFLAGS ?= -g -O2
+XCFLAGS =
+override CFLAGS += -D_GNU_SOURCE \
+	-Wall -Wextra -Wno-unused-parameter -Wno-sign-compare \
+	-L../src/
+
+ifdef CONFIG_HAVE_STRINGOP_OVERFLOW
+  XCFLAGS += -Wstringop-overflow=0
+endif
+ifdef CONFIG_HAVE_ARRAY_BOUNDS
+  XCFLAGS += -Warray-bounds=0
+endif
+
+CXXFLAGS ?=
+override CXXFLAGS += $(CFLAGS) -std=c++11
+
+test_targets += \
+	232c93d07b74-test \
+	35fa71a030ca-test \
+	500f9fbadef8-test \
+	7ad0e4b2f83c-test \
+	8a9973408177-test \
+	917257daa0fe-test \
+	a0908ae19763-test \
+	a4c0b3decb33-test \
+	accept \
+	accept-link \
+	accept-reuse \
+	accept-test \
+	across-fork splice \
+	b19062a56726-test \
+	b5837bd5311d-test \
+	ce593a6c480a-test \
+	close-opath \
+	connect \
+	cq-full \
+	cq-overflow \
+	cq-peek-batch \
+	cq-ready \
+	cq-size \
+	d4ae271dfaae-test \
+	d77a67ed5f27-test \
+	defer \
+	double-poll-crash \
+	eeed8b54e0df-test \
+	empty-eownerdead \
+	eventfd \
+	eventfd-disable \
+	eventfd-ring \
+	fadvise \
+	fallocate \
+	fc2a85cb02ef-test \
+	file-register \
+	file-update \
+	files-exit-hang-poll \
+	files-exit-hang-timeout \
+	fixed-link \
+	fsync \
+	hardlink \
+	io-cancel \
+	io_uring_enter \
+	io_uring_register \
+	io_uring_setup \
+	iopoll \
+	lfs-openat \
+	lfs-openat-write \
+	link \
+	link-timeout \
+	link_drain \
+	madvise \
+	mkdir \
+	multicqes_drain \
+	nop \
+	nop-all-sizes \
+	open-close \
+	openat2 \
+	personality \
+	pipe-eof \
+	pipe-reuse \
+	poll \
+	poll-cancel \
+	poll-cancel-ton \
+	poll-link \
+	poll-many \
+	poll-mshot-update \
+	poll-ring \
+	poll-v-poll \
+	probe \
+	read-write \
+	register-restrictions \
+	rename \
+	ring-leak \
+	ring-leak2 \
+	rw_merge_test \
+	self \
+	send_recv \
+	send_recvmsg \
+	shared-wq \
+	short-read \
+	shutdown \
+	sigfd-deadlock \
+	socket-rw \
+	socket-rw-eagain \
+	sq-full \
+	sq-poll-dup \
+	sq-poll-kthread \
+	sq-poll-share \
+	sqpoll-disable-exit \
+	sqpoll-exit-hang \
+	sqpoll-cancel-hang \
+	sqpoll-sleep \
+	sq-space_left \
+	stdout \
+	submit-reuse \
+	submit-link-fail \
+	symlink \
+	teardowns \
+	thread-exit \
+	timeout \
+	timeout-new \
+	timeout-overflow \
+	unlink \
+	wakeup-hang \
+	sendmsg_fs_cve \
+	rsrc_tags \
+	# EOL
+
+all_targets += $(test_targets)
+
+include ../Makefile.quiet
+
+ifdef CONFIG_HAVE_STATX
+test_targets += statx
+endif
+all_targets += statx
+
+ifdef CONFIG_HAVE_CXX
+test_targets += sq-full-cpp
+endif
+all_targets += sq-full-cpp
+
+helpers = helpers.o
+
+all: ${helpers} $(test_targets)
+
+helpers.o: helpers.c helpers.c
+	$(QUIET_CC)$(CC) $(CPPFLAGS) $(CFLAGS) -o $@ -c $< -luring
+
+%: %.c ${helpers} helpers.h
+	$(QUIET_CC)$(CC) $(CPPFLAGS) $(CFLAGS) -o $@ $< ${helpers} -luring $(XCFLAGS)
+
+%: %.cc ${helpers} helpers.h
+	$(QUIET_CXX)$(CXX) $(CPPFLAGS) $(CXXFLAGS) -o $@ $< ${helpers} -luring $(XCFLAGS)
+
+test_srcs := \
+	helpers.c \
+	232c93d07b74-test.c \
+	35fa71a030ca-test.c \
+	500f9fbadef8-test.c \
+	7ad0e4b2f83c-test.c \
+	8a9973408177-test.c \
+	917257daa0fe-test.c \
+	a0908ae19763-test.c \
+	a4c0b3decb33-test.c \
+	accept-link.c \
+	accept-reuse.c \
+	accept-test.c \
+	accept.c \
+	across-fork.c \
+	b19062a56726-test.c \
+	b5837bd5311d-test.c \
+	ce593a6c480a-test.c \
+	close-opath.c \
+	connect.c \
+	cq-full.c \
+	cq-overflow.c \
+	cq-peek-batch.c \
+	cq-ready.c\
+	cq-size.c \
+	d4ae271dfaae-test.c \
+	d77a67ed5f27-test.c \
+	defer.c \
+	double-poll-crash.c \
+	eeed8b54e0df-test.c \
+	empty-eownerdead.c \
+	eventfd-disable.c \
+	eventfd-ring.c \
+	eventfd.c \
+	fadvise.c \
+	fallocate.c \
+	fc2a85cb02ef-test.c \
+	file-register.c \
+	file-update.c \
+	files-exit-hang-poll.c \
+	files-exit-hang-timeout.c \
+	fixed-link.c \
+	fsync.c \
+	hardlink.c \
+	io-cancel.c \
+	io_uring_enter.c \
+	io_uring_register.c \
+	io_uring_setup.c \
+	iopoll.c \
+	lfs-openat-write.c \
+	lfs-openat.c \
+	link-timeout.c \
+	link.c \
+	link_drain.c \
+	madvise.c \
+	mkdir.c \
+	multicqes_drain.c \
+	nop-all-sizes.c \
+	nop.c \
+	open-close.c \
+	openat2.c \
+	personality.c \
+	pipe-eof.c \
+	pipe-reuse.c \
+	poll-cancel-ton.c \
+	poll-cancel.c \
+	poll-link.c \
+	poll-many.c \
+	poll-mshot-update.c \
+	poll-ring.c \
+	poll-v-poll.c \
+	poll.c \
+	probe.c \
+	read-write.c \
+	register-restrictions.c \
+	rename.c \
+	ring-leak.c \
+	ring-leak2.c \
+	rw_merge_test.c \
+	self.c \
+	send_recvmsg.c \
+	shared-wq.c \
+	short-read.c \
+	shutdown.c \
+	sigfd-deadlock.c \
+	socket-rw.c \
+	socket-rw-eagain.c \
+	splice.c \
+	sq-full-cpp.cc \
+	sq-full.c \
+	sq-poll-dup.c \
+	sq-poll-kthread.c \
+	sq-poll-share.c \
+	sqpoll-disable-exit.c \
+	sqpoll-exit-hang.c \
+	sqpoll-cancel-hang.c \
+	sqpoll-sleep.c \
+	sq-space_left.c \
+	statx.c \
+	stdout.c \
+	submit-reuse.c \
+	submit-link-fail.c \
+	symlink.c \
+	teardowns.c \
+	thread-exit.c \
+	timeout-new.c \
+	timeout-overflow.c \
+	timeout.c \
+	unlink.c \
+	wakeup-hang.c \
+	sendmsg_fs_cve.c \
+	rsrc_tags.c \
+	# EOL
+
+test_objs := $(patsubst %.c,%.ol,$(patsubst %.cc,%.ol,$(test_srcs)))
+
+35fa71a030ca-test: XCFLAGS = -lpthread
+232c93d07b74-test: XCFLAGS = -lpthread
+send_recv: XCFLAGS = -lpthread
+send_recvmsg: XCFLAGS = -lpthread
+poll-link: XCFLAGS = -lpthread
+accept-link: XCFLAGS = -lpthread
+submit-reuse: XCFLAGS = -lpthread
+poll-v-poll: XCFLAGS = -lpthread
+across-fork: XCFLAGS = -lpthread
+ce593a6c480a-test: XCFLAGS = -lpthread
+wakeup-hang: XCFLAGS = -lpthread
+pipe-eof: XCFLAGS = -lpthread
+timeout-new: XCFLAGS = -lpthread
+thread-exit: XCFLAGS = -lpthread
+ring-leak2: XCFLAGS = -lpthread
+poll-mshot-update: XCFLAGS = -lpthread
+
+install: $(test_targets) runtests.sh runtests-loop.sh
+	$(INSTALL) -D -d -m 755 $(datadir)/liburing-test/
+	$(INSTALL) -D -m 755 $(test_targets) $(datadir)/liburing-test/
+	$(INSTALL) -D -m 755 runtests.sh  $(datadir)/liburing-test/
+	$(INSTALL) -D -m 755 runtests-loop.sh  $(datadir)/liburing-test/
+clean:
+	@rm -f $(all_targets) $(test_objs) helpers.o output/*
+	@rm -rf output/
+
+runtests: all
+	@./runtests.sh $(test_targets)
+runtests-loop: all
+	@./runtests-loop.sh $(test_targets)

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

@@ -0,0 +1,58 @@
+/* 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"
+
+uint64_t r[1] = {0xffffffffffffffff};
+
+int main(int argc, char *argv[])
+{
+  if (argc > 1)
+    return 0;
+  mmap((void *) 0x20000000, 0x1000000, 3, 0x32, -1, 0);
+  intptr_t res = 0;
+  *(uint32_t*)0x20000080 = 0;
+  *(uint32_t*)0x20000084 = 0;
+  *(uint32_t*)0x20000088 = 0;
+  *(uint32_t*)0x2000008c = 0;
+  *(uint32_t*)0x20000090 = 0;
+  *(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;
+  res = __sys_io_uring_setup(0xa4, (struct io_uring_params *) 0x20000080);
+  if (res != -1)
+    r[0] = res;
+  *(uint32_t*)0x20000280 = -1;
+  __sys_io_uring_register(r[0], 2, (const void *) 0x20000280, 1);
+  return 0;
+}