[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>

		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>

		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>

		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,
		};
	],[])
])

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])
			],[
				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_userns], [
		#include <linux/xattr.h>

		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>

		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>

		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>

		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 #
	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>

		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>

		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>

		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
608f8749 BB	71	int get(const struct xattr_handler *handler,
	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
4967a3eb	83	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
	95	int get(struct dentry dentry, const char name,
	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	],[])
608f8749 BB	103	])
	104
	105	AC_DEFUN([ZFS_AC_KERNEL_XATTR_HANDLER_GET], [
	106	dnl #
	107	dnl # 4.7 API change,
	108	dnl # The xattr_handler->get() callback was changed to take both
	109	dnl # dentry and inode.
	110	dnl #
	111	AC_MSG_CHECKING([whether xattr_handler->get() wants dentry and inode])
	112	ZFS_LINUX_TEST_RESULT([xattr_handler_get_dentry_inode], [
f9637c6c	113	AC_MSG_RESULT(yes)
fd4c7b7a	114	AC_DEFINE(HAVE_XATTR_GET_DENTRY_INODE, 1,
8fbbc6b4	115	[xattr_handler->get() wants both dentry and inode])
f9637c6c	116	],[
4967a3eb	117	dnl #
fd4c7b7a CC	118	dnl # 4.4 API change,
	119	dnl # The xattr_handler->get() callback was changed to take a
	120	dnl # attr_handler, and handler_flags argument was removed and
	121	dnl # should be accessed by handler->flags.
4967a3eb	122	dnl #
d4701011	123	AC_MSG_RESULT(no)
608f8749 BB	124	AC_MSG_CHECKING(
	125	[whether xattr_handler->get() wants xattr_handler])
	126	ZFS_LINUX_TEST_RESULT([xattr_handler_get_xattr_handler], [
61d482f7	127	AC_MSG_RESULT(yes)
fd4c7b7a CC	128	AC_DEFINE(HAVE_XATTR_GET_HANDLER, 1,
fd4c7b7a CC	129	[xattr_handler->get() wants xattr_handler])
61d482f7	130	],[
4967a3eb	131	dnl #
fd4c7b7a	132	dnl # 2.6.33 API change,
608f8749 BB	133	dnl # The xattr_handler->get() callback was changed
	134	dnl # to take a dentry instead of an inode, and a
	135	dnl # handler_flags argument was added.
4967a3eb	136	dnl #
61d482f7	137	AC_MSG_RESULT(no)
608f8749 BB	138	AC_MSG_CHECKING(
	139	[whether xattr_handler->get() wants dentry])
	140	ZFS_LINUX_TEST_RESULT([xattr_handler_get_dentry], [
4967a3eb	141	AC_MSG_RESULT(yes)
fd4c7b7a CC	142	AC_DEFINE(HAVE_XATTR_GET_DENTRY, 1,
fd4c7b7a CC	143	[xattr_handler->get() wants dentry])
4967a3eb	144	],[
066e8252	145	ZFS_LINUX_TEST_ERROR([xattr get()])
4967a3eb	146	])
61d482f7	147	])
f9637c6c BB	148	])
	149	])
	150
	151	dnl #
4967a3eb	152	dnl # Supported xattr handler set() interfaces checked newest to oldest.
61d482f7	153	dnl #
608f8749	154	AC_DEFUN([ZFS_AC_KERNEL_SRC_XATTR_HANDLER_SET], [
e2a82961 CK	155	ZFS_LINUX_TEST_SRC([xattr_handler_set_userns], [
	156	#include <linux/xattr.h>
	157
	158	int set(const struct xattr_handler *handler,
	159	struct user_namespace *mnt_userns,
	160	struct dentry dentry, struct inode inode,
	161	const char name, const void buffer,
	162	size_t size, int flags)
	163	{ return 0; }
	164	static const struct xattr_handler
	165	xops __attribute__ ((unused)) = {
	166	.set = set,
	167	};
	168	],[])
	169
608f8749	170	ZFS_LINUX_TEST_SRC([xattr_handler_set_dentry_inode], [
f9637c6c	171	#include <linux/xattr.h>
f9637c6c	172
4967a3eb	173	int set(const struct xattr_handler *handler,
8fbbc6b4 BB	174	struct dentry dentry, struct inode inode,
	175	const char name, const void buffer,
	176	size_t size, int flags)
4967a3eb	177	{ return 0; }
b83e3e48 RY	178	static const struct xattr_handler
	179	xops __attribute__ ((unused)) = {
	180	.set = set,
	181	};
608f8749 BB	182	],[])
	183
	184	ZFS_LINUX_TEST_SRC([xattr_handler_set_xattr_handler], [
	185	#include <linux/xattr.h>
	186
	187	int set(const struct xattr_handler *handler,
	188	struct dentry dentry, const char name,
	189	const void *buffer, size_t size, int flags)
	190	{ return 0; }
	191	static const struct xattr_handler
	192	xops __attribute__ ((unused)) = {
	193	.set = set,
	194	};
	195	],[])
	196
	197	ZFS_LINUX_TEST_SRC([xattr_handler_set_dentry], [
	198	#include <linux/xattr.h>
	199
	200	int set(struct dentry dentry, const char name,
	201	const void *buffer, size_t size, int flags,
	202	int handler_flags) { return 0; }
	203	static const struct xattr_handler
	204	xops __attribute__ ((unused)) = {
	205	.set = set,
	206	};
	207	],[])
608f8749 BB	208	])
	209
	210	AC_DEFUN([ZFS_AC_KERNEL_XATTR_HANDLER_SET], [
	211	dnl #
e2a82961 CK	212	dnl # 5.12 API change,
	213	dnl # The xattr_handler->set() callback was changed to 8 arguments, and
	214	dnl # struct user_namespace* was inserted as arg #2
608f8749	215	dnl #
e2a82961 CK	216	AC_MSG_CHECKING([whether xattr_handler->set() wants dentry, inode, and user_namespace])
e2a82961 CK	217	ZFS_LINUX_TEST_RESULT([xattr_handler_set_userns], [
f9637c6c	218	AC_MSG_RESULT(yes)
e2a82961 CK	219	AC_DEFINE(HAVE_XATTR_SET_USERNS, 1,
e2a82961 CK	220	[xattr_handler->set() takes user_namespace])
f9637c6c	221	],[
4967a3eb	222	dnl #
e2a82961 CK	223	dnl # 4.7 API change,
	224	dnl # The xattr_handler->set() callback was changed to take both
	225	dnl # dentry and inode.
4967a3eb	226	dnl #
d4701011	227	AC_MSG_RESULT(no)
e2a82961 CK	228	AC_MSG_CHECKING([whether xattr_handler->set() wants dentry and inode])
e2a82961 CK	229	ZFS_LINUX_TEST_RESULT([xattr_handler_set_dentry_inode], [
61d482f7	230	AC_MSG_RESULT(yes)
e2a82961 CK	231	AC_DEFINE(HAVE_XATTR_SET_DENTRY_INODE, 1,
e2a82961 CK	232	[xattr_handler->set() wants both dentry and inode])
61d482f7	233	],[
4967a3eb	234	dnl #
e2a82961 CK	235	dnl # 4.4 API change,
	236	dnl # The xattr_handler->set() callback was changed to take a
	237	dnl # xattr_handler, and handler_flags argument was removed and
	238	dnl # should be accessed by handler->flags.
4967a3eb	239	dnl #
61d482f7	240	AC_MSG_RESULT(no)
608f8749	241	AC_MSG_CHECKING(
e2a82961 CK	242	[whether xattr_handler->set() wants xattr_handler])
e2a82961 CK	243	ZFS_LINUX_TEST_RESULT([xattr_handler_set_xattr_handler], [
4967a3eb	244	AC_MSG_RESULT(yes)
e2a82961 CK	245	AC_DEFINE(HAVE_XATTR_SET_HANDLER, 1,
e2a82961 CK	246	[xattr_handler->set() wants xattr_handler])
4967a3eb	247	],[
e2a82961 CK	248	dnl #
	249	dnl # 2.6.33 API change,
	250	dnl # The xattr_handler->set() callback was changed
	251	dnl # to take a dentry instead of an inode, and a
	252	dnl # handler_flags argument was added.
	253	dnl #
	254	AC_MSG_RESULT(no)
	255	AC_MSG_CHECKING(
	256	[whether xattr_handler->set() wants dentry])
	257	ZFS_LINUX_TEST_RESULT([xattr_handler_set_dentry], [
	258	AC_MSG_RESULT(yes)
	259	AC_DEFINE(HAVE_XATTR_SET_DENTRY, 1,
	260	[xattr_handler->set() wants dentry])
	261	],[
	262	ZFS_LINUX_TEST_ERROR([xattr set()])
	263	])
4967a3eb	264	])
61d482f7	265	])
f9637c6c BB	266	])
f9637c6c BB	267	])
023699cd MM	268
023699cd MM	269	dnl #
4967a3eb	270	dnl # Supported xattr handler list() interfaces checked newest to oldest.
61d482f7	271	dnl #
608f8749 BB	272	AC_DEFUN([ZFS_AC_KERNEL_SRC_XATTR_HANDLER_LIST], [
608f8749 BB	273	ZFS_LINUX_TEST_SRC([xattr_handler_list_simple], [
023699cd MM	274	#include <linux/xattr.h>
023699cd MM	275
4967a3eb	276	bool list(struct dentry *dentry) { return 0; }
023699cd MM	277	static const struct xattr_handler
	278	xops __attribute__ ((unused)) = {
	279	.list = list,
	280	};
608f8749 BB	281	],[])
	282
	283	ZFS_LINUX_TEST_SRC([xattr_handler_list_xattr_handler], [
	284	#include <linux/xattr.h>
	285
	286	size_t list(const struct xattr_handler *handler,
	287	struct dentry dentry, char list, size_t list_size,
	288	const char *name, size_t name_len) { return 0; }
	289	static const struct xattr_handler
	290	xops __attribute__ ((unused)) = {
	291	.list = list,
	292	};
	293	],[])
	294
	295	ZFS_LINUX_TEST_SRC([xattr_handler_list_dentry], [
	296	#include <linux/xattr.h>
	297
	298	size_t list(struct dentry *dentry,
	299	char *list, size_t list_size,
	300	const char *name, size_t name_len,
	301	int handler_flags) { return 0; }
	302	static const struct xattr_handler
	303	xops __attribute__ ((unused)) = {
	304	.list = list,
	305	};
	306	],[])
608f8749 BB	307	])
	308
	309	AC_DEFUN([ZFS_AC_KERNEL_XATTR_HANDLER_LIST], [
	310	dnl # 4.5 API change,
	311	dnl # The xattr_handler->list() callback was changed to take only a
	312	dnl # dentry and it only needs to return if it's accessible.
	313	AC_MSG_CHECKING([whether xattr_handler->list() wants simple])
	314	ZFS_LINUX_TEST_RESULT([xattr_handler_list_simple], [
023699cd	315	AC_MSG_RESULT(yes)
4967a3eb BB	316	AC_DEFINE(HAVE_XATTR_LIST_SIMPLE, 1,
4967a3eb BB	317	[xattr_handler->list() wants simple])
023699cd	318	],[
4967a3eb BB	319	dnl #
	320	dnl # 4.4 API change,
	321	dnl # The xattr_handler->list() callback was changed to take a
	322	dnl # xattr_handler, and handler_flags argument was removed
	323	dnl # and should be accessed by handler->flags.
	324	dnl #
023699cd	325	AC_MSG_RESULT(no)
4967a3eb BB	326	AC_MSG_CHECKING(
4967a3eb BB	327	[whether xattr_handler->list() wants xattr_handler])
608f8749	328	ZFS_LINUX_TEST_RESULT([xattr_handler_list_xattr_handler], [
61d482f7	329	AC_MSG_RESULT(yes)
4967a3eb	330	AC_DEFINE(HAVE_XATTR_LIST_HANDLER, 1,
61d482f7 CC	331	[xattr_handler->list() wants xattr_handler])
61d482f7 CC	332	],[
4967a3eb BB	333	dnl #
	334	dnl # 2.6.33 API change,
	335	dnl # The xattr_handler->list() callback was changed
	336	dnl # to take a dentry instead of an inode, and a
	337	dnl # handler_flags argument was added.
	338	dnl #
61d482f7	339	AC_MSG_RESULT(no)
4967a3eb BB	340	AC_MSG_CHECKING(
4967a3eb BB	341	[whether xattr_handler->list() wants dentry])
608f8749	342	ZFS_LINUX_TEST_RESULT([xattr_handler_list_dentry], [
4967a3eb BB	343	AC_MSG_RESULT(yes)
	344	AC_DEFINE(HAVE_XATTR_LIST_DENTRY, 1,
	345	[xattr_handler->list() wants dentry])
	346	],[
066e8252	347	ZFS_LINUX_TEST_ERROR([xattr list()])
4967a3eb	348	])
61d482f7	349	])
023699cd MM	350	])
	351	])
	352
	353	dnl #
	354	dnl # 3.7 API change,
	355	dnl # The posix_acl_{from,to}_xattr functions gained a new
	356	dnl # parameter: user_ns
	357	dnl #
608f8749 BB	358	AC_DEFUN([ZFS_AC_KERNEL_SRC_POSIX_ACL_FROM_XATTR_USERNS], [
608f8749 BB	359	ZFS_LINUX_TEST_SRC([posix_acl_from_xattr_userns], [
023699cd MM	360	#include <linux/cred.h>
	361	#include <linux/fs.h>
	362	#include <linux/posix_acl_xattr.h>
	363	],[
	364	posix_acl_from_xattr(&init_user_ns, NULL, 0);
608f8749 BB	365	])
	366	])
	367
	368	AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_FROM_XATTR_USERNS], [
	369	AC_MSG_CHECKING([whether posix_acl_from_xattr() needs user_ns])
	370	ZFS_LINUX_TEST_RESULT([posix_acl_from_xattr_userns], [
023699cd MM	371	AC_MSG_RESULT(yes)
	372	AC_DEFINE(HAVE_POSIX_ACL_FROM_XATTR_USERNS, 1,
	373	[posix_acl_from_xattr() needs user_ns])
	374	],[
066e8252	375	ZFS_LINUX_TEST_ERROR([posix_acl_from_xattr()])
023699cd MM	376	])
	377	])
	378
608f8749 BB	379	dnl #
	380	dnl # 4.9 API change,
	381	dnl # iops->{set,get,remove}xattr and generic_{set,get,remove}xattr are
	382	dnl # removed. xattr operations will directly go through sb->s_xattr.
	383	dnl #
	384	AC_DEFUN([ZFS_AC_KERNEL_SRC_GENERIC_SETXATTR], [
	385	ZFS_LINUX_TEST_SRC([have_generic_setxattr], [
	386	#include <linux/fs.h>
	387	#include <linux/xattr.h>
	388
	389	static const struct inode_operations
	390	iops __attribute__ ((unused)) = {
	391	.setxattr = generic_setxattr
	392	};
	393	],[])
	394	])
	395
	396	AC_DEFUN([ZFS_AC_KERNEL_GENERIC_SETXATTR], [
	397	AC_MSG_CHECKING([whether generic_setxattr() exists])
	398	ZFS_LINUX_TEST_RESULT([have_generic_setxattr], [
	399	AC_MSG_RESULT(yes)
	400	AC_DEFINE(HAVE_GENERIC_SETXATTR, 1,
	401	[generic_setxattr() exists])
	402	],[
	403	AC_MSG_RESULT(no)
	404	])
	405	])
	406
	407	AC_DEFUN([ZFS_AC_KERNEL_SRC_XATTR], [
	408	ZFS_AC_KERNEL_SRC_CONST_XATTR_HANDLER
	409	ZFS_AC_KERNEL_SRC_XATTR_HANDLER_NAME
	410	ZFS_AC_KERNEL_SRC_XATTR_HANDLER_GET
	411	ZFS_AC_KERNEL_SRC_XATTR_HANDLER_SET
	412	ZFS_AC_KERNEL_SRC_XATTR_HANDLER_LIST
	413	ZFS_AC_KERNEL_SRC_POSIX_ACL_FROM_XATTR_USERNS
	414	ZFS_AC_KERNEL_SRC_GENERIC_SETXATTR
	415	])
	416
	417	AC_DEFUN([ZFS_AC_KERNEL_XATTR], [
	418	ZFS_AC_KERNEL_CONST_XATTR_HANDLER
	419	ZFS_AC_KERNEL_XATTR_HANDLER_NAME
	420	ZFS_AC_KERNEL_XATTR_HANDLER_GET
	421	ZFS_AC_KERNEL_XATTR_HANDLER_SET
	422	ZFS_AC_KERNEL_XATTR_HANDLER_LIST
	423	ZFS_AC_KERNEL_POSIX_ACL_FROM_XATTR_USERNS
	424	ZFS_AC_KERNEL_GENERIC_SETXATTR
	425	])