polyphony 0.85 → 0.86

data/vendor/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;
+}

data/vendor/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;
+}

data/vendor/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;
+}

data/vendor/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;
+}

data/vendor/liburing/test/Makefile

@@ -0,0 +1,244 @@
+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 -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
+
+test_srcs := \
+	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.c \
+	accept-link.c \
+	accept-reuse.c \
+	accept-test.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 \
+	drop-submit.c \
+	eeed8b54e0df-test.c \
+	empty-eownerdead.c \
+	eventfd.c \
+	eventfd-disable.c \
+	eventfd-reg.c \
+	eventfd-ring.c \
+	exec-target.c \
+	exit-no-cleanup.c \
+	fadvise.c \
+	fallocate.c \
+	fc2a85cb02ef-test.c \
+	file-register.c \
+	files-exit-hang-poll.c \
+	files-exit-hang-timeout.c \
+	file-update.c \
+	file-verify.c \
+	fixed-link.c \
+	fpos.c \
+	fsync.c \
+	hardlink.c \
+	io-cancel.c \
+	iopoll.c \
+	io_uring_enter.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 \
+	mkdir.c \
+	msg-ring.c \
+	multicqes_drain.c \
+	nop-all-sizes.c \
+	nop.c \
+	openat2.c \
+	open-close.c \
+	personality.c \
+	pipe-eof.c \
+	pipe-reuse.c \
+	poll.c \
+	poll-cancel.c \
+	poll-cancel-ton.c \
+	poll-link.c \
+	poll-many.c \
+	poll-mshot-update.c \
+	poll-ring.c \
+	poll-v-poll.c \
+	pollfree.c \
+	probe.c \
+	read-write.c \
+	register-restrictions.c \
+	rename.c \
+	ring-leak2.c \
+	ring-leak.c \
+	rsrc_tags.c \
+	rw_merge_test.c \
+	self.c \
+	sendmsg_fs_cve.c \
+	send_recv.c \
+	send_recvmsg.c \
+	shared-wq.c \
+	short-read.c \
+	shutdown.c \
+	sigfd-deadlock.c \
+	socket-rw.c \
+	socket-rw-eagain.c \
+	socket-rw-offset.c \
+	splice.c \
+	sq-full.c \
+	sq-full-cpp.cc \
+	sqpoll-cancel-hang.c \
+	sqpoll-disable-exit.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-link-fail.c \
+	submit-reuse.c \
+	symlink.c \
+	teardowns.c \
+	thread-exit.c \
+	timeout.c \
+	timeout-new.c \
+	timeout-overflow.c \
+	unlink.c \
+	wakeup-hang.c \
+	skip-cqe.c \
+	# EOL
+
+
+all_targets :=
+include ../Makefile.quiet
+
+
+ifdef CONFIG_HAVE_STATX
+	test_srcs += statx.c
+endif
+
+ifdef CONFIG_HAVE_GLIBC_STATX
+	test_srcs += statx.c
+endif
+all_targets += statx
+
+
+ifdef CONFIG_HAVE_CXX
+	test_srcs += sq-full-cpp.cc
+endif
+all_targets += sq-full-cpp
+
+
+test_targets := $(patsubst %.c,%,$(patsubst %.cc,%,$(test_srcs)))
+all_targets += $(test_targets)
+
+#
+# Build ../src/syscall.c manually from test's Makefile to support
+# liburing nolibc.
+#
+# Functions in ../src/syscall.c require libc to work with, if we
+# build liburing without libc, we don't have those functions
+# in liburing.a. So build it manually here.
+#
+helpers = helpers.o ../src/syscall.o
+
+all: $(test_targets)
+
+../src/syscall.o: ../src/syscall.c
+	$(QUIET_CC)$(CC) $(CPPFLAGS) $(CFLAGS) -o $@ -c $<
+
+helpers.o: helpers.c
+	$(QUIET_CC)$(CC) $(CPPFLAGS) $(CFLAGS) -o $@ -c $<
+
+%: %.c $(helpers) helpers.h ../src/liburing.a
+	$(QUIET_CC)$(CC) $(CPPFLAGS) $(CFLAGS) -o $@ $< $(helpers) $(LDFLAGS)
+
+%: %.cc $(helpers) helpers.h ../src/liburing.a
+	$(QUIET_CXX)$(CXX) $(CPPFLAGS) $(CXXFLAGS) -o $@ $< $(helpers) $(LDFLAGS)
+
+
+35fa71a030ca-test: override LDFLAGS += -lpthread
+232c93d07b74-test: override LDFLAGS += -lpthread
+send_recv: override LDFLAGS += -lpthread
+send_recvmsg: override LDFLAGS += -lpthread
+poll-link: override LDFLAGS += -lpthread
+accept-link: override LDFLAGS += -lpthread
+submit-reuse: override LDFLAGS += -lpthread
+poll-v-poll: override LDFLAGS += -lpthread
+across-fork: override LDFLAGS += -lpthread
+ce593a6c480a-test: override LDFLAGS += -lpthread
+wakeup-hang: override LDFLAGS += -lpthread
+pipe-eof: override LDFLAGS += -lpthread
+timeout-new: override LDFLAGS += -lpthread
+thread-exit: override LDFLAGS += -lpthread
+ring-leak2: override LDFLAGS += -lpthread
+poll-mshot-update: override LDFLAGS += -lpthread
+exit-no-cleanup: override LDFLAGS += -lpthread
+pollfree: override LDFLAGS += -lpthread
+msg-ring: override LDFLAGS += -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) helpers.o output/*
+	@rm -rf output/
+
+runtests: all
+	@./runtests.sh $(test_targets)
+
+runtests-loop: all
+	@./runtests-loop.sh $(test_targets)
+
+.PHONY: all install clean runtests runtests-loop

data/vendor/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;
+}