[mirror_zfs.git] / config / kernel-acl.m4

dnl #
dnl # Check if posix_acl_release can be used from a ZFS_META_LICENSED
dnl # module.  The is_owner_or_cap macro was replaced by
dnl # inode_owner_or_capable
dnl #
AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_RELEASE], [
	AC_MSG_CHECKING([whether posix_acl_release() is available])
	ZFS_LINUX_TRY_COMPILE([
		#include <linux/cred.h>
		#include <linux/fs.h>
		#include <linux/posix_acl.h>
	],[
		struct posix_acl* tmp = posix_acl_alloc(1, 0);
		posix_acl_release(tmp);
	],[
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_POSIX_ACL_RELEASE, 1,
		    [posix_acl_release() is available])

		AC_MSG_CHECKING([whether posix_acl_release() is GPL-only])
		ZFS_LINUX_TRY_COMPILE([
			#include <linux/module.h>
			#include <linux/cred.h>
			#include <linux/fs.h>
			#include <linux/posix_acl.h>

			MODULE_LICENSE("$ZFS_META_LICENSE");
		],[
			struct posix_acl* tmp = posix_acl_alloc(1, 0);
			posix_acl_release(tmp);
		],[
			AC_MSG_RESULT(no)
		],[
			AC_MSG_RESULT(yes)
			AC_DEFINE(HAVE_POSIX_ACL_RELEASE_GPL_ONLY, 1,
			    [posix_acl_release() is GPL-only])
		])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # 3.14 API change,
dnl # set_cached_acl() and forget_cached_acl() changed from inline to
dnl # EXPORT_SYMBOL. In the former case, they may not be usable because of
dnl # posix_acl_release. In the latter case, we can always use them.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_SET_CACHED_ACL_USABLE], [
	AC_MSG_CHECKING([whether set_cached_acl() is usable])
	ZFS_LINUX_TRY_COMPILE([
		#include <linux/module.h>
		#include <linux/cred.h>
		#include <linux/fs.h>
		#include <linux/posix_acl.h>

		MODULE_LICENSE("$ZFS_META_LICENSE");
	],[
		struct inode *ip = NULL;
		struct posix_acl *acl = posix_acl_alloc(1, 0);
		set_cached_acl(ip, ACL_TYPE_ACCESS, acl);
		forget_cached_acl(ip, ACL_TYPE_ACCESS);
	],[
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_SET_CACHED_ACL_USABLE, 1,
		    [posix_acl_release() is usable])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # 3.1 API change,
dnl # posix_acl_chmod_masq() is not exported anymore and posix_acl_chmod()
dnl # was introduced to replace it.
dnl #
dnl # 3.14 API change,
dnl # posix_acl_chmod() is changed to __posix_acl_chmod()
dnl #
AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_CHMOD], [
	AC_MSG_CHECKING([whether posix_acl_chmod exists])
	ZFS_LINUX_TRY_COMPILE([
		#include <linux/fs.h>
		#include <linux/posix_acl.h>
	],[
		posix_acl_chmod(NULL, 0, 0)
	],[
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_POSIX_ACL_CHMOD, 1, [posix_acl_chmod() exists])
	],[
		AC_MSG_RESULT(no)
	])

	AC_MSG_CHECKING([whether __posix_acl_chmod exists])
	ZFS_LINUX_TRY_COMPILE([
		#include <linux/fs.h>
		#include <linux/posix_acl.h>
	],[
		__posix_acl_chmod(NULL, 0, 0)
	],[
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE___POSIX_ACL_CHMOD, 1, [__posix_acl_chmod() exists])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # 3.1 API change,
dnl # posix_acl_equiv_mode now wants an umode_t* instead of a mode_t*
dnl #
AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_EQUIV_MODE_WANTS_UMODE_T], [
	AC_MSG_CHECKING([whether posix_acl_equiv_mode() wants umode_t])
	ZFS_LINUX_TRY_COMPILE([
		#include <linux/fs.h>
		#include <linux/posix_acl.h>
	],[
		umode_t tmp;
		posix_acl_equiv_mode(NULL,&tmp);
	],[
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_POSIX_ACL_EQUIV_MODE_UMODE_T, 1,
		    [ posix_acl_equiv_mode wants umode_t*])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # 4.8 API change,
dnl # The function posix_acl_valid now must be passed a namespace.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_VALID_WITH_NS], [
	AC_MSG_CHECKING([whether posix_acl_valid() wants user namespace])
	ZFS_LINUX_TRY_COMPILE([
		#include <linux/fs.h>
		#include <linux/posix_acl.h>
	],[
		struct user_namespace *user_ns = NULL;
		const struct posix_acl *acl = NULL;
		int error;

		error = posix_acl_valid(user_ns, acl);
	],[
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_POSIX_ACL_VALID_WITH_NS, 1,
		    [posix_acl_valid() wants user namespace])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # 2.6.27 API change,
dnl # Check if inode_operations contains the function permission
dnl # and expects the nameidata structure to have been removed.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_PERMISSION], [
	AC_MSG_CHECKING([whether iops->permission() exists])
	ZFS_LINUX_TRY_COMPILE([
		#include <linux/fs.h>

		int permission_fn(struct inode *inode, int mask) { return 0; }

		static const struct inode_operations
		    iops __attribute__ ((unused)) = {
			.permission = permission_fn,
		};
	],[
	],[
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_PERMISSION, 1, [iops->permission() exists])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # 2.6.26 API change,
dnl # Check if inode_operations contains the function permission
dnl # and expects the nameidata structure to be passed.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_PERMISSION_WITH_NAMEIDATA], [
	AC_MSG_CHECKING([whether iops->permission() wants nameidata])
	ZFS_LINUX_TRY_COMPILE([
		#include <linux/fs.h>
		#include <linux/sched.h>

		int permission_fn(struct inode *inode, int mask,
		    struct nameidata *nd) { return 0; }

		static const struct inode_operations
		    iops __attribute__ ((unused)) = {
			.permission = permission_fn,
		};
	],[
	],[
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_PERMISSION, 1, [iops->permission() exists])
		AC_DEFINE(HAVE_PERMISSION_WITH_NAMEIDATA, 1,
		    [iops->permission() with nameidata exists])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # 2.6.32 API change,
dnl # Check if inode_operations contains the function check_acl
dnl #
AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_CHECK_ACL], [
	AC_MSG_CHECKING([whether iops->check_acl() exists])
	ZFS_LINUX_TRY_COMPILE([
		#include <linux/fs.h>

		int check_acl_fn(struct inode *inode, int mask) { return 0; }

		static const struct inode_operations
		    iops __attribute__ ((unused)) = {
			.check_acl = check_acl_fn,
		};
	],[
	],[
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_CHECK_ACL, 1, [iops->check_acl() exists])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # 2.6.38 API change,
dnl # The function check_acl gained a new parameter: flags
dnl #
AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_CHECK_ACL_WITH_FLAGS], [
	AC_MSG_CHECKING([whether iops->check_acl() wants flags])
	ZFS_LINUX_TRY_COMPILE([
		#include <linux/fs.h>

		int check_acl_fn(struct inode *inode, int mask,
		    unsigned int flags) { return 0; }

		static const struct inode_operations
		    iops __attribute__ ((unused)) = {
			.check_acl = check_acl_fn,
		};
	],[
	],[
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_CHECK_ACL, 1, [iops->check_acl() exists])
		AC_DEFINE(HAVE_CHECK_ACL_WITH_FLAGS, 1,
		    [iops->check_acl() wants flags])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # 3.1 API change,
dnl # Check if inode_operations contains the function get_acl
dnl #
AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_GET_ACL], [
	AC_MSG_CHECKING([whether iops->get_acl() exists])
	ZFS_LINUX_TRY_COMPILE([
		#include <linux/fs.h>

		struct posix_acl *get_acl_fn(struct inode *inode, int type)
		    { return NULL; }

		static const struct inode_operations
		    iops __attribute__ ((unused)) = {
			.get_acl = get_acl_fn,
		};
	],[
	],[
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_GET_ACL, 1, [iops->get_acl() exists])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # 3.14 API change,
dnl # Check if inode_operations contains the function set_acl
dnl #
AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_SET_ACL], [
	AC_MSG_CHECKING([whether iops->set_acl() exists])
	ZFS_LINUX_TRY_COMPILE([
		#include <linux/fs.h>

		int set_acl_fn(struct inode *inode, struct posix_acl *acl, int type)
		    { return 0; }

		static const struct inode_operations
		    iops __attribute__ ((unused)) = {
			.set_acl = set_acl_fn,
		};
	],[
	],[
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_SET_ACL, 1, [iops->set_acl() exists])
	],[
		AC_MSG_RESULT(no)
	])
])

dnl #
dnl # 4.7 API change,
dnl # The kernel get_acl will now check cache before calling i_op->get_acl and
dnl # do set_cached_acl after that, so i_op->get_acl don't need to do that
dnl # anymore.
dnl #
AC_DEFUN([ZFS_AC_KERNEL_GET_ACL_HANDLE_CACHE], [
	AC_MSG_CHECKING([whether uncached_acl_sentinel() exists])
	ZFS_LINUX_TRY_COMPILE([
		#include <linux/fs.h>
	],[
		void *sentinel __attribute__ ((unused)) = uncached_acl_sentinel(NULL);
	],[
		AC_MSG_RESULT(yes)
		AC_DEFINE(HAVE_KERNEL_GET_ACL_HANDLE_CACHE, 1, [uncached_acl_sentinel() exists])
	],[
		AC_MSG_RESULT(no)
	])
])
Commit	Line	Data
023699cd	1	dnl #
e33045ee BB	2	dnl # Check if posix_acl_release can be used from a ZFS_META_LICENSED
e33045ee BB	3	dnl # module. The is_owner_or_cap macro was replaced by
023699cd MM	4	dnl # inode_owner_or_capable
	5	dnl #
	6	AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_RELEASE], [
	7	AC_MSG_CHECKING([whether posix_acl_release() is available])
	8	ZFS_LINUX_TRY_COMPILE([
	9	#include <linux/cred.h>
	10	#include <linux/fs.h>
	11	#include <linux/posix_acl.h>
	12	],[
	13	struct posix_acl* tmp = posix_acl_alloc(1, 0);
	14	posix_acl_release(tmp);
	15	],[
	16	AC_MSG_RESULT(yes)
	17	AC_DEFINE(HAVE_POSIX_ACL_RELEASE, 1,
	18	[posix_acl_release() is available])
023699cd	19
e42d4666 CC	20	AC_MSG_CHECKING([whether posix_acl_release() is GPL-only])
	21	ZFS_LINUX_TRY_COMPILE([
	22	#include <linux/module.h>
	23	#include <linux/cred.h>
	24	#include <linux/fs.h>
	25	#include <linux/posix_acl.h>
023699cd	26
e42d4666 CC	27	MODULE_LICENSE("$ZFS_META_LICENSE");
	28	],[
	29	struct posix_acl* tmp = posix_acl_alloc(1, 0);
	30	posix_acl_release(tmp);
	31	],[
	32	AC_MSG_RESULT(no)
	33	],[
	34	AC_MSG_RESULT(yes)
	35	AC_DEFINE(HAVE_POSIX_ACL_RELEASE_GPL_ONLY, 1,
	36	[posix_acl_release() is GPL-only])
	37	])
023699cd MM	38	],[
023699cd MM	39	AC_MSG_RESULT(no)
023699cd MM	40	])
	41	])
	42
3779913b CC	43	dnl #
	44	dnl # 3.14 API change,
	45	dnl # set_cached_acl() and forget_cached_acl() changed from inline to
	46	dnl # EXPORT_SYMBOL. In the former case, they may not be usable because of
	47	dnl # posix_acl_release. In the latter case, we can always use them.
	48	dnl #
	49	AC_DEFUN([ZFS_AC_KERNEL_SET_CACHED_ACL_USABLE], [
	50	AC_MSG_CHECKING([whether set_cached_acl() is usable])
	51	ZFS_LINUX_TRY_COMPILE([
	52	#include <linux/module.h>
	53	#include <linux/cred.h>
	54	#include <linux/fs.h>
	55	#include <linux/posix_acl.h>
	56
	57	MODULE_LICENSE("$ZFS_META_LICENSE");
	58	],[
	59	struct inode *ip = NULL;
	60	struct posix_acl *acl = posix_acl_alloc(1, 0);
7e5ea7be GN	61	set_cached_acl(ip, ACL_TYPE_ACCESS, acl);
7e5ea7be GN	62	forget_cached_acl(ip, ACL_TYPE_ACCESS);
3779913b CC	63	],[
	64	AC_MSG_RESULT(yes)
	65	AC_DEFINE(HAVE_SET_CACHED_ACL_USABLE, 1,
	66	[posix_acl_release() is usable])
	67	],[
	68	AC_MSG_RESULT(no)
	69	])
	70	])
	71
023699cd MM	72	dnl #
	73	dnl # 3.1 API change,
	74	dnl # posix_acl_chmod_masq() is not exported anymore and posix_acl_chmod()
	75	dnl # was introduced to replace it.
	76	dnl #
408ec0d2 CC	77	dnl # 3.14 API change,
	78	dnl # posix_acl_chmod() is changed to __posix_acl_chmod()
	79	dnl #
023699cd MM	80	AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_CHMOD], [
	81	AC_MSG_CHECKING([whether posix_acl_chmod exists])
	82	ZFS_LINUX_TRY_COMPILE([
	83	#include <linux/fs.h>
	84	#include <linux/posix_acl.h>
	85	],[
	86	posix_acl_chmod(NULL, 0, 0)
	87	],[
	88	AC_MSG_RESULT(yes)
	89	AC_DEFINE(HAVE_POSIX_ACL_CHMOD, 1, [posix_acl_chmod() exists])
	90	],[
	91	AC_MSG_RESULT(no)
	92	])
408ec0d2 CC	93
	94	AC_MSG_CHECKING([whether __posix_acl_chmod exists])
	95	ZFS_LINUX_TRY_COMPILE([
	96	#include <linux/fs.h>
	97	#include <linux/posix_acl.h>
	98	],[
	99	__posix_acl_chmod(NULL, 0, 0)
	100	],[
	101	AC_MSG_RESULT(yes)
	102	AC_DEFINE(HAVE___POSIX_ACL_CHMOD, 1, [__posix_acl_chmod() exists])
	103	],[
	104	AC_MSG_RESULT(no)
	105	])
023699cd MM	106	])
023699cd MM	107
023699cd MM	108	dnl #
	109	dnl # 3.1 API change,
	110	dnl # posix_acl_equiv_mode now wants an umode_t* instead of a mode_t*
	111	dnl #
	112	AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_EQUIV_MODE_WANTS_UMODE_T], [
	113	AC_MSG_CHECKING([whether posix_acl_equiv_mode() wants umode_t])
	114	ZFS_LINUX_TRY_COMPILE([
	115	#include <linux/fs.h>
	116	#include <linux/posix_acl.h>
	117	],[
	118	umode_t tmp;
	119	posix_acl_equiv_mode(NULL,&tmp);
	120	],[
	121	AC_MSG_RESULT(yes)
	122	AC_DEFINE(HAVE_POSIX_ACL_EQUIV_MODE_UMODE_T, 1,
	123	[ posix_acl_equiv_mode wants umode_t*])
	124	],[
	125	AC_MSG_RESULT(no)
	126	])
	127	])
	128
4b908d32 BB	129	dnl #
	130	dnl # 4.8 API change,
	131	dnl # The function posix_acl_valid now must be passed a namespace.
	132	dnl #
	133	AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_VALID_WITH_NS], [
	134	AC_MSG_CHECKING([whether posix_acl_valid() wants user namespace])
	135	ZFS_LINUX_TRY_COMPILE([
	136	#include <linux/fs.h>
	137	#include <linux/posix_acl.h>
	138	],[
	139	struct user_namespace *user_ns = NULL;
	140	const struct posix_acl *acl = NULL;
	141	int error;
	142
	143	error = posix_acl_valid(user_ns, acl);
	144	],[
	145	AC_MSG_RESULT(yes)
	146	AC_DEFINE(HAVE_POSIX_ACL_VALID_WITH_NS, 1,
	147	[posix_acl_valid() wants user namespace])
	148	],[
	149	AC_MSG_RESULT(no)
	150	])
	151	])
	152
023699cd MM	153	dnl #
	154	dnl # 2.6.27 API change,
	155	dnl # Check if inode_operations contains the function permission
	156	dnl # and expects the nameidata structure to have been removed.
	157	dnl #
	158	AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_PERMISSION], [
	159	AC_MSG_CHECKING([whether iops->permission() exists])
	160	ZFS_LINUX_TRY_COMPILE([
	161	#include <linux/fs.h>
	162
	163	int permission_fn(struct inode *inode, int mask) { return 0; }
	164
	165	static const struct inode_operations
	166	iops __attribute__ ((unused)) = {
	167	.permission = permission_fn,
	168	};
	169	],[
	170	],[
	171	AC_MSG_RESULT(yes)
	172	AC_DEFINE(HAVE_PERMISSION, 1, [iops->permission() exists])
	173	],[
	174	AC_MSG_RESULT(no)
	175	])
	176	])
	177
	178	dnl #
	179	dnl # 2.6.26 API change,
	180	dnl # Check if inode_operations contains the function permission
	181	dnl # and expects the nameidata structure to be passed.
	182	dnl #
	183	AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_PERMISSION_WITH_NAMEIDATA], [
	184	AC_MSG_CHECKING([whether iops->permission() wants nameidata])
	185	ZFS_LINUX_TRY_COMPILE([
	186	#include <linux/fs.h>
e921f650	187	#include <linux/sched.h>
023699cd MM	188
	189	int permission_fn(struct inode *inode, int mask,
	190	struct nameidata *nd) { return 0; }
	191
	192	static const struct inode_operations
	193	iops __attribute__ ((unused)) = {
	194	.permission = permission_fn,
	195	};
	196	],[
	197	],[
	198	AC_MSG_RESULT(yes)
	199	AC_DEFINE(HAVE_PERMISSION, 1, [iops->permission() exists])
	200	AC_DEFINE(HAVE_PERMISSION_WITH_NAMEIDATA, 1,
	201	[iops->permission() with nameidata exists])
	202	],[
	203	AC_MSG_RESULT(no)
	204	])
	205	])
	206
	207	dnl #
	208	dnl # 2.6.32 API change,
	209	dnl # Check if inode_operations contains the function check_acl
	210	dnl #
	211	AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_CHECK_ACL], [
	212	AC_MSG_CHECKING([whether iops->check_acl() exists])
	213	ZFS_LINUX_TRY_COMPILE([
	214	#include <linux/fs.h>
	215
	216	int check_acl_fn(struct inode *inode, int mask) { return 0; }
	217
	218	static const struct inode_operations
	219	iops __attribute__ ((unused)) = {
	220	.check_acl = check_acl_fn,
	221	};
	222	],[
	223	],[
	224	AC_MSG_RESULT(yes)
	225	AC_DEFINE(HAVE_CHECK_ACL, 1, [iops->check_acl() exists])
	226	],[
	227	AC_MSG_RESULT(no)
	228	])
	229	])
	230
	231	dnl #
	232	dnl # 2.6.38 API change,
	233	dnl # The function check_acl gained a new parameter: flags
	234	dnl #
	235	AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_CHECK_ACL_WITH_FLAGS], [
	236	AC_MSG_CHECKING([whether iops->check_acl() wants flags])
	237	ZFS_LINUX_TRY_COMPILE([
	238	#include <linux/fs.h>
	239
	240	int check_acl_fn(struct inode *inode, int mask,
	241	unsigned int flags) { return 0; }
	242
	243	static const struct inode_operations
	244	iops __attribute__ ((unused)) = {
	245	.check_acl = check_acl_fn,
	246	};
	247	],[
	248	],[
	249	AC_MSG_RESULT(yes)
	250	AC_DEFINE(HAVE_CHECK_ACL, 1, [iops->check_acl() exists])
	251	AC_DEFINE(HAVE_CHECK_ACL_WITH_FLAGS, 1,
252	[iops->check_acl() wants flags])
253	],[
254	AC_MSG_RESULT(no)
255	])
256	])
257
258	dnl #
259	dnl # 3.1 API change,
260	dnl # Check if inode_operations contains the function get_acl
261	dnl #
262	AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_GET_ACL], [
263	AC_MSG_CHECKING([whether iops->get_acl() exists])
264	ZFS_LINUX_TRY_COMPILE([
265	#include <linux/fs.h>
266
267	struct posix_acl get_acl_fn(struct inode inode, int type)
268	{ return NULL; }
269
270	static const struct inode_operations
271	iops __attribute__ ((unused)) = {
272	.get_acl = get_acl_fn,
273	};
274	],[
275	],[
276	AC_MSG_RESULT(yes)
277	AC_DEFINE(HAVE_GET_ACL, 1, [iops->get_acl() exists])
278	],[
279	AC_MSG_RESULT(no)
280	])
281	])
afb6c031	282
0420c126	283	dnl #
	284	dnl # 3.14 API change,
	285	dnl # Check if inode_operations contains the function set_acl
	286	dnl #
	287	AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_SET_ACL], [
	288	AC_MSG_CHECKING([whether iops->set_acl() exists])
	289	ZFS_LINUX_TRY_COMPILE([
	290	#include <linux/fs.h>
	291
	292	int set_acl_fn(struct inode inode, struct posix_acl acl, int type)
	293	{ return 0; }
	294
	295	static const struct inode_operations
	296	iops __attribute__ ((unused)) = {
	297	.set_acl = set_acl_fn,
	298	};
	299	],[
	300	],[
	301	AC_MSG_RESULT(yes)
	302	AC_DEFINE(HAVE_SET_ACL, 1, [iops->set_acl() exists])
	303	],[
	304	AC_MSG_RESULT(no)
	305	])
	306	])
	307
afb6c031 CC	308	dnl #
	309	dnl # 4.7 API change,
	310	dnl # The kernel get_acl will now check cache before calling i_op->get_acl and
	311	dnl # do set_cached_acl after that, so i_op->get_acl don't need to do that
	312	dnl # anymore.
	313	dnl #
3779913b	314	AC_DEFUN([ZFS_AC_KERNEL_GET_ACL_HANDLE_CACHE], [
afb6c031 CC	315	AC_MSG_CHECKING([whether uncached_acl_sentinel() exists])
	316	ZFS_LINUX_TRY_COMPILE([
	317	#include <linux/fs.h>
	318	],[
	319	void *sentinel __attribute__ ((unused)) = uncached_acl_sentinel(NULL);
	320	],[
	321	AC_MSG_RESULT(yes)
	322	AC_DEFINE(HAVE_KERNEL_GET_ACL_HANDLE_CACHE, 1, [uncached_acl_sentinel() exists])
	323	],[
	324	AC_MSG_RESULT(no)
	325	])
	326	])