blob: 02a2cf61631836d4f810d22a0626e72a79b8d0ab [file] [log] [blame]
Aneesh Kumar K.V85ff8722010-09-28 00:27:39 +05301/*
2 * Copyright IBM Corporation, 2010
3 * Author Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of version 2.1 of the GNU Lesser General Public License
7 * as published by the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it would be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
12 *
13 */
14
15#include <linux/module.h>
16#include <linux/fs.h>
17#include <net/9p/9p.h>
18#include <net/9p/client.h>
19#include <linux/slab.h>
Aneesh Kumar K.V22d8dcd2010-09-28 00:27:40 +053020#include <linux/sched.h>
Aneesh Kumar K.V85ff8722010-09-28 00:27:39 +053021#include <linux/posix_acl_xattr.h>
22#include "xattr.h"
23#include "acl.h"
Aneesh Kumar K.V22d8dcd2010-09-28 00:27:40 +053024#include "v9fs_vfs.h"
Aneesh Kumar K.V76381a42010-09-28 00:27:41 +053025#include "v9fs.h"
Aneesh Kumar K.V85ff8722010-09-28 00:27:39 +053026
27static struct posix_acl *__v9fs_get_acl(struct p9_fid *fid, char *name)
28{
29 ssize_t size;
30 void *value = NULL;
Joe Perches009ca382010-11-15 03:04:51 +000031 struct posix_acl *acl = NULL;
Aneesh Kumar K.V85ff8722010-09-28 00:27:39 +053032
33 size = v9fs_fid_xattr_get(fid, name, NULL, 0);
34 if (size > 0) {
35 value = kzalloc(size, GFP_NOFS);
36 if (!value)
37 return ERR_PTR(-ENOMEM);
38 size = v9fs_fid_xattr_get(fid, name, value, size);
39 if (size > 0) {
40 acl = posix_acl_from_xattr(value, size);
41 if (IS_ERR(acl))
42 goto err_out;
43 }
44 } else if (size == -ENODATA || size == 0 ||
45 size == -ENOSYS || size == -EOPNOTSUPP) {
46 acl = NULL;
47 } else
48 acl = ERR_PTR(-EIO);
49
50err_out:
51 kfree(value);
52 return acl;
53}
54
55int v9fs_get_acl(struct inode *inode, struct p9_fid *fid)
56{
57 int retval = 0;
58 struct posix_acl *pacl, *dacl;
Aneesh Kumar K.V76381a42010-09-28 00:27:41 +053059 struct v9fs_session_info *v9ses;
Aneesh Kumar K.V85ff8722010-09-28 00:27:39 +053060
Aneesh Kumar K.V76381a42010-09-28 00:27:41 +053061 v9ses = v9fs_inode2v9ses(inode);
62 if ((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT) {
63 set_cached_acl(inode, ACL_TYPE_DEFAULT, NULL);
64 set_cached_acl(inode, ACL_TYPE_ACCESS, NULL);
65 return 0;
66 }
Aneesh Kumar K.V85ff8722010-09-28 00:27:39 +053067 /* get the default/access acl values and cache them */
68 dacl = __v9fs_get_acl(fid, POSIX_ACL_XATTR_DEFAULT);
69 pacl = __v9fs_get_acl(fid, POSIX_ACL_XATTR_ACCESS);
70
71 if (!IS_ERR(dacl) && !IS_ERR(pacl)) {
72 set_cached_acl(inode, ACL_TYPE_DEFAULT, dacl);
73 set_cached_acl(inode, ACL_TYPE_ACCESS, pacl);
74 posix_acl_release(dacl);
75 posix_acl_release(pacl);
76 } else
77 retval = -EIO;
78
79 return retval;
80}
81
82static struct posix_acl *v9fs_get_cached_acl(struct inode *inode, int type)
83{
84 struct posix_acl *acl;
85 /*
86 * 9p Always cache the acl value when
87 * instantiating the inode (v9fs_inode_from_fid)
88 */
89 acl = get_cached_acl(inode, type);
90 BUG_ON(acl == ACL_NOT_CACHED);
91 return acl;
92}
93
Nick Pigginb74c79e2011-01-07 17:49:58 +110094int v9fs_check_acl(struct inode *inode, int mask, unsigned int flags)
Aneesh Kumar K.V85ff8722010-09-28 00:27:39 +053095{
Aneesh Kumar K.V76381a42010-09-28 00:27:41 +053096 struct posix_acl *acl;
97 struct v9fs_session_info *v9ses;
98
Nick Pigginb74c79e2011-01-07 17:49:58 +110099 if (flags & IPERM_FLAG_RCU)
100 return -ECHILD;
101
Aneesh Kumar K.V76381a42010-09-28 00:27:41 +0530102 v9ses = v9fs_inode2v9ses(inode);
103 if ((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT) {
104 /*
105 * On access = client mode get the acl
106 * values from the server
107 */
108 return 0;
109 }
110 acl = v9fs_get_cached_acl(inode, ACL_TYPE_ACCESS);
Aneesh Kumar K.V85ff8722010-09-28 00:27:39 +0530111
112 if (IS_ERR(acl))
113 return PTR_ERR(acl);
114 if (acl) {
115 int error = posix_acl_permission(inode, acl, mask);
116 posix_acl_release(acl);
117 return error;
118 }
119 return -EAGAIN;
120}
Aneesh Kumar K.V7a4566b2010-09-28 00:27:39 +0530121
Aneesh Kumar K.V6e8dc552010-09-28 00:27:40 +0530122static int v9fs_set_acl(struct dentry *dentry, int type, struct posix_acl *acl)
123{
124 int retval;
125 char *name;
126 size_t size;
127 void *buffer;
128 struct inode *inode = dentry->d_inode;
129
130 set_cached_acl(inode, type, acl);
131 /* Set a setxattr request to server */
132 size = posix_acl_xattr_size(acl->a_count);
133 buffer = kmalloc(size, GFP_KERNEL);
134 if (!buffer)
135 return -ENOMEM;
136 retval = posix_acl_to_xattr(acl, buffer, size);
137 if (retval < 0)
138 goto err_free_out;
139 switch (type) {
140 case ACL_TYPE_ACCESS:
141 name = POSIX_ACL_XATTR_ACCESS;
142 break;
143 case ACL_TYPE_DEFAULT:
144 name = POSIX_ACL_XATTR_DEFAULT;
145 break;
146 default:
147 BUG();
148 }
149 retval = v9fs_xattr_set(dentry, name, buffer, size, 0);
150err_free_out:
151 kfree(buffer);
152 return retval;
153}
154
155int v9fs_acl_chmod(struct dentry *dentry)
156{
157 int retval = 0;
158 struct posix_acl *acl, *clone;
159 struct inode *inode = dentry->d_inode;
160
161 if (S_ISLNK(inode->i_mode))
162 return -EOPNOTSUPP;
163 acl = v9fs_get_cached_acl(inode, ACL_TYPE_ACCESS);
164 if (acl) {
165 clone = posix_acl_clone(acl, GFP_KERNEL);
166 posix_acl_release(acl);
167 if (!clone)
168 return -ENOMEM;
169 retval = posix_acl_chmod_masq(clone, inode->i_mode);
170 if (!retval)
171 retval = v9fs_set_acl(dentry, ACL_TYPE_ACCESS, clone);
172 posix_acl_release(clone);
173 }
174 return retval;
175}
176
Aneesh Kumar K.Vad77dbc2010-09-28 00:27:40 +0530177int v9fs_set_create_acl(struct dentry *dentry,
178 struct posix_acl *dpacl, struct posix_acl *pacl)
179{
180 if (dpacl)
181 v9fs_set_acl(dentry, ACL_TYPE_DEFAULT, dpacl);
182 if (pacl)
183 v9fs_set_acl(dentry, ACL_TYPE_ACCESS, pacl);
184 posix_acl_release(dpacl);
185 posix_acl_release(pacl);
186 return 0;
187}
188
189int v9fs_acl_mode(struct inode *dir, mode_t *modep,
190 struct posix_acl **dpacl, struct posix_acl **pacl)
191{
192 int retval = 0;
193 mode_t mode = *modep;
194 struct posix_acl *acl = NULL;
195
196 if (!S_ISLNK(mode)) {
197 acl = v9fs_get_cached_acl(dir, ACL_TYPE_DEFAULT);
198 if (IS_ERR(acl))
199 return PTR_ERR(acl);
200 if (!acl)
201 mode &= ~current_umask();
202 }
203 if (acl) {
204 struct posix_acl *clone;
205
206 if (S_ISDIR(mode))
207 *dpacl = acl;
208 clone = posix_acl_clone(acl, GFP_NOFS);
209 retval = -ENOMEM;
210 if (!clone)
211 goto cleanup;
212
213 retval = posix_acl_create_masq(clone, &mode);
214 if (retval < 0) {
215 posix_acl_release(clone);
216 goto cleanup;
217 }
218 if (retval > 0)
219 *pacl = clone;
220 }
221 *modep = mode;
222 return 0;
223cleanup:
224 posix_acl_release(acl);
225 return retval;
226
227}
228
Aneesh Kumar K.V76381a42010-09-28 00:27:41 +0530229static int v9fs_remote_get_acl(struct dentry *dentry, const char *name,
230 void *buffer, size_t size, int type)
231{
232 char *full_name;
233
234 switch (type) {
235 case ACL_TYPE_ACCESS:
236 full_name = POSIX_ACL_XATTR_ACCESS;
237 break;
238 case ACL_TYPE_DEFAULT:
239 full_name = POSIX_ACL_XATTR_DEFAULT;
240 break;
241 default:
242 BUG();
243 }
244 return v9fs_xattr_get(dentry, full_name, buffer, size);
245}
246
Aneesh Kumar K.V7a4566b2010-09-28 00:27:39 +0530247static int v9fs_xattr_get_acl(struct dentry *dentry, const char *name,
248 void *buffer, size_t size, int type)
249{
Aneesh Kumar K.V76381a42010-09-28 00:27:41 +0530250 struct v9fs_session_info *v9ses;
Aneesh Kumar K.V7a4566b2010-09-28 00:27:39 +0530251 struct posix_acl *acl;
252 int error;
253
254 if (strcmp(name, "") != 0)
255 return -EINVAL;
256
Aneesh Kumar K.V76381a42010-09-28 00:27:41 +0530257 v9ses = v9fs_inode2v9ses(dentry->d_inode);
258 /*
259 * We allow set/get/list of acl when access=client is not specified
260 */
261 if ((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT)
262 return v9fs_remote_get_acl(dentry, name, buffer, size, type);
263
Aneesh Kumar K.V7a4566b2010-09-28 00:27:39 +0530264 acl = v9fs_get_cached_acl(dentry->d_inode, type);
265 if (IS_ERR(acl))
266 return PTR_ERR(acl);
267 if (acl == NULL)
268 return -ENODATA;
269 error = posix_acl_to_xattr(acl, buffer, size);
270 posix_acl_release(acl);
271
272 return error;
273}
274
Aneesh Kumar K.V76381a42010-09-28 00:27:41 +0530275static int v9fs_remote_set_acl(struct dentry *dentry, const char *name,
276 const void *value, size_t size,
277 int flags, int type)
278{
279 char *full_name;
280
281 switch (type) {
282 case ACL_TYPE_ACCESS:
283 full_name = POSIX_ACL_XATTR_ACCESS;
284 break;
285 case ACL_TYPE_DEFAULT:
286 full_name = POSIX_ACL_XATTR_DEFAULT;
287 break;
288 default:
289 BUG();
290 }
291 return v9fs_xattr_set(dentry, full_name, value, size, flags);
292}
293
294
Aneesh Kumar K.V7a4566b2010-09-28 00:27:39 +0530295static int v9fs_xattr_set_acl(struct dentry *dentry, const char *name,
296 const void *value, size_t size,
297 int flags, int type)
298{
Aneesh Kumar K.V22d8dcd2010-09-28 00:27:40 +0530299 int retval;
300 struct posix_acl *acl;
Aneesh Kumar K.V76381a42010-09-28 00:27:41 +0530301 struct v9fs_session_info *v9ses;
Aneesh Kumar K.V22d8dcd2010-09-28 00:27:40 +0530302 struct inode *inode = dentry->d_inode;
303
304 if (strcmp(name, "") != 0)
305 return -EINVAL;
Aneesh Kumar K.V76381a42010-09-28 00:27:41 +0530306
307 v9ses = v9fs_inode2v9ses(dentry->d_inode);
308 /*
309 * set the attribute on the remote. Without even looking at the
310 * xattr value. We leave it to the server to validate
311 */
312 if ((v9ses->flags & V9FS_ACCESS_MASK) != V9FS_ACCESS_CLIENT)
313 return v9fs_remote_set_acl(dentry, name,
314 value, size, flags, type);
315
Aneesh Kumar K.V22d8dcd2010-09-28 00:27:40 +0530316 if (S_ISLNK(inode->i_mode))
317 return -EOPNOTSUPP;
318 if (!is_owner_or_cap(inode))
319 return -EPERM;
320 if (value) {
321 /* update the cached acl value */
322 acl = posix_acl_from_xattr(value, size);
323 if (IS_ERR(acl))
324 return PTR_ERR(acl);
325 else if (acl) {
326 retval = posix_acl_valid(acl);
327 if (retval)
328 goto err_out;
329 }
330 } else
331 acl = NULL;
332
333 switch (type) {
334 case ACL_TYPE_ACCESS:
335 name = POSIX_ACL_XATTR_ACCESS;
336 if (acl) {
337 mode_t mode = inode->i_mode;
338 retval = posix_acl_equiv_mode(acl, &mode);
339 if (retval < 0)
340 goto err_out;
341 else {
342 struct iattr iattr;
343 if (retval == 0) {
344 /*
345 * ACL can be represented
346 * by the mode bits. So don't
347 * update ACL.
348 */
349 acl = NULL;
350 value = NULL;
351 size = 0;
352 }
353 /* Updte the mode bits */
354 iattr.ia_mode = ((mode & S_IALLUGO) |
355 (inode->i_mode & ~S_IALLUGO));
356 iattr.ia_valid = ATTR_MODE;
357 /* FIXME should we update ctime ?
358 * What is the following setxattr update the
359 * mode ?
360 */
361 v9fs_vfs_setattr_dotl(dentry, &iattr);
362 }
363 }
364 break;
365 case ACL_TYPE_DEFAULT:
366 name = POSIX_ACL_XATTR_DEFAULT;
367 if (!S_ISDIR(inode->i_mode)) {
Aneesh Kumar K.V6f81c112010-12-10 12:19:31 +0530368 retval = acl ? -EINVAL : 0;
Aneesh Kumar K.V22d8dcd2010-09-28 00:27:40 +0530369 goto err_out;
370 }
371 break;
372 default:
373 BUG();
374 }
375 retval = v9fs_xattr_set(dentry, name, value, size, flags);
376 if (!retval)
377 set_cached_acl(inode, type, acl);
378err_out:
379 posix_acl_release(acl);
380 return retval;
Aneesh Kumar K.V7a4566b2010-09-28 00:27:39 +0530381}
382
383const struct xattr_handler v9fs_xattr_acl_access_handler = {
384 .prefix = POSIX_ACL_XATTR_ACCESS,
385 .flags = ACL_TYPE_ACCESS,
386 .get = v9fs_xattr_get_acl,
387 .set = v9fs_xattr_set_acl,
388};
389
390const struct xattr_handler v9fs_xattr_acl_default_handler = {
391 .prefix = POSIX_ACL_XATTR_DEFAULT,
392 .flags = ACL_TYPE_DEFAULT,
393 .get = v9fs_xattr_get_acl,
394 .set = v9fs_xattr_set_acl,
395};