polyphony 0.85 → 0.86

data/vendor/liburing/man/io_uring_sqe_set_flags.3

@@ -0,0 +1,60 @@
+.\" Copyright (C) 2022 Stefan Roesch <shr@fb.com>
+.\"
+.\" SPDX-License-Identifier: LGPL-2.0-or-later
+.\"
+.TH io_uring_sqe_set_flags "January 25, 2022" "liburing-2.1" "liburing Manual"
+.SH NAME
+io_uring_sqe_set_flags - set flags for submission queue entry
+.SH SYNOPSIS
+.nf
+.BR "#include <liburing.h>"
+.PP
+.BI "void io_uring_sqe_set_flags(struct io_uring_sqe *sqe,"
+.BI "                            unsigned flags)"
+.fi
+.PP
+.SH DESCRIPTION
+.PP
+The io_uring_sqe_set_flags() function allows the caller to change the
+behavior of the submission queue entry by specifying flags. It enables the
+.I flags
+belonging to the
+.I sqe
+submission queue entry param.
+
+.I flags
+is a bit mask of 0 or more of the following values ORed together:
+.TP
+.B IOSQE_FIXED_FILE
+The file descriptor in the SQE refers to the index of a previously registered
+file or direct file descriptor, not a normal file descriptor.
+.TP
+.B IOSQE_ASYNC
+Normal operation for io_uring is to try and issue an sqe as non-blocking first,
+and if that fails, execute it in an async manner. To support more efficient
+overlapped operation of requests that the application knows/assumes will
+always (or most of the time) block, the application can ask for an sqe to be
+issued async from the start.
+.TP
+.B IOSQE_IO_LINK
+When this flag is specified, the SQE forms a link with the next SQE in the
+submission ring. That next SQE will not be started before the previous request
+completes. This, in effect, forms a chain of SQEs, which can be arbitrarily
+long. The tail of the chain is denoted by the first SQE that does not have this
+flag set. Chains are not supported across submission boundaries. Even if the
+last SQE in a submission has this flag set, it will still terminate the current
+chain. This flag has no effect on previous SQE submissions, nor does it impact
+SQEs that are outside of the chain tail. This means that multiple chains can be
+executing in parallel, or chains and individual SQEs. Only members inside the
+chain are serialized. A chain of SQEs will be broken, if any request in that
+chain ends in error.
+.TP
+.B IOSQE_IO_DRAIN
+When this flag is specified, the SQE will not be started before previously
+submitted SQEs have completed, and new SQEs will not be started before this
+one completes.
+
+.SH RETURN VALUE
+None
+.SH SEE ALSO
+.BR io_uring_submit (3),  io_uring_register(3)

data/vendor/liburing/man/io_uring_sqring_wait.3

@@ -0,0 +1,30 @@
+.\" Copyright (C) 2022 Stefan Roesch <shr@fb.com>
+.\"
+.\" SPDX-License-Identifier: LGPL-2.0-or-later
+.\"
+.TH io_uring_sqring_wait "January 25, 2022" "liburing-2.1" "liburing Manual"
+.SH NAME
+io_uring_sqring_wait - wait for free space in the SQ ring
+.SH SYNOPSIS
+.nf
+.BR "#include <liburing.h>"
+.PP
+.BI "int io_uring_sqring_wait(struct io_uring *ring)"
+.fi
+.PP
+.SH DESCRIPTION
+.PP
+The function io_uring_sqring_wait() allows the caller to wait for space
+to free up in the SQ ring belonging to the
+.I ring
+param, which happens when the kernel side thread
+has consumed one or more entries. If the SQ ring is currently non-full,
+no action is taken.
+
+This feature can only be used when SQPOLL is enabled.
+
+.SH RETURN VALUE
+On success it returns the free space. If the kernel does not support the
+feature, -EINVAL is returned.
+.SH SEE ALSO
+.BR io_uring_submit (3),  io_uring_wait_cqe (3),  io_uring_wait_cqes (3)

data/vendor/liburing/man/io_uring_submit.3

@@ -0,0 +1,29 @@
+.\" Copyright (C) 2021 Stefan Roesch <shr@fb.com>
+.\"
+.\" SPDX-License-Identifier: LGPL-2.0-or-later
+.\"
+.TH io_uring_submit 3 "November 15, 2021" "liburing-2.1" "liburing Manual"
+.SH NAME
+io_uring_submit - submit requests to the submission queue
+.fi
+.SH SYNOPSIS
+.nf
+.BR "#include <liburing.h>"
+.PP
+.BI "int io_uring_submit(struct io_uring *ring)"
+.PP
+.SH DESCRIPTION
+.PP
+The io_uring_submit() function submits the next events to the submission
+queue belonging to the
+.I ring.
+
+After the caller retrieves a submission queue entry (SQE) with io_uring_get_sqe(),
+prepares the SQE, it can be submitted with io_uring_submit().
+
+.SH RETURN VALUE
+On success
+.BR io_uring_submit (3)
+returns the number of submitted submission queue entries. On failure it returns -errno.
+.SH SEE ALSO
+.BR io_uring_get_sqe (3),  io_uring_submit_and_wait (3), io_uring_submit_and_wait_timeout (3)

data/vendor/liburing/man/io_uring_submit_and_wait.3

@@ -0,0 +1,34 @@
+.\" Copyright (C) 2021 Stefan Roesch <shr@fb.com>
+.\"
+.\" SPDX-License-Identifier: LGPL-2.0-or-later
+.\"
+.TH io_uring_submit_and_wait 3 "November 15, 2021" "liburing-2.1" "liburing Manual"
+.SH NAME
+io_uring_submit_and_wait - submit requests to the submission queue and wait for completion
+.fi
+.SH SYNOPSIS
+.nf
+.BR "#include <liburing.h>"
+.PP
+.BI "int io_uring_submit_and_wait(struct io_uring *ring,"
+.fi
+.BI "                             unsigned wait_nr)"
+.PP
+.SH DESCRIPTION
+.PP
+The io_uring_submit_and_wait() function submits the next events to the submission
+queue belonging to the
+.I ring
+and waits for
+.I wait_nr
+completion events.
+
+After the caller retrieves a submission queue entry (SQE) with io_uring_get_sqe(),
+prepares the SQE, it can be submitted with io_uring_submit_and_wait().
+
+.SH RETURN VALUE
+On success
+.BR io_uring_submit_and_wait (3)
+returns the number of submitted submission queue entries. On failure it returns -errno.
+.SH SEE ALSO
+.BR io_uring_get_sqe (3),  io_uring_submit (3), io_uring_submit_and_wait_timeout (3)

data/vendor/liburing/man/io_uring_submit_and_wait_timeout.3

@@ -0,0 +1,49 @@
+.\" Copyright (C) 2021 Stefan Roesch <shr@fb.com>
+.\"
+.\" SPDX-License-Identifier: LGPL-2.0-or-later
+.\"
+.TH io_uring_submit_and_wait_timeout 3 "November 15, 2021" "liburing-2.1" "liburing Manual"
+.SH NAME
+io_uring_submit_and_wait_timeout - submit requests to the submission queue and
+wait for the completion with timeout
+.fi
+.SH SYNOPSIS
+.nf
+.BR "#include <liburing.h>"
+.PP
+.BI "int io_uring_submit_and_wait_timeout(struct io_uring *ring,"
+.fi
+.BI "                                     struct io_uring_cqe **cqe_ptr,"
+.fi
+.BI "                                     unsigned wait_nr,"
+.fi
+.BI "                                     struct __kernel_timespec *ts,"
+.fi
+.BI "                                     sigset_t *sigmask)"
+.PP
+.SH DESCRIPTION
+.PP
+The io_uring_submit_and_wait_timeout() function submits the next events to the submission
+queue belonging to the
+.I ring
+and waits for
+.I wait_nr
+completion events or until the timeout
+.I ts
+expires.The completion events are stored in the
+.I cqe_ptr array.
+The
+.I sigmask
+specifies the set of signals to block. The prevailing signal mask is restored
+before returning.
+
+After the caller retrieves a submission queue entry (SQE) with io_uring_get_sqe(),
+prepares the SQE, it can be submitted with io_uring_submit_and_wait_timeout().
+
+
+.SH RETURN VALUE
+On success
+.BR io_uring_submit_and_wait_timeout (3)
+returns the number of submitted submission queue entries. On failure it returns -errno.
+.SH SEE ALSO
+.BR io_uring_get_sqe (3),  io_uring_submit (3), io_uring_submit_and_wait (3), io_uring_wait_cqe (3)

data/vendor/liburing/man/io_uring_unregister_buffers.3

@@ -0,0 +1,26 @@
+.\" Copyright (C) 2021 Stefan Roesch <shr@fb.com>
+.\"
+.\" SPDX-License-Identifier: LGPL-2.0-or-later
+.\"
+.TH io_uring_unregister_buffers 3 "November 15, 2021" "liburing-2.1" "liburing Manual"
+.SH NAME
+io_uring_unregister_buffers - unregister buffers for fixed buffer operations
+.fi
+.SH SYNOPSIS
+.nf
+.BR "#include <liburing.h>"
+.PP
+.BI "int io_uring_unregister_buffers(struct io_uring *ring)"
+.PP
+.SH DESCRIPTION
+.PP
+The io_uring_unregister_buffers() function unregisters
+the fixed buffers previously registered to the
+.I ring.
+
+.SH RETURN VALUE
+On success
+.BR io_uring_unregister_buffers (3)
+returns 0. On failure it returns -errno.
+.SH SEE ALSO
+.BR io_uring_register_buffers (3)

data/vendor/liburing/man/io_uring_unregister_files.3

@@ -0,0 +1,26 @@
+.\" Copyright (C) 2021 Stefan Roesch <shr@fb.com>
+.\"
+.\" SPDX-License-Identifier: LGPL-2.0-or-later
+.\"
+.TH io_uring_unregister_files 3 "November 15, 2021" "liburing-2.1" "liburing Manual"
+.SH NAME
+io_uring_unregister_files - unregister file descriptors
+.fi
+.SH SYNOPSIS
+.nf
+.BR "#include <liburing.h>"
+.PP
+.BI "int io_uring_unregister_files(struct io_uring *ring)"
+.PP
+.SH DESCRIPTION
+.PP
+The io_uring_unregister_files() function unregisters
+the file descriptors previously registered to the
+.I ring.
+
+.SH RETURN VALUE
+On success
+.BR io_uring_unregister_files (3)
+returns 0. On failure it returns -errno.
+.SH SEE ALSO
+.BR io_uring_register_files (3)

data/vendor/liburing/man/io_uring_wait_cqe.3

@@ -0,0 +1,33 @@
+.\" Copyright (C) 2021 Stefan Roesch <shr@fb.com>
+.\"
+.\" SPDX-License-Identifier: LGPL-2.0-or-later
+.\"
+.TH io_uring_wait_cqe 3 "November 15, 2021" "liburing-2.1" "liburing Manual"
+.SH NAME
+io_uring_wait_cqe - wait for one io_uring completion event
+.SH SYNOPSIS
+.nf
+.BR "#include <liburing.h>"
+.PP
+.BI "int io_uring_wait_cqe(struct io_uring *ring,"
+.BI "                      struct io_uring_cqe **cqe_ptr);"
+.fi
+.PP
+.SH DESCRIPTION
+.PP
+The io_uring_wait_cqe() function returns an IO completion from the
+queue belonging to the
+.I ring
+param, waiting for it if necessary. The
+.I cqe_ptr
+param is filled in on success.
+
+After the caller has submitted a request with io_uring_submit(), he can retrieve
+the completion with io_uring_wait_cqe().
+
+.SH RETURN VALUE
+On success
+.BR io_uring_wait_cqe (3)
+returns 0 and the cqe_ptr parm is filled in. On failure it returns -errno.
+.SH SEE ALSO
+.BR io_uring_submit (3),  io_uring_wait_cqes(3)

data/vendor/liburing/man/io_uring_wait_cqe_nr.3

@@ -0,0 +1,36 @@
+.\" Copyright (C) 2021 Stefan Roesch <shr@fb.com>
+.\"
+.\" SPDX-License-Identifier: LGPL-2.0-or-later
+.\"
+.TH io_uring_wait_cqe_nr 3 "November 15, 2021" "liburing-2.1" "liburing Manual"
+.SH NAME
+io_uring_wait_cqe_nr - wait for one or more io_uring completion events
+.SH SYNOPSIS
+.nf
+.BR "#include <liburing.h>"
+.PP
+.BI "int io_uring_wait_cqe_nr(struct io_uring *ring,"
+.BI "                         struct io_uring_cqe **cqe_ptr,"
+.BI "                         unsigned wait_nr)"
+.fi
+.PP
+.SH DESCRIPTION
+.PP
+The io_uring_wait_cqe_nr() function returns
+.I wait_nr
+IO completion events from the
+queue belonging to the
+.I ring
+param, waiting for it if necessary. The
+.I cqe_ptr
+param is filled in on success.
+
+After the caller has submitted a request with io_uring_submit(), he can retrieve
+the completion with io_uring_wait_cqe_nr().
+
+.SH RETURN VALUE
+On success
+.BR io_uring_wait_cqe_nr (3)
+returns 0 and the cqe_ptr parm is filled in. On failure it returns -errno.
+.SH SEE ALSO
+.BR io_uring_submit (3),  io_uring_wait_cqes (3)

data/vendor/liburing/man/io_uring_wait_cqe_timeout.3

@@ -0,0 +1,39 @@
+.\" Copyright (C) 2021 Stefan Roesch <shr@fb.com>
+.\"
+.\" SPDX-License-Identifier: LGPL-2.0-or-later
+.\"
+.TH io_uring_wait_cqe_timeout 3 "November 15, 2021" "liburing-2.1" "liburing Manual"
+.SH NAME
+io_uring_wait_cqe_timeout - wait for one io_uring completion event with timeout
+.SH SYNOPSIS
+.nf
+.BR "#include <liburing.h>"
+.PP
+.BI "int io_uring_wait_cqe_timeout(struct io_uring *ring,"
+.BI "                              struct io_uring_cqe **cqe_ptr,"
+.BI "                              struct __kernel_timespec *ts)"
+.PP
+.SH DESCRIPTION
+.PP
+The io_uring_wait_cqe_timeout() function returns one IO completion from the
+queue belonging to the
+.I ring
+param, waiting for it if necessary or until the timeout
+.I ts
+expires.
+
+The
+.I cqe_ptr
+param is filled in on success.
+
+If
+.I ts
+is specified, the application does not need to call io_uring_submit (3) before
+calling io_uring_wait_cqes (3).
+
+.SH RETURN VALUE
+On success
+.BR io_uring_wait_cqes (3)
+returns 0 and the cqe_ptr parm is filled in. On failure it returns -errno.
+.SH SEE ALSO
+.BR io_uring_submit (3),  io_uring_wait_cqe_timeout (3), io_uring_wait_cqe(3).

data/vendor/liburing/man/io_uring_wait_cqes.3

@@ -0,0 +1,46 @@
+.\" Copyright (C) 2021 Stefan Roesch <shr@fb.com>
+.\"
+.\" SPDX-License-Identifier: LGPL-2.0-or-later
+.\"
+.TH io_uring_wait_cqes 3 "November 15, 2021" "liburing-2.1" "liburing Manual"
+.SH NAME
+io_uring_wait_cqes - wait for one or more io_uring completion events
+.SH SYNOPSIS
+.nf
+.BR "#include <liburing.h>"
+.PP
+.BI "int io_uring_wait_cqes(struct io_uring *ring,"
+.BI "                       struct io_uring_cqe **cqe_ptr,"
+.BI "                       unsigned wait_nr,"
+.BI "                       struct __kernel_timespec *ts,"
+.BI "                       sigset_t *sigmask)
+.fi
+.PP
+.SH DESCRIPTION
+.PP
+The io_uring_wait_cqes() function returns
+.I wait_nr
+IO completions from the queue belonging to the
+.I ring
+param, waiting for it if necessary or until the timeout
+.I ts
+expires. The
+.I sigmask
+specifies the set of signals to block. The prevailing signal mask is restored
+before returning.
+
+The
+.I cqe_ptr
+param is filled in on success.
+
+If
+.I ts
+is specified, the application does not need to call io_uring_submit (3) before
+calling io_uring_wait_cqes (3).
+
+.SH RETURN VALUE
+On success
+.BR io_uring_wait_cqes (3)
+returns 0 and the cqe_ptr parm is filled in. On failure it returns -errno.
+.SH SEE ALSO
+.BR io_uring_submit (3),  io_uring_wait_cqe_timeout (3), io_uring_wait_cqe(3).

data/vendor/liburing/src/Makefile

@@ -0,0 +1,89 @@
+include ../Makefile.common
+
+prefix ?= /usr
+includedir ?= $(prefix)/include
+libdir ?= $(prefix)/lib
+libdevdir ?= $(prefix)/lib
+
+CPPFLAGS ?=
+override CPPFLAGS += -D_GNU_SOURCE \
+	-Iinclude/ -include ../config-host.h
+CFLAGS ?= -g -O2 -Wall -Wextra -fno-stack-protector
+override CFLAGS += -Wno-unused-parameter -Wno-sign-compare -DLIBURING_INTERNAL
+SO_CFLAGS=-fPIC $(CFLAGS)
+L_CFLAGS=$(CFLAGS)
+LINK_FLAGS=
+LINK_FLAGS+=$(LDFLAGS)
+ENABLE_SHARED ?= 1
+
+soname=liburing.so
+libname=$(soname).$(VERSION)
+all_targets += liburing.a
+
+ifeq ($(ENABLE_SHARED),1)
+all_targets += $(libname)
+endif
+
+include ../Makefile.quiet
+
+ifneq ($(MAKECMDGOALS),clean)
+include ../config-host.mak
+endif
+
+all: $(all_targets)
+
+liburing_srcs := setup.c queue.c register.c
+
+ifeq ($(CONFIG_NOLIBC),y)
+	liburing_srcs += nolibc.c
+	override CFLAGS += -nostdlib -nodefaultlibs -ffreestanding
+	override CPPFLAGS += -nostdlib -nodefaultlibs -ffreestanding
+	override LINK_FLAGS += -nostdlib -nodefaultlibs
+else
+	liburing_srcs += syscall.c
+endif
+
+override CPPFLAGS += -MT "$@" -MMD -MP -MF "$@.d"
+liburing_objs := $(patsubst %.c,%.ol,$(liburing_srcs))
+liburing_sobjs := $(patsubst %.c,%.os,$(liburing_srcs))
+
+%.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
+
+$(libname): $(liburing_sobjs) liburing.map
+	$(QUIET_CC)$(CC) $(SO_CFLAGS) -shared -Wl,--version-script=liburing.map -Wl,-soname=$(soname) -o $@ $(liburing_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 liburing.a $(libdevdir)/liburing.a
+ifeq ($(ENABLE_SHARED),1)
+	install -D -m 755 $(libname) $(libdir)/$(libname)
+	ln -sf $(libname) $(libdir)/$(soname)
+	ln -sf $(relativelibdir)$(libname) $(libdevdir)/liburing.so
+endif
+
+clean:
+	@rm -f $(all_targets) $(liburing_objs) $(liburing_sobjs) $(soname).new
+	@rm -f *.so* *.a *.o *.d
+	@rm -f include/liburing/compat.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/syscall.h

@@ -0,0 +1,95 @@
+/* SPDX-License-Identifier: MIT */
+
+#ifndef __INTERNAL__LIBURING_SYSCALL_H
+	#error "This file should be included from src/syscall.h (liburing)"
+#endif
+
+#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,21 @@
+/* SPDX-License-Identifier: MIT */
+
+#ifndef __INTERNAL__LIBURING_LIB_H
+	#error "This file should be included from src/lib.h (liburing)"
+#endif
+
+#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 */