Index: libcfa/src/concurrency/io.cfa
===================================================================
--- libcfa/src/concurrency/io.cfa	(revision 124c1b7d8164dc87fd5c283690c523ad199ce87f)
+++ libcfa/src/concurrency/io.cfa	(revision 5751a56c72a73cfd724a07d14af375206ec3dcc6)
@@ -16,5 +16,5 @@
 #if defined(__CFA_DEBUG__)
 	// #define __CFA_DEBUG_PRINT_IO__
-	#define __CFA_DEBUG_PRINT_IO_CORE__
+	// #define __CFA_DEBUG_PRINT_IO_CORE__
 #endif
 
@@ -22,5 +22,5 @@
 #include "bitmanip.hfa"
 
-#if !defined(HAVE_LINUX_IO_URING_H)
+#if !defined(CFA_HAVE_LINUX_IO_URING_H)
 	void __kernel_io_startup( cluster &, unsigned, bool ) {
 		// Nothing to do without io_uring
@@ -490,4 +490,13 @@
 	static uint32_t __release_consumed_submission( struct __io_data & ring );
 
+	static inline void process(struct io_uring_cqe & cqe, struct __processor_id_t * id ) {
+		struct __io_user_data_t * data = (struct __io_user_data_t *)(uintptr_t)cqe.user_data;
+		__cfadbg_print_safe( io, "Kernel I/O : Syscall completed : cqe %p, result %d for %p\n", data, cqe.res, data->thrd );
+
+		data->result = cqe.res;
+		if(!id) { unpark(     data->thrd __cfaabi_dbg_ctx2 ); }
+		else  { __unpark( id, data->thrd __cfaabi_dbg_ctx2 ); }
+	}
+
 	// Process a single completion message from the io_uring
 	// This is NOT thread-safe
@@ -538,10 +547,5 @@
 			/* paranoid */ verify(&cqe);
 
-			struct __io_user_data_t * data = (struct __io_user_data_t *)(uintptr_t)cqe.user_data;
-			__cfadbg_print_safe( io, "Kernel I/O : Performed reading io cqe %p, result %d for %p\n", data, cqe.res, data->thrd );
-
-			data->result = cqe.res;
-			if(!mask) { unpark( data->thrd __cfaabi_dbg_ctx2 ); }
-			else      { __unpark( &ring.poller.slow.id, data->thrd __cfaabi_dbg_ctx2 ); }
+			process( cqe, !mask ? (struct __processor_id_t *)0p : &ring.poller.slow.id );
 		}
 
Index: libcfa/src/concurrency/iocall.cfa
===================================================================
--- libcfa/src/concurrency/iocall.cfa	(revision 124c1b7d8164dc87fd5c283690c523ad199ce87f)
+++ libcfa/src/concurrency/iocall.cfa	(revision 5751a56c72a73cfd724a07d14af375206ec3dcc6)
@@ -20,5 +20,5 @@
 //=============================================================================================
 
-#if defined(HAVE_LINUX_IO_URING_H)
+#if defined(CFA_HAVE_LINUX_IO_URING_H)
 	#include <stdint.h>
 	#include <linux/io_uring.h>
@@ -122,5 +122,5 @@
 #if defined(HAVE_PREADV2)
 	ssize_t cfa_preadv2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags) {
-		#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_READV)
+		#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_READV)
 			return preadv2(fd, iov, iovcnt, offset, flags);
 		#else
@@ -134,5 +134,5 @@
 
 	ssize_t cfa_preadv2_fixed(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags) {
-		#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_READV)
+		#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_READV)
 			return preadv2(fd, iov, iovcnt, offset, flags);
 		#else
@@ -149,5 +149,5 @@
 #if defined(HAVE_PWRITEV2)
 	ssize_t cfa_pwritev2(int fd, const struct iovec *iov, int iovcnt, off_t offset, int flags) {
-		#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_WRITEV)
+		#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_WRITEV)
 			return pwritev2(fd, iov, iovcnt, offset, flags);
 		#else
@@ -162,5 +162,5 @@
 
 int cfa_fsync(int fd) {
-	#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_FSYNC)
+	#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_FSYNC)
 		return fsync(fd);
 	#else
@@ -174,5 +174,5 @@
 
 int cfa_sync_file_range(int fd, int64_t offset, int64_t nbytes, unsigned int flags) {
-	#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_SYNC_FILE_RANGE)
+	#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_SYNC_FILE_RANGE)
 		return sync_file_range(fd, offset, nbytes, flags);
 	#else
@@ -190,5 +190,5 @@
 
 ssize_t cfa_sendmsg(int sockfd, const struct msghdr *msg, int flags) {
-	#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_SENDMSG)
+	#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_SENDMSG)
 		return sendmsg(sockfd, msg, flags);
 	#else
@@ -203,5 +203,5 @@
 
 ssize_t cfa_recvmsg(int sockfd, struct msghdr *msg, int flags) {
-	#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_RECVMSG)
+	#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_RECVMSG)
 		return recvmsg(sockfd, msg, flags);
 	#else
@@ -216,5 +216,5 @@
 
 ssize_t cfa_send(int sockfd, const void *buf, size_t len, int flags) {
-	#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_SEND)
+	#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_SEND)
 		return send( sockfd, buf, len, flags );
 	#else
@@ -231,5 +231,5 @@
 
 ssize_t cfa_recv(int sockfd, void *buf, size_t len, int flags) {
-	#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_RECV)
+	#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_RECV)
 		return recv( sockfd, buf, len, flags );
 	#else
@@ -246,5 +246,5 @@
 
 int cfa_accept4(int sockfd, struct sockaddr *addr, socklen_t *addrlen, int flags) {
-	#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_ACCEPT)
+	#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_ACCEPT)
 		return accept4( sockfd, addr, addrlen, flags );
 	#else
@@ -261,5 +261,5 @@
 
 int cfa_connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
-	#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_CONNECT)
+	#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_CONNECT)
 		return connect( sockfd, addr, addrlen );
 	#else
@@ -275,5 +275,5 @@
 
 int cfa_fallocate(int fd, int mode, uint64_t offset, uint64_t len) {
-	#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_FALLOCATE)
+	#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_FALLOCATE)
 		return fallocate( fd, mode, offset, len );
 	#else
@@ -290,5 +290,5 @@
 
 int cfa_fadvise(int fd, uint64_t offset, uint64_t len, int advice) {
-	#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_FADVISE)
+	#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_FADVISE)
 		return posix_fadvise( fd, offset, len, advice );
 	#else
@@ -305,5 +305,5 @@
 
 int cfa_madvise(void *addr, size_t length, int advice) {
-	#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_MADVISE)
+	#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_MADVISE)
 		return madvise( addr, length, advice );
 	#else
@@ -320,5 +320,5 @@
 
 int cfa_openat(int dirfd, const char *pathname, int flags, mode_t mode) {
-	#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_OPENAT)
+	#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_OPENAT)
 		return openat( dirfd, pathname, flags, mode );
 	#else
@@ -335,5 +335,5 @@
 
 int cfa_close(int fd) {
-	#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_CLOSE)
+	#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_CLOSE)
 		return close( fd );
 	#else
@@ -349,5 +349,5 @@
 struct statx;
 int cfa_statx(int dirfd, const char *pathname, int flags, unsigned int mask, struct statx *statxbuf) {
-	#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_STATX)
+	#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_STATX)
 		#if defined(__NR_statx)
 			return syscall( __NR_statx, dirfd, pathname, flags, mask, statxbuf );
@@ -367,5 +367,5 @@
 
 ssize_t cfa_read(int fd, void *buf, size_t count) {
-	#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_READ)
+	#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_READ)
 		return read( fd, buf, count );
 	#else
@@ -379,5 +379,5 @@
 
 ssize_t cfa_write(int fd, void *buf, size_t count) {
-	#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_WRITE)
+	#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_WRITE)
 		return read( fd, buf, count );
 	#else
@@ -391,5 +391,5 @@
 
 ssize_t cfa_splice(int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len, unsigned int flags) {
-	#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_SPLICE)
+	#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_SPLICE)
 		return splice( fd_in, off_in, fd_out, off_out, len, flags );
 	#else
@@ -405,6 +405,22 @@
 }
 
+ssize_t cfa_splice(int fd_in, loff_t *off_in, int fd_out, loff_t *off_out, size_t len, unsigned int flags, int in_flags, int out_flags) {
+	#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_SPLICE)
+		return splice( fd_in, off_in, fd_out, off_out, len, flags );
+	#else
+		__submit_prelude
+
+		(*sqe){ IORING_OP_SPLICE, fd_out, 0p, len, off_out };
+		sqe->splice_fd_in  = fd_in;
+		sqe->splice_off_in = off_in;
+		sqe->splice_flags  = flags | out_flags;
+		sqe->flags = in_flags;
+
+		__submit_wait
+	#endif
+}
+
 ssize_t cfa_tee(int fd_in, int fd_out, size_t len, unsigned int flags) {
-	#if !defined(HAVE_LINUX_IO_URING_H) || !defined(IORING_OP_TEE)
+	#if !defined(CFA_HAVE_LINUX_IO_URING_H) || !defined(CFA_HAVE_IORING_OP_TEE)
 		return tee( fd_in, fd_out, len, flags );
 	#else
@@ -429,10 +445,10 @@
 
 bool has_user_level_blocking( fptr_t func ) {
-	#if defined(HAVE_LINUX_IO_URING_H)
+	#if defined(CFA_HAVE_LINUX_IO_URING_H)
 		#if defined(HAVE_PREADV2)
 			if( /*func == (fptr_t)preadv2 || */
 				func == (fptr_t)cfa_preadv2 )
-				#define _CFA_IO_FEATURE_IORING_OP_READV ,
-				return IS_DEFINED(IORING_OP_READV);
+				#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_READV ,
+				return IS_DEFINED(CFA_HAVE_IORING_OP_READV);
 		#endif
 
@@ -440,92 +456,93 @@
 			if( /*func == (fptr_t)pwritev2 || */
 				func == (fptr_t)cfa_pwritev2 )
-				#define _CFA_IO_FEATURE_IORING_OP_WRITEV ,
-				return IS_DEFINED(IORING_OP_WRITEV);
+				#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_WRITEV ,
+				return IS_DEFINED(CFA_HAVE_IORING_OP_WRITEV);
 		#endif
 
 		if( /*func == (fptr_t)fsync || */
 			func == (fptr_t)cfa_fsync )
-			#define _CFA_IO_FEATURE_IORING_OP_FSYNC ,
-			return IS_DEFINED(IORING_OP_FSYNC);
+			#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_FSYNC ,
+			return IS_DEFINED(CFA_HAVE_IORING_OP_FSYNC);
 
 		if( /*func == (fptr_t)ync_file_range || */
 			func == (fptr_t)cfa_sync_file_range )
-			#define _CFA_IO_FEATURE_IORING_OP_SYNC_FILE_RANGE ,
-			return IS_DEFINED(IORING_OP_SYNC_FILE_RANGE);
+			#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_SYNC_FILE_RANGE ,
+			return IS_DEFINED(CFA_HAVE_IORING_OP_SYNC_FILE_RANGE);
 
 		if( /*func == (fptr_t)sendmsg || */
 			func == (fptr_t)cfa_sendmsg )
-			#define _CFA_IO_FEATURE_IORING_OP_SENDMSG ,
-			return IS_DEFINED(IORING_OP_SENDMSG);
+			#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_SENDMSG ,
+			return IS_DEFINED(CFA_HAVE_IORING_OP_SENDMSG);
 
 		if( /*func == (fptr_t)recvmsg || */
 			func == (fptr_t)cfa_recvmsg )
-			#define _CFA_IO_FEATURE_IORING_OP_RECVMSG ,
-			return IS_DEFINED(IORING_OP_RECVMSG);
+			#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_RECVMSG ,
+			return IS_DEFINED(CFA_HAVE_IORING_OP_RECVMSG);
 
 		if( /*func == (fptr_t)send || */
 			func == (fptr_t)cfa_send )
-			#define _CFA_IO_FEATURE_IORING_OP_SEND ,
-			return IS_DEFINED(IORING_OP_SEND);
+			#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_SEND ,
+			return IS_DEFINED(CFA_HAVE_IORING_OP_SEND);
 
 		if( /*func == (fptr_t)recv || */
 			func == (fptr_t)cfa_recv )
-			#define _CFA_IO_FEATURE_IORING_OP_RECV ,
-			return IS_DEFINED(IORING_OP_RECV);
+			#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_RECV ,
+			return IS_DEFINED(CFA_HAVE_IORING_OP_RECV);
 
 		if( /*func == (fptr_t)accept4 || */
 			func == (fptr_t)cfa_accept4 )
-			#define _CFA_IO_FEATURE_IORING_OP_ACCEPT ,
-			return IS_DEFINED(IORING_OP_ACCEPT);
+			#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_ACCEPT ,
+			return IS_DEFINED(CFA_HAVE_IORING_OP_ACCEPT);
 
 		if( /*func == (fptr_t)connect || */
 			func == (fptr_t)cfa_connect )
-			#define _CFA_IO_FEATURE_IORING_OP_CONNECT ,
-			return IS_DEFINED(IORING_OP_CONNECT);
+			#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_CONNECT ,
+			return IS_DEFINED(CFA_HAVE_IORING_OP_CONNECT);
 
 		if( /*func == (fptr_t)fallocate || */
 			func == (fptr_t)cfa_fallocate )
-			#define _CFA_IO_FEATURE_IORING_OP_FALLOCATE ,
-			return IS_DEFINED(IORING_OP_FALLOCATE);
+			#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_FALLOCATE ,
+			return IS_DEFINED(CFA_HAVE_IORING_OP_FALLOCATE);
 
 		if( /*func == (fptr_t)posix_fadvise || */
 			func == (fptr_t)cfa_fadvise )
-			#define _CFA_IO_FEATURE_IORING_OP_FADVISE ,
-			return IS_DEFINED(IORING_OP_FADVISE);
+			#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_FADVISE ,
+			return IS_DEFINED(CFA_HAVE_IORING_OP_FADVISE);
 
 		if( /*func == (fptr_t)madvise || */
 			func == (fptr_t)cfa_madvise )
-			#define _CFA_IO_FEATURE_IORING_OP_MADVISE ,
-			return IS_DEFINED(IORING_OP_MADVISE);
+			#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_MADVISE ,
+			return IS_DEFINED(CFA_HAVE_IORING_OP_MADVISE);
 
 		if( /*func == (fptr_t)openat || */
 			func == (fptr_t)cfa_openat )
-			#define _CFA_IO_FEATURE_IORING_OP_OPENAT ,
-			return IS_DEFINED(IORING_OP_OPENAT);
+			#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_OPENAT ,
+			return IS_DEFINED(CFA_HAVE_IORING_OP_OPENAT);
 
 		if( /*func == (fptr_t)close || */
 			func == (fptr_t)cfa_close )
-			#define _CFA_IO_FEATURE_IORING_OP_CLOSE ,
-			return IS_DEFINED(IORING_OP_CLOSE);
+			#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_CLOSE ,
+			return IS_DEFINED(CFA_HAVE_IORING_OP_CLOSE);
 
 		if( /*func == (fptr_t)read || */
 			func == (fptr_t)cfa_read )
-			#define _CFA_IO_FEATURE_IORING_OP_READ ,
-			return IS_DEFINED(IORING_OP_READ);
+			#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_READ ,
+			return IS_DEFINED(CFA_HAVE_IORING_OP_READ);
 
 		if( /*func == (fptr_t)write || */
 			func == (fptr_t)cfa_write )
-			#define _CFA_IO_FEATURE_IORING_OP_WRITE ,
-			return IS_DEFINED(IORING_OP_WRITE);
+			#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_WRITE ,
+			return IS_DEFINED(CFA_HAVE_IORING_OP_WRITE);
 
 		if( /*func == (fptr_t)splice || */
-			func == (fptr_t)cfa_splice )
-			#define _CFA_IO_FEATURE_IORING_OP_SPLICE ,
-			return IS_DEFINED(IORING_OP_SPLICE);
+			func == (fptr_t)(ssize_t (*)(int, loff_t *, int, loff_t *, size_t, unsigned int))cfa_splice,
+			func == (fptr_t)(ssize_t (*)(int, loff_t *, int, loff_t *, size_t, unsigned int, int, int))cfa_splice )
+			#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_SPLICE ,
+			return IS_DEFINED(CFA_HAVE_IORING_OP_SPLICE);
 
 		if( /*func == (fptr_t)tee || */
 			func == (fptr_t)cfa_tee )
-			#define _CFA_IO_FEATURE_IORING_OP_TEE ,
-			return IS_DEFINED(IORING_OP_TEE);
+			#define _CFA_IO_FEATURE_CFA_HAVE_IORING_OP_TEE ,
+			return IS_DEFINED(CFA_HAVE_IORING_OP_TEE);
 	#endif
 
Index: libcfa/src/concurrency/stats.cfa
===================================================================
--- libcfa/src/concurrency/stats.cfa	(revision 124c1b7d8164dc87fd5c283690c523ad199ce87f)
+++ libcfa/src/concurrency/stats.cfa	(revision 5751a56c72a73cfd724a07d14af375206ec3dcc6)
@@ -24,5 +24,5 @@
 		stats->ready.sleep.exits   = 0;
 
-		#if defined(HAVE_LINUX_IO_URING_H)
+		#if defined(CFA_HAVE_LINUX_IO_URING_H)
 			stats->io.submit_q.submit_avg.rdy = 0;
 			stats->io.submit_q.submit_avg.csm = 0;
@@ -59,5 +59,5 @@
 		__atomic_fetch_add( &cltr->ready.sleep.exits  , proc->ready.sleep.exits  , __ATOMIC_SEQ_CST );
 
-		#if defined(HAVE_LINUX_IO_URING_H)
+		#if defined(CFA_HAVE_LINUX_IO_URING_H)
 			__atomic_fetch_add( &cltr->io.submit_q.submit_avg.rdy          , proc->io.submit_q.submit_avg.rdy          , __ATOMIC_SEQ_CST );
 			__atomic_fetch_add( &cltr->io.submit_q.submit_avg.csm          , proc->io.submit_q.submit_avg.csm          , __ATOMIC_SEQ_CST );
@@ -121,5 +121,5 @@
 		}
 
-		#if defined(HAVE_LINUX_IO_URING_H)
+		#if defined(CFA_HAVE_LINUX_IO_URING_H)
 			if( flags & CFA_STATS_IO ) {
 				double avgrdy = ((double)io.submit_q.submit_avg.rdy) / io.submit_q.submit_avg.cnt;
Index: libcfa/src/concurrency/stats.hfa
===================================================================
--- libcfa/src/concurrency/stats.hfa	(revision 124c1b7d8164dc87fd5c283690c523ad199ce87f)
+++ libcfa/src/concurrency/stats.hfa	(revision 5751a56c72a73cfd724a07d14af375206ec3dcc6)
@@ -11,5 +11,5 @@
 	enum {
 		CFA_STATS_READY_Q  = 0x01,
-		#if defined(HAVE_LINUX_IO_URING_H)
+		#if defined(CFA_HAVE_LINUX_IO_URING_H)
 			CFA_STATS_IO = 0x02,
 		#endif
@@ -64,5 +64,5 @@
 	};
 
-	#if defined(HAVE_LINUX_IO_URING_H)
+	#if defined(CFA_HAVE_LINUX_IO_URING_H)
 		struct __attribute__((aligned(64))) __stats_io_t{
 			struct {
@@ -99,5 +99,5 @@
 	struct __attribute__((aligned(128))) __stats_t {
 		__stats_readQ_t ready;
-		#if defined(HAVE_LINUX_IO_URING_H)
+		#if defined(CFA_HAVE_LINUX_IO_URING_H)
 			__stats_io_t    io;
 		#endif