config/kernel-acl.m4

   1 dnl #
   2 dnl # Check if posix_acl_release can be used from a ZFS_META_LICENSED
   3 dnl # module.  The is_owner_or_cap macro was replaced by
   4 dnl # inode_owner_or_capable
   5 dnl #
   6 AC_DEFUN([ZFS_AC_KERNEL_SRC_POSIX_ACL_RELEASE], [
   7         ZFS_LINUX_TEST_SRC([posix_acl_release], [
   8                 #include <linux/cred.h>
   9                 #include <linux/fs.h>
  10                 #include <linux/posix_acl.h>
  11         ], [
  12                 struct posix_acl *tmp = posix_acl_alloc(1, 0);
  13                 posix_acl_release(tmp);
  14         ], [], [$ZFS_META_LICENSE])
  15 ])
  16
  17 AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_RELEASE], [
  18         AC_MSG_CHECKING([whether posix_acl_release() is available])
  19         ZFS_LINUX_TEST_RESULT([posix_acl_release], [
  20                 AC_MSG_RESULT(yes)
  21                 AC_DEFINE(HAVE_POSIX_ACL_RELEASE, 1,
  22                     [posix_acl_release() is available])
  23
  24                 AC_MSG_CHECKING([whether posix_acl_release() is GPL-only])
  25                 ZFS_LINUX_TEST_RESULT([posix_acl_release_license], [
  26                         AC_MSG_RESULT(no)
  27                 ],[
  28                         AC_MSG_RESULT(yes)
  29                         AC_DEFINE(HAVE_POSIX_ACL_RELEASE_GPL_ONLY, 1,
  30                             [posix_acl_release() is GPL-only])
  31                 ])
  32         ],[
  33                 AC_MSG_RESULT(no)
  34         ])
  35 ])
  36
  37 dnl #
  38 dnl # 3.14 API change,
  39 dnl # set_cached_acl() and forget_cached_acl() changed from inline to
  40 dnl # EXPORT_SYMBOL. In the former case, they may not be usable because of
  41 dnl # posix_acl_release. In the latter case, we can always use them.
  42 dnl #
  43 AC_DEFUN([ZFS_AC_KERNEL_SRC_SET_CACHED_ACL_USABLE], [
  44         ZFS_LINUX_TEST_SRC([set_cached_acl], [
  45                 #include <linux/cred.h>
  46                 #include <linux/fs.h>
  47                 #include <linux/posix_acl.h>
  48         ], [
  49                 struct inode *ip = NULL;
  50                 struct posix_acl *acl = posix_acl_alloc(1, 0);
  51                 set_cached_acl(ip, ACL_TYPE_ACCESS, acl);
  52                 forget_cached_acl(ip, ACL_TYPE_ACCESS);
  53         ], [], [$ZFS_META_LICENSE])
  54 ])
  55
  56 AC_DEFUN([ZFS_AC_KERNEL_SET_CACHED_ACL_USABLE], [
  57         AC_MSG_CHECKING([whether set_cached_acl() is usable])
  58         ZFS_LINUX_TEST_RESULT([set_cached_acl_license], [
  59                 AC_MSG_RESULT(yes)
  60                 AC_DEFINE(HAVE_SET_CACHED_ACL_USABLE, 1,
  61                     [set_cached_acl() is usable])
  62         ],[
  63                 AC_MSG_RESULT(no)
  64         ])
  65 ])
  66
  67 dnl #
  68 dnl # 3.1 API change,
  69 dnl # posix_acl_chmod() was added as the preferred interface.
  70 dnl #
  71 dnl # 3.14 API change,
  72 dnl # posix_acl_chmod() was changed to __posix_acl_chmod()
  73 dnl #
  74 AC_DEFUN([ZFS_AC_KERNEL_SRC_POSIX_ACL_CHMOD], [
  75         ZFS_LINUX_TEST_SRC([posix_acl_chmod], [
  76                 #include <linux/fs.h>
  77                 #include <linux/posix_acl.h>
  78         ],[
  79                 posix_acl_chmod(NULL, 0, 0)
  80         ])
  81
  82         ZFS_LINUX_TEST_SRC([__posix_acl_chmod], [
  83                 #include <linux/fs.h>
  84                 #include <linux/posix_acl.h>
  85         ],[
  86                 __posix_acl_chmod(NULL, 0, 0)
  87         ])
  88 ])
  89
  90 AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_CHMOD], [
  91         AC_MSG_CHECKING([whether __posix_acl_chmod exists])
  92         ZFS_LINUX_TEST_RESULT([__posix_acl_chmod], [
  93                 AC_MSG_RESULT(yes)
  94                 AC_DEFINE(HAVE___POSIX_ACL_CHMOD, 1,
  95                     [__posix_acl_chmod() exists])
  96         ],[
  97                 AC_MSG_RESULT(no)
  98
  99                 AC_MSG_CHECKING([whether posix_acl_chmod exists])
 100                 ZFS_LINUX_TEST_RESULT([posix_acl_chmod], [
 101                         AC_MSG_RESULT(yes)
 102                         AC_DEFINE(HAVE_POSIX_ACL_CHMOD, 1,
 103                             [posix_acl_chmod() exists])
 104                 ],[
 105                         ZFS_LINUX_TEST_ERROR([posix_acl_chmod()])
 106                 ])
 107         ])
 108 ])
 109
 110 dnl #
 111 dnl # 3.1 API change,
 112 dnl # posix_acl_equiv_mode now wants an umode_t instead of a mode_t
 113 dnl #
 114 AC_DEFUN([ZFS_AC_KERNEL_SRC_POSIX_ACL_EQUIV_MODE_WANTS_UMODE_T], [
 115         ZFS_LINUX_TEST_SRC([posix_acl_equiv_mode], [
 116                 #include <linux/fs.h>
 117                 #include <linux/posix_acl.h>
 118         ],[
 119                 umode_t tmp;
 120                 posix_acl_equiv_mode(NULL, &tmp);
 121         ])
 122 ])
 123
 124 AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_EQUIV_MODE_WANTS_UMODE_T], [
 125         AC_MSG_CHECKING([whether posix_acl_equiv_mode() wants umode_t])
 126         ZFS_LINUX_TEST_RESULT([posix_acl_equiv_mode], [
 127                 AC_MSG_RESULT(yes)
 128         ],[
 129                 ZFS_LINUX_TEST_ERROR([posix_acl_equiv_mode()])
 130         ])
 131 ])
 132
 133 dnl #
 134 dnl # 4.8 API change,
 135 dnl # The function posix_acl_valid now must be passed a namespace.
 136 dnl #
 137 AC_DEFUN([ZFS_AC_KERNEL_SRC_POSIX_ACL_VALID_WITH_NS], [
 138         ZFS_LINUX_TEST_SRC([posix_acl_valid_with_ns], [
 139                 #include <linux/fs.h>
 140                 #include <linux/posix_acl.h>
 141         ],[
 142                 struct user_namespace *user_ns = NULL;
 143                 const struct posix_acl *acl = NULL;
 144                 int error;
 145
 146                 error = posix_acl_valid(user_ns, acl);
 147         ])
 148 ])
 149
 150 AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_VALID_WITH_NS], [
 151         AC_MSG_CHECKING([whether posix_acl_valid() wants user namespace])
 152         ZFS_LINUX_TEST_RESULT([posix_acl_valid_with_ns], [
 153                 AC_MSG_RESULT(yes)
 154                 AC_DEFINE(HAVE_POSIX_ACL_VALID_WITH_NS, 1,
 155                     [posix_acl_valid() wants user namespace])
 156         ],[
 157                 AC_MSG_RESULT(no)
 158         ])
 159 ])
 160
 161 dnl #
 162 dnl # 3.1 API change,
 163 dnl # Check if inode_operations contains the function get_acl
 164 dnl #
 165 AC_DEFUN([ZFS_AC_KERNEL_SRC_INODE_OPERATIONS_GET_ACL], [
 166         ZFS_LINUX_TEST_SRC([inode_operations_get_acl], [
 167                 #include <linux/fs.h>
 168
 169                 struct posix_acl *get_acl_fn(struct inode *inode, int type)
 170                     { return NULL; }
 171
 172                 static const struct inode_operations
 173                     iops __attribute__ ((unused)) = {
 174                         .get_acl = get_acl_fn,
 175                 };
 176         ],[])
 177 ])
 178
 179 AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_GET_ACL], [
 180         AC_MSG_CHECKING([whether iops->get_acl() exists])
 181         ZFS_LINUX_TEST_RESULT([inode_operations_get_acl], [
 182                 AC_MSG_RESULT(yes)
 183         ],[
 184                 ZFS_LINUX_TEST_ERROR([iops->get_acl()])
 185         ])
 186 ])
 187
 188 dnl #
 189 dnl # 3.14 API change,
 190 dnl # Check if inode_operations contains the function set_acl
 191 dnl #
 192 AC_DEFUN([ZFS_AC_KERNEL_SRC_INODE_OPERATIONS_SET_ACL], [
 193         ZFS_LINUX_TEST_SRC([inode_operations_set_acl], [
 194                 #include <linux/fs.h>
 195
 196                 int set_acl_fn(struct inode *inode, struct posix_acl *acl,
 197                     int type) { return 0; }
 198
 199                 static const struct inode_operations
 200                     iops __attribute__ ((unused)) = {
 201                         .set_acl = set_acl_fn,
 202                 };
 203         ],[])
 204 ])
 205
 206 AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_SET_ACL], [
 207         AC_MSG_CHECKING([whether iops->set_acl() exists])
 208         ZFS_LINUX_TEST_RESULT([inode_operations_set_acl], [
 209                 AC_MSG_RESULT(yes)
 210                 AC_DEFINE(HAVE_SET_ACL, 1, [iops->set_acl() exists])
 211         ],[
 212                 AC_MSG_RESULT(no)
 213         ])
 214 ])
 215
 216 dnl #
 217 dnl # 4.7 API change,
 218 dnl # The kernel get_acl will now check cache before calling i_op->get_acl and
 219 dnl # do set_cached_acl after that, so i_op->get_acl don't need to do that
 220 dnl # anymore.
 221 dnl #
 222 AC_DEFUN([ZFS_AC_KERNEL_SRC_GET_ACL_HANDLE_CACHE], [
 223         ZFS_LINUX_TEST_SRC([get_acl_handle_cache], [
 224                 #include <linux/fs.h>
 225         ],[
 226                 void *sentinel __attribute__ ((unused)) =
 227                     uncached_acl_sentinel(NULL);
 228         ])
 229 ])
 230
 231 AC_DEFUN([ZFS_AC_KERNEL_GET_ACL_HANDLE_CACHE], [
 232         AC_MSG_CHECKING([whether uncached_acl_sentinel() exists])
 233         ZFS_LINUX_TEST_RESULT([get_acl_handle_cache], [
 234                 AC_MSG_RESULT(yes)
 235                 AC_DEFINE(HAVE_KERNEL_GET_ACL_HANDLE_CACHE, 1,
 236                     [uncached_acl_sentinel() exists])
 237         ],[
 238                 AC_MSG_RESULT(no)
 239         ])
 240 ])
 241
 242 dnl #
 243 dnl # 4.16 kernel: check if struct posix_acl acl.a_refcount is a refcount_t.
 244 dnl # It's an atomic_t on older kernels.
 245 dnl #
 246 AC_DEFUN([ZFS_AC_KERNEL_SRC_ACL_HAS_REFCOUNT], [
 247         ZFS_LINUX_TEST_SRC([acl_refcount], [
 248                 #include <linux/backing-dev.h>
 249                 #include <linux/refcount.h>
 250                 #include <linux/posix_acl.h>
 251         ],[
 252                 struct posix_acl acl;
 253                 refcount_t *r __attribute__ ((unused)) = &acl.a_refcount;
 254         ])
 255 ])
 256
 257 AC_DEFUN([ZFS_AC_KERNEL_ACL_HAS_REFCOUNT], [
 258         AC_MSG_CHECKING([whether posix_acl has refcount_t])
 259         ZFS_LINUX_TEST_RESULT([acl_refcount], [
 260                 AC_MSG_RESULT(yes)
 261                 AC_DEFINE(HAVE_ACL_REFCOUNT, 1, [posix_acl has refcount_t])
 262         ],[
 263                 AC_MSG_RESULT(no)
 264         ])
 265 ])
 266
 267 AC_DEFUN([ZFS_AC_KERNEL_SRC_ACL], [
 268         ZFS_AC_KERNEL_SRC_POSIX_ACL_RELEASE
 269         ZFS_AC_KERNEL_SRC_SET_CACHED_ACL_USABLE
 270         ZFS_AC_KERNEL_SRC_POSIX_ACL_CHMOD
 271         ZFS_AC_KERNEL_SRC_POSIX_ACL_EQUIV_MODE_WANTS_UMODE_T
 272         ZFS_AC_KERNEL_SRC_POSIX_ACL_VALID_WITH_NS
 273         ZFS_AC_KERNEL_SRC_INODE_OPERATIONS_GET_ACL
 274         ZFS_AC_KERNEL_SRC_INODE_OPERATIONS_SET_ACL
 275         ZFS_AC_KERNEL_SRC_GET_ACL_HANDLE_CACHE
 276         ZFS_AC_KERNEL_SRC_ACL_HAS_REFCOUNT
 277 ])
 278
 279 AC_DEFUN([ZFS_AC_KERNEL_ACL], [
 280         ZFS_AC_KERNEL_POSIX_ACL_RELEASE
 281         ZFS_AC_KERNEL_SET_CACHED_ACL_USABLE
 282         ZFS_AC_KERNEL_POSIX_ACL_CHMOD
 283         ZFS_AC_KERNEL_POSIX_ACL_EQUIV_MODE_WANTS_UMODE_T
 284         ZFS_AC_KERNEL_POSIX_ACL_VALID_WITH_NS
 285         ZFS_AC_KERNEL_INODE_OPERATIONS_GET_ACL
 286         ZFS_AC_KERNEL_INODE_OPERATIONS_SET_ACL
 287         ZFS_AC_KERNEL_GET_ACL_HANDLE_CACHE
 288         ZFS_AC_KERNEL_ACL_HAS_REFCOUNT
 289 ])