polyphony 0.94 → 0.95

data/vendor/liburing/test/nop.c

@@ -11,12 +11,16 @@
 #include <fcntl.h>
 
 #include "liburing.h"
+#include "test.h"
 
-static int test_single_nop(struct io_uring *ring)
+static int seq;
+
+static int test_single_nop(struct io_uring *ring, unsigned req_flags)
 {
 	struct io_uring_cqe *cqe;
 	struct io_uring_sqe *sqe;
 	int ret;
+	bool cqe32 = (ring->flags & IORING_SETUP_CQE32);
 
 	sqe = io_uring_get_sqe(ring);
 	if (!sqe) {
@@ -25,6 +29,8 @@ static int test_single_nop(struct io_uring *ring)
 	}
 
 	io_uring_prep_nop(sqe);
+	sqe->user_data = ++seq;
+	sqe->flags |= req_flags;
 
 	ret = io_uring_submit(ring);
 	if (ret <= 0) {
@@ -37,18 +43,33 @@ static int test_single_nop(struct io_uring *ring)
 		fprintf(stderr, "wait completion %d\n", ret);
 		goto err;
 	}
+	if (!cqe->user_data) {
+		fprintf(stderr, "Unexpected 0 user_data\n");
+		goto err;
+	}
+	if (cqe32) {
+		if (cqe->big_cqe[0] != 0) {
+			fprintf(stderr, "Unexpected extra1\n");
+			goto err;
 
+		}
+		if (cqe->big_cqe[1] != 0) {
+			fprintf(stderr, "Unexpected extra2\n");
+			goto err;
+		}
+	}
 	io_uring_cqe_seen(ring, cqe);
 	return 0;
 err:
 	return 1;
 }
 
-static int test_barrier_nop(struct io_uring *ring)
+static int test_barrier_nop(struct io_uring *ring, unsigned req_flags)
 {
 	struct io_uring_cqe *cqe;
 	struct io_uring_sqe *sqe;
 	int ret, i;
+	bool cqe32 = (ring->flags & IORING_SETUP_CQE32);
 
 	for (i = 0; i < 8; i++) {
 		sqe = io_uring_get_sqe(ring);
@@ -60,6 +81,8 @@ static int test_barrier_nop(struct io_uring *ring)
 		io_uring_prep_nop(sqe);
 		if (i == 4)
 			sqe->flags = IOSQE_IO_DRAIN;
+		sqe->user_data = ++seq;
+		sqe->flags |= req_flags;
 	}
 
 	ret = io_uring_submit(ring);
@@ -77,6 +100,20 @@ static int test_barrier_nop(struct io_uring *ring)
 			fprintf(stderr, "wait completion %d\n", ret);
 			goto err;
 		}
+		if (!cqe->user_data) {
+			fprintf(stderr, "Unexpected 0 user_data\n");
+			goto err;
+		}
+		if (cqe32) {
+			if (cqe->big_cqe[0] != 0) {
+				fprintf(stderr, "Unexpected extra1\n");
+				goto err;
+			}
+			if (cqe->big_cqe[1] != 0) {
+				fprintf(stderr, "Unexpected extra2\n");
+				goto err;
+			}
+		}
 		io_uring_cqe_seen(ring, cqe);
 	}
 
@@ -85,30 +122,55 @@ err:
 	return 1;
 }
 
-int main(int argc, char *argv[])
+static int test_ring(unsigned flags)
 {
 	struct io_uring ring;
-	int ret;
-
-	if (argc > 1)
-		return 0;
+	struct io_uring_params p = { };
+	int ret, i;
 
-	ret = io_uring_queue_init(8, &ring, 0);
+	p.flags = flags;
+	ret = io_uring_queue_init_params(8, &ring, &p);
 	if (ret) {
+		if (ret == -EINVAL)
+			return 0;
 		fprintf(stderr, "ring setup failed: %d\n", ret);
 		return 1;
 	}
 
-	ret = test_single_nop(&ring);
-	if (ret) {
-		fprintf(stderr, "test_single_nop failed\n");
-		return ret;
+	for (i = 0; i < 1000; i++) {
+		unsigned req_flags = (i & 1) ? IOSQE_ASYNC : 0;
+
+		ret = test_single_nop(&ring, req_flags);
+		if (ret) {
+			fprintf(stderr, "test_single_nop failed\n");
+			goto err;
+		}
+
+		ret = test_barrier_nop(&ring, req_flags);
+		if (ret) {
+			fprintf(stderr, "test_barrier_nop failed\n");
+			goto err;
+		}
 	}
+err:
+	io_uring_queue_exit(&ring);
+	return ret;
+}
 
-	ret = test_barrier_nop(&ring);
-	if (ret) {
-		fprintf(stderr, "test_barrier_nop failed\n");
-		return ret;
+int main(int argc, char *argv[])
+{
+	int ret;
+
+	if (argc > 1)
+		return 0;
+
+	FOR_ALL_TEST_CONFIGS {
+		ret = test_ring(IORING_GET_TEST_CONFIG_FLAGS());
+		if (ret) {
+			fprintf(stderr, "Normal ring test failed: %s\n",
+					IORING_GET_TEST_CONFIG_DESCRIPTION());
+			return ret;
+		}
 	}
 
 	return 0;

data/vendor/liburing/test/nvme.h

@@ -0,0 +1,168 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: Helpers for NVMe uring passthrough commands
+ */
+#ifndef LIBURING_NVME_H
+#define LIBURING_NVME_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <sys/ioctl.h>
+#include <linux/nvme_ioctl.h>
+
+/*
+ * If the uapi headers installed on the system lacks nvme uring command
+ * support, use the local version to prevent compilation issues.
+ */
+#ifndef CONFIG_HAVE_NVME_URING
+struct nvme_uring_cmd {
+	__u8	opcode;
+	__u8	flags;
+	__u16	rsvd1;
+	__u32	nsid;
+	__u32	cdw2;
+	__u32	cdw3;
+	__u64	metadata;
+	__u64	addr;
+	__u32	metadata_len;
+	__u32	data_len;
+	__u32	cdw10;
+	__u32	cdw11;
+	__u32	cdw12;
+	__u32	cdw13;
+	__u32	cdw14;
+	__u32	cdw15;
+	__u32	timeout_ms;
+	__u32   rsvd2;
+};
+
+#define NVME_URING_CMD_IO	_IOWR('N', 0x80, struct nvme_uring_cmd)
+#define NVME_URING_CMD_IO_VEC	_IOWR('N', 0x81, struct nvme_uring_cmd)
+#endif /* CONFIG_HAVE_NVME_URING */
+
+#define NVME_DEFAULT_IOCTL_TIMEOUT 0
+#define NVME_IDENTIFY_DATA_SIZE 4096
+#define NVME_IDENTIFY_CSI_SHIFT 24
+#define NVME_IDENTIFY_CNS_NS 0
+#define NVME_CSI_NVM 0
+
+enum nvme_admin_opcode {
+	nvme_admin_identify		= 0x06,
+};
+
+enum nvme_io_opcode {
+	nvme_cmd_write			= 0x01,
+	nvme_cmd_read			= 0x02,
+};
+
+int nsid;
+__u32 lba_shift;
+
+struct nvme_lbaf {
+	__le16			ms;
+	__u8			ds;
+	__u8			rp;
+};
+
+struct nvme_id_ns {
+	__le64			nsze;
+	__le64			ncap;
+	__le64			nuse;
+	__u8			nsfeat;
+	__u8			nlbaf;
+	__u8			flbas;
+	__u8			mc;
+	__u8			dpc;
+	__u8			dps;
+	__u8			nmic;
+	__u8			rescap;
+	__u8			fpi;
+	__u8			dlfeat;
+	__le16			nawun;
+	__le16			nawupf;
+	__le16			nacwu;
+	__le16			nabsn;
+	__le16			nabo;
+	__le16			nabspf;
+	__le16			noiob;
+	__u8			nvmcap[16];
+	__le16			npwg;
+	__le16			npwa;
+	__le16			npdg;
+	__le16			npda;
+	__le16			nows;
+	__le16			mssrl;
+	__le32			mcl;
+	__u8			msrc;
+	__u8			rsvd81[11];
+	__le32			anagrpid;
+	__u8			rsvd96[3];
+	__u8			nsattr;
+	__le16			nvmsetid;
+	__le16			endgid;
+	__u8			nguid[16];
+	__u8			eui64[8];
+	struct nvme_lbaf	lbaf[16];
+	__u8			rsvd192[192];
+	__u8			vs[3712];
+};
+
+static inline int ilog2(uint32_t i)
+{
+	int log = -1;
+
+	while (i) {
+		i >>= 1;
+		log++;
+	}
+	return log;
+}
+
+int nvme_get_info(const char *file)
+{
+	struct nvme_id_ns ns;
+	int fd, err;
+	__u32 lba_size;
+
+	fd = open(file, O_RDONLY);
+	if (fd < 0) {
+		perror("file open");
+		return -errno;
+	}
+
+	nsid = ioctl(fd, NVME_IOCTL_ID);
+	if (nsid < 0) {
+		close(fd);
+		return -errno;
+	}
+
+	struct nvme_passthru_cmd cmd = {
+		.opcode         = nvme_admin_identify,
+		.nsid           = nsid,
+		.addr           = (__u64)(uintptr_t)&ns,
+		.data_len       = NVME_IDENTIFY_DATA_SIZE,
+		.cdw10          = NVME_IDENTIFY_CNS_NS,
+		.cdw11          = NVME_CSI_NVM << NVME_IDENTIFY_CSI_SHIFT,
+		.timeout_ms     = NVME_DEFAULT_IOCTL_TIMEOUT,
+	};
+
+	err = ioctl(fd, NVME_IOCTL_ADMIN_CMD, &cmd);
+	if (err) {
+		close(fd);
+		return err;
+	}
+
+	lba_size = 1 << ns.lbaf[(ns.flbas & 0x0f)].ds;
+	lba_shift = ilog2(lba_size);
+
+	close(fd);
+	return 0;
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/vendor/liburing/test/open-direct-link.c

@@ -0,0 +1,188 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: link <open file><read from file><close file>
+ *
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+
+#include "liburing.h"
+#include "helpers.h"
+
+#define MAX_FILES	8
+#define FNAME		".link.direct"
+
+static int test(struct io_uring *ring, int skip_success, int drain, int async)
+{
+	struct io_uring_cqe *cqe;
+	struct io_uring_sqe *sqe;
+	char buf[4096];
+	int ret, i;
+
+	/* drain and cqe skip are mutually exclusive */
+	if (skip_success && drain)
+		return 1;
+
+	sqe = io_uring_get_sqe(ring);
+	io_uring_prep_openat_direct(sqe, AT_FDCWD, FNAME, O_RDONLY, 0, 0);
+	if (!drain)
+		sqe->flags |= IOSQE_IO_LINK;
+	if (skip_success)
+		sqe->flags |= IOSQE_CQE_SKIP_SUCCESS;
+	if (async)
+		sqe->flags |= IOSQE_ASYNC;
+	sqe->user_data = 1;
+
+	sqe = io_uring_get_sqe(ring);
+	io_uring_prep_read(sqe, 0, buf, sizeof(buf), 0);
+	sqe->flags |= IOSQE_FIXED_FILE;
+	if (drain)
+		sqe->flags |= IOSQE_IO_DRAIN;
+	else
+		sqe->flags |= IOSQE_IO_LINK;
+	if (async)
+		sqe->flags |= IOSQE_ASYNC;
+	sqe->user_data = 2;
+
+	sqe = io_uring_get_sqe(ring);
+	io_uring_prep_close_direct(sqe, 0);
+	sqe->user_data = 3;
+	if (skip_success)
+		sqe->flags |= IOSQE_CQE_SKIP_SUCCESS;
+	if (drain)
+		sqe->flags |= IOSQE_IO_DRAIN;
+	if (async)
+		sqe->flags |= IOSQE_ASYNC;
+
+	ret = io_uring_submit(ring);
+	if (ret != 3) {
+		fprintf(stderr, "sqe submit failed: %d\n", ret);
+		goto err;
+	}
+
+	if (skip_success) {
+		ret = io_uring_wait_cqe(ring, &cqe);
+		if (ret < 0) {
+			fprintf(stderr, "wait completion %d\n", ret);
+			goto err;
+		}
+		if (cqe->user_data != 2) {
+			fprintf(stderr, "Unexpected cqe %lu/%d\n",
+					(unsigned long) cqe->user_data,
+					cqe->res);
+			goto err;
+		}
+		if (cqe->res != sizeof(buf)) {
+			fprintf(stderr, "bad read %d\n", cqe->res);
+			goto err;
+		}
+		io_uring_cqe_seen(ring, cqe);
+		return 0;
+	}
+	
+	for (i = 0; i < 3; i++) {
+		ret = io_uring_wait_cqe(ring, &cqe);
+		if (ret < 0) {
+			fprintf(stderr, "wait completion %d\n", ret);
+			goto err;
+		}
+		switch (cqe->user_data) {
+		case 1:
+			if (cqe->res) {
+				fprintf(stderr, "bad open %d\n", cqe->res);
+				goto err;
+			}
+			break;
+		case 2:
+			if (cqe->res != sizeof(buf)) {
+				fprintf(stderr, "bad read %d\n", cqe->res);
+				goto err;
+			}
+			break;
+		case 3:
+			if (cqe->res) {
+				fprintf(stderr, "bad close %d\n", cqe->res);
+				goto err;
+			}
+			break;
+		}
+		io_uring_cqe_seen(ring, cqe);
+	}
+
+	return 0;
+err:
+	return 1;
+}
+
+int main(int argc, char *argv[])
+{
+	struct io_uring ring;
+	struct io_uring_params p = { };
+	int ret, files[MAX_FILES];
+
+	if (argc > 1)
+		return 0;
+
+	ret = io_uring_queue_init_params(8, &ring, &p);
+	if (ret) {
+		fprintf(stderr, "ring setup failed: %d\n", ret);
+		return 1;
+	}
+	if (!(p.features & IORING_FEAT_CQE_SKIP))
+		return 0;
+
+	memset(files, -1, sizeof(files));
+	ret = io_uring_register_files(&ring, files, ARRAY_SIZE(files));
+	if (ret) {
+		fprintf(stderr, "Failed registering files\n");
+		return 1;
+	}
+
+	t_create_file(FNAME, 4096);
+
+	ret = test(&ring, 0, 0, 0);
+	if (ret) {
+		fprintf(stderr, "test 0 0 0 failed\n");
+		goto err;
+	}
+
+	ret = test(&ring, 0, 1, 0);
+	if (ret) {
+		fprintf(stderr, "test 0 1 0 failed\n");
+		goto err;
+	}
+
+	ret = test(&ring, 0, 0, 1);
+	if (ret) {
+		fprintf(stderr, "test 0 0 1 failed\n");
+		goto err;
+	}
+
+	ret = test(&ring, 0, 1, 1);
+	if (ret) {
+		fprintf(stderr, "test 0 1 1 failed\n");
+		goto err;
+	}
+
+	ret = test(&ring, 1, 0, 0);
+	if (ret) {
+		fprintf(stderr, "test 1 0 0 failed\n");
+		goto err;
+	}
+
+	ret = test(&ring, 1, 0, 1);
+	if (ret) {
+		fprintf(stderr, "test 1 0 1 failed\n");
+		goto err;
+	}
+
+	unlink(FNAME);
+	return 0;
+err:
+	unlink(FNAME);
+	return 1;
+}

data/vendor/liburing/test/open-direct-pick.c

@@ -0,0 +1,180 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: run various openat(2) tests
+ *
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <limits.h>
+
+#include "helpers.h"
+#include "liburing.h"
+
+#define FDS	800
+
+static int no_direct_pick;
+
+static int submit_wait(struct io_uring *ring)
+{
+	struct io_uring_cqe *cqe;
+	int ret;
+
+	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 completion %d\n", ret);
+		return 1;
+	}
+
+	ret = cqe->res;
+	io_uring_cqe_seen(ring, cqe);
+	return ret;
+}
+
+static inline int try_close(struct io_uring *ring, int slot)
+{
+	struct io_uring_sqe *sqe;
+
+	sqe = io_uring_get_sqe(ring);
+	io_uring_prep_close_direct(sqe, slot);
+	return submit_wait(ring);
+}
+
+static int do_opens(struct io_uring *ring, const char *path, int nr,
+		    int expect_enfile)
+{
+	struct io_uring_cqe *cqe;
+	struct io_uring_sqe *sqe;
+	int i, ret;
+
+	for (i = 0; i < nr; i++) {
+		sqe = io_uring_get_sqe(ring);
+		if (!sqe) {
+			fprintf(stderr, "get sqe failed\n");
+			goto err;
+		}
+		io_uring_prep_openat_direct(sqe, -1, path, O_RDONLY, 0, 0);
+		sqe->file_index = UINT_MAX;
+
+		ret = io_uring_submit(ring);
+		if (ret <= 0) {
+			fprintf(stderr, "sqe submit failed: %d\n", ret);
+			goto err;
+		}
+	}
+
+	for (i = 0; i < nr; i++) {
+		ret = io_uring_wait_cqe(ring, &cqe);
+		if (ret < 0) {
+			fprintf(stderr, "wait completion %d\n", ret);
+			goto err;
+		}
+		ret = cqe->res;
+		if (ret < 0) {
+			if (!expect_enfile || ret != -ENFILE) {
+				printf("open=%d, %d\n", cqe->res, i);
+				goto err;
+			}
+			if (!i && ret == -EINVAL) {
+				no_direct_pick = 1;
+				return 0;
+			}
+		}
+		io_uring_cqe_seen(ring, cqe);
+	}
+	return 0;
+err:
+	return 1;
+}
+
+static int test_openat(struct io_uring *ring, const char *path)
+{
+	int ret, i;
+
+	/* open all */
+	ret = do_opens(ring, path, FDS, 0);
+	if (ret)
+		goto err;
+	if (no_direct_pick)
+		return 0;
+
+	/* now close 100 randomly */
+	for (i = 0; i < 100; i++) {
+		do {
+			int slot = rand() % FDS;
+			ret = try_close(ring, slot);
+			if (ret == -EBADF)
+				continue;
+			break;
+		} while (1);
+	}
+
+	/* opening 100 should work, we closed 100 */
+	ret = do_opens(ring, path, 100, 0);
+	if (ret)
+		goto err;
+
+	/* we should be full now, expect -ENFILE */
+	ret = do_opens(ring, path, 1, 1);
+	if (ret)
+		goto err;
+
+	return ret;
+err:
+	fprintf(stderr,"%s: err=%d\n", __FUNCTION__, ret);
+	return -1;
+}
+
+int main(int argc, char *argv[])
+{
+	struct io_uring ring;
+	const char *path;
+	int ret;
+
+	if (argc > 1)
+		return 0;
+
+	ret = io_uring_queue_init(8, &ring, 0);
+	if (ret) {
+		fprintf(stderr, "ring setup failed\n");
+		return 1;
+	}
+
+	ret = io_uring_register_files_sparse(&ring, FDS);
+	if (ret ) {
+		if (ret != -EINVAL) {
+			fprintf(stderr, "Sparse file registration failed\n");
+			return 1;
+		}
+		/* skip, kernel doesn't support sparse file array */
+		return 0;
+	}
+
+	path = "/tmp/.open.direct.pick";
+	t_create_file(path, 4096);
+
+	ret = test_openat(&ring, path);
+	if (ret < 0) {
+		if (ret == -EINVAL) {
+			fprintf(stdout, "Open not supported, skipping\n");
+			goto done;
+		}
+		fprintf(stderr, "test_openat absolute failed: %d\n", ret);
+		goto err;
+	}
+
+done:
+	unlink(path);
+	return 0;
+err:
+	unlink(path);
+	return 1;
+}

data/vendor/liburing/test/openat2.c

@@ -246,12 +246,12 @@ int main(int argc, char *argv[])
 	}
 
 	if (argc > 1) {
-		path = "/tmp/.open.close";
+		path = "/tmp/.open.at2";
 		path_rel = argv[1];
 		do_unlink = 0;
 	} else {
-		path = "/tmp/.open.close";
-		path_rel = ".open.close";
+		path = "/tmp/.open.at2";
+		path_rel = ".open.at2";
 		do_unlink = 1;
 	}