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