uringmachine 0.16 → 0.18

data/vendor/liburing/src/include/liburing.h

@@ -28,6 +28,13 @@
 #define uring_likely(cond)	__builtin_expect(!!(cond), 1)
 #endif
 
+/*
+ * NOTE: Only use IOURINGINLINE macro for 'static inline' functions
+ *       that are expected to be available in the FFI bindings.
+ *
+ *       Functions that are marked as IOURINGINLINE should be
+ *       included in the liburing-ffi.map file.
+ */
 #ifndef IOURINGINLINE
 #define IOURINGINLINE static inline
 #endif
@@ -146,6 +153,11 @@ struct io_uring_zcrx_rq {
  * Library interface
  */
 
+static inline __u64 uring_ptr_to_u64(const void *ptr)
+{
+	return (__u64) (unsigned long) ptr;
+}
+
 /*
  * return an allocated io_uring_probe structure, or NULL if probe fails (for
  * example, if it is not available). The caller is responsible for freeing it
@@ -274,6 +286,7 @@ int io_uring_unregister_buf_ring(struct io_uring *ring, int bgid);
 int io_uring_buf_ring_head(struct io_uring *ring, int buf_group, uint16_t *head);
 int io_uring_register_sync_cancel(struct io_uring *ring,
 				 struct io_uring_sync_cancel_reg *reg);
+int io_uring_register_sync_msg(struct io_uring_sqe *sqe);
 
 int io_uring_register_file_alloc_range(struct io_uring *ring,
 					unsigned off, unsigned len);
@@ -355,7 +368,7 @@ struct io_uring_cqe_iter {
 	unsigned tail;
 };
 
-IOURINGINLINE struct io_uring_cqe_iter
+static inline struct io_uring_cqe_iter
 io_uring_cqe_iter_init(const struct io_uring *ring)
 {
 	return (struct io_uring_cqe_iter) {
@@ -368,7 +381,7 @@ io_uring_cqe_iter_init(const struct io_uring *ring)
 	};
 }
 
-IOURINGINLINE bool io_uring_cqe_iter_next(struct io_uring_cqe_iter *iter,
+static inline bool io_uring_cqe_iter_next(struct io_uring_cqe_iter *iter,
 					  struct io_uring_cqe **cqe)
 {
 	if (iter->head == iter->tail)
@@ -716,7 +729,7 @@ IOURINGINLINE void io_uring_prep_accept(struct io_uring_sqe *sqe, int fd,
 					socklen_t *addrlen, int flags)
 {
 	io_uring_prep_rw(IORING_OP_ACCEPT, sqe, fd, addr, 0,
-				(__u64) (unsigned long) addrlen);
+				uring_ptr_to_u64(addrlen));
 	sqe->accept_flags = (__u32) flags;
 }
 
@@ -902,7 +915,7 @@ IOURINGINLINE void io_uring_prep_statx(struct io_uring_sqe *sqe, int dfd,
 				       unsigned mask, struct statx *statxbuf)
 {
 	io_uring_prep_rw(IORING_OP_STATX, sqe, dfd, path, mask,
-				(__u64) (unsigned long) statxbuf);
+				uring_ptr_to_u64(statxbuf));
 	sqe->statx_flags = (__u32) flags;
 }
 
@@ -1746,6 +1759,9 @@ struct io_uring_sqe *io_uring_get_sqe(struct io_uring *ring);
 ssize_t io_uring_mlock_size(unsigned entries, unsigned flags);
 ssize_t io_uring_mlock_size_params(unsigned entries, struct io_uring_params *p);
 
+ssize_t io_uring_memory_size(unsigned entries, unsigned flags);
+ssize_t io_uring_memory_size_params(unsigned entries, struct io_uring_params *p);
+
 /*
  * Versioning information for liburing.
  *

data/vendor/liburing/src/lib.h

@@ -29,10 +29,8 @@
 #endif
 
 #ifndef container_of
-#define container_of(PTR, TYPE, FIELD) ({			\
-	__typeof__(((TYPE *)0)->FIELD) *__FIELD_PTR = (PTR);	\
-	(TYPE *)((char *) __FIELD_PTR - offsetof(TYPE, FIELD));	\
-})
+#define container_of(PTR, TYPE, MEMBER)				\
+	((TYPE *)((char *)(PTR) - __builtin_offsetof(TYPE, MEMBER)))
 #endif
 
 #define __maybe_unused		__attribute__((__unused__))

data/vendor/liburing/src/liburing-ffi.map

@@ -237,3 +237,10 @@ LIBURING_2.10 {
 		__io_uring_clone_buffers;
 		__io_uring_clone_buffers_offset;
 } LIBURING_2.9;
+
+LIBURING_2.11 {
+	global:
+		io_uring_memory_size;
+		io_uring_memory_size_params;
+		io_uring_register_sync_msg;
+} LIBURING_2.10;

data/vendor/liburing/src/liburing.map

@@ -119,3 +119,10 @@ LIBURING_2.10 {
 		__io_uring_clone_buffers;
 		__io_uring_clone_buffers_offset;
 } LIBURING_2.9;
+
+LIBURING_2.11 {
+	global:
+		io_uring_memory_size;
+		io_uring_memory_size_params;
+		io_uring_register_sync_msg;
+} LIBURING_2.10;

data/vendor/liburing/src/register.c

@@ -368,6 +368,11 @@ int io_uring_register_sync_cancel(struct io_uring *ring,
 	return do_register(ring, IORING_REGISTER_SYNC_CANCEL, reg, 1);
 }
 
+int io_uring_register_sync_msg(struct io_uring_sqe *sqe)
+{
+	return __sys_io_uring_register(-1, IORING_REGISTER_SEND_MSG_RING, sqe, 1);
+}
+
 int io_uring_register_file_alloc_range(struct io_uring *ring,
 					unsigned off, unsigned len)
 {

data/vendor/liburing/src/sanitize.c

@@ -115,10 +115,11 @@ static inline void initialize_sanitize_handlers()
 	sanitize_handlers[IORING_OP_FTRUNCATE] = sanitize_sqe_addr;
 	sanitize_handlers[IORING_OP_BIND] = sanitize_sqe_addr;
 	sanitize_handlers[IORING_OP_LISTEN] = sanitize_sqe_addr;
-	sanitize_handlers[IORING_OP_RECV_ZC] = sanitize_sqe_addr,
-	sanitize_handlers[IORING_OP_EPOLL_WAIT] = sanitize_sqe_addr,
-	sanitize_handlers[IORING_OP_READV_FIXED] = sanitize_sqe_addr,
-	sanitize_handlers[IORING_OP_WRITEV_FIXED] = sanitize_sqe_addr,
+	sanitize_handlers[IORING_OP_RECV_ZC] = sanitize_sqe_addr;
+	sanitize_handlers[IORING_OP_EPOLL_WAIT] = sanitize_sqe_addr;
+	sanitize_handlers[IORING_OP_READV_FIXED] = sanitize_sqe_addr;
+	sanitize_handlers[IORING_OP_WRITEV_FIXED] = sanitize_sqe_addr;
+	_Static_assert(IORING_OP_WRITEV_FIXED + 1 == IORING_OP_LAST, "Need an implementation for all IORING_OP_* codes");
 	sanitize_handlers_initialized = true;
 }
 

data/vendor/liburing/src/setup.c

@@ -7,6 +7,7 @@
 #include "int_flags.h"
 #include "setup.h"
 #include "liburing/io_uring.h"
+#include <stdio.h>
 
 #define KERN_MAX_ENTRIES	32768
 #define KERN_MAX_CQ_ENTRIES	(2 * KERN_MAX_ENTRIES)
@@ -498,27 +499,57 @@ __cold void io_uring_free_probe(struct io_uring_probe *probe)
 	free(probe);
 }
 
-static size_t npages(size_t size, long page_size)
-{
-	size--;
-	size /= page_size;
-	return __fls((int) size);
-}
-
 static size_t rings_size(struct io_uring_params *p, unsigned entries,
 			 unsigned cq_entries, long page_size)
 {
 	size_t pages, sq_size, cq_size;
 
-	cq_size = KRING_SIZE + params_cq_size(p, cq_entries);
-	cq_size = (cq_size + 63) & ~63UL;
-	pages = (size_t) 1 << npages(cq_size, page_size);
+	/*
+	 * CQ ring size is number of pages that we need for the
+	 * struct io_uring_cqe entries, which may be 16b (default) or
+	 * 32b if the ring is setup with IORING_SETUP_CQE32. We also need
+	 * room for the head/tail parts.
+	 */
+	cq_size = params_cq_size(p, cq_entries);
+	cq_size += KRING_SIZE;
+	cq_size = (cq_size + page_size - 1) & ~(page_size - 1);
+	pages = (size_t) cq_size / page_size;
 
 	sq_size = params_sqes_size(p, entries);
-	pages += (size_t) 1 << npages(sq_size, page_size);
+	sq_size = (sq_size + page_size - 1) & ~(page_size - 1);
+	pages += sq_size / page_size;
 	return pages * page_size;
 }
 
+ssize_t io_uring_memory_size_params(unsigned entries, struct io_uring_params *p)
+{
+	unsigned sq, cq;
+	long page_size;
+	ssize_t ret;
+
+	if (!entries)
+		return -EINVAL;
+	if (entries > KERN_MAX_ENTRIES) {
+		if (!(p->flags & IORING_SETUP_CLAMP))
+			return -EINVAL;
+		entries = KERN_MAX_ENTRIES;
+	}
+
+	ret = get_sq_cq_entries(entries, p, &sq, &cq);
+	if (ret)
+		return ret;
+
+	page_size = get_page_size();
+	return rings_size(p, sq, cq, page_size);
+}
+
+ssize_t io_uring_memory_size(unsigned entries, unsigned ring_flags)
+{
+	struct io_uring_params p = { .flags = ring_flags, };
+
+	return io_uring_memory_size_params(entries, &p);
+}
+
 /*
  * Return the required ulimit -l memlock memory required for a given ring
  * setup, in bytes. May return -errno on error. On newer (5.12+) kernels,
@@ -532,10 +563,7 @@ __cold ssize_t io_uring_mlock_size_params(unsigned entries,
 {
 	struct io_uring_params lp;
 	struct io_uring ring;
-	unsigned cq_entries, sq;
-	long page_size;
 	ssize_t ret;
-	int cret;
 
 	memset(&lp, 0, sizeof(lp));
 
@@ -557,20 +585,7 @@ __cold ssize_t io_uring_mlock_size_params(unsigned entries,
 	if (lp.features & IORING_FEAT_NATIVE_WORKERS)
 		return 0;
 
-	if (!entries)
-		return -EINVAL;
-	if (entries > KERN_MAX_ENTRIES) {
-		if (!(p->flags & IORING_SETUP_CLAMP))
-			return -EINVAL;
-		entries = KERN_MAX_ENTRIES;
-	}
-
-	cret = get_sq_cq_entries(entries, p, &sq, &cq_entries);
-	if (cret)
-		return cret;
-
-	page_size = get_page_size();
-	return rings_size(p, sq, cq_entries, page_size);
+	return io_uring_memory_size_params(entries, p);
 }
 
 /*

data/vendor/liburing/test/Makefile

@@ -86,6 +86,7 @@ test_srcs := \
 	eventfd-disable.c \
 	eventfd-reg.c \
 	eventfd-ring.c \
+	evfd-short-read.c \
 	evloop.c \
 	exec-target.c \
 	exit-no-cleanup.c \
@@ -95,6 +96,7 @@ test_srcs := \
 	fd-install.c \
 	fd-pass.c \
 	fdinfo.c \
+	fdinfo-sqpoll.c \
 	fifo-nonblock-read.c \
 	file-exit-unreg.c \
 	file-register.c \
@@ -112,6 +114,7 @@ test_srcs := \
 	fsnotify.c \
 	fsync.c \
 	futex.c \
+	futex-kill.c \
 	hardlink.c \
 	ignore-single-mmap.c \
 	init-mem.c \
@@ -174,8 +177,10 @@ test_srcs := \
 	read-mshot-stdin.c \
 	read-write.c \
 	recv-bundle-short-ooo.c \
+	recv-inc-ooo.c \
 	recv-msgall.c \
 	recv-msgall-stream.c \
+	recv-mshot-fair.c \
 	recv-multishot.c \
 	reg-fd-only.c \
 	reg-hint.c \
@@ -232,6 +237,7 @@ test_srcs := \
 	sync-cancel.c \
 	teardowns.c \
 	thread-exit.c \
+	timerfd-short-read.c \
 	timeout.c \
 	timeout-new.c \
 	truncate.c \
@@ -246,6 +252,7 @@ test_srcs := \
 	xattr.c \
 	zcrx.c \
 	vec-regbuf.c \
+	timestamp.c \
 	# EOL
 
 # Please keep this list sorted alphabetically.

data/vendor/liburing/test/cmd-discard.c

@@ -380,9 +380,9 @@ int main(int argc, char *argv[])
 	bdev_size_lbas = bdev_size / lba_size;
 	close(fd);
 
-	buffer = aligned_alloc(lba_size, lba_size);
+	buffer = t_aligned_alloc(lba_size, lba_size);
 	if (!buffer) {
-		fprintf(stderr, "aligned_alloc failed\n");
+		fprintf(stderr, "t_aligned_alloc failed\n");
 		return T_EXIT_FAIL;
 	}
 	for (i = 0; i < lba_size; i++)

data/vendor/liburing/test/evfd-short-read.c

@@ -0,0 +1,84 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: Check that trying to read two eventfd events will still
+ *		return one when generated. There was a kernel commit that
+ *		all of a sudden pretended that anonymous inodes were
+ *		regular files, which broke the io_uring short read/write
+ *		handling logic. See:
+ *
+ *		https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id=cfd86ef7e8e7
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <sys/eventfd.h>
+
+#include "liburing.h"
+#include "helpers.h"
+
+static void sig_alrm(int sig)
+{
+	fprintf(stderr, "Test failed due to timeout\n");
+	exit(T_EXIT_FAIL);
+}
+
+int main(int argc, char *argv[])
+{
+	struct io_uring_params p = {};
+	struct sigaction act = { };
+	struct io_uring_sqe *sqe;
+	struct io_uring_cqe *cqe;
+	struct io_uring ring;
+	uint64_t ptr[2], tmp;
+	int ret, evfd;
+
+	if (argc > 1)
+		return T_EXIT_SKIP;
+
+	ret = io_uring_queue_init_params(8, &ring, &p);
+	if (ret) {
+		fprintf(stderr, "ring setup failed: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	evfd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
+	if (evfd < 0) {
+		perror("eventfd");
+		return T_EXIT_FAIL;
+	}
+
+	sqe = io_uring_get_sqe(&ring);
+	io_uring_prep_read(sqe, evfd, ptr, sizeof(ptr), 0);
+	sqe->user_data = 1;
+
+	io_uring_submit(&ring);
+
+	act.sa_handler = sig_alrm;
+	sigaction(SIGALRM, &act, NULL);
+	alarm(1);
+
+	usleep(10000);
+	tmp = 1;
+	ret = write(evfd, &tmp, sizeof(tmp));
+	if (ret < 0) {
+		perror("write");
+		return T_EXIT_FAIL;
+	} else if (ret != sizeof(tmp)) {
+		fprintf(stderr, "Short eventfd write\n");
+		return T_EXIT_FAIL;
+	}
+
+	ret = io_uring_wait_cqe(&ring, &cqe);
+	if (ret) {
+		fprintf(stderr, "wait: %d\n", ret);
+		return T_EXIT_FAIL;
+	}
+
+	io_uring_cqe_seen(&ring, cqe);
+	close(evfd);
+	return 0;
+}

data/vendor/liburing/test/fdinfo-sqpoll.c

@@ -0,0 +1,117 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: Race fdinfo reading with SQPOLL thread exiting
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <pthread.h>
+
+#include "helpers.h"
+#include "liburing.h"
+
+struct data {
+	struct io_uring ring;
+	pthread_t thread;
+	pthread_barrier_t barrier;
+	volatile int done;
+};
+
+static int rand_between(int a, int b)
+{
+	return a + rand() % (b - a + 1);
+}
+
+static void *fdinfo_read(void *__data)
+{
+	struct data *d = __data;
+	char fd_name[128];
+	char *buf;
+	int fd;
+
+	buf = malloc(4096);
+
+	sprintf(fd_name, "/proc/self/fdinfo/%d", d->ring.ring_fd);
+	fd = open(fd_name, O_RDONLY);
+	if (fd < 0) {
+		perror("open");
+		return NULL;
+	}
+
+	pthread_barrier_wait(&d->barrier);
+
+	do {
+		int ret = read(fd, buf, 4096);
+
+		if (ret < 0) {
+			perror("fdinfo read");
+			break;
+		}
+	} while (!d->done);
+
+	close(fd);
+	free(buf);
+	return NULL;
+}
+
+static int __test(void)
+{
+	struct data d = { };
+	void *tret;
+	int ret;
+
+	ret = t_create_ring(8, &d.ring, IORING_SETUP_SQPOLL);
+	if (ret == T_SETUP_SKIP)
+		exit(T_EXIT_SKIP);
+	else if (ret < 0)
+		exit(T_EXIT_FAIL);
+	pthread_barrier_init(&d.barrier, NULL, 2);
+	pthread_create(&d.thread, NULL, fdinfo_read, &d);
+	pthread_barrier_wait(&d.barrier);
+	usleep(rand_between(1000, 100000));
+	d.done = 1;
+	pthread_join(d.thread, &tret);
+	exit(T_EXIT_PASS);
+}
+
+static int test(void)
+{
+	pid_t pid;
+
+	pid = fork();
+	if (pid) {
+		int wstatus;
+
+		usleep(rand_between(10, 2000));
+		kill(pid, SIGINT);
+		waitpid(pid, &wstatus, 0);
+	} else {
+		return __test();
+	}
+
+	return T_EXIT_PASS;
+}
+
+int main(int argc, char *argv[])
+{
+	int i, ret;
+
+	if (argc > 1)
+		return T_EXIT_SKIP;
+
+	for (i = 0; i < 1000; i++) {
+		ret = test();
+		if (ret == T_EXIT_SKIP) {
+			return T_EXIT_SKIP;
+		} else if (ret) {
+			fprintf(stderr, "test failed\n");
+			return T_EXIT_FAIL;
+		}
+	}
+
+	return T_EXIT_PASS;
+}

data/vendor/liburing/test/fdinfo.c

@@ -1,6 +1,6 @@
 /* SPDX-License-Identifier: MIT */
 /*
- * Description: basic read/write tests with buffered, O_DIRECT, and SQPOLL
+ * Description: do SQPOLL IO with concurrent fdinfo reading
  */
 #include <errno.h>
 #include <stdio.h>

data/vendor/liburing/test/fixed-buf-merge.c

@@ -44,9 +44,9 @@ int main(int argc, char *argv[])
 		goto err_unlink;
 	}
 
-	to_free = buffer = aligned_alloc(4096, 128 * 4096);
+	to_free = buffer = t_aligned_alloc(4096, 128 * 4096);
 	if (!buffer) {
-		perror("aligned_alloc");
+		perror("t_aligned_alloc");
 		goto err_unlink;
 	}
 

data/vendor/liburing/test/futex-kill.c

@@ -0,0 +1,135 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * Description: Test FUTEX2_PRIVATE with an active waiter being killed
+ *
+ */
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <stdlib.h>
+#include <string.h>
+#include <linux/futex.h>
+
+#include "liburing.h"
+#include "helpers.h"
+
+#ifndef FUTEX2_SIZE_U32
+#define FUTEX2_SIZE_U32		0x02
+#endif
+#ifndef FUTEX2_PRIVATE
+#define FUTEX2_PRIVATE		128
+#endif
+
+static int do_child(int ring_flags, int async, int vectored)
+{
+	struct io_uring_params p = { .flags = ring_flags, };
+	struct io_uring_sqe *sqe;
+	struct io_uring ring;
+	struct futex_waitv fw = { };
+	unsigned int *futex;
+	int ret;
+
+	ret = t_create_ring_params(16, &ring, &p);
+	if (ret) {
+		if (ret == T_SETUP_SKIP)
+			return T_EXIT_SKIP;
+		fprintf(stderr, "ring setup failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	futex = malloc(sizeof(*futex));
+	*futex = 0;
+	fw.uaddr = (unsigned long) futex;
+	fw.flags = FUTEX2_SIZE_U32|FUTEX2_PRIVATE;
+
+	sqe = io_uring_get_sqe(&ring);
+	if (!vectored)
+		io_uring_prep_futex_wait(sqe, futex, 0, FUTEX_BITSET_MATCH_ANY,
+					FUTEX2_SIZE_U32|FUTEX2_PRIVATE, 0);
+	else
+		io_uring_prep_futex_waitv(sqe, &fw, 1, 0);
+	if (async)
+		sqe->flags |= IOSQE_ASYNC;
+	io_uring_submit(&ring);
+	return T_EXIT_PASS;
+}
+
+static int test(int sqpoll, int async, int vectored)
+{
+	int status, ring_flags = 0;
+	pid_t pid;
+
+	if (sqpoll)
+		ring_flags |= IORING_SETUP_SQPOLL;
+
+	pid = fork();
+	if (pid < 0) {
+		perror("fork");
+		return T_EXIT_FAIL;
+	} else if (!pid) {
+		exit(do_child(ring_flags, async, vectored));
+	}
+
+	usleep(10000);
+	kill(pid, 9);
+	waitpid(pid, &status, 0);
+	return T_EXIT_PASS;
+}
+
+int main(int argc, char *argv[])
+{
+	int ret;
+
+	ret = test(0, 0, 0);
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test 0 0 0 failed\n");
+		return T_EXIT_FAIL;
+	} else if (ret == T_EXIT_SKIP) {
+		return T_EXIT_SKIP;
+	}
+
+	ret = test(0, 1, 0);
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test 0 1 0 failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	ret = test(0, 0, 1);
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test 0 0 1 failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	ret = test(0, 1, 1);
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test 0 1 1 failed\n");
+		return T_EXIT_FAIL;
+	}
+
+
+	ret = test(IORING_SETUP_SQPOLL, 0, 0);
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test SQPOLL 0 0 failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	ret = test(IORING_SETUP_SQPOLL, 1, 0);
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test SQPOLL 1 0 failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	ret = test(IORING_SETUP_SQPOLL, 0, 1);
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test SQPOLL 0 1 failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	ret = test(IORING_SETUP_SQPOLL, 1, 1);
+	if (ret == T_EXIT_FAIL) {
+		fprintf(stderr, "test SQPOLL 1 1 failed\n");
+		return T_EXIT_FAIL;
+	}
+
+	return T_EXIT_PASS;
+}

data/vendor/liburing/test/helpers.c

@@ -364,7 +364,7 @@ unsigned long long utime_since_now(struct timeval *tv)
 	return utime_since(tv, &end);
 }
 
-void *aligned_alloc(size_t alignment, size_t size)
+void *t_aligned_alloc(size_t alignment, size_t size)
 {
 	void *ret;
 

data/vendor/liburing/test/helpers.h

@@ -31,7 +31,7 @@ enum t_test_result {
  * To avoid making large changes in tests, define a helper
  * function that wraps posix_memalign as our own aligned_alloc.
  */
-void *aligned_alloc(size_t alignment, size_t size);
+void *t_aligned_alloc(size_t alignment, size_t size);
 
 /*
  * Helper for binding socket to an ephemeral port.