1 // SPDX-License-Identifier: GPL-2.0
5 #include <linux/nfs3.h>
6 #include <linux/nfs_fs.h>
7 #include <linux/posix_acl_xattr.h>
8 #include <linux/nfsacl.h>
13 #define NFSDBG_FACILITY NFSDBG_PROC
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()
20 static void nfs3_prepare_get_acl(struct posix_acl
**p
)
22 struct posix_acl
*sentinel
= uncached_acl_sentinel(current
);
24 if (cmpxchg(p
, ACL_NOT_CACHED
, sentinel
) != ACL_NOT_CACHED
) {
25 /* Not the first reader or sentinel already in place. */
29 static void nfs3_complete_get_acl(struct posix_acl
**p
, struct posix_acl
*acl
)
31 struct posix_acl
*sentinel
= uncached_acl_sentinel(current
);
33 /* Only cache the ACL if our sentinel is still in place. */
35 if (cmpxchg(p
, sentinel
, acl
) != sentinel
)
36 posix_acl_release(acl
);
39 static void nfs3_abort_get_acl(struct posix_acl
**p
)
41 struct posix_acl
*sentinel
= uncached_acl_sentinel(current
);
43 /* Remove our sentinel upon failure. */
44 cmpxchg(p
, sentinel
, ACL_NOT_CACHED
);
47 struct posix_acl
*nfs3_get_acl(struct inode
*inode
, int type
)
49 struct nfs_server
*server
= NFS_SERVER(inode
);
50 struct page
*pages
[NFSACL_MAXPAGES
] = { };
51 struct nfs3_getaclargs args
= {
53 /* The xdr layer may allocate pages here. */
56 struct nfs3_getaclres res
= {
59 struct rpc_message msg
= {
65 if (!nfs_server_capable(inode
, NFS_CAP_ACLS
))
66 return ERR_PTR(-EOPNOTSUPP
);
68 status
= nfs_revalidate_inode(server
, inode
);
70 return ERR_PTR(status
);
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.
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
;
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
);
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
);
96 status
= rpc_call_sync(server
->client_acl
, &msg
, 0);
97 dprintk("NFS reply getacl: %d\n", status
);
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
]);
105 status
= nfs_refresh_inode(inode
, res
.fattr
);
108 case -EPROTONOSUPPORT
:
109 dprintk("NFS_V3_ACL extension not supported; disabling\n");
110 server
->caps
&= ~NFS_CAP_ACLS
;
112 status
= -EOPNOTSUPP
;
116 if ((args
.mask
& res
.mask
) != args
.mask
) {
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
;
129 if (res
.mask
& NFS_ACL
)
130 nfs3_complete_get_acl(&inode
->i_acl
, res
.acl_access
);
132 forget_cached_acl(inode
, ACL_TYPE_ACCESS
);
134 if (res
.mask
& NFS_DFACL
)
135 nfs3_complete_get_acl(&inode
->i_default_acl
, res
.acl_default
);
137 forget_cached_acl(inode
, ACL_TYPE_DEFAULT
);
139 nfs_free_fattr(res
.fattr
);
140 if (type
== ACL_TYPE_ACCESS
) {
141 posix_acl_release(res
.acl_default
);
142 return res
.acl_access
;
144 posix_acl_release(res
.acl_access
);
145 return res
.acl_default
;
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
);
157 static int __nfs3_proc_setacls(struct inode
*inode
, struct posix_acl
*acl
,
158 struct posix_acl
*dfacl
)
160 struct nfs_server
*server
= NFS_SERVER(inode
);
161 struct nfs_fattr
*fattr
;
162 struct page
*pages
[NFSACL_MAXPAGES
];
163 struct nfs3_setaclargs args
= {
169 struct rpc_message msg
= {
175 if (acl
== NULL
&& (!S_ISDIR(inode
->i_mode
) || dfacl
== NULL
))
178 status
= -EOPNOTSUPP
;
179 if (!nfs_server_capable(inode
, NFS_CAP_ACLS
))
182 /* We are doing this here because XDR marshalling does not
183 * return any results, it BUGs. */
185 if (acl
!= NULL
&& acl
->a_count
> NFS_ACL_MAX_ENTRIES
)
187 if (dfacl
!= NULL
&& dfacl
->a_count
> NFS_ACL_MAX_ENTRIES
)
189 if (S_ISDIR(inode
->i_mode
)) {
190 args
.mask
|= NFS_DFACL
;
191 args
.acl_default
= dfacl
;
192 args
.len
= nfsacl_size(acl
, dfacl
);
194 args
.len
= nfsacl_size(acl
, NULL
);
196 if (args
.len
> NFS_ACL_INLINE_BUFSIZE
) {
197 unsigned int npages
= 1 + ((args
.len
- 1) >> PAGE_SHIFT
);
201 args
.pages
[args
.npages
] = alloc_page(GFP_KERNEL
);
202 if (args
.pages
[args
.npages
] == NULL
)
205 } while (args
.npages
< npages
);
208 dprintk("NFS call setacl\n");
210 fattr
= nfs_alloc_fattr();
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
);
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
);
228 case -EPROTONOSUPPORT
:
229 dprintk("NFS_V3_ACL SETACL RPC not supported"
230 "(will not retry)\n");
231 server
->caps
&= ~NFS_CAP_ACLS
;
233 status
= -EOPNOTSUPP
;
235 nfs_free_fattr(fattr
);
237 while (args
.npages
!= 0) {
239 __free_page(args
.pages
[args
.npages
]);
245 int nfs3_proc_setacls(struct inode
*inode
, struct posix_acl
*acl
,
246 struct posix_acl
*dfacl
)
249 ret
= __nfs3_proc_setacls(inode
, acl
, dfacl
);
250 return (ret
== -EOPNOTSUPP
) ? 0 : ret
;
254 int nfs3_set_acl(struct inode
*inode
, struct posix_acl
*acl
, int type
)
256 struct posix_acl
*orig
= acl
, *dfacl
= NULL
, *alloc
;
259 if (S_ISDIR(inode
->i_mode
)) {
261 case ACL_TYPE_ACCESS
:
262 alloc
= get_acl(inode
, ACL_TYPE_DEFAULT
);
268 case ACL_TYPE_DEFAULT
:
269 alloc
= get_acl(inode
, ACL_TYPE_ACCESS
);
279 alloc
= posix_acl_from_mode(inode
->i_mode
, GFP_KERNEL
);
284 status
= __nfs3_proc_setacls(inode
, acl
, dfacl
);
287 posix_acl_release(acl
);
289 posix_acl_release(dfacl
);
293 status
= PTR_ERR(alloc
);
297 const struct xattr_handler
*nfs3_xattr_handlers
[] = {
298 &posix_acl_access_xattr_handler
,
299 &posix_acl_default_xattr_handler
,
304 nfs3_list_one_acl(struct inode
*inode
, int type
, const char *name
, void *data
,
305 size_t size
, ssize_t
*result
)
307 struct posix_acl
*acl
;
308 char *p
= data
+ *result
;
310 acl
= get_acl(inode
, type
);
311 if (IS_ERR_OR_NULL(acl
))
314 posix_acl_release(acl
);
316 *result
+= strlen(name
);
328 nfs3_listxattr(struct dentry
*dentry
, char *data
, size_t size
)
330 struct inode
*inode
= d_inode(dentry
);
334 error
= nfs3_list_one_acl(inode
, ACL_TYPE_ACCESS
,
335 XATTR_NAME_POSIX_ACL_ACCESS
, data
, size
, &result
);
339 error
= nfs3_list_one_acl(inode
, ACL_TYPE_DEFAULT
,
340 XATTR_NAME_POSIX_ACL_DEFAULT
, data
, size
, &result
);