IO-AIO/configure.ac

AC_INIT
AC_CONFIG_SRCDIR([libeio/eio.h])
AC_CONFIG_HEADERS([config.h])

AC_PREREQ(2.60)
AC_USE_SYSTEM_EXTENSIONS

AC_PROG_CC

m4_include([libeio/libeio.m4])

# for these to work, you need to run autoheader in IO::AIO, not libeio :(

AC_CACHE_CHECK(for set/getrlimit, ac_cv_rlimits, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
#include <sys/time.h>
#include <sys/resource.h>
int main (void)
{
   struct rlimit srl;
   int res;
   srl.rlim_cur = srl.rlim_max = RLIM_INFINITY;
   res = getrlimit (RLIMIT_NOFILE, &srl);
   res = setrlimit (RLIMIT_NOFILE, &srl);
   return 0;
}
]])],ac_cv_rlimits=yes,ac_cv_rlimits=no)])
test $ac_cv_rlimits = yes && AC_DEFINE(HAVE_RLIMITS, 1, setrlimit/getrlimit is available)

dnl at least uclibc defines _POSIX_ADVISORY_INFO without *any* of the required
dnl functionality actually being present. ugh.
AC_CACHE_CHECK(for posix_madvise, ac_cv_posix_madvise, [AC_LINK_IFELSE([AC_LANG_SOURCE([
#include <sys/mman.h>
int main (void)
{
   int res = posix_madvise ((void *)0, (size_t)0, POSIX_MADV_NORMAL);
   int a = POSIX_MADV_SEQUENTIAL;
   int b = POSIX_MADV_RANDOM;
   int c = POSIX_MADV_WILLNEED;
   int d = POSIX_MADV_DONTNEED;
   return 0;
}
])],ac_cv_posix_madvise=yes,ac_cv_posix_madvise=no)])
test $ac_cv_posix_madvise = yes && AC_DEFINE(HAVE_POSIX_MADVISE, 1, posix_madvise(2) is available)

AC_CACHE_CHECK(for posix_fadvise, ac_cv_posix_fadvise, [AC_LINK_IFELSE([AC_LANG_SOURCE([
#define _XOPEN_SOURCE 600
#include <fcntl.h>
int main (void)
{
   int res = posix_fadvise ((int)0, (off_t)0, (off_t)0, POSIX_FADV_NORMAL);
   int a = POSIX_FADV_SEQUENTIAL;
   int b = POSIX_FADV_NOREUSE;
   int c = POSIX_FADV_RANDOM;
   int d = POSIX_FADV_WILLNEED;
   int e = POSIX_FADV_DONTNEED;
   return 0;
}
])],ac_cv_posix_fadvise=yes,ac_cv_posix_fadvise=no)])
test $ac_cv_posix_fadvise = yes && AC_DEFINE(HAVE_POSIX_FADVISE, 1, posix_fadvise(2) is available)

dnl lots of linux specifics
AC_CHECK_HEADERS([linux/fs.h linux/fiemap.h])

dnl glibc major/minor macros
AC_CHECK_HEADERS([sys/sysmacros.h])

dnl solaris major/minor
AC_CHECK_HEADERS([sys/mkdev.h])

dnl readv / preadv, vmsplice
AC_CHECK_HEADERS([sys/uio.h])

dnl fexecve has always been in the single unix specification
dnl but some atrocities (like opsnbsd and osx) claim implementing it
dnl but then not definining it. ugh. garbage. and fexecve would be
dnl useful for security, but, no, not on openbsd. we'd rather lie
dnl about it.
AC_CACHE_CHECK(for fexecve, ac_cv_fexecve, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
#include <fcntl.h>
#include <unistd.h>
int main (void)
{
   int res = fexecve (-1, "argv", 0);
   return 0;
}
]])],ac_cv_fexecve=yes,ac_cv_fexecve=no)])
test $ac_cv_fexecve = yes && AC_DEFINE(HAVE_FEXECVE, 1, fexecve(2) is available)

AC_CACHE_CHECK([for siginfo_t], ac_cv_siginfo_t, [AC_LINK_IFELSE([AC_LANG_SOURCE([
#include <signal.h>
int main (void)
{
   siginfo_t si;
   si.si_code;
   si.si_pid;
   si.si_uid;
   si.si_value.sival_int;
   si.si_value.sival_ptr;
   return 0;
}
])],ac_cv_siginfo_t=yes,ac_cv_siginfo_t=no)])
test $ac_cv_siginfo_t = yes && AC_DEFINE(HAVE_SIGINFO_T, 1, have siginfo_t in signal.h)

AC_CACHE_CHECK([for unix-style syscall interface], ac_cv_syscall, [AC_LINK_IFELSE([AC_LANG_SOURCE([
#include <unistd.h>
#include <sys/syscall.h>
int main (void)
{
   long res = syscall (SYS_exit, 0);
   return 0;
}
])],ac_cv_syscall=yes,ac_cv_syscall=no)])
test $ac_cv_syscall = yes && AC_DEFINE(HAVE_SYSCALL, 1, unix syscall interface)

AC_CACHE_CHECK([for splice, vmsplice and tee], ac_cv_linux_splice, [AC_LINK_IFELSE([AC_LANG_SOURCE([
#include <sys/types.h>
#include <fcntl.h>
#include <sys/uio.h>
int main (void)
{
   ssize_t res;
   res = splice ((int)0, (loff_t)0, (int)0, (loff_t *)0, (size_t)0, SPLICE_F_MOVE | SPLICE_F_NONBLOCK | SPLICE_F_MORE);
   res = tee ((int)0, (int)0, (size_t)0, SPLICE_F_NONBLOCK);
   res = vmsplice ((int)0, (struct iovec *)0, 0, SPLICE_F_NONBLOCK | SPLICE_F_GIFT);
   return 0;
}
])],ac_cv_linux_splice=yes,ac_cv_linux_splice=no)])
test $ac_cv_linux_splice = yes && AC_DEFINE(HAVE_LINUX_SPLICE, 1, splice/vmsplice/tee(2) are available)

AC_CACHE_CHECK(for pipe2, ac_cv_pipe2, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
#include <fcntl.h>
#include <unistd.h>
int main (void)
{
   int res;
   res = pipe2 (0, 0);
   return 0;
}
]])],ac_cv_pipe2=yes,ac_cv_pipe2=no)])
test $ac_cv_pipe2 = yes && AC_DEFINE(HAVE_PIPE2, 1, pipe2(2) is available)

AC_CACHE_CHECK(for eventfd, ac_cv_eventfd, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
#include <sys/eventfd.h>
int main (void)
{
   int res;
   res = eventfd (1, EFD_CLOEXEC | EFD_NONBLOCK);
   return 0;
}
]])],ac_cv_eventfd=yes,ac_cv_eventfd=no)])
test $ac_cv_eventfd = yes && AC_DEFINE(HAVE_EVENTFD, 1, eventfd(2) is available)

AC_CACHE_CHECK(for timerfd_*, ac_cv_timerfd, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
#include <sys/timerfd.h>
int main (void)
{
   struct itimerspec its;
   int res;
   res = timerfd_create (CLOCK_REALTIME, TFD_CLOEXEC | TFD_NONBLOCK);
   res = timerfd_settime (res, TFD_TIMER_ABSTIME /*| TFD_TIMER_CANCEL_ON_SET*/, &its, 0);
   res = timerfd_gettime (res, &its);
   return 0;
}
]])],ac_cv_timerfd=yes,ac_cv_timerfd=no)])
test $ac_cv_timerfd = yes && AC_DEFINE(HAVE_TIMERFD, 1, timerfd_*(2) are available)

AC_CACHE_CHECK(for memfd_create, ac_cv_memfd_create, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
#include <sys/mman.h>
int main (void)
{
   int res = memfd_create ("name", MFD_CLOEXEC | MFD_ALLOW_SEALING);
   return 0;
}
]])],ac_cv_memfd_create=yes,ac_cv_memfd_create=no)])
test $ac_cv_memfd_create = yes && AC_DEFINE(HAVE_MEMFD_CREATE, 1, memfd_create(2) is available)

AC_CACHE_CHECK(for copy_file_range, ac_cv_copy_file_range, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
#include <unistd.h>
#include <sys/syscall.h>
/*#include <linux/copy.h>*/
int main (void)
{
   int res;
   /*res = syscall (SYS_copy_file_range, 0, 0, 0, 0, 0, COPY_FR_REFLINK | COPY_FR_DEDUP | COPY_FR_COPY);*/
   res = syscall (SYS_copy_file_range, 0, 0, 0, 0, 0, 0);
   return 0;
}
]])],ac_cv_copy_file_range=yes,ac_cv_copy_file_range=no)])
test $ac_cv_copy_file_range = yes && AC_DEFINE(HAVE_COPY_FILE_RANGE, 1, copy_file_range(2) is available)

AC_CACHE_CHECK(for st_xtimensec, ac_cv_xtimensec, [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

int main (void)
{
   return PL_statcache.st_atimensec
        + PL_statcache.st_mtimensec
        + PL_statcache.st_ctimensec;
}
]])],ac_cv_xtimensec=yes,ac_cv_xtimensec=no)])
test $ac_cv_xtimensec = yes && AC_DEFINE(HAVE_ST_XTIMENSEC, 1, stat nanosecond access by st_xtimensec)

AC_CACHE_CHECK(for st_xtimespec, ac_cv_xtimespec, [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

int main (void)
{
   return PL_statcache.st_atim.tv_nsec
        + PL_statcache.st_mtim.tv_nsec
        + PL_statcache.st_ctim.tv_nsec;
}
]])],ac_cv_xtimespec=yes,ac_cv_xtimespec=no)])
test $ac_cv_xtimespec = yes && AC_DEFINE(HAVE_ST_XTIMESPEC, 1, stat nanosecond access by st_xtimespec)

# apparently, True64 uses st_u[amc]time, aix uses at_[amc]time_n and apple uses st_[amc,birth]timespec?

AC_CACHE_CHECK(for st_birthtimensec, ac_cv_birthtimensec, [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

int main (void)
{
   return PL_statcache.st_birthtime + PL_statcache.st_birthtimensec;
}
]])],ac_cv_birthtimensec=yes,ac_cv_birthtimensec=no)])
test $ac_cv_birthtimensec = yes && AC_DEFINE(HAVE_ST_BIRTHTIMENSEC, 1, birthtime nanosecond access by st_birthtimensec)

AC_CACHE_CHECK(for st_birthtimespec, ac_cv_birthtimespec, [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

int main (void)
{
   return PL_statcache.st_birthtim.tv_sec + PL_statcache.st_birthtim.tv_nsec;
}
]])],ac_cv_birthtimespec=yes,ac_cv_birthtimespec=no)])
test $ac_cv_birthtimespec = yes && AC_DEFINE(HAVE_ST_BIRTHTIMESPEC, 1, birthtime nanosecond access by st_birthtimespec)

AC_CACHE_CHECK(for st_gen, ac_cv_st_gen, [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

int main (void)
{
   return PL_statcache.st_gen;
}
]])],ac_cv_st_gen=yes,ac_cv_st_gen=no)])
test $ac_cv_st_gen = yes && AC_DEFINE(HAVE_ST_GEN, 1, stat st_gen member)

AC_CACHE_CHECK(for statx, ac_cv_statx, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include <fcntl.h>
int res;
int main (void)
{
   struct statx sx;
   int res;
   res = statx (AT_FDCWD, ".",
         AT_EMPTY_PATH | AT_NO_AUTOMOUNT | AT_SYMLINK_NOFOLLOW | AT_STATX_SYNC_AS_STAT | AT_STATX_FORCE_SYNC | AT_STATX_DONT_SYNC,
         STATX_ALL, &sx);
   STATX_TYPE; STATX_MODE; STATX_NLINK; STATX_UID; STATX_GID; STATX_ATIME; STATX_MTIME; STATX_CTIME;
   STATX_INO; STATX_SIZE; STATX_BLOCKS; STATX_BASIC_STATS; STATX_BTIME; STATX_ALL;
   STATX_ATTR_COMPRESSED; STATX_ATTR_IMMUTABLE; STATX_ATTR_APPEND; STATX_ATTR_NODUMP; STATX_ATTR_ENCRYPTED;
   return 0;
}
]])],ac_cv_statx=yes,ac_cv_statx=no)])
test $ac_cv_statx = yes && AC_DEFINE(HAVE_STATX, 1, statx(2) is available)

AC_CACHE_CHECK(for accept4, ac_cv_accept4, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
#include <sys/types.h>
#include <sys/socket.h>
int main (void)
{
   int res = accept4 (1, (struct sockaddr *)0, (socklen_t)0, SOCK_NONBLOCK | SOCK_CLOEXEC);
   return 0;
}
]])],ac_cv_accept4=yes,ac_cv_accept4=no)])
test $ac_cv_accept4 = yes && AC_DEFINE(HAVE_ACCEPT4, 1, accept4(2) is available)

AC_CHECK_HEADERS([sys/mount.h])
AC_CACHE_CHECK(for mount, ac_cv_mount, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
#include <sys/mount.h>
int main (void)
{
   int res = mount ("path", "path", "fstype", MS_RDONLY, 0);
   return 0;
}
]])],ac_cv_mount=yes,ac_cv_mount=no)])
test $ac_cv_mount = yes && AC_DEFINE(HAVE_MOUNT, 1, mount is available)
AC_CACHE_CHECK(for umount, ac_cv_umount, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
#include <sys/mount.h>
int main (void)
{
   int res = umount ("path");
   return 0;
}
]])],ac_cv_umount=yes,ac_cv_umount=no)])
test $ac_cv_umount = yes && AC_DEFINE(HAVE_UMOUNT, 1, umount is available)
AC_CACHE_CHECK(for umount2, ac_cv_umount2, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
#include <sys/mount.h>
int main (void)
{
   int res = umount2 ("path", MNT_FORCE|MNT_DETACH);
   return 0;
}
]])],ac_cv_umount2=yes,ac_cv_umount2=no)])
test $ac_cv_umount2 = yes && AC_DEFINE(HAVE_UMOUNT2, 1, umount2 is available)

AC_OUTPUT

Revision:	1.20
Committed:	Wed Sep 28 08:24:25 2022 UTC (20 months, 1 week ago) by root
Branch:	MAIN
CVS Tags:	rel-4_80
Changes since 1.19:	+16 -0 lines
Log Message:	* empty log message *
#	Content
1	AC_INIT
2	AC_CONFIG_SRCDIR([libeio/eio.h])
3	AC_CONFIG_HEADERS([config.h])
4
5	AC_PREREQ(2.60)
6	AC_USE_SYSTEM_EXTENSIONS
7
8	AC_PROG_CC
9
10	m4_include([libeio/libeio.m4])
11
12	# for these to work, you need to run autoheader in IO::AIO, not libeio :(
13
14	AC_CACHE_CHECK(for set/getrlimit, ac_cv_rlimits, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
15	#include <sys/time.h>
16	#include <sys/resource.h>
17	int main (void)
18	{
19	struct rlimit srl;
20	int res;
21	srl.rlim_cur = srl.rlim_max = RLIM_INFINITY;
22	res = getrlimit (RLIMIT_NOFILE, &srl);
23	res = setrlimit (RLIMIT_NOFILE, &srl);
24	return 0;
25	}
26	]])],ac_cv_rlimits=yes,ac_cv_rlimits=no)])
27	test $ac_cv_rlimits = yes && AC_DEFINE(HAVE_RLIMITS, 1, setrlimit/getrlimit is available)
28
29	dnl at least uclibc defines _POSIX_ADVISORY_INFO without any of the required
30	dnl functionality actually being present. ugh.
31	AC_CACHE_CHECK(for posix_madvise, ac_cv_posix_madvise, [AC_LINK_IFELSE([AC_LANG_SOURCE([
32	#include <sys/mman.h>
33	int main (void)
34	{
35	int res = posix_madvise ((void *)0, (size_t)0, POSIX_MADV_NORMAL);
36	int a = POSIX_MADV_SEQUENTIAL;
37	int b = POSIX_MADV_RANDOM;
38	int c = POSIX_MADV_WILLNEED;
39	int d = POSIX_MADV_DONTNEED;
40	return 0;
41	}
42	])],ac_cv_posix_madvise=yes,ac_cv_posix_madvise=no)])
43	test $ac_cv_posix_madvise = yes && AC_DEFINE(HAVE_POSIX_MADVISE, 1, posix_madvise(2) is available)
44
45	AC_CACHE_CHECK(for posix_fadvise, ac_cv_posix_fadvise, [AC_LINK_IFELSE([AC_LANG_SOURCE([
46	#define _XOPEN_SOURCE 600
47	#include <fcntl.h>
48	int main (void)
49	{
50	int res = posix_fadvise ((int)0, (off_t)0, (off_t)0, POSIX_FADV_NORMAL);
51	int a = POSIX_FADV_SEQUENTIAL;
52	int b = POSIX_FADV_NOREUSE;
53	int c = POSIX_FADV_RANDOM;
54	int d = POSIX_FADV_WILLNEED;
55	int e = POSIX_FADV_DONTNEED;
56	return 0;
57	}
58	])],ac_cv_posix_fadvise=yes,ac_cv_posix_fadvise=no)])
59	test $ac_cv_posix_fadvise = yes && AC_DEFINE(HAVE_POSIX_FADVISE, 1, posix_fadvise(2) is available)
60
61	dnl lots of linux specifics
62	AC_CHECK_HEADERS([linux/fs.h linux/fiemap.h])
63
64	dnl glibc major/minor macros
65	AC_CHECK_HEADERS([sys/sysmacros.h])
66
67	dnl solaris major/minor
68	AC_CHECK_HEADERS([sys/mkdev.h])
69
70	dnl readv / preadv, vmsplice
71	AC_CHECK_HEADERS([sys/uio.h])
72
73	dnl fexecve has always been in the single unix specification
74	dnl but some atrocities (like opsnbsd and osx) claim implementing it
75	dnl but then not definining it. ugh. garbage. and fexecve would be
76	dnl useful for security, but, no, not on openbsd. we'd rather lie
77	dnl about it.
78	AC_CACHE_CHECK(for fexecve, ac_cv_fexecve, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
79	#include <fcntl.h>
80	#include <unistd.h>
81	int main (void)
82	{
83	int res = fexecve (-1, "argv", 0);
84	return 0;
85	}
86	]])],ac_cv_fexecve=yes,ac_cv_fexecve=no)])
87	test $ac_cv_fexecve = yes && AC_DEFINE(HAVE_FEXECVE, 1, fexecve(2) is available)
88
89	AC_CACHE_CHECK([for siginfo_t], ac_cv_siginfo_t, [AC_LINK_IFELSE([AC_LANG_SOURCE([
90	#include <signal.h>
91	int main (void)
92	{
93	siginfo_t si;
94	si.si_code;
95	si.si_pid;
96	si.si_uid;
97	si.si_value.sival_int;
98	si.si_value.sival_ptr;
99	return 0;
100	}
101	])],ac_cv_siginfo_t=yes,ac_cv_siginfo_t=no)])
102	test $ac_cv_siginfo_t = yes && AC_DEFINE(HAVE_SIGINFO_T, 1, have siginfo_t in signal.h)
103
104	AC_CACHE_CHECK([for unix-style syscall interface], ac_cv_syscall, [AC_LINK_IFELSE([AC_LANG_SOURCE([
105	#include <unistd.h>
106	#include <sys/syscall.h>
107	int main (void)
108	{
109	long res = syscall (SYS_exit, 0);
110	return 0;
111	}
112	])],ac_cv_syscall=yes,ac_cv_syscall=no)])
113	test $ac_cv_syscall = yes && AC_DEFINE(HAVE_SYSCALL, 1, unix syscall interface)
114
115	AC_CACHE_CHECK([for splice, vmsplice and tee], ac_cv_linux_splice, [AC_LINK_IFELSE([AC_LANG_SOURCE([
116	#include <sys/types.h>
117	#include <fcntl.h>
118	#include <sys/uio.h>
119	int main (void)
120	{
121	ssize_t res;
122	res = splice ((int)0, (loff_t)0, (int)0, (loff_t *)0, (size_t)0, SPLICE_F_MOVE \| SPLICE_F_NONBLOCK \| SPLICE_F_MORE);
123	res = tee ((int)0, (int)0, (size_t)0, SPLICE_F_NONBLOCK);
124	res = vmsplice ((int)0, (struct iovec *)0, 0, SPLICE_F_NONBLOCK \| SPLICE_F_GIFT);
125	return 0;
126	}
127	])],ac_cv_linux_splice=yes,ac_cv_linux_splice=no)])
128	test $ac_cv_linux_splice = yes && AC_DEFINE(HAVE_LINUX_SPLICE, 1, splice/vmsplice/tee(2) are available)
129
130	AC_CACHE_CHECK(for pipe2, ac_cv_pipe2, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
131	#include <fcntl.h>
132	#include <unistd.h>
133	int main (void)
134	{
135	int res;
136	res = pipe2 (0, 0);
137	return 0;
138	}
139	]])],ac_cv_pipe2=yes,ac_cv_pipe2=no)])
140	test $ac_cv_pipe2 = yes && AC_DEFINE(HAVE_PIPE2, 1, pipe2(2) is available)
141
142	AC_CACHE_CHECK(for eventfd, ac_cv_eventfd, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
143	#include <sys/eventfd.h>
144	int main (void)
145	{
146	int res;
147	res = eventfd (1, EFD_CLOEXEC \| EFD_NONBLOCK);
148	return 0;
149	}
150	]])],ac_cv_eventfd=yes,ac_cv_eventfd=no)])
151	test $ac_cv_eventfd = yes && AC_DEFINE(HAVE_EVENTFD, 1, eventfd(2) is available)
152
153	AC_CACHE_CHECK(for timerfd_*, ac_cv_timerfd, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
154	#include <sys/timerfd.h>
155	int main (void)
156	{
157	struct itimerspec its;
158	int res;
159	res = timerfd_create (CLOCK_REALTIME, TFD_CLOEXEC \| TFD_NONBLOCK);
160	res = timerfd_settime (res, TFD_TIMER_ABSTIME /\| TFD_TIMER_CANCEL_ON_SET/, &its, 0);
161	res = timerfd_gettime (res, &its);
162	return 0;
163	}
164	]])],ac_cv_timerfd=yes,ac_cv_timerfd=no)])
165	test $ac_cv_timerfd = yes && AC_DEFINE(HAVE_TIMERFD, 1, timerfd_*(2) are available)
166
167	AC_CACHE_CHECK(for memfd_create, ac_cv_memfd_create, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
168	#include <sys/mman.h>
169	int main (void)
170	{
171	int res = memfd_create ("name", MFD_CLOEXEC \| MFD_ALLOW_SEALING);
172	return 0;
173	}
174	]])],ac_cv_memfd_create=yes,ac_cv_memfd_create=no)])
175	test $ac_cv_memfd_create = yes && AC_DEFINE(HAVE_MEMFD_CREATE, 1, memfd_create(2) is available)
176
177	AC_CACHE_CHECK(for copy_file_range, ac_cv_copy_file_range, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
178	#include <unistd.h>
179	#include <sys/syscall.h>
180	/#include <linux/copy.h>/
181	int main (void)
182	{
183	int res;
184	/res = syscall (SYS_copy_file_range, 0, 0, 0, 0, 0, COPY_FR_REFLINK \| COPY_FR_DEDUP \| COPY_FR_COPY);/
185	res = syscall (SYS_copy_file_range, 0, 0, 0, 0, 0, 0);
186	return 0;
187	}
188	]])],ac_cv_copy_file_range=yes,ac_cv_copy_file_range=no)])
189	test $ac_cv_copy_file_range = yes && AC_DEFINE(HAVE_COPY_FILE_RANGE, 1, copy_file_range(2) is available)
190
191	AC_CACHE_CHECK(for st_xtimensec, ac_cv_xtimensec, [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
192	#include "EXTERN.h"
193	#include "perl.h"
194	#include "XSUB.h"
195
196	int main (void)
197	{
198	return PL_statcache.st_atimensec
199	+ PL_statcache.st_mtimensec
200	+ PL_statcache.st_ctimensec;
201	}
202	]])],ac_cv_xtimensec=yes,ac_cv_xtimensec=no)])
203	test $ac_cv_xtimensec = yes && AC_DEFINE(HAVE_ST_XTIMENSEC, 1, stat nanosecond access by st_xtimensec)
204
205	AC_CACHE_CHECK(for st_xtimespec, ac_cv_xtimespec, [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
206	#include "EXTERN.h"
207	#include "perl.h"
208	#include "XSUB.h"
209
210	int main (void)
211	{
212	return PL_statcache.st_atim.tv_nsec
213	+ PL_statcache.st_mtim.tv_nsec
214	+ PL_statcache.st_ctim.tv_nsec;
215	}
216	]])],ac_cv_xtimespec=yes,ac_cv_xtimespec=no)])
217	test $ac_cv_xtimespec = yes && AC_DEFINE(HAVE_ST_XTIMESPEC, 1, stat nanosecond access by st_xtimespec)
218
219	# apparently, True64 uses st_u[amc]time, aix uses at_[amc]time_n and apple uses st_[amc,birth]timespec?
220
221	AC_CACHE_CHECK(for st_birthtimensec, ac_cv_birthtimensec, [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
222	#include "EXTERN.h"
223	#include "perl.h"
224	#include "XSUB.h"
225
226	int main (void)
227	{
228	return PL_statcache.st_birthtime + PL_statcache.st_birthtimensec;
229	}
230	]])],ac_cv_birthtimensec=yes,ac_cv_birthtimensec=no)])
231	test $ac_cv_birthtimensec = yes && AC_DEFINE(HAVE_ST_BIRTHTIMENSEC, 1, birthtime nanosecond access by st_birthtimensec)
232
233	AC_CACHE_CHECK(for st_birthtimespec, ac_cv_birthtimespec, [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
234	#include "EXTERN.h"
235	#include "perl.h"
236	#include "XSUB.h"
237
238	int main (void)
239	{
240	return PL_statcache.st_birthtim.tv_sec + PL_statcache.st_birthtim.tv_nsec;
241	}
242	]])],ac_cv_birthtimespec=yes,ac_cv_birthtimespec=no)])
243	test $ac_cv_birthtimespec = yes && AC_DEFINE(HAVE_ST_BIRTHTIMESPEC, 1, birthtime nanosecond access by st_birthtimespec)
244
245	AC_CACHE_CHECK(for st_gen, ac_cv_st_gen, [AC_COMPILE_IFELSE([AC_LANG_SOURCE([[
246	#include "EXTERN.h"
247	#include "perl.h"
248	#include "XSUB.h"
249
250	int main (void)
251	{
252	return PL_statcache.st_gen;
253	}
254	]])],ac_cv_st_gen=yes,ac_cv_st_gen=no)])
255	test $ac_cv_st_gen = yes && AC_DEFINE(HAVE_ST_GEN, 1, stat st_gen member)
256
257	AC_CACHE_CHECK(for statx, ac_cv_statx, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
258	#include <sys/types.h>
259	#include <sys/stat.h>
260	#include <unistd.h>
261	#include <fcntl.h>
262	int res;
263	int main (void)
264	{
265	struct statx sx;
266	int res;
267	res = statx (AT_FDCWD, ".",
268	AT_EMPTY_PATH \| AT_NO_AUTOMOUNT \| AT_SYMLINK_NOFOLLOW \| AT_STATX_SYNC_AS_STAT \| AT_STATX_FORCE_SYNC \| AT_STATX_DONT_SYNC,
269	STATX_ALL, &sx);
270	STATX_TYPE; STATX_MODE; STATX_NLINK; STATX_UID; STATX_GID; STATX_ATIME; STATX_MTIME; STATX_CTIME;
271	STATX_INO; STATX_SIZE; STATX_BLOCKS; STATX_BASIC_STATS; STATX_BTIME; STATX_ALL;
272	STATX_ATTR_COMPRESSED; STATX_ATTR_IMMUTABLE; STATX_ATTR_APPEND; STATX_ATTR_NODUMP; STATX_ATTR_ENCRYPTED;
273	return 0;
274	}
275	]])],ac_cv_statx=yes,ac_cv_statx=no)])
276	test $ac_cv_statx = yes && AC_DEFINE(HAVE_STATX, 1, statx(2) is available)
277
278	AC_CACHE_CHECK(for accept4, ac_cv_accept4, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
279	#include <sys/types.h>
280	#include <sys/socket.h>
281	int main (void)
282	{
283	int res = accept4 (1, (struct sockaddr *)0, (socklen_t)0, SOCK_NONBLOCK \| SOCK_CLOEXEC);
284	return 0;
285	}
286	]])],ac_cv_accept4=yes,ac_cv_accept4=no)])
287	test $ac_cv_accept4 = yes && AC_DEFINE(HAVE_ACCEPT4, 1, accept4(2) is available)
288
289	AC_CHECK_HEADERS([sys/mount.h])
290	AC_CACHE_CHECK(for mount, ac_cv_mount, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
291	#include <sys/mount.h>
292	int main (void)
293	{
294	int res = mount ("path", "path", "fstype", MS_RDONLY, 0);
295	return 0;
296	}
297	]])],ac_cv_mount=yes,ac_cv_mount=no)])
298	test $ac_cv_mount = yes && AC_DEFINE(HAVE_MOUNT, 1, mount is available)
299	AC_CACHE_CHECK(for umount, ac_cv_umount, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
300	#include <sys/mount.h>
301	int main (void)
302	{
303	int res = umount ("path");
304	return 0;
305	}
306	]])],ac_cv_umount=yes,ac_cv_umount=no)])
307	test $ac_cv_umount = yes && AC_DEFINE(HAVE_UMOUNT, 1, umount is available)
308	AC_CACHE_CHECK(for umount2, ac_cv_umount2, [AC_LINK_IFELSE([AC_LANG_SOURCE([[
309	#include <sys/mount.h>
310	int main (void)
311	{
312	int res = umount2 ("path", MNT_FORCE\|MNT_DETACH);
313	return 0;
314	}
315	]])],ac_cv_umount2=yes,ac_cv_umount2=no)])
316	test $ac_cv_umount2 = yes && AC_DEFINE(HAVE_UMOUNT2, 1, umount2 is available)
317
318	AC_OUTPUT
319