[mirror_zfs.git] / config / kernel-xattr-handler.m4

dnl #
dnl # 2.6.35 API change,
dnl # The 'struct xattr_handler' was constified in the generic
dnl # super_block structure.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_CONST_XATTR_HANDLER], [
	ZFS_LINUX_TEST_SRC([const_xattr_handler], [
		#include <linux/fs.h>
		#include <linux/xattr.h>

		const struct xattr_handler xattr_test_handler = {
			.prefix	= "test",
			.get	= NULL,
			.set	= NULL,
		};

		const struct xattr_handler *xattr_handlers[] = {
			&xattr_test_handler,
		};

		const struct super_block sb __attribute__ ((unused)) = {
			.s_xattr = xattr_handlers,
		};
	],[])
])

AC_DEFUN([ZFS_AC_KERNEL_CONST_XATTR_HANDLER], [
	AC_MSG_CHECKING([whether super_block uses const struct xattr_handler])
	ZFS_LINUX_TEST_RESULT([const_xattr_handler], [
		AC_MSG_RESULT([yes])
	],[
		ZFS_LINUX_TEST_ERROR([const xattr_handler])
	])
])

dnl #
dnl # 4.5 API change,
dnl # struct xattr_handler added new member "name".
dnl # xattr_handler which matches to whole name rather than prefix should use
dnl # "name" instead of "prefix", e.g. "system.posix_acl_access"
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_XATTR_HANDLER_NAME], [
	ZFS_LINUX_TEST_SRC([xattr_handler_name], [
		#include <linux/xattr.h>

		static const struct xattr_handler
		    xops __attribute__ ((unused)) = {
			.name = XATTR_NAME_POSIX_ACL_ACCESS,
		};
	],[])
])

AC_DEFUN([ZFS_AC_KERNEL_XATTR_HANDLER_NAME], [
	AC_MSG_CHECKING([whether xattr_handler has name])
	ZFS_LINUX_TEST_RESULT([xattr_handler_name], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_XATTR_HANDLER_NAME, 1,
		    [xattr_handler has name])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # Supported xattr handler get() interfaces checked newest to oldest.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_XATTR_HANDLER_GET], [
	ZFS_LINUX_TEST_SRC([xattr_handler_get_dentry_inode], [
		#include <linux/xattr.h>

		static int get(const struct xattr_handler *handler,
		    struct dentry *dentry, struct inode *inode,
		    const char *name, void *buffer, size_t size) { return 0; }
		static const struct xattr_handler
		    xops __attribute__ ((unused)) = {
			.get = get,
		};
	],[])

	ZFS_LINUX_TEST_SRC([xattr_handler_get_xattr_handler], [
		#include <linux/xattr.h>

		static int get(const struct xattr_handler *handler,
		    struct dentry *dentry, const char *name,
		    void *buffer, size_t size) { return 0; }
		static const struct xattr_handler
		    xops __attribute__ ((unused)) = {
			.get = get,
		};
	],[])

	ZFS_LINUX_TEST_SRC([xattr_handler_get_dentry], [
		#include <linux/xattr.h>

		static int get(struct dentry *dentry, const char *name,
		    void *buffer, size_t size, int handler_flags)
		    { return 0; }
		static const struct xattr_handler
		    xops __attribute__ ((unused)) = {
			.get = get,
		};
	],[])

	ZFS_LINUX_TEST_SRC([xattr_handler_get_dentry_inode_flags], [
		#include <linux/xattr.h>

		static int get(const struct xattr_handler *handler,
		    struct dentry *dentry, struct inode *inode,
		    const char *name, void *buffer,
		    size_t size, int flags) { return 0; }
		static const struct xattr_handler
		    xops __attribute__ ((unused)) = {
			.get = get,
		};
	],[])
])

AC_DEFUN([ZFS_AC_KERNEL_XATTR_HANDLER_GET], [
	dnl #
	dnl # 4.7 API change,
	dnl # The xattr_handler->get() callback was changed to take both
	dnl # dentry and inode.
	dnl #
	AC_MSG_CHECKING([whether xattr_handler->get() wants dentry and inode])
	ZFS_LINUX_TEST_RESULT([xattr_handler_get_dentry_inode], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_XATTR_GET_DENTRY_INODE, 1,
		    [xattr_handler->get() wants both dentry and inode])
	],[
		dnl #
		dnl # 4.4 API change,
		dnl # The xattr_handler->get() callback was changed to take a
		dnl # attr_handler, and handler_flags argument was removed and
		dnl # should be accessed by handler->flags.
		dnl #
		AC_MSG_RESULT(no)
		AC_MSG_CHECKING(
		    [whether xattr_handler->get() wants xattr_handler])
		ZFS_LINUX_TEST_RESULT([xattr_handler_get_xattr_handler], [
			AC_MSG_RESULT(yes)
			AC_DEFINE(HAVE_XATTR_GET_HANDLER, 1,
			    [xattr_handler->get() wants xattr_handler])
		],[
			dnl #
			dnl # 2.6.33 API change,
			dnl # The xattr_handler->get() callback was changed
			dnl # to take a dentry instead of an inode, and a
			dnl # handler_flags argument was added.
			dnl #
			AC_MSG_RESULT(no)
			AC_MSG_CHECKING(
			    [whether xattr_handler->get() wants dentry])
			ZFS_LINUX_TEST_RESULT([xattr_handler_get_dentry], [
				AC_MSG_RESULT(yes)
				AC_DEFINE(HAVE_XATTR_GET_DENTRY, 1,
				    [xattr_handler->get() wants dentry])
			],[
				dnl #
				dnl # Android API change,
				dnl # The xattr_handler->get() callback was
				dnl # changed to take dentry, inode and flags.
				dnl #
				AC_MSG_RESULT(no)
				AC_MSG_CHECKING(
				    [whether xattr_handler->get() wants dentry and inode and flags])
				ZFS_LINUX_TEST_RESULT([xattr_handler_get_dentry_inode_flags], [
					AC_MSG_RESULT(yes)
					AC_DEFINE(HAVE_XATTR_GET_DENTRY_INODE_FLAGS, 1,
					    [xattr_handler->get() wants dentry and inode and flags])
				],[
					ZFS_LINUX_TEST_ERROR([xattr get()])
				])
			])
		])
	])
])

dnl #
dnl # Supported xattr handler set() interfaces checked newest to oldest.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_XATTR_HANDLER_SET], [
	ZFS_LINUX_TEST_SRC([xattr_handler_set_mnt_idmap], [
		#include <linux/xattr.h>

		static int set(const struct xattr_handler *handler,
			struct mnt_idmap *idmap,
			struct dentry *dentry, struct inode *inode,
			const char *name, const void *buffer,
			size_t size, int flags)
			{ return 0; }
		static const struct xattr_handler
			xops __attribute__ ((unused)) = {
			.set = set,
		};
	],[])

	ZFS_LINUX_TEST_SRC([xattr_handler_set_userns], [
		#include <linux/xattr.h>

		static int set(const struct xattr_handler *handler,
			struct user_namespace *mnt_userns,
			struct dentry *dentry, struct inode *inode,
			const char *name, const void *buffer,
			size_t size, int flags)
			{ return 0; }
		static const struct xattr_handler
			xops __attribute__ ((unused)) = {
			.set = set,
		};
	],[])

	ZFS_LINUX_TEST_SRC([xattr_handler_set_dentry_inode], [
		#include <linux/xattr.h>

		static int set(const struct xattr_handler *handler,
		    struct dentry *dentry, struct inode *inode,
		    const char *name, const void *buffer,
		    size_t size, int flags)
		    { return 0; }
		static const struct xattr_handler
		    xops __attribute__ ((unused)) = {
			.set = set,
		};
	],[])

	ZFS_LINUX_TEST_SRC([xattr_handler_set_xattr_handler], [
		#include <linux/xattr.h>

		static int set(const struct xattr_handler *handler,
		    struct dentry *dentry, const char *name,
		    const void *buffer, size_t size, int flags)
		    { return 0; }
		static const struct xattr_handler
		    xops __attribute__ ((unused)) = {
			.set = set,
		};
	],[])

	ZFS_LINUX_TEST_SRC([xattr_handler_set_dentry], [
		#include <linux/xattr.h>

		static int set(struct dentry *dentry, const char *name,
		    const void *buffer, size_t size, int flags,
		    int handler_flags) { return 0; }
		static const struct xattr_handler
		    xops __attribute__ ((unused)) = {
			.set = set,
		};
	],[])
])

AC_DEFUN([ZFS_AC_KERNEL_XATTR_HANDLER_SET], [
	dnl #
	dnl # 5.12 API change,
	dnl # The xattr_handler->set() callback was changed to 8 arguments, and
	dnl # struct user_namespace* was inserted as arg #2
	dnl #
	dnl # 6.3 API change,
	dnl # The xattr_handler->set() callback 2nd arg is now struct mnt_idmap *
	dnl #
	AC_MSG_CHECKING([whether xattr_handler->set() wants dentry, inode, and mnt_idmap])
	ZFS_LINUX_TEST_RESULT([xattr_handler_set_mnt_idmap], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_XATTR_SET_IDMAP, 1,
		    [xattr_handler->set() takes mnt_idmap])
	], [
		AC_MSG_CHECKING([whether xattr_handler->set() wants dentry, inode, and user_namespace])
		ZFS_LINUX_TEST_RESULT([xattr_handler_set_userns], [
			AC_MSG_RESULT(yes)
			AC_DEFINE(HAVE_XATTR_SET_USERNS, 1,
			    [xattr_handler->set() takes user_namespace])
		],[
			dnl #
			dnl # 4.7 API change,
			dnl # The xattr_handler->set() callback was changed to take both
			dnl # dentry and inode.
			dnl #
			AC_MSG_RESULT(no)
			AC_MSG_CHECKING([whether xattr_handler->set() wants dentry and inode])
			ZFS_LINUX_TEST_RESULT([xattr_handler_set_dentry_inode], [
				AC_MSG_RESULT(yes)
				AC_DEFINE(HAVE_XATTR_SET_DENTRY_INODE, 1,
				    [xattr_handler->set() wants both dentry and inode])
			],[
				dnl #
				dnl # 4.4 API change,
				dnl # The xattr_handler->set() callback was changed to take a
				dnl # xattr_handler, and handler_flags argument was removed and
				dnl # should be accessed by handler->flags.
				dnl #
				AC_MSG_RESULT(no)
				AC_MSG_CHECKING(
				    [whether xattr_handler->set() wants xattr_handler])
				ZFS_LINUX_TEST_RESULT([xattr_handler_set_xattr_handler], [
					AC_MSG_RESULT(yes)
					AC_DEFINE(HAVE_XATTR_SET_HANDLER, 1,
					    [xattr_handler->set() wants xattr_handler])
				],[
					dnl #
					dnl # 2.6.33 API change,
					dnl # The xattr_handler->set() callback was changed
					dnl # to take a dentry instead of an inode, and a
					dnl # handler_flags argument was added.
					dnl #
					AC_MSG_RESULT(no)
					AC_MSG_CHECKING(
					    [whether xattr_handler->set() wants dentry])
					ZFS_LINUX_TEST_RESULT([xattr_handler_set_dentry], [
						AC_MSG_RESULT(yes)
						AC_DEFINE(HAVE_XATTR_SET_DENTRY, 1,
						    [xattr_handler->set() wants dentry])
					],[
						ZFS_LINUX_TEST_ERROR([xattr set()])
					])
				])
			])
		])
	])
])

dnl #
dnl # Supported xattr handler list() interfaces checked newest to oldest.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_XATTR_HANDLER_LIST], [
	ZFS_LINUX_TEST_SRC([xattr_handler_list_simple], [
		#include <linux/xattr.h>

		static bool list(struct dentry *dentry) { return 0; }
		static const struct xattr_handler
		    xops __attribute__ ((unused)) = {
			.list = list,
		};
	],[])

	ZFS_LINUX_TEST_SRC([xattr_handler_list_xattr_handler], [
		#include <linux/xattr.h>

		static size_t list(const struct xattr_handler *handler,
		    struct dentry *dentry, char *list, size_t list_size,
		    const char *name, size_t name_len) { return 0; }
		static const struct xattr_handler
		    xops __attribute__ ((unused)) = {
			.list = list,
		};
	],[])

	ZFS_LINUX_TEST_SRC([xattr_handler_list_dentry], [
		#include <linux/xattr.h>

		static size_t list(struct dentry *dentry,
		    char *list, size_t list_size,
		    const char *name, size_t name_len,
		    int handler_flags) { return 0; }
		static const struct xattr_handler
		    xops __attribute__ ((unused)) = {
			.list = list,
		};
	],[])
])

AC_DEFUN([ZFS_AC_KERNEL_XATTR_HANDLER_LIST], [
	dnl # 4.5 API change,
	dnl # The xattr_handler->list() callback was changed to take only a
	dnl # dentry and it only needs to return if it's accessible.
	AC_MSG_CHECKING([whether xattr_handler->list() wants simple])
	ZFS_LINUX_TEST_RESULT([xattr_handler_list_simple], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_XATTR_LIST_SIMPLE, 1,
		    [xattr_handler->list() wants simple])
	],[
		dnl #
		dnl # 4.4 API change,
		dnl # The xattr_handler->list() callback was changed to take a
		dnl # xattr_handler, and handler_flags argument was removed
		dnl # and should be accessed by handler->flags.
		dnl #
		AC_MSG_RESULT(no)
		AC_MSG_CHECKING(
		    [whether xattr_handler->list() wants xattr_handler])
		ZFS_LINUX_TEST_RESULT([xattr_handler_list_xattr_handler], [
			AC_MSG_RESULT(yes)
			AC_DEFINE(HAVE_XATTR_LIST_HANDLER, 1,
			    [xattr_handler->list() wants xattr_handler])
		],[
			dnl #
			dnl # 2.6.33 API change,
			dnl # The xattr_handler->list() callback was changed
			dnl # to take a dentry instead of an inode, and a
			dnl # handler_flags argument was added.
			dnl #
			AC_MSG_RESULT(no)
			AC_MSG_CHECKING(
			    [whether xattr_handler->list() wants dentry])
			ZFS_LINUX_TEST_RESULT([xattr_handler_list_dentry], [
				AC_MSG_RESULT(yes)
				AC_DEFINE(HAVE_XATTR_LIST_DENTRY, 1,
				    [xattr_handler->list() wants dentry])
			],[
				ZFS_LINUX_TEST_ERROR([xattr list()])
			])
		])
	])
])

dnl #
dnl # 3.7 API change,
dnl # The posix_acl_{from,to}_xattr functions gained a new
dnl # parameter: user_ns
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_POSIX_ACL_FROM_XATTR_USERNS], [
	ZFS_LINUX_TEST_SRC([posix_acl_from_xattr_userns], [
		#include <linux/cred.h>
		#include <linux/fs.h>
		#include <linux/posix_acl_xattr.h>
	],[
		posix_acl_from_xattr(&init_user_ns, NULL, 0);
	])
])

AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_FROM_XATTR_USERNS], [
	AC_MSG_CHECKING([whether posix_acl_from_xattr() needs user_ns])
	ZFS_LINUX_TEST_RESULT([posix_acl_from_xattr_userns], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_POSIX_ACL_FROM_XATTR_USERNS, 1,
		    [posix_acl_from_xattr() needs user_ns])
	],[
		ZFS_LINUX_TEST_ERROR([posix_acl_from_xattr()])
	])
])

dnl #
dnl # 4.9 API change,
dnl # iops->{set,get,remove}xattr and generic_{set,get,remove}xattr are
dnl # removed. xattr operations will directly go through sb->s_xattr.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SRC_GENERIC_SETXATTR], [
	ZFS_LINUX_TEST_SRC([have_generic_setxattr], [
		#include <linux/fs.h>
		#include <linux/xattr.h>

		static const struct inode_operations
		    iops __attribute__ ((unused)) = {
			.setxattr = generic_setxattr
		};
	],[])
])

AC_DEFUN([ZFS_AC_KERNEL_GENERIC_SETXATTR], [
	AC_MSG_CHECKING([whether generic_setxattr() exists])
	ZFS_LINUX_TEST_RESULT([have_generic_setxattr], [
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_GENERIC_SETXATTR, 1,
		    [generic_setxattr() exists])
	],[
		AC_MSG_RESULT(no)
	])
])

AC_DEFUN([ZFS_AC_KERNEL_SRC_XATTR], [
	ZFS_AC_KERNEL_SRC_CONST_XATTR_HANDLER
	ZFS_AC_KERNEL_SRC_XATTR_HANDLER_NAME
	ZFS_AC_KERNEL_SRC_XATTR_HANDLER_GET
	ZFS_AC_KERNEL_SRC_XATTR_HANDLER_SET
	ZFS_AC_KERNEL_SRC_XATTR_HANDLER_LIST
	ZFS_AC_KERNEL_SRC_POSIX_ACL_FROM_XATTR_USERNS
	ZFS_AC_KERNEL_SRC_GENERIC_SETXATTR
])

AC_DEFUN([ZFS_AC_KERNEL_XATTR], [
	ZFS_AC_KERNEL_CONST_XATTR_HANDLER
	ZFS_AC_KERNEL_XATTR_HANDLER_NAME
	ZFS_AC_KERNEL_XATTR_HANDLER_GET
	ZFS_AC_KERNEL_XATTR_HANDLER_SET
	ZFS_AC_KERNEL_XATTR_HANDLER_LIST
	ZFS_AC_KERNEL_POSIX_ACL_FROM_XATTR_USERNS
	ZFS_AC_KERNEL_GENERIC_SETXATTR
])
Commit	Line	Data
777d4af8 BB	1	dnl #
	2	dnl # 2.6.35 API change,
	3	dnl # The 'struct xattr_handler' was constified in the generic
	4	dnl # super_block structure.
	5	dnl #
608f8749 BB	6	AC_DEFUN([ZFS_AC_KERNEL_SRC_CONST_XATTR_HANDLER], [
608f8749 BB	7	ZFS_LINUX_TEST_SRC([const_xattr_handler], [
777d4af8 BB	8	#include <linux/fs.h>
	9	#include <linux/xattr.h>
	10
	11	const struct xattr_handler xattr_test_handler = {
	12	.prefix = "test",
	13	.get = NULL,
	14	.set = NULL,
	15	};
	16
	17	const struct xattr_handler *xattr_handlers[] = {
	18	&xattr_test_handler,
	19	};
777d4af8	20
b83e3e48 RY	21	const struct super_block sb __attribute__ ((unused)) = {
	22	.s_xattr = xattr_handlers,
	23	};
608f8749 BB	24	],[])
	25	])
	26
	27	AC_DEFUN([ZFS_AC_KERNEL_CONST_XATTR_HANDLER], [
	28	AC_MSG_CHECKING([whether super_block uses const struct xattr_handler])
	29	ZFS_LINUX_TEST_RESULT([const_xattr_handler], [
777d4af8	30	AC_MSG_RESULT([yes])
777d4af8	31	],[
066e8252	32	ZFS_LINUX_TEST_ERROR([const xattr_handler])
777d4af8 BB	33	])
777d4af8 BB	34	])
f9637c6c	35
232604b5 CC	36	dnl #
	37	dnl # 4.5 API change,
	38	dnl # struct xattr_handler added new member "name".
	39	dnl # xattr_handler which matches to whole name rather than prefix should use
	40	dnl # "name" instead of "prefix", e.g. "system.posix_acl_access"
	41	dnl #
608f8749 BB	42	AC_DEFUN([ZFS_AC_KERNEL_SRC_XATTR_HANDLER_NAME], [
608f8749 BB	43	ZFS_LINUX_TEST_SRC([xattr_handler_name], [
232604b5 CC	44	#include <linux/xattr.h>
	45
	46	static const struct xattr_handler
	47	xops __attribute__ ((unused)) = {
	48	.name = XATTR_NAME_POSIX_ACL_ACCESS,
	49	};
608f8749 BB	50	],[])
	51	])
	52
	53	AC_DEFUN([ZFS_AC_KERNEL_XATTR_HANDLER_NAME], [
	54	AC_MSG_CHECKING([whether xattr_handler has name])
	55	ZFS_LINUX_TEST_RESULT([xattr_handler_name], [
232604b5 CC	56	AC_MSG_RESULT(yes)
	57	AC_DEFINE(HAVE_XATTR_HANDLER_NAME, 1,
	58	[xattr_handler has name])
	59	],[
	60	AC_MSG_RESULT(no)
	61	])
0fedeedd CC	62	])
	63
	64	dnl #
608f8749	65	dnl # Supported xattr handler get() interfaces checked newest to oldest.
0fedeedd	66	dnl #
608f8749 BB	67	AC_DEFUN([ZFS_AC_KERNEL_SRC_XATTR_HANDLER_GET], [
608f8749 BB	68	ZFS_LINUX_TEST_SRC([xattr_handler_get_dentry_inode], [
0fedeedd CC	69	#include <linux/xattr.h>
0fedeedd CC	70
a41d0b29	71	static int get(const struct xattr_handler *handler,
608f8749 BB	72	struct dentry dentry, struct inode inode,
	73	const char name, void buffer, size_t size) { return 0; }
	74	static const struct xattr_handler
	75	xops __attribute__ ((unused)) = {
	76	.get = get,
0fedeedd	77	};
608f8749	78	],[])
232604b5	79
608f8749	80	ZFS_LINUX_TEST_SRC([xattr_handler_get_xattr_handler], [
f9637c6c	81	#include <linux/xattr.h>
f9637c6c	82
a41d0b29	83	static int get(const struct xattr_handler *handler,
608f8749 BB	84	struct dentry dentry, const char name,
608f8749 BB	85	void *buffer, size_t size) { return 0; }
b83e3e48 RY	86	static const struct xattr_handler
	87	xops __attribute__ ((unused)) = {
	88	.get = get,
	89	};
608f8749 BB	90	],[])
	91
	92	ZFS_LINUX_TEST_SRC([xattr_handler_get_dentry], [
	93	#include <linux/xattr.h>
	94
a41d0b29	95	static int get(struct dentry dentry, const char name,
608f8749 BB	96	void *buffer, size_t size, int handler_flags)
	97	{ return 0; }
	98	static const struct xattr_handler
	99	xops __attribute__ ((unused)) = {
	100	.get = get,
	101	};
	102	],[])
238cd4b8 WH	103
	104	ZFS_LINUX_TEST_SRC([xattr_handler_get_dentry_inode_flags], [
	105	#include <linux/xattr.h>
	106
a41d0b29	107	static int get(const struct xattr_handler *handler,
238cd4b8 WH	108	struct dentry dentry, struct inode inode,
	109	const char name, void buffer,
	110	size_t size, int flags) { return 0; }
	111	static const struct xattr_handler
	112	xops __attribute__ ((unused)) = {
	113	.get = get,
	114	};
	115	],[])
608f8749 BB	116	])
	117
	118	AC_DEFUN([ZFS_AC_KERNEL_XATTR_HANDLER_GET], [
	119	dnl #
	120	dnl # 4.7 API change,
	121	dnl # The xattr_handler->get() callback was changed to take both
	122	dnl # dentry and inode.
	123	dnl #
	124	AC_MSG_CHECKING([whether xattr_handler->get() wants dentry and inode])
	125	ZFS_LINUX_TEST_RESULT([xattr_handler_get_dentry_inode], [
f9637c6c	126	AC_MSG_RESULT(yes)
fd4c7b7a	127	AC_DEFINE(HAVE_XATTR_GET_DENTRY_INODE, 1,
8fbbc6b4	128	[xattr_handler->get() wants both dentry and inode])
f9637c6c	129	],[
4967a3eb	130	dnl #
fd4c7b7a CC	131	dnl # 4.4 API change,
	132	dnl # The xattr_handler->get() callback was changed to take a
	133	dnl # attr_handler, and handler_flags argument was removed and
	134	dnl # should be accessed by handler->flags.
4967a3eb	135	dnl #
d4701011	136	AC_MSG_RESULT(no)
608f8749 BB	137	AC_MSG_CHECKING(
	138	[whether xattr_handler->get() wants xattr_handler])
	139	ZFS_LINUX_TEST_RESULT([xattr_handler_get_xattr_handler], [
61d482f7	140	AC_MSG_RESULT(yes)
fd4c7b7a CC	141	AC_DEFINE(HAVE_XATTR_GET_HANDLER, 1,
fd4c7b7a CC	142	[xattr_handler->get() wants xattr_handler])
61d482f7	143	],[
4967a3eb	144	dnl #
fd4c7b7a	145	dnl # 2.6.33 API change,
608f8749 BB	146	dnl # The xattr_handler->get() callback was changed
	147	dnl # to take a dentry instead of an inode, and a
	148	dnl # handler_flags argument was added.
4967a3eb	149	dnl #
61d482f7	150	AC_MSG_RESULT(no)
608f8749 BB	151	AC_MSG_CHECKING(
	152	[whether xattr_handler->get() wants dentry])
	153	ZFS_LINUX_TEST_RESULT([xattr_handler_get_dentry], [
4967a3eb	154	AC_MSG_RESULT(yes)
fd4c7b7a CC	155	AC_DEFINE(HAVE_XATTR_GET_DENTRY, 1,
fd4c7b7a CC	156	[xattr_handler->get() wants dentry])
4967a3eb	157	],[
238cd4b8 WH	158	dnl #
	159	dnl # Android API change,
	160	dnl # The xattr_handler->get() callback was
	161	dnl # changed to take dentry, inode and flags.
	162	dnl #
	163	AC_MSG_RESULT(no)
	164	AC_MSG_CHECKING(
	165	[whether xattr_handler->get() wants dentry and inode and flags])
	166	ZFS_LINUX_TEST_RESULT([xattr_handler_get_dentry_inode_flags], [
	167	AC_MSG_RESULT(yes)
	168	AC_DEFINE(HAVE_XATTR_GET_DENTRY_INODE_FLAGS, 1,
	169	[xattr_handler->get() wants dentry and inode and flags])
	170	],[
	171	ZFS_LINUX_TEST_ERROR([xattr get()])
	172	])
4967a3eb	173	])
61d482f7	174	])
f9637c6c BB	175	])
	176	])
	177
	178	dnl #
4967a3eb	179	dnl # Supported xattr handler set() interfaces checked newest to oldest.
61d482f7	180	dnl #
608f8749	181	AC_DEFUN([ZFS_AC_KERNEL_SRC_XATTR_HANDLER_SET], [
d4dc53da YY	182	ZFS_LINUX_TEST_SRC([xattr_handler_set_mnt_idmap], [
	183	#include <linux/xattr.h>
	184
a41d0b29	185	static int set(const struct xattr_handler *handler,
d4dc53da YY	186	struct mnt_idmap *idmap,
	187	struct dentry dentry, struct inode inode,
	188	const char name, const void buffer,
	189	size_t size, int flags)
	190	{ return 0; }
	191	static const struct xattr_handler
	192	xops __attribute__ ((unused)) = {
	193	.set = set,
	194	};
	195	],[])
	196
e2a82961 CK	197	ZFS_LINUX_TEST_SRC([xattr_handler_set_userns], [
	198	#include <linux/xattr.h>
	199
a41d0b29	200	static int set(const struct xattr_handler *handler,
e2a82961 CK	201	struct user_namespace *mnt_userns,
	202	struct dentry dentry, struct inode inode,
	203	const char name, const void buffer,
	204	size_t size, int flags)
	205	{ return 0; }
	206	static const struct xattr_handler
	207	xops __attribute__ ((unused)) = {
	208	.set = set,
	209	};
	210	],[])
	211
608f8749	212	ZFS_LINUX_TEST_SRC([xattr_handler_set_dentry_inode], [
f9637c6c	213	#include <linux/xattr.h>
f9637c6c	214
a41d0b29	215	static int set(const struct xattr_handler *handler,
8fbbc6b4 BB	216	struct dentry dentry, struct inode inode,
	217	const char name, const void buffer,
	218	size_t size, int flags)
4967a3eb	219	{ return 0; }
b83e3e48 RY	220	static const struct xattr_handler
	221	xops __attribute__ ((unused)) = {
	222	.set = set,
	223	};
608f8749 BB	224	],[])
	225
	226	ZFS_LINUX_TEST_SRC([xattr_handler_set_xattr_handler], [
	227	#include <linux/xattr.h>
	228
a41d0b29	229	static int set(const struct xattr_handler *handler,
608f8749 BB	230	struct dentry dentry, const char name,
	231	const void *buffer, size_t size, int flags)
	232	{ return 0; }
	233	static const struct xattr_handler
	234	xops __attribute__ ((unused)) = {
	235	.set = set,
	236	};
	237	],[])
	238
	239	ZFS_LINUX_TEST_SRC([xattr_handler_set_dentry], [
	240	#include <linux/xattr.h>
	241
a41d0b29	242	static int set(struct dentry dentry, const char name,
608f8749 BB	243	const void *buffer, size_t size, int flags,
	244	int handler_flags) { return 0; }
	245	static const struct xattr_handler
	246	xops __attribute__ ((unused)) = {
	247	.set = set,
	248	};
	249	],[])
608f8749 BB	250	])
	251
	252	AC_DEFUN([ZFS_AC_KERNEL_XATTR_HANDLER_SET], [
	253	dnl #
e2a82961 CK	254	dnl # 5.12 API change,
	255	dnl # The xattr_handler->set() callback was changed to 8 arguments, and
	256	dnl # struct user_namespace* was inserted as arg #2
608f8749	257	dnl #
d4dc53da YY	258	dnl # 6.3 API change,
	259	dnl # The xattr_handler->set() callback 2nd arg is now struct mnt_idmap *
	260	dnl #
	261	AC_MSG_CHECKING([whether xattr_handler->set() wants dentry, inode, and mnt_idmap])
	262	ZFS_LINUX_TEST_RESULT([xattr_handler_set_mnt_idmap], [
f9637c6c	263	AC_MSG_RESULT(yes)
d4dc53da YY	264	AC_DEFINE(HAVE_XATTR_SET_IDMAP, 1,
	265	[xattr_handler->set() takes mnt_idmap])
	266	], [
	267	AC_MSG_CHECKING([whether xattr_handler->set() wants dentry, inode, and user_namespace])
	268	ZFS_LINUX_TEST_RESULT([xattr_handler_set_userns], [
61d482f7	269	AC_MSG_RESULT(yes)
d4dc53da YY	270	AC_DEFINE(HAVE_XATTR_SET_USERNS, 1,
d4dc53da YY	271	[xattr_handler->set() takes user_namespace])
61d482f7	272	],[
4967a3eb	273	dnl #
d4dc53da YY	274	dnl # 4.7 API change,
	275	dnl # The xattr_handler->set() callback was changed to take both
	276	dnl # dentry and inode.
4967a3eb	277	dnl #
61d482f7	278	AC_MSG_RESULT(no)
d4dc53da YY	279	AC_MSG_CHECKING([whether xattr_handler->set() wants dentry and inode])
d4dc53da YY	280	ZFS_LINUX_TEST_RESULT([xattr_handler_set_dentry_inode], [
4967a3eb	281	AC_MSG_RESULT(yes)
d4dc53da YY	282	AC_DEFINE(HAVE_XATTR_SET_DENTRY_INODE, 1,
d4dc53da YY	283	[xattr_handler->set() wants both dentry and inode])
4967a3eb	284	],[
e2a82961	285	dnl #
d4dc53da YY	286	dnl # 4.4 API change,
	287	dnl # The xattr_handler->set() callback was changed to take a
	288	dnl # xattr_handler, and handler_flags argument was removed and
	289	dnl # should be accessed by handler->flags.
e2a82961 CK	290	dnl #
	291	AC_MSG_RESULT(no)
	292	AC_MSG_CHECKING(
d4dc53da YY	293	[whether xattr_handler->set() wants xattr_handler])
d4dc53da YY	294	ZFS_LINUX_TEST_RESULT([xattr_handler_set_xattr_handler], [
e2a82961	295	AC_MSG_RESULT(yes)
d4dc53da YY	296	AC_DEFINE(HAVE_XATTR_SET_HANDLER, 1,
d4dc53da YY	297	[xattr_handler->set() wants xattr_handler])
e2a82961	298	],[
d4dc53da YY	299	dnl #
	300	dnl # 2.6.33 API change,
	301	dnl # The xattr_handler->set() callback was changed
	302	dnl # to take a dentry instead of an inode, and a
	303	dnl # handler_flags argument was added.
	304	dnl #
	305	AC_MSG_RESULT(no)
	306	AC_MSG_CHECKING(
	307	[whether xattr_handler->set() wants dentry])
	308	ZFS_LINUX_TEST_RESULT([xattr_handler_set_dentry], [
	309	AC_MSG_RESULT(yes)
	310	AC_DEFINE(HAVE_XATTR_SET_DENTRY, 1,
	311	[xattr_handler->set() wants dentry])
	312	],[
	313	ZFS_LINUX_TEST_ERROR([xattr set()])
	314	])
e2a82961	315	])
4967a3eb	316	])
61d482f7	317	])
f9637c6c BB	318	])
f9637c6c BB	319	])
023699cd MM	320
023699cd MM	321	dnl #
4967a3eb	322	dnl # Supported xattr handler list() interfaces checked newest to oldest.
61d482f7	323	dnl #
608f8749 BB	324	AC_DEFUN([ZFS_AC_KERNEL_SRC_XATTR_HANDLER_LIST], [
608f8749 BB	325	ZFS_LINUX_TEST_SRC([xattr_handler_list_simple], [
023699cd MM	326	#include <linux/xattr.h>
023699cd MM	327
a41d0b29	328	static bool list(struct dentry *dentry) { return 0; }
023699cd MM	329	static const struct xattr_handler
	330	xops __attribute__ ((unused)) = {
	331	.list = list,
	332	};
608f8749 BB	333	],[])
	334
	335	ZFS_LINUX_TEST_SRC([xattr_handler_list_xattr_handler], [
	336	#include <linux/xattr.h>
	337
a41d0b29	338	static size_t list(const struct xattr_handler *handler,
608f8749 BB	339	struct dentry dentry, char list, size_t list_size,
	340	const char *name, size_t name_len) { return 0; }
	341	static const struct xattr_handler
	342	xops __attribute__ ((unused)) = {
	343	.list = list,
	344	};
	345	],[])
	346
	347	ZFS_LINUX_TEST_SRC([xattr_handler_list_dentry], [
	348	#include <linux/xattr.h>
	349
a41d0b29	350	static size_t list(struct dentry *dentry,
608f8749 BB	351	char *list, size_t list_size,
	352	const char *name, size_t name_len,
	353	int handler_flags) { return 0; }
	354	static const struct xattr_handler
	355	xops __attribute__ ((unused)) = {
	356	.list = list,
	357	};
	358	],[])
608f8749 BB	359	])
	360
	361	AC_DEFUN([ZFS_AC_KERNEL_XATTR_HANDLER_LIST], [
	362	dnl # 4.5 API change,
	363	dnl # The xattr_handler->list() callback was changed to take only a
	364	dnl # dentry and it only needs to return if it's accessible.
	365	AC_MSG_CHECKING([whether xattr_handler->list() wants simple])
	366	ZFS_LINUX_TEST_RESULT([xattr_handler_list_simple], [
023699cd	367	AC_MSG_RESULT(yes)
4967a3eb BB	368	AC_DEFINE(HAVE_XATTR_LIST_SIMPLE, 1,
4967a3eb BB	369	[xattr_handler->list() wants simple])
023699cd	370	],[
4967a3eb BB	371	dnl #
	372	dnl # 4.4 API change,
	373	dnl # The xattr_handler->list() callback was changed to take a
	374	dnl # xattr_handler, and handler_flags argument was removed
	375	dnl # and should be accessed by handler->flags.
	376	dnl #
023699cd	377	AC_MSG_RESULT(no)
4967a3eb BB	378	AC_MSG_CHECKING(
4967a3eb BB	379	[whether xattr_handler->list() wants xattr_handler])
608f8749	380	ZFS_LINUX_TEST_RESULT([xattr_handler_list_xattr_handler], [
61d482f7	381	AC_MSG_RESULT(yes)
4967a3eb	382	AC_DEFINE(HAVE_XATTR_LIST_HANDLER, 1,
61d482f7 CC	383	[xattr_handler->list() wants xattr_handler])
61d482f7 CC	384	],[
4967a3eb BB	385	dnl #
	386	dnl # 2.6.33 API change,
	387	dnl # The xattr_handler->list() callback was changed
	388	dnl # to take a dentry instead of an inode, and a
	389	dnl # handler_flags argument was added.
	390	dnl #
61d482f7	391	AC_MSG_RESULT(no)
4967a3eb BB	392	AC_MSG_CHECKING(
4967a3eb BB	393	[whether xattr_handler->list() wants dentry])
608f8749	394	ZFS_LINUX_TEST_RESULT([xattr_handler_list_dentry], [
4967a3eb BB	395	AC_MSG_RESULT(yes)
	396	AC_DEFINE(HAVE_XATTR_LIST_DENTRY, 1,
	397	[xattr_handler->list() wants dentry])
	398	],[
066e8252	399	ZFS_LINUX_TEST_ERROR([xattr list()])
4967a3eb	400	])
61d482f7	401	])
023699cd MM	402	])
	403	])
	404
	405	dnl #
	406	dnl # 3.7 API change,
	407	dnl # The posix_acl_{from,to}_xattr functions gained a new
	408	dnl # parameter: user_ns
	409	dnl #
608f8749 BB	410	AC_DEFUN([ZFS_AC_KERNEL_SRC_POSIX_ACL_FROM_XATTR_USERNS], [
608f8749 BB	411	ZFS_LINUX_TEST_SRC([posix_acl_from_xattr_userns], [
023699cd MM	412	#include <linux/cred.h>
	413	#include <linux/fs.h>
	414	#include <linux/posix_acl_xattr.h>
	415	],[
	416	posix_acl_from_xattr(&init_user_ns, NULL, 0);
608f8749 BB	417	])
	418	])
	419
	420	AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_FROM_XATTR_USERNS], [
	421	AC_MSG_CHECKING([whether posix_acl_from_xattr() needs user_ns])
	422	ZFS_LINUX_TEST_RESULT([posix_acl_from_xattr_userns], [
023699cd MM	423	AC_MSG_RESULT(yes)
	424	AC_DEFINE(HAVE_POSIX_ACL_FROM_XATTR_USERNS, 1,
	425	[posix_acl_from_xattr() needs user_ns])
	426	],[
066e8252	427	ZFS_LINUX_TEST_ERROR([posix_acl_from_xattr()])
023699cd MM	428	])
	429	])
	430
608f8749 BB	431	dnl #
	432	dnl # 4.9 API change,
	433	dnl # iops->{set,get,remove}xattr and generic_{set,get,remove}xattr are
	434	dnl # removed. xattr operations will directly go through sb->s_xattr.
	435	dnl #
	436	AC_DEFUN([ZFS_AC_KERNEL_SRC_GENERIC_SETXATTR], [
	437	ZFS_LINUX_TEST_SRC([have_generic_setxattr], [
	438	#include <linux/fs.h>
	439	#include <linux/xattr.h>
	440
	441	static const struct inode_operations
	442	iops __attribute__ ((unused)) = {
	443	.setxattr = generic_setxattr
	444	};
	445	],[])
	446	])
	447
	448	AC_DEFUN([ZFS_AC_KERNEL_GENERIC_SETXATTR], [
	449	AC_MSG_CHECKING([whether generic_setxattr() exists])
	450	ZFS_LINUX_TEST_RESULT([have_generic_setxattr], [
	451	AC_MSG_RESULT(yes)
	452	AC_DEFINE(HAVE_GENERIC_SETXATTR, 1,
	453	[generic_setxattr() exists])
	454	],[
	455	AC_MSG_RESULT(no)
	456	])
	457	])
	458
	459	AC_DEFUN([ZFS_AC_KERNEL_SRC_XATTR], [
	460	ZFS_AC_KERNEL_SRC_CONST_XATTR_HANDLER
	461	ZFS_AC_KERNEL_SRC_XATTR_HANDLER_NAME
	462	ZFS_AC_KERNEL_SRC_XATTR_HANDLER_GET
	463	ZFS_AC_KERNEL_SRC_XATTR_HANDLER_SET
	464	ZFS_AC_KERNEL_SRC_XATTR_HANDLER_LIST
	465	ZFS_AC_KERNEL_SRC_POSIX_ACL_FROM_XATTR_USERNS
	466	ZFS_AC_KERNEL_SRC_GENERIC_SETXATTR
	467	])
	468
	469	AC_DEFUN([ZFS_AC_KERNEL_XATTR], [
	470	ZFS_AC_KERNEL_CONST_XATTR_HANDLER
	471	ZFS_AC_KERNEL_XATTR_HANDLER_NAME
	472	ZFS_AC_KERNEL_XATTR_HANDLER_GET
	473	ZFS_AC_KERNEL_XATTR_HANDLER_SET
	474	ZFS_AC_KERNEL_XATTR_HANDLER_LIST
	475	ZFS_AC_KERNEL_POSIX_ACL_FROM_XATTR_USERNS
	476	ZFS_AC_KERNEL_GENERIC_SETXATTR
	477	])