uringmachine 0.1

data/vendor/liburing/examples/ucontext-cp.c

@@ -0,0 +1,258 @@
+/* SPDX-License-Identifier: MIT */
+/*
+ * gcc -Wall -O2 -D_GNU_SOURCE -o ucontext-cp ucontext-cp.c -luring
+ */
+#define _POSIX_C_SOURCE 199309L
+#include <stdio.h>
+#include <fcntl.h>
+#include <string.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <assert.h>
+#include <errno.h>
+#include <ucontext.h>
+#include <signal.h>
+#include <inttypes.h>
+#include <sys/types.h>
+#include <sys/ioctl.h>
+#include <sys/timerfd.h>
+#include <poll.h>
+#include "liburing.h"
+
+#define QD	64
+#define BS	1024
+
+#ifndef SIGSTKSZ
+#define SIGSTKSZ 8192
+#endif
+
+typedef struct {
+	struct io_uring *ring;
+	unsigned char *stack_buf;
+	ucontext_t ctx_main, ctx_fnew;
+} async_context;
+
+typedef struct {
+	async_context *pctx;
+	int *psuccess;
+	int *pfailure;
+	int infd;
+	int outfd;
+} arguments_bundle;
+
+#define DEFINE_AWAIT_OP(operation) 					\
+static ssize_t await_##operation(					\
+	async_context *pctx,						\
+	int fd,								\
+	const struct iovec *ioves,					\
+	unsigned int nr_vecs,						\
+	off_t offset)							\
+{									\
+	struct io_uring_sqe *sqe = io_uring_get_sqe(pctx->ring);	\
+	struct io_uring_cqe *cqe;					\
+									\
+	if (!sqe)							\
+		return -1;						\
+									\
+	io_uring_prep_##operation(sqe, fd, ioves, nr_vecs, offset);	\
+	io_uring_sqe_set_data(sqe, pctx);				\
+	swapcontext(&pctx->ctx_fnew, &pctx->ctx_main);			\
+	io_uring_peek_cqe(pctx->ring, &cqe);				\
+	assert(cqe);							\
+	io_uring_cqe_seen(pctx->ring, cqe);				\
+									\
+	return cqe->res;						\
+}
+
+DEFINE_AWAIT_OP(readv)
+DEFINE_AWAIT_OP(writev)
+#undef DEFINE_AWAIT_OP
+
+static int await_delay(async_context *pctx, time_t seconds)
+{
+	struct io_uring_sqe *sqe = io_uring_get_sqe(pctx->ring);
+	struct io_uring_cqe *cqe;
+	struct __kernel_timespec ts = {
+		.tv_sec = seconds,
+		.tv_nsec = 0
+	};
+
+	if (!sqe)
+		return -1;
+
+	io_uring_prep_timeout(sqe, &ts, 0, 0);
+	io_uring_sqe_set_data(sqe, pctx);
+	swapcontext(&pctx->ctx_fnew, &pctx->ctx_main);
+	io_uring_peek_cqe(pctx->ring, &cqe);
+	assert(cqe);
+	io_uring_cqe_seen(pctx->ring, cqe);
+
+	return 0;
+}
+
+static int setup_context(async_context *pctx, struct io_uring *ring)
+{
+	int ret;
+
+	pctx->ring = ring;
+	ret = getcontext(&pctx->ctx_fnew);
+	if (ret < 0) {
+		perror("getcontext");
+		return -1;
+	}
+	pctx->stack_buf = malloc(SIGSTKSZ);
+	if (!pctx->stack_buf) {
+		perror("malloc");
+		return -1;
+	}
+	pctx->ctx_fnew.uc_stack.ss_sp = pctx->stack_buf;
+	pctx->ctx_fnew.uc_stack.ss_size = SIGSTKSZ;
+	pctx->ctx_fnew.uc_link = &pctx->ctx_main;
+
+	return 0;
+}
+
+static int copy_file(async_context *pctx, int infd, int outfd, struct iovec* piov)
+{
+	off_t offset = 0;
+
+	for (;;) {
+		ssize_t bytes_read;
+
+		printf("%d->%d: readv %ld bytes from %ld\n", infd, outfd, (long) piov->iov_len, (long) offset);
+		if ((bytes_read = await_readv(pctx, infd, piov, 1, offset)) < 0) {
+			perror("await_readv");
+			return 1;
+		}
+		if (bytes_read == 0)
+			return 0;
+
+		piov->iov_len = bytes_read;
+
+		printf("%d->%d: writev %ld bytes from %ld\n", infd, outfd, (long) piov->iov_len, (long) offset);
+		if (await_writev(pctx, outfd, piov, 1, offset) != bytes_read) {
+			perror("await_writev");
+			return 1;
+		}
+		if (bytes_read < BS)
+			return 0;
+		offset += bytes_read;
+
+		printf("%d->%d: wait %ds\n", infd, outfd, 1);
+		await_delay(pctx, 1);
+	}
+}
+
+static void copy_file_wrapper(arguments_bundle *pbundle)
+{
+	struct iovec iov = {
+		.iov_base = malloc(BS),
+		.iov_len = BS,
+	};
+	async_context *pctx = pbundle->pctx;
+
+	int ret = copy_file(pctx, pbundle->infd, pbundle->outfd, &iov);
+
+	printf("%d->%d: done with ret code %d\n", pbundle->infd, pbundle->outfd, ret);
+
+	if (ret == 0) {
+		++*pbundle->psuccess;
+	} else {
+		++*pbundle->pfailure;
+	}
+
+	free(iov.iov_base);
+	close(pbundle->infd);
+	close(pbundle->outfd);
+	free(pbundle->pctx->stack_buf);
+	free(pbundle->pctx);
+	free(pbundle);
+
+	swapcontext(&pctx->ctx_fnew, &pctx->ctx_main);
+}
+
+int main(int argc, char *argv[])
+{
+	struct io_uring ring;
+	int i, req_count, ret;
+	int success = 0, failure = 0;
+
+	if (argc < 3) {
+		fprintf(stderr, "%s: infile1 outfile1 [infile2 outfile2 [...]]\n", argv[0]);
+		return 1;
+	}
+
+	ret = io_uring_queue_init(QD, &ring, 0);
+	if (ret < 0) {
+		fprintf(stderr, "queue_init: %s\n", strerror(-ret));
+		return -1;
+	}
+
+	req_count = (argc - 1) / 2;
+	printf("copying %d files...\n", req_count);
+
+	for (i = 1; i < argc; i += 2) {
+		int infd, outfd;
+
+		async_context *pctx = malloc(sizeof(*pctx));
+
+		if (!pctx || setup_context(pctx, &ring))
+			return 1;
+
+		infd = open(argv[i], O_RDONLY);
+		if (infd < 0) {
+			perror("open infile");
+			return 1;
+		}
+		outfd = open(argv[i + 1], O_WRONLY | O_CREAT | O_TRUNC, 0644);
+		if (outfd < 0) {
+			perror("open outfile");
+			return 1;
+		}
+
+		arguments_bundle *pbundle = malloc(sizeof(*pbundle));
+		pbundle->pctx = pctx;
+		pbundle->psuccess = &success;
+		pbundle->pfailure = &failure;
+		pbundle->infd = infd;
+		pbundle->outfd = outfd;
+
+		makecontext(&pctx->ctx_fnew, (void (*)(void)) copy_file_wrapper, 1, pbundle);
+
+		if (swapcontext(&pctx->ctx_main, &pctx->ctx_fnew)) {
+			perror("swapcontext");
+			return 1;
+		}
+	}
+
+	/* event loop */
+	while (success + failure < req_count) {
+		struct io_uring_cqe *cqe;
+
+		/* usually be timed waiting */
+		ret = io_uring_submit_and_wait(&ring, 1);
+		if (ret < 0) {
+			fprintf(stderr, "submit_and_wait: %s\n", strerror(-ret));
+			return 1;
+		}
+
+		ret = io_uring_wait_cqe(&ring, &cqe);
+		if (ret < 0) {
+			fprintf(stderr, "wait_cqe: %s\n", strerror(-ret));
+			return 1;
+		}
+
+		async_context *pctx = io_uring_cqe_get_data(cqe);
+
+		if (swapcontext(&pctx->ctx_main, &pctx->ctx_fnew)) {
+			perror("swapcontext");
+			return 1;
+		}
+	}
+
+	io_uring_queue_exit(&ring);
+
+	printf("finished with %d success(es) and %d failure(s)\n", success, failure);
+
+	return failure > 0;
+}

data/vendor/liburing/liburing-ffi.pc.in

@@ -0,0 +1,12 @@
+prefix=@prefix@
+exec_prefix=${prefix}
+libdir=@libdir@
+includedir=@includedir@
+
+Name: @NAME@
+Version: @VERSION@
+Description: io_uring FFI library
+URL: https://git.kernel.dk/cgit/liburing/
+
+Libs: -L${libdir} -luring-ffi
+Cflags: -I${includedir}

data/vendor/liburing/liburing.pc.in

@@ -0,0 +1,12 @@
+prefix=@prefix@
+exec_prefix=${prefix}
+libdir=@libdir@
+includedir=@includedir@
+
+Name: @NAME@
+Version: @VERSION@
+Description: io_uring library
+URL: https://git.kernel.dk/cgit/liburing/
+
+Libs: -L${libdir} -luring
+Cflags: -I${includedir} -D_GNU_SOURCE

data/vendor/liburing/liburing.spec

@@ -0,0 +1,66 @@
+Name: liburing
+Version: 2.8
+Release: 1%{?dist}
+Summary: Linux-native io_uring I/O access library
+License: (GPLv2 with exceptions and LGPLv2+) or MIT
+Source0: https://brick.kernel.dk/snaps/%{name}-%{version}.tar.gz
+Source1: https://brick.kernel.dk/snaps/%{name}-%{version}.tar.gz.asc
+URL: https://git.kernel.dk/cgit/liburing/
+BuildRequires: gcc
+BuildRequires: make
+
+%description
+Provides native async IO for the Linux kernel, in a fast and efficient
+manner, for both buffered and O_DIRECT.
+
+%package devel
+Summary: Development files for Linux-native io_uring I/O access library
+Requires: %{name}%{_isa} = %{version}-%{release}
+Requires: pkgconfig
+
+%description devel
+This package provides header files to include and libraries to link with
+for the Linux-native io_uring.
+
+%prep
+%autosetup
+
+%build
+%set_build_flags
+./configure --prefix=%{_prefix} --libdir=%{_libdir} --libdevdir=%{_libdir} --mandir=%{_mandir} --includedir=%{_includedir}
+
+%make_build
+
+%install
+%make_install
+
+%files
+%attr(0755,root,root) %{_libdir}/liburing.so.*
+%license COPYING
+
+%files devel
+%{_includedir}/liburing/
+%{_includedir}/liburing.h
+%{_libdir}/liburing.so
+%exclude %{_libdir}/liburing.a
+%{_libdir}/pkgconfig/*
+%{_mandir}/man2/*
+%{_mandir}/man3/*
+%{_mandir}/man7/*
+
+%changelog
+* Thu Oct 31 2019 Jeff Moyer <jmoyer@redhat.com> - 0.2-1
+- Add io_uring_cq_ready()
+- Add io_uring_peek_batch_cqe()
+- Add io_uring_prep_accept()
+- Add io_uring_prep_{recv,send}msg()
+- Add io_uring_prep_timeout_remove()
+- Add io_uring_queue_init_params()
+- Add io_uring_register_files_update()
+- Add io_uring_sq_space_left()
+- Add io_uring_wait_cqe_timeout()
+- Add io_uring_wait_cqes()
+- Add io_uring_wait_cqes_timeout()
+
+* Tue Jan 8 2019 Jens Axboe <axboe@kernel.dk> - 0.1
+- Initial version

data/vendor/liburing/make-debs.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+# Copyright (C) 2019  Liu Changcheng <changcheng.liu@aliyun.com>
+# Author: Liu Changcheng <changcheng.liu@aliyun.com>
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+#
+set -xe
+
+# Create dir for build
+base=${1:-/tmp/release}
+distro=unstable
+releasedir=$base/$(lsb_release -si)/liburing
+rm -rf $releasedir
+mkdir -p $releasedir
+HEAD=$(which head)
+DCH=$(which dch)
+
+src_dir=$(readlink -e `basename $0`)
+liburing_dir=$(dirname $src_dir)
+basename=$(basename $liburing_dir)
+dirname=$(dirname $liburing_dir)
+version=$(git describe --match "lib*" | cut -d '-' -f 2)
+outfile="liburing-$version"
+orgfile=$(echo $outfile | tr '-' '_')
+
+# Prepare source code
+cp -arf ${dirname}/${basename} ${releasedir}/${outfile}
+cd ${releasedir}/${outfile}
+git clean -dxf
+
+# Change changelog if it's needed
+cur_ver=`$HEAD < debian/changelog | sed -n -e 's/.* (\(.*\)) .*/\1/p'`
+if [ "$cur_ver" != "$version-1" ]; then
+	$DCH -D $distro --force-distribution -b -v "$version-1" "new version"
+fi
+
+# Create tar archive
+cd ../
+tar cvzf ${outfile}.tar.gz ${outfile}
+ln -s ${outfile}.tar.gz ${orgfile}.orig.tar.gz
+
+# Build debian package
+cd -
+debuild

data/vendor/liburing/src/Makefile

@@ -0,0 +1,129 @@
+include ../Makefile.common
+
+prefix ?= /usr
+includedir ?= $(prefix)/include
+libdir ?= $(prefix)/lib
+libdevdir ?= $(prefix)/lib
+
+LIBURING_CFLAGS ?=
+CPPFLAGS ?=
+override CPPFLAGS += -D_GNU_SOURCE \
+	-Iinclude/ -include ../config-host.h \
+	-D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64
+CFLAGS ?= -O3 -Wall -Wextra -fno-stack-protector
+override CFLAGS += -Wno-unused-parameter \
+	-DLIBURING_INTERNAL \
+	$(LIBURING_CFLAGS)
+SO_CFLAGS=-fPIC $(CFLAGS)
+L_CFLAGS=$(CFLAGS)
+LINK_FLAGS=-Wl,-z,defs
+LINK_FLAGS+=$(LDFLAGS)
+ENABLE_SHARED ?= 1
+
+soname=liburing.so.$(VERSION_MAJOR)
+libname=liburing.so.$(VERSION)
+ffi_soname=liburing-ffi.so.$(VERSION_MAJOR)
+ffi_libname=liburing-ffi.so.$(VERSION)
+
+all_targets += liburing.a
+all_targets += liburing-ffi.a
+
+ifeq ($(ENABLE_SHARED),1)
+all_targets += $(libname)
+all_targets += $(ffi_libname)
+endif
+
+include ../Makefile.quiet
+
+ifneq ($(MAKECMDGOALS),clean)
+include ../config-host.mak
+endif
+
+all: $(all_targets)
+
+liburing_srcs := setup.c queue.c register.c syscall.c version.c
+
+ifeq ($(CONFIG_NOLIBC),y)
+	liburing_srcs += nolibc.c
+	override CFLAGS += -nostdlib -nodefaultlibs -ffreestanding -fno-builtin -fno-stack-protector
+	override CPPFLAGS += -nostdlib -nodefaultlibs -ffreestanding -fno-builtin -fno-stack-protector
+	override LINK_FLAGS += -nostdlib -nodefaultlibs $(libgcc_link_flag)
+endif
+
+override CPPFLAGS += -MT "$@" -MMD -MP -MF "$@.d"
+liburing_objs := $(patsubst %.c,%.ol,$(liburing_srcs))
+liburing_sobjs := $(patsubst %.c,%.os,$(liburing_srcs))
+liburing_ffi_objs := ffi.ol
+liburing_ffi_sobjs := ffi.os
+
+%.os: %.c
+	$(QUIET_CC)$(CC) $(CPPFLAGS) $(SO_CFLAGS) -c -o $@ $<
+
+%.ol: %.c
+	$(QUIET_CC)$(CC) $(CPPFLAGS) $(L_CFLAGS) -c -o $@ $<
+
+# Include compiler generated dependency files.
+-include $(liburing_objs:%=%.d)
+-include $(liburing_sobjs:%=%.d)
+
+AR ?= ar
+RANLIB ?= ranlib
+liburing.a: $(liburing_objs)
+	@rm -f liburing.a
+	$(QUIET_AR)$(AR) r liburing.a $^
+	$(QUIET_RANLIB)$(RANLIB) liburing.a
+
+liburing-ffi.a: $(liburing_objs) $(liburing_ffi_objs)
+	@rm -f liburing-ffi.a
+	$(QUIET_AR)$(AR) r liburing-ffi.a $^
+	$(QUIET_RANLIB)$(RANLIB) liburing-ffi.a
+
+$(libname): $(liburing_sobjs) liburing.map
+	$(QUIET_CC)$(CC) $(SO_CFLAGS) -shared -Wl,--version-script=liburing.map -Wl,-soname=$(soname) -o $@ $(liburing_sobjs) $(LINK_FLAGS)
+
+$(ffi_libname): $(liburing_ffi_objs) $(liburing_ffi_sobjs) $(liburing_sobjs) liburing-ffi.map
+	$(QUIET_CC)$(CC) $(SO_CFLAGS) -shared -Wl,--version-script=liburing-ffi.map -Wl,-soname=$(ffi_soname) -o $@ $(liburing_sobjs) $(liburing_ffi_sobjs) $(LINK_FLAGS)
+
+install: $(all_targets)
+	install -D -m 644 include/liburing/io_uring.h $(includedir)/liburing/io_uring.h
+	install -D -m 644 include/liburing.h $(includedir)/liburing.h
+	install -D -m 644 include/liburing/compat.h $(includedir)/liburing/compat.h
+	install -D -m 644 include/liburing/barrier.h $(includedir)/liburing/barrier.h
+	install -D -m 644 include/liburing/io_uring_version.h $(includedir)/liburing/io_uring_version.h
+	install -D -m 644 liburing.a $(libdevdir)/liburing.a
+	install -D -m 644 liburing-ffi.a $(libdevdir)/liburing-ffi.a
+ifeq ($(ENABLE_SHARED),1)
+	install -D -m 755 $(libname) $(libdir)/$(libname)
+	install -D -m 755 $(ffi_libname) $(libdir)/$(ffi_libname)
+	ln -sf $(libname) $(libdir)/$(soname)
+	ln -sf $(relativelibdir)$(libname) $(libdevdir)/liburing.so
+	ln -sf $(ffi_libname) $(libdir)/$(ffi_soname)
+	ln -sf $(relativelibdir)$(ffi_libname) $(libdevdir)/liburing-ffi.so
+endif
+
+uninstall:
+	@rm -f $(includedir)/liburing/io_uring.h
+	@rm -f $(includedir)/liburing.h
+	@rm -f $(includedir)/liburing/compat.h
+	@rm -f $(includedir)/liburing/barrier.h
+	@rm -f $(includedir)/liburing/io_uring_version.h
+	@rm -f $(libdevdir)/liburing.a
+	@rm -f $(libdevdir)/liburing-ffi.a
+ifeq ($(ENABLE_SHARED),1)
+	@rm -f $(libdir)/$(libname)
+	@rm -f $(libdir)/$(ffi_libname)
+	@rm -f $(libdir)/$(soname)
+	@rm -f $(libdevdir)/liburing.so
+	@rm -f $(libdir)/$(ffi_soname)
+	@rm -f $(libdevdir)/liburing-ffi.so
+endif
+
+clean:
+	@rm -f $(all_targets) $(liburing_objs) $(liburing_sobjs) $(liburing_ffi_objs) $(liburing_ffi_sobjs) $(soname).new
+	@rm -f *.so* *.a *.o *.d
+	@rm -f include/liburing/compat.h
+	@rm -f include/liburing/io_uring_version.h
+
+	@# When cleaning, we don't include ../config-host.mak,
+	@# so the nolibc objects are always skipped, clean them up!
+	@rm -f nolibc.ol nolibc.os

data/vendor/liburing/src/arch/aarch64/lib.h

@@ -0,0 +1,47 @@
+/* SPDX-License-Identifier: MIT */
+
+#ifndef LIBURING_ARCH_AARCH64_LIB_H
+#define LIBURING_ARCH_AARCH64_LIB_H
+
+#include <elf.h>
+#include "../../syscall.h"
+
+static inline long __get_page_size(void)
+{
+	Elf64_Off buf[2];
+	long ret = 4096;
+	int fd;
+
+	fd = __sys_open("/proc/self/auxv", O_RDONLY, 0);
+	if (fd < 0)
+		return ret;
+
+	while (1) {
+		ssize_t x;
+
+		x = __sys_read(fd, buf, sizeof(buf));
+		if (x < (long) sizeof(buf))
+			break;
+
+		if (buf[0] == AT_PAGESZ) {
+			ret = buf[1];
+			break;
+		}
+	}
+
+	__sys_close(fd);
+	return ret;
+}
+
+static inline long get_page_size(void)
+{
+	static long cache_val;
+
+	if (cache_val)
+		return cache_val;
+
+	cache_val = __get_page_size();
+	return cache_val;
+}
+
+#endif /* #ifndef LIBURING_ARCH_AARCH64_LIB_H */

data/vendor/liburing/src/arch/aarch64/syscall.h

@@ -0,0 +1,91 @@
+/* SPDX-License-Identifier: MIT */
+
+#ifndef LIBURING_ARCH_AARCH64_SYSCALL_H
+#define LIBURING_ARCH_AARCH64_SYSCALL_H
+
+#if defined(__aarch64__)
+
+#define __do_syscallN(...) ({						\
+	__asm__ volatile (						\
+		"svc 0"							\
+		: "=r"(x0)						\
+		: __VA_ARGS__						\
+		: "memory", "cc");					\
+	(long) x0;							\
+})
+
+#define __do_syscall0(__n) ({						\
+	register long x8 __asm__("x8") = __n;				\
+	register long x0 __asm__("x0");					\
+									\
+	__do_syscallN("r" (x8));					\
+})
+
+#define __do_syscall1(__n, __a) ({					\
+	register long x8 __asm__("x8") = __n;				\
+	register __typeof__(__a) x0 __asm__("x0") = __a;		\
+									\
+	__do_syscallN("r" (x8), "0" (x0));				\
+})
+
+#define __do_syscall2(__n, __a, __b) ({					\
+	register long x8 __asm__("x8") = __n;				\
+	register __typeof__(__a) x0 __asm__("x0") = __a;		\
+	register __typeof__(__b) x1 __asm__("x1") = __b;		\
+									\
+	__do_syscallN("r" (x8), "0" (x0), "r" (x1));			\
+})
+
+#define __do_syscall3(__n, __a, __b, __c) ({				\
+	register long x8 __asm__("x8") = __n;				\
+	register __typeof__(__a) x0 __asm__("x0") = __a;		\
+	register __typeof__(__b) x1 __asm__("x1") = __b;		\
+	register __typeof__(__c) x2 __asm__("x2") = __c;		\
+									\
+	__do_syscallN("r" (x8), "0" (x0), "r" (x1), "r" (x2));		\
+})
+
+#define __do_syscall4(__n, __a, __b, __c, __d) ({			\
+	register long x8 __asm__("x8") = __n;				\
+	register __typeof__(__a) x0 __asm__("x0") = __a;		\
+	register __typeof__(__b) x1 __asm__("x1") = __b;		\
+	register __typeof__(__c) x2 __asm__("x2") = __c;		\
+	register __typeof__(__d) x3 __asm__("x3") = __d;		\
+									\
+	__do_syscallN("r" (x8), "0" (x0), "r" (x1), "r" (x2), "r" (x3));\
+})
+
+#define __do_syscall5(__n, __a, __b, __c, __d, __e) ({			\
+	register long x8 __asm__("x8") = __n;				\
+	register __typeof__(__a) x0 __asm__("x0") = __a;		\
+	register __typeof__(__b) x1 __asm__("x1") = __b;		\
+	register __typeof__(__c) x2 __asm__("x2") = __c;		\
+	register __typeof__(__d) x3 __asm__("x3") = __d;		\
+	register __typeof__(__e) x4 __asm__("x4") = __e;		\
+									\
+	__do_syscallN("r" (x8), "0" (x0), "r" (x1), "r" (x2), "r" (x3),	\
+			"r"(x4));					\
+})
+
+#define __do_syscall6(__n, __a, __b, __c, __d, __e, __f) ({		\
+	register long x8 __asm__("x8") = __n;				\
+	register __typeof__(__a) x0 __asm__("x0") = __a;		\
+	register __typeof__(__b) x1 __asm__("x1") = __b;		\
+	register __typeof__(__c) x2 __asm__("x2") = __c;		\
+	register __typeof__(__d) x3 __asm__("x3") = __d;		\
+	register __typeof__(__e) x4 __asm__("x4") = __e;		\
+	register __typeof__(__f) x5 __asm__("x5") = __f;		\
+									\
+	__do_syscallN("r" (x8), "0" (x0), "r" (x1), "r" (x2), "r" (x3),	\
+			"r" (x4), "r"(x5));				\
+})
+
+#include "../syscall-defs.h"
+
+#else /* #if defined(__aarch64__) */
+
+#include "../generic/syscall.h"
+
+#endif /* #if defined(__aarch64__) */
+
+#endif /* #ifndef LIBURING_ARCH_AARCH64_SYSCALL_H */

data/vendor/liburing/src/arch/generic/lib.h

@@ -0,0 +1,17 @@
+/* SPDX-License-Identifier: MIT */
+
+#ifndef LIBURING_ARCH_GENERIC_LIB_H
+#define LIBURING_ARCH_GENERIC_LIB_H
+
+static inline long get_page_size(void)
+{
+	long page_size;
+
+	page_size = sysconf(_SC_PAGESIZE);
+	if (page_size < 0)
+		page_size = 4096;
+
+	return page_size;
+}
+
+#endif /* #ifndef LIBURING_ARCH_GENERIC_LIB_H */