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 dnl # 5.15 API change,
 166 dnl # Added the bool rcu argument to get_acl for rcu path walk.
 167 dnl #
 168 AC_DEFUN([ZFS_AC_KERNEL_SRC_INODE_OPERATIONS_GET_ACL], [
 169         ZFS_LINUX_TEST_SRC([inode_operations_get_acl], [
 170                 #include <linux/fs.h>
 171
 172                 struct posix_acl *get_acl_fn(struct inode *inode, int type)
 173                     { return NULL; }
 174
 175                 static const struct inode_operations
 176                     iops __attribute__ ((unused)) = {
 177                         .get_acl = get_acl_fn,
 178                 };
 179         ],[])
 180
 181         ZFS_LINUX_TEST_SRC([inode_operations_get_acl_rcu], [
 182                 #include <linux/fs.h>
 183
 184                 struct posix_acl *get_acl_fn(struct inode *inode, int type,
 185                     bool rcu) { return NULL; }
 186
 187                 static const struct inode_operations
 188                     iops __attribute__ ((unused)) = {
 189                         .get_acl = get_acl_fn,
 190                 };
 191         ],[])
 192 ])
 193
 194 AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_GET_ACL], [
 195         AC_MSG_CHECKING([whether iops->get_acl() exists])
 196         ZFS_LINUX_TEST_RESULT([inode_operations_get_acl], [
 197                 AC_MSG_RESULT(yes)
 198                 AC_DEFINE(HAVE_GET_ACL, 1, [iops->get_acl() exists])
 199         ],[
 200                 ZFS_LINUX_TEST_RESULT([inode_operations_get_acl_rcu], [
 201                         AC_MSG_RESULT(yes)
 202                         AC_DEFINE(HAVE_GET_ACL_RCU, 1, [iops->get_acl() takes rcu])
 203                 ],[
 204                         ZFS_LINUX_TEST_ERROR([iops->get_acl()])
 205                 ])
 206         ])
 207 ])
 208
 209 dnl #
 210 dnl # 3.14 API change,
 211 dnl # Check if inode_operations contains the function set_acl
 212 dnl #
 213 dnl # 5.12 API change,
 214 dnl # set_acl() added a user_namespace* parameter first
 215 dnl #
 216 AC_DEFUN([ZFS_AC_KERNEL_SRC_INODE_OPERATIONS_SET_ACL], [
 217         ZFS_LINUX_TEST_SRC([inode_operations_set_acl_userns], [
 218                 #include <linux/fs.h>
 219
 220                 int set_acl_fn(struct user_namespace *userns,
 221                     struct inode *inode, struct posix_acl *acl,
 222                     int type) { return 0; }
 223
 224                 static const struct inode_operations
 225                     iops __attribute__ ((unused)) = {
 226                         .set_acl = set_acl_fn,
 227                 };
 228         ],[])
 229         ZFS_LINUX_TEST_SRC([inode_operations_set_acl], [
 230                 #include <linux/fs.h>
 231
 232                 int set_acl_fn(struct inode *inode, struct posix_acl *acl,
 233                     int type) { return 0; }
 234
 235                 static const struct inode_operations
 236                     iops __attribute__ ((unused)) = {
 237                         .set_acl = set_acl_fn,
 238                 };
 239         ],[])
 240 ])
 241
 242 AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_SET_ACL], [
 243         AC_MSG_CHECKING([whether iops->set_acl() exists])
 244         ZFS_LINUX_TEST_RESULT([inode_operations_set_acl_userns], [
 245                 AC_MSG_RESULT(yes)
 246                 AC_DEFINE(HAVE_SET_ACL, 1, [iops->set_acl() exists])
 247                 AC_DEFINE(HAVE_SET_ACL_USERNS, 1, [iops->set_acl() takes 4 args])
 248         ],[
 249                 ZFS_LINUX_TEST_RESULT([inode_operations_set_acl], [
 250                         AC_MSG_RESULT(yes)
 251                         AC_DEFINE(HAVE_SET_ACL, 1, [iops->set_acl() exists, takes 3 args])
 252                 ],[
 253                         AC_MSG_RESULT(no)
 254                 ])
 255         ])
 256 ])
 257
 258 dnl #
 259 dnl # 4.7 API change,
 260 dnl # The kernel get_acl will now check cache before calling i_op->get_acl and
 261 dnl # do set_cached_acl after that, so i_op->get_acl don't need to do that
 262 dnl # anymore.
 263 dnl #
 264 AC_DEFUN([ZFS_AC_KERNEL_SRC_GET_ACL_HANDLE_CACHE], [
 265         ZFS_LINUX_TEST_SRC([get_acl_handle_cache], [
 266                 #include <linux/fs.h>
 267         ],[
 268                 void *sentinel __attribute__ ((unused)) =
 269                     uncached_acl_sentinel(NULL);
 270         ])
 271 ])
 272
 273 AC_DEFUN([ZFS_AC_KERNEL_GET_ACL_HANDLE_CACHE], [
 274         AC_MSG_CHECKING([whether uncached_acl_sentinel() exists])
 275         ZFS_LINUX_TEST_RESULT([get_acl_handle_cache], [
 276                 AC_MSG_RESULT(yes)
 277                 AC_DEFINE(HAVE_KERNEL_GET_ACL_HANDLE_CACHE, 1,
 278                     [uncached_acl_sentinel() exists])
 279         ],[
 280                 AC_MSG_RESULT(no)
 281         ])
 282 ])
 283
 284 dnl #
 285 dnl # 4.16 kernel: check if struct posix_acl acl.a_refcount is a refcount_t.
 286 dnl # It's an atomic_t on older kernels.
 287 dnl #
 288 AC_DEFUN([ZFS_AC_KERNEL_SRC_ACL_HAS_REFCOUNT], [
 289         ZFS_LINUX_TEST_SRC([acl_refcount], [
 290                 #include <linux/backing-dev.h>
 291                 #include <linux/refcount.h>
 292                 #include <linux/posix_acl.h>
 293         ],[
 294                 struct posix_acl acl;
 295                 refcount_t *r __attribute__ ((unused)) = &acl.a_refcount;
 296         ])
 297 ])
 298
 299 AC_DEFUN([ZFS_AC_KERNEL_ACL_HAS_REFCOUNT], [
 300         AC_MSG_CHECKING([whether posix_acl has refcount_t])
 301         ZFS_LINUX_TEST_RESULT([acl_refcount], [
 302                 AC_MSG_RESULT(yes)
 303                 AC_DEFINE(HAVE_ACL_REFCOUNT, 1, [posix_acl has refcount_t])
 304         ],[
 305                 AC_MSG_RESULT(no)
 306         ])
 307 ])
 308
 309 AC_DEFUN([ZFS_AC_KERNEL_SRC_ACL], [
 310         ZFS_AC_KERNEL_SRC_POSIX_ACL_RELEASE
 311         ZFS_AC_KERNEL_SRC_SET_CACHED_ACL_USABLE
 312         ZFS_AC_KERNEL_SRC_POSIX_ACL_CHMOD
 313         ZFS_AC_KERNEL_SRC_POSIX_ACL_EQUIV_MODE_WANTS_UMODE_T
 314         ZFS_AC_KERNEL_SRC_POSIX_ACL_VALID_WITH_NS
 315         ZFS_AC_KERNEL_SRC_INODE_OPERATIONS_GET_ACL
 316         ZFS_AC_KERNEL_SRC_INODE_OPERATIONS_SET_ACL
 317         ZFS_AC_KERNEL_SRC_GET_ACL_HANDLE_CACHE
 318         ZFS_AC_KERNEL_SRC_ACL_HAS_REFCOUNT
 319 ])
 320
 321 AC_DEFUN([ZFS_AC_KERNEL_ACL], [
 322         ZFS_AC_KERNEL_POSIX_ACL_RELEASE
 323         ZFS_AC_KERNEL_SET_CACHED_ACL_USABLE
 324         ZFS_AC_KERNEL_POSIX_ACL_CHMOD
 325         ZFS_AC_KERNEL_POSIX_ACL_EQUIV_MODE_WANTS_UMODE_T
 326         ZFS_AC_KERNEL_POSIX_ACL_VALID_WITH_NS
 327         ZFS_AC_KERNEL_INODE_OPERATIONS_GET_ACL
 328         ZFS_AC_KERNEL_INODE_OPERATIONS_SET_ACL
 329         ZFS_AC_KERNEL_GET_ACL_HANDLE_CACHE
 330         ZFS_AC_KERNEL_ACL_HAS_REFCOUNT
 331 ])