2 * Copyright IBM Corporation, 2010
3 * Author Aneesh Kumar K.V <aneesh.kumar@linux.vnet.ibm.com>
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.
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.
15 #include <linux/module.h>
17 #include <net/9p/9p.h>
18 #include <net/9p/client.h>
19 #include <linux/slab.h>
20 #include <linux/sched.h>
21 #include <linux/posix_acl_xattr.h>
28 static struct posix_acl
*__v9fs_get_acl(struct p9_fid
*fid
, char *name
)
32 struct posix_acl
*acl
= NULL
;
34 size
= v9fs_fid_xattr_get(fid
, name
, NULL
, 0);
36 value
= kzalloc(size
, GFP_NOFS
);
38 return ERR_PTR(-ENOMEM
);
39 size
= v9fs_fid_xattr_get(fid
, name
, value
, size
);
41 acl
= posix_acl_from_xattr(&init_user_ns
, value
, size
);
45 } else if (size
== -ENODATA
|| size
== 0 ||
46 size
== -ENOSYS
|| size
== -EOPNOTSUPP
) {
56 int v9fs_get_acl(struct inode
*inode
, struct p9_fid
*fid
)
59 struct posix_acl
*pacl
, *dacl
;
60 struct v9fs_session_info
*v9ses
;
62 v9ses
= v9fs_inode2v9ses(inode
);
63 if (((v9ses
->flags
& V9FS_ACCESS_MASK
) != V9FS_ACCESS_CLIENT
) ||
64 ((v9ses
->flags
& V9FS_ACL_MASK
) != V9FS_POSIX_ACL
)) {
65 set_cached_acl(inode
, ACL_TYPE_DEFAULT
, NULL
);
66 set_cached_acl(inode
, ACL_TYPE_ACCESS
, NULL
);
69 /* get the default/access acl values and cache them */
70 dacl
= __v9fs_get_acl(fid
, POSIX_ACL_XATTR_DEFAULT
);
71 pacl
= __v9fs_get_acl(fid
, POSIX_ACL_XATTR_ACCESS
);
73 if (!IS_ERR(dacl
) && !IS_ERR(pacl
)) {
74 set_cached_acl(inode
, ACL_TYPE_DEFAULT
, dacl
);
75 set_cached_acl(inode
, ACL_TYPE_ACCESS
, pacl
);
80 posix_acl_release(dacl
);
83 posix_acl_release(pacl
);
88 static struct posix_acl
*v9fs_get_cached_acl(struct inode
*inode
, int type
)
90 struct posix_acl
*acl
;
92 * 9p Always cache the acl value when
93 * instantiating the inode (v9fs_inode_from_fid)
95 acl
= get_cached_acl(inode
, type
);
96 BUG_ON(acl
== ACL_NOT_CACHED
);
100 struct posix_acl
*v9fs_iop_get_acl(struct inode
*inode
, int type
)
102 struct v9fs_session_info
*v9ses
;
104 v9ses
= v9fs_inode2v9ses(inode
);
105 if (((v9ses
->flags
& V9FS_ACCESS_MASK
) != V9FS_ACCESS_CLIENT
) ||
106 ((v9ses
->flags
& V9FS_ACL_MASK
) != V9FS_POSIX_ACL
)) {
108 * On access = client and acl = on mode get the acl
109 * values from the server
113 return v9fs_get_cached_acl(inode
, type
);
117 static int v9fs_set_acl(struct p9_fid
*fid
, int type
, struct posix_acl
*acl
)
126 /* Set a setxattr request to server */
127 size
= posix_acl_xattr_size(acl
->a_count
);
128 buffer
= kmalloc(size
, GFP_KERNEL
);
131 retval
= posix_acl_to_xattr(&init_user_ns
, acl
, buffer
, size
);
135 case ACL_TYPE_ACCESS
:
136 name
= POSIX_ACL_XATTR_ACCESS
;
138 case ACL_TYPE_DEFAULT
:
139 name
= POSIX_ACL_XATTR_DEFAULT
;
144 retval
= v9fs_fid_xattr_set(fid
, name
, buffer
, size
, 0);
150 int v9fs_acl_chmod(struct inode
*inode
, struct p9_fid
*fid
)
153 struct posix_acl
*acl
;
155 if (S_ISLNK(inode
->i_mode
))
157 acl
= v9fs_get_cached_acl(inode
, ACL_TYPE_ACCESS
);
159 retval
= posix_acl_chmod(&acl
, GFP_KERNEL
, inode
->i_mode
);
162 set_cached_acl(inode
, ACL_TYPE_ACCESS
, acl
);
163 retval
= v9fs_set_acl(fid
, ACL_TYPE_ACCESS
, acl
);
164 posix_acl_release(acl
);
169 int v9fs_set_create_acl(struct dentry
*dentry
,
170 struct posix_acl
*dacl
, struct posix_acl
*acl
)
172 struct p9_fid
*fid
= v9fs_fid_lookup(dentry
);
173 set_cached_acl(dentry
->d_inode
, ACL_TYPE_DEFAULT
, dacl
);
174 set_cached_acl(dentry
->d_inode
, ACL_TYPE_ACCESS
, acl
);
176 v9fs_set_acl(fid
, ACL_TYPE_DEFAULT
, dacl
);
177 v9fs_set_acl(fid
, ACL_TYPE_ACCESS
, acl
);
182 void v9fs_put_acl(struct posix_acl
*dacl
,
183 struct posix_acl
*acl
)
185 posix_acl_release(dacl
);
186 posix_acl_release(acl
);
189 int v9fs_acl_mode(struct inode
*dir
, umode_t
*modep
,
190 struct posix_acl
**dpacl
, struct posix_acl
**pacl
)
193 umode_t mode
= *modep
;
194 struct posix_acl
*acl
= NULL
;
196 if (!S_ISLNK(mode
)) {
197 acl
= v9fs_get_cached_acl(dir
, ACL_TYPE_DEFAULT
);
201 mode
&= ~current_umask();
205 *dpacl
= posix_acl_dup(acl
);
206 retval
= posix_acl_create(&acl
, GFP_NOFS
, &mode
);
212 posix_acl_release(acl
);
218 static int v9fs_remote_get_acl(struct dentry
*dentry
, const char *name
,
219 void *buffer
, size_t size
, int type
)
224 case ACL_TYPE_ACCESS
:
225 full_name
= POSIX_ACL_XATTR_ACCESS
;
227 case ACL_TYPE_DEFAULT
:
228 full_name
= POSIX_ACL_XATTR_DEFAULT
;
233 return v9fs_xattr_get(dentry
, full_name
, buffer
, size
);
236 static int v9fs_xattr_get_acl(struct dentry
*dentry
, const char *name
,
237 void *buffer
, size_t size
, int type
)
239 struct v9fs_session_info
*v9ses
;
240 struct posix_acl
*acl
;
243 if (strcmp(name
, "") != 0)
246 v9ses
= v9fs_dentry2v9ses(dentry
);
248 * We allow set/get/list of acl when access=client is not specified
250 if ((v9ses
->flags
& V9FS_ACCESS_MASK
) != V9FS_ACCESS_CLIENT
)
251 return v9fs_remote_get_acl(dentry
, name
, buffer
, size
, type
);
253 acl
= v9fs_get_cached_acl(dentry
->d_inode
, type
);
258 error
= posix_acl_to_xattr(&init_user_ns
, acl
, buffer
, size
);
259 posix_acl_release(acl
);
264 static int v9fs_remote_set_acl(struct dentry
*dentry
, const char *name
,
265 const void *value
, size_t size
,
271 case ACL_TYPE_ACCESS
:
272 full_name
= POSIX_ACL_XATTR_ACCESS
;
274 case ACL_TYPE_DEFAULT
:
275 full_name
= POSIX_ACL_XATTR_DEFAULT
;
280 return v9fs_xattr_set(dentry
, full_name
, value
, size
, flags
);
284 static int v9fs_xattr_set_acl(struct dentry
*dentry
, const char *name
,
285 const void *value
, size_t size
,
289 struct posix_acl
*acl
;
290 struct v9fs_session_info
*v9ses
;
291 struct inode
*inode
= dentry
->d_inode
;
293 if (strcmp(name
, "") != 0)
296 v9ses
= v9fs_dentry2v9ses(dentry
);
298 * set the attribute on the remote. Without even looking at the
299 * xattr value. We leave it to the server to validate
301 if ((v9ses
->flags
& V9FS_ACCESS_MASK
) != V9FS_ACCESS_CLIENT
)
302 return v9fs_remote_set_acl(dentry
, name
,
303 value
, size
, flags
, type
);
305 if (S_ISLNK(inode
->i_mode
))
307 if (!inode_owner_or_capable(inode
))
310 /* update the cached acl value */
311 acl
= posix_acl_from_xattr(&init_user_ns
, value
, size
);
315 retval
= posix_acl_valid(acl
);
323 case ACL_TYPE_ACCESS
:
324 name
= POSIX_ACL_XATTR_ACCESS
;
326 umode_t mode
= inode
->i_mode
;
327 retval
= posix_acl_equiv_mode(acl
, &mode
);
334 * ACL can be represented
335 * by the mode bits. So don't
342 /* Updte the mode bits */
343 iattr
.ia_mode
= ((mode
& S_IALLUGO
) |
344 (inode
->i_mode
& ~S_IALLUGO
));
345 iattr
.ia_valid
= ATTR_MODE
;
346 /* FIXME should we update ctime ?
347 * What is the following setxattr update the
350 v9fs_vfs_setattr_dotl(dentry
, &iattr
);
354 case ACL_TYPE_DEFAULT
:
355 name
= POSIX_ACL_XATTR_DEFAULT
;
356 if (!S_ISDIR(inode
->i_mode
)) {
357 retval
= acl
? -EINVAL
: 0;
364 retval
= v9fs_xattr_set(dentry
, name
, value
, size
, flags
);
366 set_cached_acl(inode
, type
, acl
);
368 posix_acl_release(acl
);
372 const struct xattr_handler v9fs_xattr_acl_access_handler
= {
373 .prefix
= POSIX_ACL_XATTR_ACCESS
,
374 .flags
= ACL_TYPE_ACCESS
,
375 .get
= v9fs_xattr_get_acl
,
376 .set
= v9fs_xattr_set_acl
,
379 const struct xattr_handler v9fs_xattr_acl_default_handler
= {
380 .prefix
= POSIX_ACL_XATTR_DEFAULT
,
381 .flags
= ACL_TYPE_DEFAULT
,
382 .get
= v9fs_xattr_get_acl
,
383 .set
= v9fs_xattr_set_acl
,