418 lines
11 KiB
Text
418 lines
11 KiB
Text
|
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_SRC_POSIX_ACL_RELEASE], [
|
||
|
|
ZFS_LINUX_TEST_SRC([posix_acl_release], [
|
||
|
|
#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);
|
||
|
|
], [], [$ZFS_META_LICENSE])
|
||
|
|
])
|
||
|
|
|
||
|
|
AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_RELEASE], [
|
||
|
|
AC_MSG_CHECKING([whether posix_acl_release() is available])
|
||
|
|
ZFS_LINUX_TEST_RESULT([posix_acl_release], [
|
||
|
|
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_TEST_RESULT([posix_acl_release_license], [
|
||
|
|
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_SRC_SET_CACHED_ACL_USABLE], [
|
||
|
|
ZFS_LINUX_TEST_SRC([set_cached_acl], [
|
||
|
|
#include <linux/cred.h>
|
||
|
|
#include <linux/fs.h>
|
||
|
|
#include <linux/posix_acl.h>
|
||
|
|
], [
|
||
|
|
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);
|
||
|
|
], [], [$ZFS_META_LICENSE])
|
||
|
|
])
|
||
|
|
|
||
|
|
AC_DEFUN([ZFS_AC_KERNEL_SET_CACHED_ACL_USABLE], [
|
||
|
|
AC_MSG_CHECKING([whether set_cached_acl() is usable])
|
||
|
|
ZFS_LINUX_TEST_RESULT([set_cached_acl_license], [
|
||
|
|
AC_MSG_RESULT(yes)
|
||
|
|
AC_DEFINE(HAVE_SET_CACHED_ACL_USABLE, 1,
|
||
|
|
[set_cached_acl() 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_SRC_POSIX_ACL_CHMOD], [
|
||
|
|
ZFS_LINUX_TEST_SRC([posix_acl_chmod], [
|
||
|
|
#include <linux/fs.h>
|
||
|
|
#include <linux/posix_acl.h>
|
||
|
|
],[
|
||
|
|
posix_acl_chmod(NULL, 0, 0)
|
||
|
|
])
|
||
|
|
|
||
|
|
ZFS_LINUX_TEST_SRC([__posix_acl_chmod], [
|
||
|
|
#include <linux/fs.h>
|
||
|
|
#include <linux/posix_acl.h>
|
||
|
|
],[
|
||
|
|
__posix_acl_chmod(NULL, 0, 0)
|
||
|
|
])
|
||
|
|
])
|
||
|
|
|
||
|
|
AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_CHMOD], [
|
||
|
|
AC_MSG_CHECKING([whether posix_acl_chmod exists])
|
||
|
|
ZFS_LINUX_TEST_RESULT([posix_acl_chmod], [
|
||
|
|
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_TEST_RESULT([__posix_acl_chmod], [
|
||
|
|
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_SRC_POSIX_ACL_EQUIV_MODE_WANTS_UMODE_T], [
|
||
|
|
ZFS_LINUX_TEST_SRC([posix_acl_equiv_mode], [
|
||
|
|
#include <linux/fs.h>
|
||
|
|
#include <linux/posix_acl.h>
|
||
|
|
],[
|
||
|
|
umode_t tmp;
|
||
|
|
posix_acl_equiv_mode(NULL,&tmp);
|
||
|
|
])
|
||
|
|
])
|
||
|
|
|
||
|
|
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_TEST_RESULT([posix_acl_equiv_mode], [
|
||
|
|
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_SRC_POSIX_ACL_VALID_WITH_NS], [
|
||
|
|
ZFS_LINUX_TEST_SRC([posix_acl_valid_with_ns], [
|
||
|
|
#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_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_VALID_WITH_NS], [
|
||
|
|
AC_MSG_CHECKING([whether posix_acl_valid() wants user namespace])
|
||
|
|
ZFS_LINUX_TEST_RESULT([posix_acl_valid_with_ns], [
|
||
|
|
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_SRC_INODE_OPERATIONS_PERMISSION], [
|
||
|
|
ZFS_LINUX_TEST_SRC([inode_operations_permission], [
|
||
|
|
#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_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_PERMISSION], [
|
||
|
|
AC_MSG_CHECKING([whether iops->permission() exists])
|
||
|
|
ZFS_LINUX_TEST_RESULT([inode_operations_permission], [
|
||
|
|
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_SRC_INODE_OPERATIONS_PERMISSION_WITH_NAMEIDATA], [
|
||
|
|
ZFS_LINUX_TEST_SRC([inode_operations_permission_with_nameidata], [
|
||
|
|
#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_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_PERMISSION_WITH_NAMEIDATA], [
|
||
|
|
AC_MSG_CHECKING([whether iops->permission() wants nameidata])
|
||
|
|
ZFS_LINUX_TEST_RESULT([inode_operations_permission_with_nameidata], [
|
||
|
|
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_SRC_INODE_OPERATIONS_CHECK_ACL], [
|
||
|
|
ZFS_LINUX_TEST_SRC([inode_operations_check_acl], [
|
||
|
|
#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_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_CHECK_ACL], [
|
||
|
|
AC_MSG_CHECKING([whether iops->check_acl() exists])
|
||
|
|
ZFS_LINUX_TEST_RESULT([inode_operations_check_acl], [
|
||
|
|
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_SRC_INODE_OPERATIONS_CHECK_ACL_WITH_FLAGS], [
|
||
|
|
ZFS_LINUX_TEST_SRC([inode_operations_check_acl_with_flags], [
|
||
|
|
#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_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_CHECK_ACL_WITH_FLAGS], [
|
||
|
|
AC_MSG_CHECKING([whether iops->check_acl() wants flags])
|
||
|
|
ZFS_LINUX_TEST_RESULT([inode_operations_check_acl_with_flags], [
|
||
|
|
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_SRC_INODE_OPERATIONS_GET_ACL], [
|
||
|
|
ZFS_LINUX_TEST_SRC([inode_operations_get_acl], [
|
||
|
|
#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_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_GET_ACL], [
|
||
|
|
AC_MSG_CHECKING([whether iops->get_acl() exists])
|
||
|
|
ZFS_LINUX_TEST_RESULT([inode_operations_get_acl], [
|
||
|
|
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_SRC_INODE_OPERATIONS_SET_ACL], [
|
||
|
|
ZFS_LINUX_TEST_SRC([inode_operations_set_acl], [
|
||
|
|
#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_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_SET_ACL], [
|
||
|
|
AC_MSG_CHECKING([whether iops->set_acl() exists])
|
||
|
|
ZFS_LINUX_TEST_RESULT([inode_operations_set_acl], [
|
||
|
|
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_SRC_GET_ACL_HANDLE_CACHE], [
|
||
|
|
ZFS_LINUX_TEST_SRC([get_acl_handle_cache], [
|
||
|
|
#include <linux/fs.h>
|
||
|
|
],[
|
||
|
|
void *sentinel __attribute__ ((unused)) =
|
||
|
|
uncached_acl_sentinel(NULL);
|
||
|
|
])
|
||
|
|
])
|
||
|
|
|
||
|
|
AC_DEFUN([ZFS_AC_KERNEL_GET_ACL_HANDLE_CACHE], [
|
||
|
|
AC_MSG_CHECKING([whether uncached_acl_sentinel() exists])
|
||
|
|
ZFS_LINUX_TEST_RESULT([get_acl_handle_cache], [
|
||
|
|
AC_MSG_RESULT(yes)
|
||
|
|
AC_DEFINE(HAVE_KERNEL_GET_ACL_HANDLE_CACHE, 1,
|
||
|
|
[uncached_acl_sentinel() exists])
|
||
|
|
],[
|
||
|
|
AC_MSG_RESULT(no)
|
||
|
|
])
|
||
|
|
])
|
||
|
|
|
||
|
|
dnl #
|
||
|
|
dnl # 4.16 kernel: check if struct posix_acl acl.a_refcount is a refcount_t.
|
||
|
|
dnl # It's an atomic_t on older kernels.
|
||
|
|
dnl #
|
||
|
|
AC_DEFUN([ZFS_AC_KERNEL_SRC_ACL_HAS_REFCOUNT], [
|
||
|
|
ZFS_LINUX_TEST_SRC([acl_refcount], [
|
||
|
|
#include <linux/backing-dev.h>
|
||
|
|
#include <linux/refcount.h>
|
||
|
|
#include <linux/posix_acl.h>
|
||
|
|
],[
|
||
|
|
struct posix_acl acl;
|
||
|
|
refcount_t *r __attribute__ ((unused)) = &acl.a_refcount;
|
||
|
|
])
|
||
|
|
])
|
||
|
|
|
||
|
|
AC_DEFUN([ZFS_AC_KERNEL_ACL_HAS_REFCOUNT], [
|
||
|
|
AC_MSG_CHECKING([whether posix_acl has refcount_t])
|
||
|
|
ZFS_LINUX_TEST_RESULT([acl_refcount], [
|
||
|
|
AC_MSG_RESULT(yes)
|
||
|
|
AC_DEFINE(HAVE_ACL_REFCOUNT, 1, [posix_acl has refcount_t])
|
||
|
|
],[
|
||
|
|
AC_MSG_RESULT(no)
|
||
|
|
])
|
||
|
|
])
|
||
|
|
|
||
|
|
AC_DEFUN([ZFS_AC_KERNEL_SRC_ACL], [
|
||
|
|
ZFS_AC_KERNEL_SRC_POSIX_ACL_RELEASE
|
||
|
|
ZFS_AC_KERNEL_SRC_SET_CACHED_ACL_USABLE
|
||
|
|
ZFS_AC_KERNEL_SRC_POSIX_ACL_CHMOD
|
||
|
|
ZFS_AC_KERNEL_SRC_POSIX_ACL_EQUIV_MODE_WANTS_UMODE_T
|
||
|
|
ZFS_AC_KERNEL_SRC_POSIX_ACL_VALID_WITH_NS
|
||
|
|
ZFS_AC_KERNEL_SRC_INODE_OPERATIONS_PERMISSION
|
||
|
|
ZFS_AC_KERNEL_SRC_INODE_OPERATIONS_PERMISSION_WITH_NAMEIDATA
|
||
|
|
ZFS_AC_KERNEL_SRC_INODE_OPERATIONS_CHECK_ACL
|
||
|
|
ZFS_AC_KERNEL_SRC_INODE_OPERATIONS_CHECK_ACL_WITH_FLAGS
|
||
|
|
ZFS_AC_KERNEL_SRC_INODE_OPERATIONS_GET_ACL
|
||
|
|
ZFS_AC_KERNEL_SRC_INODE_OPERATIONS_SET_ACL
|
||
|
|
ZFS_AC_KERNEL_SRC_GET_ACL_HANDLE_CACHE
|
||
|
|
ZFS_AC_KERNEL_SRC_ACL_HAS_REFCOUNT
|
||
|
|
])
|
||
|
|
|
||
|
|
AC_DEFUN([ZFS_AC_KERNEL_ACL], [
|
||
|
|
ZFS_AC_KERNEL_POSIX_ACL_RELEASE
|
||
|
|
ZFS_AC_KERNEL_SET_CACHED_ACL_USABLE
|
||
|
|
ZFS_AC_KERNEL_POSIX_ACL_CHMOD
|
||
|
|
ZFS_AC_KERNEL_POSIX_ACL_EQUIV_MODE_WANTS_UMODE_T
|
||
|
|
ZFS_AC_KERNEL_POSIX_ACL_VALID_WITH_NS
|
||
|
|
ZFS_AC_KERNEL_INODE_OPERATIONS_PERMISSION
|
||
|
|
ZFS_AC_KERNEL_INODE_OPERATIONS_PERMISSION_WITH_NAMEIDATA
|
||
|
|
ZFS_AC_KERNEL_INODE_OPERATIONS_CHECK_ACL
|
||
|
|
ZFS_AC_KERNEL_INODE_OPERATIONS_CHECK_ACL_WITH_FLAGS
|
||
|
|
ZFS_AC_KERNEL_INODE_OPERATIONS_GET_ACL
|
||
|
|
ZFS_AC_KERNEL_INODE_OPERATIONS_SET_ACL
|
||
|
|
ZFS_AC_KERNEL_GET_ACL_HANDLE_CACHE
|
||
|
|
ZFS_AC_KERNEL_ACL_HAS_REFCOUNT
|
||
|
|
])
|