polyphony 0.94 → 0.95

data/vendor/liburing/test/io_uring_register.c

@@ -31,57 +31,42 @@ static int pagesize;
 static rlim_t mlock_limit;
 static int devnull;
 
-#if !defined(CONFIG_HAVE_MEMFD_CREATE)
-#include <sys/syscall.h>
-#include <linux/memfd.h>
-
-static int memfd_create(const char *name, unsigned int flags)
-{
-	return (int)syscall(SYS_memfd_create, name, flags);
-}
-#endif
-
-
-int
-expect_fail(int fd, unsigned int opcode, void *arg,
+static int expect_fail(int fd, unsigned int opcode, void *arg,
 	    unsigned int nr_args, int error)
 {
 	int ret;
 
-	printf("io_uring_register(%d, %u, %p, %u)\n",
-	       fd, opcode, arg, nr_args);
-	ret = __sys_io_uring_register(fd, opcode, arg, nr_args);
-	if (ret != -1) {
+	ret = io_uring_register(fd, opcode, arg, nr_args);
+	if (ret >= 0) {
 		int ret2 = 0;
 
-		printf("expected %s, but call succeeded\n", strerror(error));
+		fprintf(stderr, "expected %s, but call succeeded\n", strerror(error));
 		if (opcode == IORING_REGISTER_BUFFERS) {
-			ret2 = __sys_io_uring_register(fd,
-					IORING_UNREGISTER_BUFFERS, 0, 0);
+			ret2 = io_uring_register(fd, IORING_UNREGISTER_BUFFERS,
+						 0, 0);
 		} else if (opcode == IORING_REGISTER_FILES) {
-			ret2 = __sys_io_uring_register(fd,
-					IORING_UNREGISTER_FILES, 0, 0);
+			ret2 = io_uring_register(fd, IORING_UNREGISTER_FILES, 0,
+						 0);
 		}
 		if (ret2) {
-			printf("internal error: failed to unregister\n");
+			fprintf(stderr, "internal error: failed to unregister\n");
 			exit(1);
 		}
 		return 1;
 	}
 
-	if (errno != error) {
-		printf("expected %d, got %d\n", error, errno);
+	if (ret != error) {
+		fprintf(stderr, "expected %d, got %d\n", error, ret);
 		return 1;
 	}
 	return 0;
 }
 
-int
-new_io_uring(int entries, struct io_uring_params *p)
+static int new_io_uring(int entries, struct io_uring_params *p)
 {
 	int fd;
 
-	fd = __sys_io_uring_setup(entries, p);
+	fd = io_uring_setup(entries, p);
 	if (fd < 0) {
 		perror("io_uring_setup");
 		exit(1);
@@ -91,8 +76,7 @@ new_io_uring(int entries, struct io_uring_params *p)
 
 #define MAXFDS (UINT_MAX * sizeof(int))
 
-void *
-map_filebacked(size_t size)
+static void *map_filebacked(size_t size)
 {
 	int fd, ret;
 	void *addr;
@@ -127,8 +111,7 @@ map_filebacked(size_t size)
  * NOTE: this is now limited by SCM_MAX_FD (253).  Keep the code for now,
  * but probably should augment it to test 253 and 254, specifically.
  */
-int
-test_max_fds(int uring_fd)
+static int test_max_fds(int uring_fd)
 {
 	int status = 1;
 	int ret;
@@ -148,14 +131,11 @@ test_max_fds(int uring_fd)
 	fd_as = mmap(NULL, UINT_MAX * sizeof(int), PROT_READ|PROT_WRITE,
 		     MAP_PRIVATE|MAP_ANONYMOUS, -1, 0);
 	if (fd_as == MAP_FAILED) {
-		if (errno == ENOMEM) {
-			printf("Not enough memory for this test, skipping\n");
+		if (errno == ENOMEM)
 			return 0;
-		}
 		perror("mmap fd_as");
 		exit(1);
 	}
-	printf("allocated %zu bytes of address space\n", UINT_MAX * sizeof(int));
 
 	fdtable_fd = mkstemp(template);
 	if (fdtable_fd < 0) {
@@ -193,7 +173,7 @@ test_max_fds(int uring_fd)
 		fds = mmap(fds, 128*1024*1024, PROT_READ|PROT_WRITE,
 			   MAP_SHARED|MAP_FIXED, fdtable_fd, 0);
 		if (fds == MAP_FAILED) {
-			printf("mmap failed at offset %lu\n",
+			fprintf(stderr, "mmap failed at offset %lu\n",
 			       (unsigned long)((char *)fd_as - (char *)fds));
 			exit(1);
 		}
@@ -206,27 +186,20 @@ test_max_fds(int uring_fd)
 	 */
 	nr_fds = UINT_MAX;
 	while (nr_fds) {
-		ret = __sys_io_uring_register(uring_fd, IORING_REGISTER_FILES,
-						fd_as, nr_fds);
+		ret = io_uring_register(uring_fd, IORING_REGISTER_FILES, fd_as,
+					nr_fds);
 		if (ret != 0) {
 			nr_fds /= 2;
 			continue;
 		}
-		printf("io_uring_register(%d, IORING_REGISTER_FILES, %p, %llu)"
-		       "...succeeded\n", uring_fd, fd_as, nr_fds);
 		status = 0;
-		printf("io_uring_register(%d, IORING_UNREGISTER_FILES, 0, 0)...",
-		       uring_fd);
-		ret = __sys_io_uring_register(uring_fd, IORING_UNREGISTER_FILES,
-						0, 0);
+		ret = io_uring_register(uring_fd, IORING_UNREGISTER_FILES, 0, 0);
 		if (ret < 0) {
 			ret = errno;
-			printf("failed\n");
 			errno = ret;
 			perror("io_uring_register UNREGISTER_FILES");
 			exit(1);
 		}
-		printf("succeeded\n");
 		break;
 	}
 
@@ -234,15 +207,14 @@ test_max_fds(int uring_fd)
 	close(fdtable_fd);
 	ret = munmap(fd_as, UINT_MAX * sizeof(int));
 	if (ret != 0) {
-		printf("munmap(%zu) failed\n", UINT_MAX * sizeof(int));
+		fprintf(stderr, "munmap(%zu) failed\n", UINT_MAX * sizeof(int));
 		exit(1);
 	}
 
 	return status;
 }
 
-int
-test_memlock_exceeded(int fd)
+static int test_memlock_exceeded(int fd)
 {
 	int ret;
 	void *buf;
@@ -257,11 +229,9 @@ test_memlock_exceeded(int fd)
 	iov.iov_base = buf;
 
 	while (iov.iov_len) {
-		ret = __sys_io_uring_register(fd, IORING_REGISTER_BUFFERS, &iov, 1);
+		ret = io_uring_register(fd, IORING_REGISTER_BUFFERS, &iov, 1);
 		if (ret < 0) {
 			if (errno == ENOMEM) {
-				printf("io_uring_register of %zu bytes failed "
-				       "with ENOMEM (expected).\n", iov.iov_len);
 				iov.iov_len /= 2;
 				continue;
 			}
@@ -269,16 +239,13 @@ test_memlock_exceeded(int fd)
 				free(buf);
 				return 0;
 			}
-			printf("expected success or EFAULT, got %d\n", errno);
+			fprintf(stderr, "expected success or EFAULT, got %d\n", errno);
 			free(buf);
 			return 1;
 		}
-		printf("successfully registered %zu bytes (%d).\n",
-		       iov.iov_len, ret);
-		ret = __sys_io_uring_register(fd, IORING_UNREGISTER_BUFFERS,
-						NULL, 0);
+		ret = io_uring_register(fd, IORING_UNREGISTER_BUFFERS, NULL, 0);
 		if (ret != 0) {
-			printf("error: unregister failed with %d\n", errno);
+			fprintf(stderr, "error: unregister failed with %d\n", errno);
 			free(buf);
 			return 1;
 		}
@@ -291,8 +258,7 @@ test_memlock_exceeded(int fd)
 	return 0;
 }
 
-int
-test_iovec_nr(int fd)
+static int test_iovec_nr(int fd)
 {
 	int i, ret, status = 0;
 	unsigned int nr = 1000000;
@@ -311,20 +277,18 @@ test_iovec_nr(int fd)
 		iovs[i].iov_len = pagesize;
 	}
 
-	status |= expect_fail(fd, IORING_REGISTER_BUFFERS, iovs, nr, EINVAL);
+	status |= expect_fail(fd, IORING_REGISTER_BUFFERS, iovs, nr, -EINVAL);
 
 	/* reduce to UIO_MAXIOV */
 	nr = UIO_MAXIOV;
-	printf("io_uring_register(%d, %u, %p, %u)\n",
-	       fd, IORING_REGISTER_BUFFERS, iovs, nr);
-	ret = __sys_io_uring_register(fd, IORING_REGISTER_BUFFERS, iovs, nr);
+	ret = io_uring_register(fd, IORING_REGISTER_BUFFERS, iovs, nr);
 	if (ret && (errno == ENOMEM || errno == EPERM) && geteuid()) {
-		printf("can't register large iovec for regular users, skip\n");
+		fprintf(stderr, "can't register large iovec for regular users, skip\n");
 	} else if (ret != 0) {
-		printf("expected success, got %d\n", errno);
+		fprintf(stderr, "expected success, got %d\n", errno);
 		status = 1;
 	} else {
-		__sys_io_uring_register(fd, IORING_UNREGISTER_BUFFERS, 0, 0);
+		io_uring_register(fd, IORING_UNREGISTER_BUFFERS, 0, 0);
 	}
 	free(buf);
 	free(iovs);
@@ -334,8 +298,7 @@ test_iovec_nr(int fd)
 /*
  * io_uring limit is 1G.  iov_len limit is ~OUL, I think
  */
-int
-test_iovec_size(int fd)
+static int test_iovec_size(int fd)
 {
 	unsigned int status = 0;
 	int ret;
@@ -345,12 +308,12 @@ test_iovec_size(int fd)
 	/* NULL pointer for base */
 	iov.iov_base = 0;
 	iov.iov_len = 4096;
-	status |= expect_fail(fd, IORING_REGISTER_BUFFERS, &iov, 1, EFAULT);
+	status |= expect_fail(fd, IORING_REGISTER_BUFFERS, &iov, 1, -EFAULT);
 
 	/* valid base, 0 length */
 	iov.iov_base = &buf;
 	iov.iov_len = 0;
-	status |= expect_fail(fd, IORING_REGISTER_BUFFERS, &iov, 1, EFAULT);
+	status |= expect_fail(fd, IORING_REGISTER_BUFFERS, &iov, 1, -EFAULT);
 
 	/* valid base, length exceeds size */
 	/* this requires an unampped page directly after buf */
@@ -361,7 +324,7 @@ test_iovec_size(int fd)
 	assert(ret == 0);
 	iov.iov_base = buf;
 	iov.iov_len = 2 * pagesize;
-	status |= expect_fail(fd, IORING_REGISTER_BUFFERS, &iov, 1, EFAULT);
+	status |= expect_fail(fd, IORING_REGISTER_BUFFERS, &iov, 1, -EFAULT);
 	munmap(buf, pagesize);
 
 	/* huge page */
@@ -379,23 +342,23 @@ test_iovec_size(int fd)
 		 */
 		iov.iov_base = buf;
 		iov.iov_len = 2*1024*1024;
-		ret = __sys_io_uring_register(fd, IORING_REGISTER_BUFFERS, &iov, 1);
+		ret = io_uring_register(fd, IORING_REGISTER_BUFFERS, &iov, 1);
 		if (ret < 0) {
-			if (errno == ENOMEM)
+			if (ret == -ENOMEM)
 				printf("Unable to test registering of a huge "
 				       "page.  Try increasing the "
 				       "RLIMIT_MEMLOCK resource limit by at "
 				       "least 2MB.");
 			else {
-				printf("expected success, got %d\n", errno);
+				fprintf(stderr, "expected success, got %d\n", ret);
 				status = 1;
 			}
 		} else {
-			printf("Success!\n");
-			ret = __sys_io_uring_register(fd,
-					IORING_UNREGISTER_BUFFERS, 0, 0);
+			ret = io_uring_register(fd, IORING_UNREGISTER_BUFFERS,
+						0, 0);
 			if (ret < 0) {
-				perror("io_uring_unregister");
+				fprintf(stderr, "io_uring_unregister: %s\n",
+					strerror(-ret));
 				status = 1;
 			}
 		}
@@ -409,8 +372,7 @@ test_iovec_size(int fd)
 		status = 1;
 	iov.iov_base = buf;
 	iov.iov_len = 2*1024*1024;
-	printf("reserve file-backed buffers\n");
-	status |= expect_fail(fd, IORING_REGISTER_BUFFERS, &iov, 1, EOPNOTSUPP);
+	status |= expect_fail(fd, IORING_REGISTER_BUFFERS, &iov, 1, -EOPNOTSUPP);
 	munmap(buf, 2*1024*1024);
 
 	/* bump up against the soft limit and make sure we get EFAULT
@@ -422,18 +384,7 @@ test_iovec_size(int fd)
 	return status;
 }
 
-void
-dump_sqe(struct io_uring_sqe *sqe)
-{
-	printf("\topcode: %d\n", sqe->opcode);
-	printf("\tflags:  0x%.8x\n", sqe->flags);
-	printf("\tfd:     %d\n", sqe->fd);
-	if (sqe->opcode == IORING_OP_POLL_ADD)
-		printf("\tpoll_events: 0x%.8x\n", sqe->poll_events);
-}
-
-int
-ioring_poll(struct io_uring *ring, int fd, int fixed)
+static int ioring_poll(struct io_uring *ring, int fd, int fixed)
 {
 	int ret;
 	struct io_uring_sqe *sqe;
@@ -447,22 +398,20 @@ ioring_poll(struct io_uring *ring, int fd, int fixed)
 	sqe->fd = fd;
 	sqe->poll_events = POLLIN|POLLOUT;
 
-	printf("io_uring_submit:\n");
-	dump_sqe(sqe);
 	ret = io_uring_submit(ring);
 	if (ret != 1) {
-		printf("failed to submit poll sqe: %d.\n", errno);
+		fprintf(stderr, "failed to submit poll sqe: %d.\n", ret);
 		return 1;
 	}
 
 	ret = io_uring_wait_cqe(ring, &cqe);
 	if (ret < 0) {
-		printf("io_uring_wait_cqe failed with %d\n", ret);
+		fprintf(stderr, "io_uring_wait_cqe failed with %d\n", ret);
 		return 1;
 	}
 	ret = 0;
 	if (cqe->res != POLLOUT) {
-		printf("io_uring_wait_cqe: expected 0x%.8x, got 0x%.8x\n",
+		fprintf(stderr, "io_uring_wait_cqe: expected 0x%.8x, got 0x%.8x\n",
 		       POLLOUT, cqe->res);
 		ret = 1;
 	}
@@ -471,8 +420,7 @@ ioring_poll(struct io_uring *ring, int fd, int fixed)
 	return ret;
 }
 
-int
-test_poll_ringfd(void)
+static int test_poll_ringfd(void)
 {
 	int status = 0;
 	int ret;
@@ -494,7 +442,7 @@ test_poll_ringfd(void)
 	 * fail, because the kernel does not allow registering of the
 	 * ring_fd.
 	 */
-	status |= expect_fail(fd, IORING_REGISTER_FILES, &fd, 1, EBADF);
+	status |= expect_fail(fd, IORING_REGISTER_FILES, &fd, 1, -EBADF);
 
 	/* tear down queue */
 	io_uring_queue_exit(&ring);
@@ -502,115 +450,7 @@ test_poll_ringfd(void)
 	return status;
 }
 
-static int test_shmem(void)
-{
-	const char pattern = 0xEA;
-	const int len = 4096;
-	struct io_uring_sqe *sqe;
-	struct io_uring_cqe *cqe;
-	struct io_uring ring;
-	struct iovec iov;
-	int memfd, ret, i;
-	char *mem;
-	int pipefd[2] = {-1, -1};
-
-	ret = io_uring_queue_init(8, &ring, 0);
-	if (ret)
-		return 1;
-
-	if (pipe(pipefd)) {
-		perror("pipe");
-		return 1;
-	}
-	memfd = memfd_create("uring-shmem-test", 0);
-	if (memfd < 0) {
-		fprintf(stderr, "memfd_create() failed %i\n", -errno);
-		return 1;
-	}
-	if (ftruncate(memfd, len)) {
-		fprintf(stderr, "can't truncate memfd\n");
-		return 1;
-	}
-	mem = mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_SHARED, memfd, 0);
-	if (!mem) {
-		fprintf(stderr, "mmap failed\n");
-		return 1;
-	}
-	for (i = 0; i < len; i++)
-		mem[i] = pattern;
-
-	iov.iov_base = mem;
-	iov.iov_len = len;
-	ret = io_uring_register_buffers(&ring, &iov, 1);
-	if (ret) {
-		if (ret == -EOPNOTSUPP) {
-			fprintf(stdout, "memfd registration isn't supported, "
-					"skip\n");
-			goto out;
-		}
-
-		fprintf(stderr, "buffer reg failed: %d\n", ret);
-		return 1;
-	}
-
-	/* check that we can read and write from/to shmem reg buffer */
-	sqe = io_uring_get_sqe(&ring);
-	io_uring_prep_write_fixed(sqe, pipefd[1], mem, 512, 0, 0);
-	sqe->user_data = 1;
-
-	ret = io_uring_submit(&ring);
-	if (ret != 1) {
-		fprintf(stderr, "submit write failed\n");
-		return 1;
-	}
-	ret = io_uring_wait_cqe(&ring, &cqe);
-	if (ret < 0 || cqe->user_data != 1 || cqe->res != 512) {
-		fprintf(stderr, "reading from shmem failed\n");
-		return 1;
-	}
-	io_uring_cqe_seen(&ring, cqe);
-
-	/* clean it, should be populated with the pattern back from the pipe */
-	memset(mem, 0, 512);
-	sqe = io_uring_get_sqe(&ring);
-	io_uring_prep_read_fixed(sqe, pipefd[0], mem, 512, 0, 0);
-	sqe->user_data = 2;
-
-	ret = io_uring_submit(&ring);
-	if (ret != 1) {
-		fprintf(stderr, "submit write failed\n");
-		return 1;
-	}
-	ret = io_uring_wait_cqe(&ring, &cqe);
-	if (ret < 0 || cqe->user_data != 2 || cqe->res != 512) {
-		fprintf(stderr, "reading from shmem failed\n");
-		return 1;
-	}
-	io_uring_cqe_seen(&ring, cqe);
-
-	for (i = 0; i < 512; i++) {
-		if (mem[i] != pattern) {
-			fprintf(stderr, "data integrity fail\n");
-			return 1;
-		}
-	}
-
-	ret = io_uring_unregister_buffers(&ring);
-	if (ret) {
-		fprintf(stderr, "buffer unreg failed: %d\n", ret);
-		return 1;
-	}
-out:
-	io_uring_queue_exit(&ring);
-	close(pipefd[0]);
-	close(pipefd[1]);
-	munmap(mem, len);
-	close(memfd);
-	return 0;
-}
-
-int
-main(int argc, char **argv)
+int main(int argc, char **argv)
 {
 	int fd, ret;
 	unsigned int status = 0;
@@ -618,33 +458,31 @@ main(int argc, char **argv)
 	struct rlimit rlim;
 
 	if (argc > 1)
-		return 0;
+		return T_EXIT_SKIP;
 
 	/* setup globals */
 	pagesize = getpagesize();
 	ret = getrlimit(RLIMIT_MEMLOCK, &rlim);
 	if (ret < 0) {
 		perror("getrlimit");
-		return 1;
+		return T_EXIT_PASS;
 	}
 	mlock_limit = rlim.rlim_cur;
-	printf("RELIMIT_MEMLOCK: %llu (%llu)\n", (unsigned long long) rlim.rlim_cur,
-		(unsigned long long) rlim.rlim_max);
 	devnull = open("/dev/null", O_RDWR);
 	if (devnull < 0) {
 		perror("open /dev/null");
-		exit(1);
+		exit(T_EXIT_FAIL);
 	}
 
 	/* invalid fd */
-	status |= expect_fail(-1, 0, NULL, 0, EBADF);
+	status |= expect_fail(-1, 0, NULL, 0, -EBADF);
 	/* valid fd that is not an io_uring fd */
-	status |= expect_fail(devnull, 0, NULL, 0, EOPNOTSUPP);
+	status |= expect_fail(devnull, 0, NULL, 0, -EOPNOTSUPP);
 
 	/* invalid opcode */
 	memset(&p, 0, sizeof(p));
 	fd = new_io_uring(1, &p);
-	ret = expect_fail(fd, ~0U, NULL, 0, EINVAL);
+	ret = expect_fail(fd, ~0U, NULL, 0, -EINVAL);
 	if (ret) {
 		/* if this succeeds, tear down the io_uring instance
 		 * and start clean for the next test. */
@@ -661,16 +499,8 @@ main(int argc, char **argv)
 	/* uring poll on the uring fd */
 	status |= test_poll_ringfd();
 
-	if (!status)
-		printf("PASS\n");
-	else
-		printf("FAIL\n");
-
-	ret = test_shmem();
-	if (ret) {
-		fprintf(stderr, "test_shmem() failed\n");
-		status |= 1;
-	}
+	if (status)
+		fprintf(stderr, "FAIL\n");
 
 	return status;
 }

data/vendor/liburing/test/io_uring_setup.c

@@ -15,6 +15,7 @@
 #include <errno.h>
 #include <sys/sysinfo.h>
 #include "liburing.h"
+#include "helpers.h"
 
 #include "../syscall.h"
 
@@ -97,29 +98,25 @@ dump_resv(struct io_uring_params *p)
 /* bogus: setup returns a valid fd on success... expect can't predict the
    fd we'll get, so this really only takes 1 parameter: error */
 int
-try_io_uring_setup(unsigned entries, struct io_uring_params *p, int expect, int error)
+try_io_uring_setup(unsigned entries, struct io_uring_params *p, int expect)
 {
-	int ret, err;
+	int ret;
 
-	printf("io_uring_setup(%u, %p), flags: %s, feat: %s, resv: %s, sq_thread_cpu: %u\n",
-	       entries, p, flags_string(p), features_string(p), dump_resv(p),
-	       p ? p->sq_thread_cpu : 0);
-
-	ret = __sys_io_uring_setup(entries, p);
+	ret = io_uring_setup(entries, p);
 	if (ret != expect) {
-		printf("expected %d, got %d\n", expect, ret);
+		fprintf(stderr, "expected %d, got %d\n", expect, ret);
 		/* if we got a valid uring, close it */
 		if (ret > 0)
 			close(ret);
 		return 1;
 	}
-	err = errno;
-	if (expect == -1 && error != err) {
-		if (err == EPERM && geteuid() != 0) {
+
+	if (expect < 0 && expect != ret) {
+		if (ret == -EPERM && geteuid() != 0) {
 			printf("Needs root, not flagging as an error\n");
 			return 0;
 		}
-		printf("expected errno %d, got %d\n", error, err);
+		fprintf(stderr, "expected errno %d, got %d\n", expect, ret);
 		return 1;
 	}
 
@@ -134,32 +131,32 @@ main(int argc, char **argv)
 	struct io_uring_params p;
 
 	if (argc > 1)
-		return 0;
+		return T_EXIT_SKIP;
 
 	memset(&p, 0, sizeof(p));
-	status |= try_io_uring_setup(0, &p, -1, EINVAL);
-	status |= try_io_uring_setup(1, NULL, -1, EFAULT);
+	status |= try_io_uring_setup(0, &p, -EINVAL);
+	status |= try_io_uring_setup(1, NULL, -EFAULT);
 
 	/* resv array is non-zero */
 	memset(&p, 0, sizeof(p));
 	p.resv[0] = p.resv[1] = p.resv[2] = 1;
-	status |= try_io_uring_setup(1, &p, -1, EINVAL);
+	status |= try_io_uring_setup(1, &p, -EINVAL);
 
 	/* invalid flags */
 	memset(&p, 0, sizeof(p));
 	p.flags = ~0U;
-	status |= try_io_uring_setup(1, &p, -1, EINVAL);
+	status |= try_io_uring_setup(1, &p, -EINVAL);
 
 	/* IORING_SETUP_SQ_AFF set but not IORING_SETUP_SQPOLL */
 	memset(&p, 0, sizeof(p));
 	p.flags = IORING_SETUP_SQ_AFF;
-	status |= try_io_uring_setup(1, &p, -1, EINVAL);
+	status |= try_io_uring_setup(1, &p, -EINVAL);
 
 	/* attempt to bind to invalid cpu */
 	memset(&p, 0, sizeof(p));
 	p.flags = IORING_SETUP_SQPOLL | IORING_SETUP_SQ_AFF;
 	p.sq_thread_cpu = get_nprocs_conf();
-	status |= try_io_uring_setup(1, &p, -1, EINVAL);
+	status |= try_io_uring_setup(1, &p, -EINVAL);
 
 	/* I think we can limit a process to a set of cpus.  I assume
 	 * we shouldn't be able to setup a kernel thread outside of that.
@@ -167,26 +164,24 @@ main(int argc, char **argv)
 
 	/* read/write on io_uring_fd */
 	memset(&p, 0, sizeof(p));
-	fd = __sys_io_uring_setup(1, &p);
+	fd = io_uring_setup(1, &p);
 	if (fd < 0) {
-		printf("io_uring_setup failed with %d, expected success\n",
-		       errno);
+		fprintf(stderr, "io_uring_setup failed with %d, expected success\n",
+		       -fd);
 		status = 1;
 	} else {
 		char buf[4096];
 		int ret;
 		ret = read(fd, buf, 4096);
 		if (ret >= 0) {
-			printf("read from io_uring fd succeeded.  expected fail\n");
+			fprintf(stderr, "read from io_uring fd succeeded.  expected fail\n");
 			status = 1;
 		}
 	}
 
-	if (!status) {
-		printf("PASS\n");
-		return 0;
-	}
+	if (!status)
+		return T_EXIT_PASS;
 
-	printf("FAIL\n");
-	return -1;
+	fprintf(stderr, "FAIL\n");
+	return T_EXIT_FAIL;
 }