~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/fs/nfs/nfs3acl.c

Version: ~ [ linux-5.8-rc4 ] ~ [ linux-5.7.7 ] ~ [ linux-5.6.19 ] ~ [ linux-5.5.19 ] ~ [ linux-5.4.50 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.131 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.187 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.229 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.229 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.85 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 // SPDX-License-Identifier: GPL-2.0
  2 #include <linux/fs.h>
  3 #include <linux/gfp.h>
  4 #include <linux/nfs.h>
  5 #include <linux/nfs3.h>
  6 #include <linux/nfs_fs.h>
  7 #include <linux/posix_acl_xattr.h>
  8 #include <linux/nfsacl.h>
  9 
 10 #include "internal.h"
 11 #include "nfs3_fs.h"
 12 
 13 #define NFSDBG_FACILITY NFSDBG_PROC
 14 
 15 /*
 16  * nfs3_prepare_get_acl, nfs3_complete_get_acl, nfs3_abort_get_acl: Helpers for
 17  * caching get_acl results in a race-free way.  See fs/posix_acl.c:get_acl()
 18  * for explanations.
 19  */
 20 static void nfs3_prepare_get_acl(struct posix_acl **p)
 21 {
 22         struct posix_acl *sentinel = uncached_acl_sentinel(current);
 23 
 24         if (cmpxchg(p, ACL_NOT_CACHED, sentinel) != ACL_NOT_CACHED) {
 25                 /* Not the first reader or sentinel already in place. */
 26         }
 27 }
 28 
 29 static void nfs3_complete_get_acl(struct posix_acl **p, struct posix_acl *acl)
 30 {
 31         struct posix_acl *sentinel = uncached_acl_sentinel(current);
 32 
 33         /* Only cache the ACL if our sentinel is still in place. */
 34         posix_acl_dup(acl);
 35         if (cmpxchg(p, sentinel, acl) != sentinel)
 36                 posix_acl_release(acl);
 37 }
 38 
 39 static void nfs3_abort_get_acl(struct posix_acl **p)
 40 {
 41         struct posix_acl *sentinel = uncached_acl_sentinel(current);
 42 
 43         /* Remove our sentinel upon failure. */
 44         cmpxchg(p, sentinel, ACL_NOT_CACHED);
 45 }
 46 
 47 struct posix_acl *nfs3_get_acl(struct inode *inode, int type)
 48 {
 49         struct nfs_server *server = NFS_SERVER(inode);
 50         struct page *pages[NFSACL_MAXPAGES] = { };
 51         struct nfs3_getaclargs args = {
 52                 .fh = NFS_FH(inode),
 53                 /* The xdr layer may allocate pages here. */
 54                 .pages = pages,
 55         };
 56         struct nfs3_getaclres res = {
 57                 NULL,
 58         };
 59         struct rpc_message msg = {
 60                 .rpc_argp       = &args,
 61                 .rpc_resp       = &res,
 62         };
 63         int status, count;
 64 
 65         if (!nfs_server_capable(inode, NFS_CAP_ACLS))
 66                 return ERR_PTR(-EOPNOTSUPP);
 67 
 68         status = nfs_revalidate_inode(server, inode);
 69         if (status < 0)
 70                 return ERR_PTR(status);
 71 
 72         /*
 73          * Only get the access acl when explicitly requested: We don't
 74          * need it for access decisions, and only some applications use
 75          * it. Applications which request the access acl first are not
 76          * penalized from this optimization.
 77          */
 78         if (type == ACL_TYPE_ACCESS)
 79                 args.mask |= NFS_ACLCNT|NFS_ACL;
 80         if (S_ISDIR(inode->i_mode))
 81                 args.mask |= NFS_DFACLCNT|NFS_DFACL;
 82         if (args.mask == 0)
 83                 return NULL;
 84 
 85         dprintk("NFS call getacl\n");
 86         msg.rpc_proc = &server->client_acl->cl_procinfo[ACLPROC3_GETACL];
 87         res.fattr = nfs_alloc_fattr();
 88         if (res.fattr == NULL)
 89                 return ERR_PTR(-ENOMEM);
 90 
 91         if (args.mask & NFS_ACL)
 92                 nfs3_prepare_get_acl(&inode->i_acl);
 93         if (args.mask & NFS_DFACL)
 94                 nfs3_prepare_get_acl(&inode->i_default_acl);
 95 
 96         status = rpc_call_sync(server->client_acl, &msg, 0);
 97         dprintk("NFS reply getacl: %d\n", status);
 98 
 99         /* pages may have been allocated at the xdr layer. */
100         for (count = 0; count < NFSACL_MAXPAGES && args.pages[count]; count++)
101                 __free_page(args.pages[count]);
102 
103         switch (status) {
104                 case 0:
105                         status = nfs_refresh_inode(inode, res.fattr);
106                         break;
107                 case -EPFNOSUPPORT:
108                 case -EPROTONOSUPPORT:
109                         dprintk("NFS_V3_ACL extension not supported; disabling\n");
110                         server->caps &= ~NFS_CAP_ACLS;
111                 case -ENOTSUPP:
112                         status = -EOPNOTSUPP;
113                 default:
114                         goto getout;
115         }
116         if ((args.mask & res.mask) != args.mask) {
117                 status = -EIO;
118                 goto getout;
119         }
120 
121         if (res.acl_access != NULL) {
122                 if ((posix_acl_equiv_mode(res.acl_access, NULL) == 0) ||
123                     res.acl_access->a_count == 0) {
124                         posix_acl_release(res.acl_access);
125                         res.acl_access = NULL;
126                 }
127         }
128 
129         if (res.mask & NFS_ACL)
130                 nfs3_complete_get_acl(&inode->i_acl, res.acl_access);
131         else
132                 forget_cached_acl(inode, ACL_TYPE_ACCESS);
133 
134         if (res.mask & NFS_DFACL)
135                 nfs3_complete_get_acl(&inode->i_default_acl, res.acl_default);
136         else
137                 forget_cached_acl(inode, ACL_TYPE_DEFAULT);
138 
139         nfs_free_fattr(res.fattr);
140         if (type == ACL_TYPE_ACCESS) {
141                 posix_acl_release(res.acl_default);
142                 return res.acl_access;
143         } else {
144                 posix_acl_release(res.acl_access);
145                 return res.acl_default;
146         }
147 
148 getout:
149         nfs3_abort_get_acl(&inode->i_acl);
150         nfs3_abort_get_acl(&inode->i_default_acl);
151         posix_acl_release(res.acl_access);
152         posix_acl_release(res.acl_default);
153         nfs_free_fattr(res.fattr);
154         return ERR_PTR(status);
155 }
156 
157 static int __nfs3_proc_setacls(struct inode *inode, struct posix_acl *acl,
158                 struct posix_acl *dfacl)
159 {
160         struct nfs_server *server = NFS_SERVER(inode);
161         struct nfs_fattr *fattr;
162         struct page *pages[NFSACL_MAXPAGES];
163         struct nfs3_setaclargs args = {
164                 .inode = inode,
165                 .mask = NFS_ACL,
166                 .acl_access = acl,
167                 .pages = pages,
168         };
169         struct rpc_message msg = {
170                 .rpc_argp       = &args,
171                 .rpc_resp       = &fattr,
172         };
173         int status = 0;
174 
175         if (acl == NULL && (!S_ISDIR(inode->i_mode) || dfacl == NULL))
176                 goto out;
177 
178         status = -EOPNOTSUPP;
179         if (!nfs_server_capable(inode, NFS_CAP_ACLS))
180                 goto out;
181 
182         /* We are doing this here because XDR marshalling does not
183          * return any results, it BUGs. */
184         status = -ENOSPC;
185         if (acl != NULL && acl->a_count > NFS_ACL_MAX_ENTRIES)
186                 goto out;
187         if (dfacl != NULL && dfacl->a_count > NFS_ACL_MAX_ENTRIES)
188                 goto out;
189         if (S_ISDIR(inode->i_mode)) {
190                 args.mask |= NFS_DFACL;
191                 args.acl_default = dfacl;
192                 args.len = nfsacl_size(acl, dfacl);
193         } else
194                 args.len = nfsacl_size(acl, NULL);
195 
196         if (args.len > NFS_ACL_INLINE_BUFSIZE) {
197                 unsigned int npages = 1 + ((args.len - 1) >> PAGE_SHIFT);
198 
199                 status = -ENOMEM;
200                 do {
201                         args.pages[args.npages] = alloc_page(GFP_KERNEL);
202                         if (args.pages[args.npages] == NULL)
203                                 goto out_freepages;
204                         args.npages++;
205                 } while (args.npages < npages);
206         }
207 
208         dprintk("NFS call setacl\n");
209         status = -ENOMEM;
210         fattr = nfs_alloc_fattr();
211         if (fattr == NULL)
212                 goto out_freepages;
213 
214         msg.rpc_proc = &server->client_acl->cl_procinfo[ACLPROC3_SETACL];
215         msg.rpc_resp = fattr;
216         status = rpc_call_sync(server->client_acl, &msg, 0);
217         nfs_access_zap_cache(inode);
218         nfs_zap_acl_cache(inode);
219         dprintk("NFS reply setacl: %d\n", status);
220 
221         switch (status) {
222                 case 0:
223                         status = nfs_refresh_inode(inode, fattr);
224                         set_cached_acl(inode, ACL_TYPE_ACCESS, acl);
225                         set_cached_acl(inode, ACL_TYPE_DEFAULT, dfacl);
226                         break;
227                 case -EPFNOSUPPORT:
228                 case -EPROTONOSUPPORT:
229                         dprintk("NFS_V3_ACL SETACL RPC not supported"
230                                         "(will not retry)\n");
231                         server->caps &= ~NFS_CAP_ACLS;
232                 case -ENOTSUPP:
233                         status = -EOPNOTSUPP;
234         }
235         nfs_free_fattr(fattr);
236 out_freepages:
237         while (args.npages != 0) {
238                 args.npages--;
239                 __free_page(args.pages[args.npages]);
240         }
241 out:
242         return status;
243 }
244 
245 int nfs3_proc_setacls(struct inode *inode, struct posix_acl *acl,
246                 struct posix_acl *dfacl)
247 {
248         int ret;
249         ret = __nfs3_proc_setacls(inode, acl, dfacl);
250         return (ret == -EOPNOTSUPP) ? 0 : ret;
251 
252 }
253 
254 int nfs3_set_acl(struct inode *inode, struct posix_acl *acl, int type)
255 {
256         struct posix_acl *alloc = NULL, *dfacl = NULL;
257         int status;
258 
259         if (S_ISDIR(inode->i_mode)) {
260                 switch(type) {
261                 case ACL_TYPE_ACCESS:
262                         alloc = dfacl = get_acl(inode, ACL_TYPE_DEFAULT);
263                         if (IS_ERR(alloc))
264                                 goto fail;
265                         break;
266 
267                 case ACL_TYPE_DEFAULT:
268                         dfacl = acl;
269                         alloc = acl = get_acl(inode, ACL_TYPE_ACCESS);
270                         if (IS_ERR(alloc))
271                                 goto fail;
272                         break;
273                 }
274         }
275 
276         if (acl == NULL) {
277                 alloc = acl = posix_acl_from_mode(inode->i_mode, GFP_KERNEL);
278                 if (IS_ERR(alloc))
279                         goto fail;
280         }
281         status = __nfs3_proc_setacls(inode, acl, dfacl);
282         posix_acl_release(alloc);
283         return status;
284 
285 fail:
286         return PTR_ERR(alloc);
287 }
288 
289 const struct xattr_handler *nfs3_xattr_handlers[] = {
290         &posix_acl_access_xattr_handler,
291         &posix_acl_default_xattr_handler,
292         NULL,
293 };
294 
295 static int
296 nfs3_list_one_acl(struct inode *inode, int type, const char *name, void *data,
297                 size_t size, ssize_t *result)
298 {
299         struct posix_acl *acl;
300         char *p = data + *result;
301 
302         acl = get_acl(inode, type);
303         if (IS_ERR_OR_NULL(acl))
304                 return 0;
305 
306         posix_acl_release(acl);
307 
308         *result += strlen(name);
309         *result += 1;
310         if (!size)
311                 return 0;
312         if (*result > size)
313                 return -ERANGE;
314 
315         strcpy(p, name);
316         return 0;
317 }
318 
319 ssize_t
320 nfs3_listxattr(struct dentry *dentry, char *data, size_t size)
321 {
322         struct inode *inode = d_inode(dentry);
323         ssize_t result = 0;
324         int error;
325 
326         error = nfs3_list_one_acl(inode, ACL_TYPE_ACCESS,
327                         XATTR_NAME_POSIX_ACL_ACCESS, data, size, &result);
328         if (error)
329                 return error;
330 
331         error = nfs3_list_one_acl(inode, ACL_TYPE_DEFAULT,
332                         XATTR_NAME_POSIX_ACL_DEFAULT, data, size, &result);
333         if (error)
334                 return error;
335         return result;
336 }
337 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp