iou 0.1

data/vendor/liburing/test/500f9fbadef8.c

@@ -0,0 +1,91 @@
+/* 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 T_EXIT_SKIP;
+
+	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 T_EXIT_FAIL;
+
+	}
+
+	sprintf(buf, "./XXXXXX");
+	fd = mkostemp(buf, O_WRONLY | O_DIRECT | O_CREAT);
+	if (fd < 0) {
+		if (errno == EINVAL)
+			return T_EXIT_SKIP;
+		perror("mkostemp");
+		return T_EXIT_FAIL;
+	}
+
+	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 T_EXIT_PASS;
+err:
+	close(fd);
+	unlink(buf);
+	return T_EXIT_FAIL;
+skipped:
+	fprintf(stderr, "Polling not supported in current dir, test skipped\n");
+	close(fd);
+	unlink(buf);
+	return T_EXIT_SKIP;
+}

data/vendor/liburing/test/7ad0e4b2f83c.c

@@ -0,0 +1,94 @@
+/* SPDX-License-Identifier: MIT */
+#include <stdio.h>
+#include <time.h>
+#include <sys/time.h>
+#include "liburing.h"
+#include "helpers.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 T_EXIT_SKIP;
+
+	ret = io_uring_queue_init(32, &ring, 0);
+	if (ret) {
+		fprintf(stderr, "io_uring_queue_init=%d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	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 T_EXIT_FAIL;
+	}
+
+
+	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 T_EXIT_FAIL;
+	}
+	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 T_EXIT_FAIL;
+	}
+
+	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 T_EXIT_PASS;
+	}
+
+	fprintf(stderr, "%s: Timeout seems wonky (got %lu)\n", __FUNCTION__,
+								msec);
+	io_uring_queue_exit(&ring);
+	return T_EXIT_FAIL;
+}

data/vendor/liburing/test/8a9973408177.c

@@ -0,0 +1,107 @@
+/* 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"
+#include "helpers.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 T_EXIT_SKIP;
+
+	ret = io_uring_queue_init(8, &ring, 0);
+	if (ret) {
+		printf("ring setup failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	ret = register_file(&ring);
+	if (ret)
+		return ret;
+	ret = test_single_fsync(&ring);
+	if (ret) {
+		printf("test_single_fsync failed\n");
+		return ret;
+	}
+
+	return T_EXIT_PASS;
+}

data/vendor/liburing/test/917257daa0fe.c

@@ -0,0 +1,54 @@
+/* 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 "helpers.h"
+#include "../src/syscall.h"
+
+int main(int argc, char *argv[])
+{
+  if (argc > 1)
+    return T_EXIT_SKIP;
+
+  mmap((void *) 0x20000000, 0x1000000, 3, MAP_ANON|MAP_PRIVATE, -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 T_EXIT_PASS;
+}

data/vendor/liburing/test/Makefile

@@ -0,0 +1,297 @@
+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 \
+	-D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64
+
+CFLAGS ?= -g -O3 -Wall -Wextra
+XCFLAGS = -Wno-unused-parameter -Wno-sign-compare
+
+ifdef CONFIG_HAVE_STRINGOP_OVERFLOW
+	XCFLAGS += -Wstringop-overflow=0
+endif
+
+ifdef CONFIG_HAVE_ARRAY_BOUNDS
+	XCFLAGS += -Warray-bounds=0
+endif
+
+CXXFLAGS ?= $(CFLAGS)
+override CFLAGS += $(XCFLAGS) -DLIBURING_BUILD_TEST
+override CXXFLAGS += $(XCFLAGS) -std=c++11 -DLIBURING_BUILD_TEST
+
+LDFLAGS ?=
+override LDFLAGS += -L../src/ -luring -lpthread
+
+# Please keep this list sorted alphabetically.
+test_srcs := \
+	232c93d07b74.c \
+	35fa71a030ca.c \
+	500f9fbadef8.c \
+	7ad0e4b2f83c.c \
+	8a9973408177.c \
+	917257daa0fe.c \
+	a0908ae19763.c \
+	a4c0b3decb33.c \
+	accept.c \
+	accept-link.c \
+	accept-non-empty.c \
+	accept-reuse.c \
+	accept-test.c \
+	across-fork.c \
+	b19062a56726.c \
+	b5837bd5311d.c \
+	bind-listen.c \
+	buf-ring.c \
+	buf-ring-nommap.c \
+	buf-ring-put.c \
+	ce593a6c480a.c \
+	close-opath.c \
+	connect.c \
+	connect-rep.c \
+	coredump.c \
+	cq-full.c \
+	cq-overflow.c \
+	cq-peek-batch.c \
+	cq-ready.c \
+	cq-size.c \
+	d4ae271dfaae.c \
+	d77a67ed5f27.c \
+	defer.c \
+	defer-taskrun.c \
+	defer-tw-timeout.c \
+	double-poll-crash.c \
+	drop-submit.c \
+	eeed8b54e0df.c \
+	empty-eownerdead.c \
+	eploop.c \
+	eventfd.c \
+	eventfd-disable.c \
+	eventfd-reg.c \
+	eventfd-ring.c \
+	evloop.c \
+	exec-target.c \
+	exit-no-cleanup.c \
+	fadvise.c \
+	fallocate.c \
+	fc2a85cb02ef.c \
+	fd-install.c \
+	fd-pass.c \
+	fdinfo.c \
+	file-register.c \
+	files-exit-hang-poll.c \
+	files-exit-hang-timeout.c \
+	file-update.c \
+	file-verify.c \
+	fixed-buf-iter.c \
+	fixed-buf-merge.c \
+	fixed-hugepage.c \
+	fixed-link.c \
+	fixed-reuse.c \
+	fpos.c \
+	fsnotify.c \
+	fsync.c \
+	futex.c \
+	hardlink.c \
+	ignore-single-mmap.c \
+	init-mem.c \
+	io-cancel.c \
+	iopoll.c \
+	iopoll-leak.c \
+	iopoll-overflow.c \
+	io_uring_enter.c \
+	io_uring_passthrough.c \
+	io_uring_register.c \
+	io_uring_setup.c \
+	lfs-openat.c \
+	lfs-openat-write.c \
+	link.c \
+	link_drain.c \
+	link-timeout.c \
+	madvise.c \
+	min-timeout.c \
+	min-timeout-wait.c \
+	mkdir.c \
+	msg-ring.c \
+	msg-ring-fd.c \
+	msg-ring-flags.c \
+	msg-ring-overflow.c \
+	multicqes_drain.c \
+	napi-test.c \
+	no-mmap-inval.c \
+	nolibc.c \
+	nop-all-sizes.c \
+	nop.c \
+	ooo-file-unreg.c \
+	openat2.c \
+	open-close.c \
+	open-direct-link.c \
+	open-direct-pick.c \
+	personality.c \
+	pipe-bug.c \
+	pipe-eof.c \
+	pipe-reuse.c \
+	poll.c \
+	poll-cancel.c \
+	poll-cancel-all.c \
+	poll-cancel-ton.c \
+	poll-link.c \
+	poll-many.c \
+	poll-mshot-overflow.c \
+	poll-mshot-update.c \
+	poll-race.c \
+	poll-race-mshot.c \
+	poll-ring.c \
+	poll-v-poll.c \
+	probe.c \
+	read-before-exit.c \
+	read-mshot.c \
+	read-mshot-empty.c \
+	read-write.c \
+	recv-msgall.c \
+	recv-msgall-stream.c \
+	recv-multishot.c \
+	reg-fd-only.c \
+	reg-hint.c \
+	reg-reg-ring.c \
+	regbuf-merge.c \
+	register-restrictions.c \
+	rename.c \
+	ringbuf-read.c \
+	ringbuf-status.c \
+	ring-leak2.c \
+	ring-leak.c \
+	rsrc_tags.c \
+	rw_merge_test.c \
+	self.c \
+	recvsend_bundle.c \
+	send_recv.c \
+	send_recvmsg.c \
+	send-zerocopy.c \
+	shared-wq.c \
+	short-read.c \
+	shutdown.c \
+	sigfd-deadlock.c \
+	single-issuer.c \
+	skip-cqe.c \
+	socket.c \
+	socket-io-cmd.c \
+	socket-getsetsock-cmd.c \
+	socket-rw.c \
+	socket-rw-eagain.c \
+	socket-rw-offset.c \
+	splice.c \
+	sq-full.c \
+	sq-full-cpp.cc \
+	sqpoll-disable-exit.c \
+	sqpoll-exec.c \
+	sq-poll-dup.c \
+	sqpoll-exit-hang.c \
+	sq-poll-kthread.c \
+	sq-poll-share.c \
+	sqpoll-sleep.c \
+	sq-space_left.c \
+	stdout.c \
+	submit-and-wait.c \
+	submit-link-fail.c \
+	submit-reuse.c \
+	symlink.c \
+	sync-cancel.c \
+	teardowns.c \
+	thread-exit.c \
+	timeout.c \
+	timeout-new.c \
+	truncate.c \
+	tty-write-dpoll.c \
+	unlink.c \
+	version.c \
+	waitid.c \
+	wait-timeout.c \
+	wakeup-hang.c \
+	wq-aff.c \
+	xattr.c \
+	# EOL
+
+all_targets :=
+include ../Makefile.quiet
+
+ifdef CONFIG_HAVE_STATX
+	test_srcs += statx.c
+else ifdef CONFIG_HAVE_GLIBC_STATX
+	test_srcs += statx.c
+endif
+all_targets += statx.t
+
+ifdef CONFIG_HAVE_CXX
+	test_srcs += sq-full-cpp.cc
+endif
+all_targets += sq-full-cpp.t
+
+
+test_targets := $(patsubst %.c,%,$(test_srcs))
+test_targets := $(patsubst %.cc,%,$(test_targets))
+run_test_targets := $(patsubst %,%.run_test,$(test_targets))
+test_targets := $(patsubst %,%.t,$(test_targets))
+all_targets += $(test_targets)
+helpers = helpers.o
+
+all: $(test_targets)
+
+helpers.o: helpers.c
+	$(QUIET_CC)$(CC) $(CPPFLAGS) $(CFLAGS) -o $@ -c $<
+
+LIBURING := $(shell if [ -e ../src/liburing.a ]; then echo ../src/liburing.a; fi)
+
+%.t: %.c $(helpers) helpers.h $(LIBURING)
+	$(QUIET_CC)$(CC) $(CPPFLAGS) $(CFLAGS) -o $@ $< $(helpers) $(LDFLAGS)
+
+#
+# Clang++ is not happy with -Wmissing-prototypes:
+#
+#   cc1plus: warning: command-line option '-Wmissing-prototypes' \
+#   is valid for C/ObjC but not for C++
+#
+%.t: %.cc $(helpers) helpers.h $(LIBURING)
+	$(QUIET_CXX)$(CXX) \
+	$(patsubst -Wmissing-prototypes,,$(CPPFLAGS)) \
+	$(patsubst -Wmissing-prototypes,,$(CXXFLAGS)) \
+	-o $@ $< $(helpers) $(LDFLAGS)
+
+
+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/
+
+uninstall:
+	@rm -rf $(datadir)/liburing-test/
+
+clean:
+	@rm -f $(all_targets) helpers.o output/*
+	@rm -rf output/
+
+runtests: all
+	@./runtests.sh $(test_targets)
+
+runtests-loop: all
+	@./runtests-loop.sh $(test_targets)
+
+%.run_test: %.t
+	@./runtests-quiet.sh $<
+
+runtests-parallel: $(run_test_targets)
+	@echo "All tests passed"
+
+.PHONY: all install clean runtests runtests-loop runtests-parallel

data/vendor/liburing/test/a0908ae19763.c

@@ -0,0 +1,59 @@
+/* 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 "helpers.h"
+#include "../src/syscall.h"
+
+static uint64_t r[1] = {0xffffffffffffffff};
+
+int main(int argc, char *argv[])
+{
+  if (argc > 1)
+    return T_EXIT_SKIP;
+  mmap((void *) 0x20000000, 0x1000000, 3, MAP_ANON|MAP_PRIVATE, -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 T_EXIT_PASS;
+}