[mirror_zfs.git] / config / kernel-vfs-iov_iter.m4

dnl #
dnl # Check for available iov_iter functionality.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_VFS_IOV_ITER], [
	ZFS_LINUX_TEST_SRC([iov_iter_types], [
		#include <linux/fs.h>
		#include <linux/uio.h>
	],[
		int type __attribute__ ((unused)) =
		    ITER_IOVEC | ITER_KVEC | ITER_BVEC | ITER_PIPE;
	])

	ZFS_LINUX_TEST_SRC([iov_iter_advance], [
		#include <linux/fs.h>
		#include <linux/uio.h>
	],[
		struct iov_iter iter = { 0 };
		size_t advance = 512;

		iov_iter_advance(&iter, advance);
	])

	ZFS_LINUX_TEST_SRC([iov_iter_revert], [
		#include <linux/fs.h>
		#include <linux/uio.h>
	],[
		struct iov_iter iter = { 0 };
		size_t revert = 512;

		iov_iter_revert(&iter, revert);
	])

	ZFS_LINUX_TEST_SRC([iov_iter_fault_in_readable], [
		#include <linux/fs.h>
		#include <linux/uio.h>
	],[
		struct iov_iter iter = { 0 };
		size_t size = 512;
		int error __attribute__ ((unused));

		error = iov_iter_fault_in_readable(&iter, size);
	])

	ZFS_LINUX_TEST_SRC([fault_in_iov_iter_readable], [
		#include <linux/fs.h>
		#include <linux/uio.h>
	],[
		struct iov_iter iter = { 0 };
		size_t size = 512;
		int error __attribute__ ((unused));

		error = fault_in_iov_iter_readable(&iter, size);
	])

	ZFS_LINUX_TEST_SRC([iov_iter_count], [
		#include <linux/fs.h>
		#include <linux/uio.h>
	],[
		struct iov_iter iter = { 0 };
		size_t bytes __attribute__ ((unused));

		bytes = iov_iter_count(&iter);
	])

	ZFS_LINUX_TEST_SRC([copy_to_iter], [
		#include <linux/fs.h>
		#include <linux/uio.h>
	],[
		struct iov_iter iter = { 0 };
		char buf[512] = { 0 };
		size_t size = 512;
		size_t bytes __attribute__ ((unused));

		bytes = copy_to_iter((const void *)&buf, size, &iter);
	])

	ZFS_LINUX_TEST_SRC([copy_from_iter], [
		#include <linux/fs.h>
		#include <linux/uio.h>
	],[
		struct iov_iter iter = { 0 };
		char buf[512] = { 0 };
		size_t size = 512;
		size_t bytes __attribute__ ((unused));

		bytes = copy_from_iter((void *)&buf, size, &iter);
	])

	ZFS_LINUX_TEST_SRC([iov_iter_type], [
		#include <linux/fs.h>
		#include <linux/uio.h>
	],[
		struct iov_iter iter = { 0 };
		__attribute__((unused)) enum iter_type i = iov_iter_type(&iter);
	])

	ZFS_LINUX_TEST_SRC([iter_iov], [
		#include <linux/fs.h>
		#include <linux/uio.h>
	],[
		struct iov_iter iter = { 0 };
		__attribute__((unused)) const struct iovec *iov = iter_iov(&iter);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_VFS_IOV_ITER], [
	enable_vfs_iov_iter="yes"

	AC_MSG_CHECKING([whether iov_iter types are available])
	ZFS_LINUX_TEST_RESULT([iov_iter_types], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_IOV_ITER_TYPES, 1,
		    [iov_iter types are available])
	],[
		AC_MSG_RESULT(no)
		enable_vfs_iov_iter="no"
	])

	AC_MSG_CHECKING([whether iov_iter_advance() is available])
	ZFS_LINUX_TEST_RESULT([iov_iter_advance], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_IOV_ITER_ADVANCE, 1,
		    [iov_iter_advance() is available])
	],[
		AC_MSG_RESULT(no)
		enable_vfs_iov_iter="no"
	])

	AC_MSG_CHECKING([whether iov_iter_revert() is available])
	ZFS_LINUX_TEST_RESULT([iov_iter_revert], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_IOV_ITER_REVERT, 1,
		    [iov_iter_revert() is available])
	],[
		AC_MSG_RESULT(no)
		enable_vfs_iov_iter="no"
	])

	AC_MSG_CHECKING([whether iov_iter_fault_in_readable() is available])
	ZFS_LINUX_TEST_RESULT([iov_iter_fault_in_readable], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_IOV_ITER_FAULT_IN_READABLE, 1,
		    [iov_iter_fault_in_readable() is available])
	],[
		AC_MSG_RESULT(no)

		AC_MSG_CHECKING([whether fault_in_iov_iter_readable() is available])
		ZFS_LINUX_TEST_RESULT([fault_in_iov_iter_readable], [
			AC_MSG_RESULT(yes)
			AC_DEFINE(HAVE_FAULT_IN_IOV_ITER_READABLE, 1,
			    [fault_in_iov_iter_readable() is available])
		],[
			AC_MSG_RESULT(no)
			enable_vfs_iov_iter="no"
		])
	])

	AC_MSG_CHECKING([whether iov_iter_count() is available])
	ZFS_LINUX_TEST_RESULT([iov_iter_count], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_IOV_ITER_COUNT, 1,
		    [iov_iter_count() is available])
	],[
		AC_MSG_RESULT(no)
		enable_vfs_iov_iter="no"
	])

	AC_MSG_CHECKING([whether copy_to_iter() is available])
	ZFS_LINUX_TEST_RESULT([copy_to_iter], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_COPY_TO_ITER, 1,
		    [copy_to_iter() is available])
	],[
		AC_MSG_RESULT(no)
		enable_vfs_iov_iter="no"
	])

	AC_MSG_CHECKING([whether copy_from_iter() is available])
	ZFS_LINUX_TEST_RESULT([copy_from_iter], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_COPY_FROM_ITER, 1,
		    [copy_from_iter() is available])
	],[
		AC_MSG_RESULT(no)
		enable_vfs_iov_iter="no"
	])

	dnl #
	dnl # This checks for iov_iter_type() in linux/uio.h. It is not
	dnl # required, however, and the module will compiled without it
	dnl # using direct access of the member attribute
	dnl #
	AC_MSG_CHECKING([whether iov_iter_type() is available])
	ZFS_LINUX_TEST_RESULT([iov_iter_type], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_IOV_ITER_TYPE, 1,
		    [iov_iter_type() is available])
	],[
		AC_MSG_RESULT(no)
	])

	dnl #
	dnl # As of the 4.9 kernel support is provided for iovecs, kvecs,
	dnl # bvecs and pipes in the iov_iter structure.  As long as the
	dnl # other support interfaces are all available the iov_iter can
	dnl # be correctly used in the uio structure.
	dnl #
	AS_IF([test "x$enable_vfs_iov_iter" = "xyes"], [
		AC_DEFINE(HAVE_VFS_IOV_ITER, 1,
		    [All required iov_iter interfaces are available])
	])

	dnl #
	dnl # Kernel 6.5 introduces the iter_iov() function that returns the
	dnl # __iov member of an iov_iter*. The iov member was renamed to this
	dnl # __iov member, and is intended to be accessed via the helper
	dnl # function now.
	dnl #
	AC_MSG_CHECKING([whether iter_iov() is available])
	ZFS_LINUX_TEST_RESULT([iter_iov], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_ITER_IOV, 1,
		    [iter_iov() is available])
	],[
		AC_MSG_RESULT(no)
	])
])
Commit	Line	Data
1c2358c1 BB	1	dnl #
	2	dnl # Check for available iov_iter functionality.
	3	dnl #
	4	AC_DEFUN([ZFS_AC_KERNEL_SRC_VFS_IOV_ITER], [
	5	ZFS_LINUX_TEST_SRC([iov_iter_types], [
	6	#include <linux/fs.h>
	7	#include <linux/uio.h>
	8	],[
	9	int type __attribute__ ((unused)) =
	10	ITER_IOVEC \| ITER_KVEC \| ITER_BVEC \| ITER_PIPE;
	11	])
	12
1c2358c1 BB	13	ZFS_LINUX_TEST_SRC([iov_iter_advance], [
	14	#include <linux/fs.h>
	15	#include <linux/uio.h>
	16	],[
	17	struct iov_iter iter = { 0 };
	18	size_t advance = 512;
	19
	20	iov_iter_advance(&iter, advance);
	21	])
	22
	23	ZFS_LINUX_TEST_SRC([iov_iter_revert], [
	24	#include <linux/fs.h>
	25	#include <linux/uio.h>
	26	],[
	27	struct iov_iter iter = { 0 };
	28	size_t revert = 512;
	29
	30	iov_iter_revert(&iter, revert);
	31	])
	32
	33	ZFS_LINUX_TEST_SRC([iov_iter_fault_in_readable], [
	34	#include <linux/fs.h>
	35	#include <linux/uio.h>
	36	],[
	37	struct iov_iter iter = { 0 };
	38	size_t size = 512;
	39	int error __attribute__ ((unused));
	40
	41	error = iov_iter_fault_in_readable(&iter, size);
	42	])
	43
299fbf75 RE	44	ZFS_LINUX_TEST_SRC([fault_in_iov_iter_readable], [
	45	#include <linux/fs.h>
	46	#include <linux/uio.h>
	47	],[
	48	struct iov_iter iter = { 0 };
	49	size_t size = 512;
	50	int error __attribute__ ((unused));
	51
	52	error = fault_in_iov_iter_readable(&iter, size);
	53	])
	54
1c2358c1 BB	55	ZFS_LINUX_TEST_SRC([iov_iter_count], [
	56	#include <linux/fs.h>
	57	#include <linux/uio.h>
	58	],[
	59	struct iov_iter iter = { 0 };
	60	size_t bytes __attribute__ ((unused));
	61
	62	bytes = iov_iter_count(&iter);
	63	])
	64
	65	ZFS_LINUX_TEST_SRC([copy_to_iter], [
	66	#include <linux/fs.h>
	67	#include <linux/uio.h>
	68	],[
	69	struct iov_iter iter = { 0 };
	70	char buf[512] = { 0 };
	71	size_t size = 512;
	72	size_t bytes __attribute__ ((unused));
	73
	74	bytes = copy_to_iter((const void *)&buf, size, &iter);
	75	])
	76
	77	ZFS_LINUX_TEST_SRC([copy_from_iter], [
	78	#include <linux/fs.h>
	79	#include <linux/uio.h>
	80	],[
	81	struct iov_iter iter = { 0 };
	82	char buf[512] = { 0 };
	83	size_t size = 512;
	84	size_t bytes __attribute__ ((unused));
	85
	86	bytes = copy_from_iter((void *)&buf, size, &iter);
	87	])
f6e22561 CK	88
	89	ZFS_LINUX_TEST_SRC([iov_iter_type], [
	90	#include <linux/fs.h>
	91	#include <linux/uio.h>
	92	],[
	93	struct iov_iter iter = { 0 };
	94	__attribute__((unused)) enum iter_type i = iov_iter_type(&iter);
	95	])
325505e5 CK	96
	97	ZFS_LINUX_TEST_SRC([iter_iov], [
	98	#include <linux/fs.h>
	99	#include <linux/uio.h>
	100	],[
	101	struct iov_iter iter = { 0 };
	102	__attribute__((unused)) const struct iovec *iov = iter_iov(&iter);
	103	])
1c2358c1 BB	104	])
	105
	106	AC_DEFUN([ZFS_AC_KERNEL_VFS_IOV_ITER], [
	107	enable_vfs_iov_iter="yes"
	108
	109	AC_MSG_CHECKING([whether iov_iter types are available])
	110	ZFS_LINUX_TEST_RESULT([iov_iter_types], [
	111	AC_MSG_RESULT(yes)
	112	AC_DEFINE(HAVE_IOV_ITER_TYPES, 1,
	113	[iov_iter types are available])
	114	],[
	115	AC_MSG_RESULT(no)
	116	enable_vfs_iov_iter="no"
	117	])
	118
1c2358c1 BB	119	AC_MSG_CHECKING([whether iov_iter_advance() is available])
	120	ZFS_LINUX_TEST_RESULT([iov_iter_advance], [
	121	AC_MSG_RESULT(yes)
	122	AC_DEFINE(HAVE_IOV_ITER_ADVANCE, 1,
	123	[iov_iter_advance() is available])
	124	],[
	125	AC_MSG_RESULT(no)
	126	enable_vfs_iov_iter="no"
	127	])
	128
	129	AC_MSG_CHECKING([whether iov_iter_revert() is available])
	130	ZFS_LINUX_TEST_RESULT([iov_iter_revert], [
	131	AC_MSG_RESULT(yes)
	132	AC_DEFINE(HAVE_IOV_ITER_REVERT, 1,
	133	[iov_iter_revert() is available])
	134	],[
	135	AC_MSG_RESULT(no)
	136	enable_vfs_iov_iter="no"
	137	])
	138
	139	AC_MSG_CHECKING([whether iov_iter_fault_in_readable() is available])
	140	ZFS_LINUX_TEST_RESULT([iov_iter_fault_in_readable], [
	141	AC_MSG_RESULT(yes)
	142	AC_DEFINE(HAVE_IOV_ITER_FAULT_IN_READABLE, 1,
	143	[iov_iter_fault_in_readable() is available])
	144	],[
5e4aedac BB	145	AC_MSG_RESULT(no)
5e4aedac BB	146
299fbf75 RE	147	AC_MSG_CHECKING([whether fault_in_iov_iter_readable() is available])
	148	ZFS_LINUX_TEST_RESULT([fault_in_iov_iter_readable], [
	149	AC_MSG_RESULT(yes)
	150	AC_DEFINE(HAVE_FAULT_IN_IOV_ITER_READABLE, 1,
	151	[fault_in_iov_iter_readable() is available])
	152	],[
	153	AC_MSG_RESULT(no)
	154	enable_vfs_iov_iter="no"
	155	])
1c2358c1 BB	156	])
	157
	158	AC_MSG_CHECKING([whether iov_iter_count() is available])
	159	ZFS_LINUX_TEST_RESULT([iov_iter_count], [
	160	AC_MSG_RESULT(yes)
	161	AC_DEFINE(HAVE_IOV_ITER_COUNT, 1,
	162	[iov_iter_count() is available])
	163	],[
	164	AC_MSG_RESULT(no)
	165	enable_vfs_iov_iter="no"
	166	])
	167
	168	AC_MSG_CHECKING([whether copy_to_iter() is available])
	169	ZFS_LINUX_TEST_RESULT([copy_to_iter], [
	170	AC_MSG_RESULT(yes)
	171	AC_DEFINE(HAVE_COPY_TO_ITER, 1,
	172	[copy_to_iter() is available])
	173	],[
	174	AC_MSG_RESULT(no)
	175	enable_vfs_iov_iter="no"
	176	])
	177
	178	AC_MSG_CHECKING([whether copy_from_iter() is available])
	179	ZFS_LINUX_TEST_RESULT([copy_from_iter], [
	180	AC_MSG_RESULT(yes)
	181	AC_DEFINE(HAVE_COPY_FROM_ITER, 1,
	182	[copy_from_iter() is available])
	183	],[
	184	AC_MSG_RESULT(no)
	185	enable_vfs_iov_iter="no"
	186	])
	187
f6e22561 CK	188	dnl #
	189	dnl # This checks for iov_iter_type() in linux/uio.h. It is not
	190	dnl # required, however, and the module will compiled without it
	191	dnl # using direct access of the member attribute
	192	dnl #
	193	AC_MSG_CHECKING([whether iov_iter_type() is available])
	194	ZFS_LINUX_TEST_RESULT([iov_iter_type], [
	195	AC_MSG_RESULT(yes)
	196	AC_DEFINE(HAVE_IOV_ITER_TYPE, 1,
	197	[iov_iter_type() is available])
	198	],[
	199	AC_MSG_RESULT(no)
	200	])
	201
1c2358c1 BB	202	dnl #
	203	dnl # As of the 4.9 kernel support is provided for iovecs, kvecs,
	204	dnl # bvecs and pipes in the iov_iter structure. As long as the
	205	dnl # other support interfaces are all available the iov_iter can
	206	dnl # be correctly used in the uio structure.
	207	dnl #
	208	AS_IF([test "x$enable_vfs_iov_iter" = "xyes"], [
	209	AC_DEFINE(HAVE_VFS_IOV_ITER, 1,
	210	[All required iov_iter interfaces are available])
	211	])
325505e5 CK	212
	213	dnl #
	214	dnl # Kernel 6.5 introduces the iter_iov() function that returns the
	215	dnl # __iov member of an iov_iter*. The iov member was renamed to this
	216	dnl # __iov member, and is intended to be accessed via the helper
	217	dnl # function now.
	218	dnl #
	219	AC_MSG_CHECKING([whether iter_iov() is available])
	220	ZFS_LINUX_TEST_RESULT([iter_iov], [
	221	AC_MSG_RESULT(yes)
	222	AC_DEFINE(HAVE_ITER_IOV, 1,
	223	[iter_iov() is available])
	224	],[
	225	AC_MSG_RESULT(no)
	226	])
1c2358c1	227	])