]> granicus.if.org Git - zfs/blob - config/kernel-acl.m4
Fix config issues: frame size and headers
[zfs] / 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_POSIX_ACL_RELEASE], [
7         AC_MSG_CHECKING([whether posix_acl_release() is available])
8         ZFS_LINUX_TRY_COMPILE([
9                 #include <linux/cred.h>
10                 #include <linux/fs.h>
11                 #include <linux/posix_acl.h>
12         ],[
13                 struct posix_acl* tmp = posix_acl_alloc(1, 0);
14                 posix_acl_release(tmp);
15         ],[
16                 AC_MSG_RESULT(yes)
17                 AC_DEFINE(HAVE_POSIX_ACL_RELEASE, 1,
18                     [posix_acl_release() is available])
19
20                 AC_MSG_CHECKING([whether posix_acl_release() is GPL-only])
21                 ZFS_LINUX_TRY_COMPILE([
22                         #include <linux/module.h>
23                         #include <linux/cred.h>
24                         #include <linux/fs.h>
25                         #include <linux/posix_acl.h>
26
27                         MODULE_LICENSE("$ZFS_META_LICENSE");
28                 ],[
29                         struct posix_acl* tmp = posix_acl_alloc(1, 0);
30                         posix_acl_release(tmp);
31                 ],[
32                         AC_MSG_RESULT(no)
33                 ],[
34                         AC_MSG_RESULT(yes)
35                         AC_DEFINE(HAVE_POSIX_ACL_RELEASE_GPL_ONLY, 1,
36                             [posix_acl_release() is GPL-only])
37                 ])
38         ],[
39                 AC_MSG_RESULT(no)
40         ])
41 ])
42
43 dnl #
44 dnl # 3.14 API change,
45 dnl # set_cached_acl() and forget_cached_acl() changed from inline to
46 dnl # EXPORT_SYMBOL. In the former case, they may not be usable because of
47 dnl # posix_acl_release. In the latter case, we can always use them.
48 dnl #
49 AC_DEFUN([ZFS_AC_KERNEL_SET_CACHED_ACL_USABLE], [
50         AC_MSG_CHECKING([whether set_cached_acl() is usable])
51         ZFS_LINUX_TRY_COMPILE([
52                 #include <linux/module.h>
53                 #include <linux/cred.h>
54                 #include <linux/fs.h>
55                 #include <linux/posix_acl.h>
56
57                 MODULE_LICENSE("$ZFS_META_LICENSE");
58         ],[
59                 struct inode *ip = NULL;
60                 struct posix_acl *acl = posix_acl_alloc(1, 0);
61                 set_cached_acl(ip, ACL_TYPE_ACCESS, acl);
62                 forget_cached_acl(ip, ACL_TYPE_ACCESS);
63         ],[
64                 AC_MSG_RESULT(yes)
65                 AC_DEFINE(HAVE_SET_CACHED_ACL_USABLE, 1,
66                     [posix_acl_release() is usable])
67         ],[
68                 AC_MSG_RESULT(no)
69         ])
70 ])
71
72 dnl #
73 dnl # 3.1 API change,
74 dnl # posix_acl_chmod_masq() is not exported anymore and posix_acl_chmod()
75 dnl # was introduced to replace it.
76 dnl #
77 dnl # 3.14 API change,
78 dnl # posix_acl_chmod() is changed to __posix_acl_chmod()
79 dnl #
80 AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_CHMOD], [
81         AC_MSG_CHECKING([whether posix_acl_chmod exists])
82         ZFS_LINUX_TRY_COMPILE([
83                 #include <linux/fs.h>
84                 #include <linux/posix_acl.h>
85         ],[
86                 posix_acl_chmod(NULL, 0, 0)
87         ],[
88                 AC_MSG_RESULT(yes)
89                 AC_DEFINE(HAVE_POSIX_ACL_CHMOD, 1, [posix_acl_chmod() exists])
90         ],[
91                 AC_MSG_RESULT(no)
92         ])
93
94         AC_MSG_CHECKING([whether __posix_acl_chmod exists])
95         ZFS_LINUX_TRY_COMPILE([
96                 #include <linux/fs.h>
97                 #include <linux/posix_acl.h>
98         ],[
99                 __posix_acl_chmod(NULL, 0, 0)
100         ],[
101                 AC_MSG_RESULT(yes)
102                 AC_DEFINE(HAVE___POSIX_ACL_CHMOD, 1, [__posix_acl_chmod() exists])
103         ],[
104                 AC_MSG_RESULT(no)
105         ])
106 ])
107
108 dnl #
109 dnl # 3.1 API change,
110 dnl # posix_acl_equiv_mode now wants an umode_t* instead of a mode_t*
111 dnl #
112 AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_EQUIV_MODE_WANTS_UMODE_T], [
113         AC_MSG_CHECKING([whether posix_acl_equiv_mode() wants umode_t])
114         ZFS_LINUX_TRY_COMPILE([
115                 #include <linux/fs.h>
116                 #include <linux/posix_acl.h>
117         ],[
118                 umode_t tmp;
119                 posix_acl_equiv_mode(NULL,&tmp);
120         ],[
121                 AC_MSG_RESULT(yes)
122                 AC_DEFINE(HAVE_POSIX_ACL_EQUIV_MODE_UMODE_T, 1,
123                     [ posix_acl_equiv_mode wants umode_t*])
124         ],[
125                 AC_MSG_RESULT(no)
126         ])
127 ])
128
129 dnl #
130 dnl # 4.8 API change,
131 dnl # The function posix_acl_valid now must be passed a namespace.
132 dnl #
133 AC_DEFUN([ZFS_AC_KERNEL_POSIX_ACL_VALID_WITH_NS], [
134         AC_MSG_CHECKING([whether posix_acl_valid() wants user namespace])
135         ZFS_LINUX_TRY_COMPILE([
136                 #include <linux/fs.h>
137                 #include <linux/posix_acl.h>
138         ],[
139                 struct user_namespace *user_ns = NULL;
140                 const struct posix_acl *acl = NULL;
141                 int error;
142
143                 error = posix_acl_valid(user_ns, acl);
144         ],[
145                 AC_MSG_RESULT(yes)
146                 AC_DEFINE(HAVE_POSIX_ACL_VALID_WITH_NS, 1,
147                     [posix_acl_valid() wants user namespace])
148         ],[
149                 AC_MSG_RESULT(no)
150         ])
151 ])
152
153 dnl #
154 dnl # 2.6.27 API change,
155 dnl # Check if inode_operations contains the function permission
156 dnl # and expects the nameidata structure to have been removed.
157 dnl #
158 AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_PERMISSION], [
159         AC_MSG_CHECKING([whether iops->permission() exists])
160         ZFS_LINUX_TRY_COMPILE([
161                 #include <linux/fs.h>
162
163                 int permission_fn(struct inode *inode, int mask) { return 0; }
164
165                 static const struct inode_operations
166                     iops __attribute__ ((unused)) = {
167                         .permission = permission_fn,
168                 };
169         ],[
170         ],[
171                 AC_MSG_RESULT(yes)
172                 AC_DEFINE(HAVE_PERMISSION, 1, [iops->permission() exists])
173         ],[
174                 AC_MSG_RESULT(no)
175         ])
176 ])
177
178 dnl #
179 dnl # 2.6.26 API change,
180 dnl # Check if inode_operations contains the function permission
181 dnl # and expects the nameidata structure to be passed.
182 dnl #
183 AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_PERMISSION_WITH_NAMEIDATA], [
184         AC_MSG_CHECKING([whether iops->permission() wants nameidata])
185         ZFS_LINUX_TRY_COMPILE([
186                 #include <linux/fs.h>
187                 #include <linux/sched.h>
188
189                 int permission_fn(struct inode *inode, int mask,
190                     struct nameidata *nd) { return 0; }
191
192                 static const struct inode_operations
193                     iops __attribute__ ((unused)) = {
194                         .permission = permission_fn,
195                 };
196         ],[
197         ],[
198                 AC_MSG_RESULT(yes)
199                 AC_DEFINE(HAVE_PERMISSION, 1, [iops->permission() exists])
200                 AC_DEFINE(HAVE_PERMISSION_WITH_NAMEIDATA, 1,
201                     [iops->permission() with nameidata exists])
202         ],[
203                 AC_MSG_RESULT(no)
204         ])
205 ])
206
207 dnl #
208 dnl # 2.6.32 API change,
209 dnl # Check if inode_operations contains the function check_acl
210 dnl #
211 AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_CHECK_ACL], [
212         AC_MSG_CHECKING([whether iops->check_acl() exists])
213         ZFS_LINUX_TRY_COMPILE([
214                 #include <linux/fs.h>
215
216                 int check_acl_fn(struct inode *inode, int mask) { return 0; }
217
218                 static const struct inode_operations
219                     iops __attribute__ ((unused)) = {
220                         .check_acl = check_acl_fn,
221                 };
222         ],[
223         ],[
224                 AC_MSG_RESULT(yes)
225                 AC_DEFINE(HAVE_CHECK_ACL, 1, [iops->check_acl() exists])
226         ],[
227                 AC_MSG_RESULT(no)
228         ])
229 ])
230
231 dnl #
232 dnl # 2.6.38 API change,
233 dnl # The function check_acl gained a new parameter: flags
234 dnl #
235 AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_CHECK_ACL_WITH_FLAGS], [
236         AC_MSG_CHECKING([whether iops->check_acl() wants flags])
237         ZFS_LINUX_TRY_COMPILE([
238                 #include <linux/fs.h>
239
240                 int check_acl_fn(struct inode *inode, int mask,
241                     unsigned int flags) { return 0; }
242
243                 static const struct inode_operations
244                     iops __attribute__ ((unused)) = {
245                         .check_acl = check_acl_fn,
246                 };
247         ],[
248         ],[
249                 AC_MSG_RESULT(yes)
250                 AC_DEFINE(HAVE_CHECK_ACL, 1, [iops->check_acl() exists])
251                 AC_DEFINE(HAVE_CHECK_ACL_WITH_FLAGS, 1,
252                     [iops->check_acl() wants flags])
253         ],[
254                 AC_MSG_RESULT(no)
255         ])
256 ])
257
258 dnl #
259 dnl # 3.1 API change,
260 dnl # Check if inode_operations contains the function get_acl
261 dnl #
262 AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_GET_ACL], [
263         AC_MSG_CHECKING([whether iops->get_acl() exists])
264         ZFS_LINUX_TRY_COMPILE([
265                 #include <linux/fs.h>
266
267                 struct posix_acl *get_acl_fn(struct inode *inode, int type)
268                     { return NULL; }
269
270                 static const struct inode_operations
271                     iops __attribute__ ((unused)) = {
272                         .get_acl = get_acl_fn,
273                 };
274         ],[
275         ],[
276                 AC_MSG_RESULT(yes)
277                 AC_DEFINE(HAVE_GET_ACL, 1, [iops->get_acl() exists])
278         ],[
279                 AC_MSG_RESULT(no)
280         ])
281 ])
282
283 dnl #
284 dnl # 3.14 API change,
285 dnl # Check if inode_operations contains the function set_acl
286 dnl #
287 AC_DEFUN([ZFS_AC_KERNEL_INODE_OPERATIONS_SET_ACL], [
288         AC_MSG_CHECKING([whether iops->set_acl() exists])
289         ZFS_LINUX_TRY_COMPILE([
290                 #include <linux/fs.h>
291
292                 int set_acl_fn(struct inode *inode, struct posix_acl *acl, int type)
293                     { return 0; }
294
295                 static const struct inode_operations
296                     iops __attribute__ ((unused)) = {
297                         .set_acl = set_acl_fn,
298                 };
299         ],[
300         ],[
301                 AC_MSG_RESULT(yes)
302                 AC_DEFINE(HAVE_SET_ACL, 1, [iops->set_acl() exists])
303         ],[
304                 AC_MSG_RESULT(no)
305         ])
306 ])
307
308 dnl #
309 dnl # 4.7 API change,
310 dnl # The kernel get_acl will now check cache before calling i_op->get_acl and
311 dnl # do set_cached_acl after that, so i_op->get_acl don't need to do that
312 dnl # anymore.
313 dnl #
314 AC_DEFUN([ZFS_AC_KERNEL_GET_ACL_HANDLE_CACHE], [
315         AC_MSG_CHECKING([whether uncached_acl_sentinel() exists])
316         ZFS_LINUX_TRY_COMPILE([
317                 #include <linux/fs.h>
318         ],[
319                 void *sentinel __attribute__ ((unused)) = uncached_acl_sentinel(NULL);
320         ],[
321                 AC_MSG_RESULT(yes)
322                 AC_DEFINE(HAVE_KERNEL_GET_ACL_HANDLE_CACHE, 1, [uncached_acl_sentinel() exists])
323         ],[
324                 AC_MSG_RESULT(no)
325         ])
326 ])