1dnl # 2dnl # Check if posix_acl_release can be used from a ZFS_META_LICENSED 3dnl # module. The is_owner_or_cap macro was replaced by 4dnl # inode_owner_or_capable 5dnl # 6AC_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 17AC_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 37dnl # 38dnl # 3.14 API change, 39dnl # set_cached_acl() and forget_cached_acl() changed from inline to 40dnl # EXPORT_SYMBOL. In the former case, they may not be usable because of 41dnl # posix_acl_release. In the latter case, we can always use them. 42dnl # 43AC_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 56AC_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 67dnl # 68dnl # 3.1 API change, 69dnl # posix_acl_chmod() was added as the preferred interface. 70dnl # 71dnl # 3.14 API change, 72dnl # posix_acl_chmod() was changed to __posix_acl_chmod() 73dnl # 74AC_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 90AC_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 110dnl # 111dnl # 3.1 API change, 112dnl # posix_acl_equiv_mode now wants an umode_t instead of a mode_t 113dnl # 114AC_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 124AC_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 133dnl # 134dnl # 4.8 API change, 135dnl # The function posix_acl_valid now must be passed a namespace. 136dnl # 137AC_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 150AC_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 161dnl # 162dnl # 3.1 API change, 163dnl # Check if inode_operations contains the function get_acl 164dnl # 165dnl # 5.15 API change, 166dnl # Added the bool rcu argument to get_acl for rcu path walk. 167dnl # 168AC_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 194AC_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 209dnl # 210dnl # 3.14 API change, 211dnl # Check if inode_operations contains the function set_acl 212dnl # 213dnl # 5.12 API change, 214dnl # set_acl() added a user_namespace* parameter first 215dnl # 216AC_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 242AC_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 258dnl # 259dnl # 4.7 API change, 260dnl # The kernel get_acl will now check cache before calling i_op->get_acl and 261dnl # do set_cached_acl after that, so i_op->get_acl don't need to do that 262dnl # anymore. 263dnl # 264AC_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 273AC_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 284dnl # 285dnl # 4.16 kernel: check if struct posix_acl acl.a_refcount is a refcount_t. 286dnl # It's an atomic_t on older kernels. 287dnl # 288AC_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 299AC_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 309AC_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 321AC_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]) 332