2 #include <linux/posix_acl.h>
3 #include <linux/reiserfs_fs.h>
4 #include <linux/errno.h>
5 #include <linux/pagemap.h>
6 #include <linux/xattr.h>
7 #include <linux/posix_acl_xattr.h>
8 #include <linux/reiserfs_xattr.h>
9 #include <linux/reiserfs_acl.h>
10 #include <asm/uaccess.h>
12 static int reiserfs_set_acl(struct inode
*inode
, int type
,
13 struct posix_acl
*acl
);
16 xattr_set_acl(struct inode
*inode
, int type
, const void *value
, size_t size
)
18 struct posix_acl
*acl
;
21 if (!reiserfs_posixacl(inode
->i_sb
))
23 if ((current
->fsuid
!= inode
->i_uid
) && !capable(CAP_FOWNER
))
27 acl
= posix_acl_from_xattr(value
, size
);
31 error
= posix_acl_valid(acl
);
38 error
= reiserfs_set_acl(inode
, type
, acl
);
41 posix_acl_release(acl
);
46 xattr_get_acl(struct inode
*inode
, int type
, void *buffer
, size_t size
)
48 struct posix_acl
*acl
;
51 if (!reiserfs_posixacl(inode
->i_sb
))
54 acl
= reiserfs_get_acl(inode
, type
);
59 error
= posix_acl_to_xattr(acl
, buffer
, size
);
60 posix_acl_release(acl
);
66 * Convert from filesystem to in-memory representation.
68 static struct posix_acl
*posix_acl_from_disk(const void *value
, size_t size
)
70 const char *end
= (char *)value
+ size
;
72 struct posix_acl
*acl
;
76 if (size
< sizeof(reiserfs_acl_header
))
77 return ERR_PTR(-EINVAL
);
78 if (((reiserfs_acl_header
*) value
)->a_version
!=
79 cpu_to_le32(REISERFS_ACL_VERSION
))
80 return ERR_PTR(-EINVAL
);
81 value
= (char *)value
+ sizeof(reiserfs_acl_header
);
82 count
= reiserfs_acl_count(size
);
84 return ERR_PTR(-EINVAL
);
87 acl
= posix_acl_alloc(count
, GFP_NOFS
);
89 return ERR_PTR(-ENOMEM
);
90 for (n
= 0; n
< count
; n
++) {
91 reiserfs_acl_entry
*entry
= (reiserfs_acl_entry
*) value
;
92 if ((char *)value
+ sizeof(reiserfs_acl_entry_short
) > end
)
94 acl
->a_entries
[n
].e_tag
= le16_to_cpu(entry
->e_tag
);
95 acl
->a_entries
[n
].e_perm
= le16_to_cpu(entry
->e_perm
);
96 switch (acl
->a_entries
[n
].e_tag
) {
101 value
= (char *)value
+
102 sizeof(reiserfs_acl_entry_short
);
103 acl
->a_entries
[n
].e_id
= ACL_UNDEFINED_ID
;
108 value
= (char *)value
+ sizeof(reiserfs_acl_entry
);
109 if ((char *)value
> end
)
111 acl
->a_entries
[n
].e_id
= le32_to_cpu(entry
->e_id
);
123 posix_acl_release(acl
);
124 return ERR_PTR(-EINVAL
);
128 * Convert from in-memory to filesystem representation.
130 static void *posix_acl_to_disk(const struct posix_acl
*acl
, size_t * size
)
132 reiserfs_acl_header
*ext_acl
;
136 *size
= reiserfs_acl_size(acl
->a_count
);
137 ext_acl
= (reiserfs_acl_header
*) kmalloc(sizeof(reiserfs_acl_header
) +
139 sizeof(reiserfs_acl_entry
),
142 return ERR_PTR(-ENOMEM
);
143 ext_acl
->a_version
= cpu_to_le32(REISERFS_ACL_VERSION
);
144 e
= (char *)ext_acl
+ sizeof(reiserfs_acl_header
);
145 for (n
= 0; n
< acl
->a_count
; n
++) {
146 reiserfs_acl_entry
*entry
= (reiserfs_acl_entry
*) e
;
147 entry
->e_tag
= cpu_to_le16(acl
->a_entries
[n
].e_tag
);
148 entry
->e_perm
= cpu_to_le16(acl
->a_entries
[n
].e_perm
);
149 switch (acl
->a_entries
[n
].e_tag
) {
152 entry
->e_id
= cpu_to_le32(acl
->a_entries
[n
].e_id
);
153 e
+= sizeof(reiserfs_acl_entry
);
160 e
+= sizeof(reiserfs_acl_entry_short
);
167 return (char *)ext_acl
;
171 return ERR_PTR(-EINVAL
);
175 * Inode operation get_posix_acl().
178 * BKL held [before 2.5.x]
180 struct posix_acl
*reiserfs_get_acl(struct inode
*inode
, int type
)
183 struct posix_acl
*acl
, **p_acl
;
186 struct reiserfs_inode_info
*reiserfs_i
= REISERFS_I(inode
);
189 case ACL_TYPE_ACCESS
:
190 name
= POSIX_ACL_XATTR_ACCESS
;
191 p_acl
= &reiserfs_i
->i_acl_access
;
193 case ACL_TYPE_DEFAULT
:
194 name
= POSIX_ACL_XATTR_DEFAULT
;
195 p_acl
= &reiserfs_i
->i_acl_default
;
198 return ERR_PTR(-EINVAL
);
201 if (IS_ERR(*p_acl
)) {
202 if (PTR_ERR(*p_acl
) == -ENODATA
)
204 } else if (*p_acl
!= NULL
)
205 return posix_acl_dup(*p_acl
);
207 size
= reiserfs_xattr_get(inode
, name
, NULL
, 0);
209 if (size
== -ENODATA
|| size
== -ENOSYS
) {
210 *p_acl
= ERR_PTR(-ENODATA
);
213 return ERR_PTR(size
);
216 value
= kmalloc(size
, GFP_NOFS
);
218 return ERR_PTR(-ENOMEM
);
220 retval
= reiserfs_xattr_get(inode
, name
, value
, size
);
221 if (retval
== -ENODATA
|| retval
== -ENOSYS
) {
222 /* This shouldn't actually happen as it should have
223 been caught above.. but just in case */
225 *p_acl
= ERR_PTR(-ENODATA
);
226 } else if (retval
< 0) {
227 acl
= ERR_PTR(retval
);
229 acl
= posix_acl_from_disk(value
, retval
);
230 *p_acl
= posix_acl_dup(acl
);
238 * Inode operation set_posix_acl().
241 * BKL held [before 2.5.x]
244 reiserfs_set_acl(struct inode
*inode
, int type
, struct posix_acl
*acl
)
248 struct posix_acl
**p_acl
;
251 struct reiserfs_inode_info
*reiserfs_i
= REISERFS_I(inode
);
253 if (S_ISLNK(inode
->i_mode
))
257 case ACL_TYPE_ACCESS
:
258 name
= POSIX_ACL_XATTR_ACCESS
;
259 p_acl
= &reiserfs_i
->i_acl_access
;
261 mode_t mode
= inode
->i_mode
;
262 error
= posix_acl_equiv_mode(acl
, &mode
);
266 inode
->i_mode
= mode
;
272 case ACL_TYPE_DEFAULT
:
273 name
= POSIX_ACL_XATTR_DEFAULT
;
274 p_acl
= &reiserfs_i
->i_acl_default
;
275 if (!S_ISDIR(inode
->i_mode
))
276 return acl
? -EACCES
: 0;
283 value
= posix_acl_to_disk(acl
, &size
);
285 return (int)PTR_ERR(value
);
286 error
= reiserfs_xattr_set(inode
, name
, value
, size
, 0);
288 error
= reiserfs_xattr_del(inode
, name
);
289 if (error
== -ENODATA
) {
290 /* This may seem odd here, but it means that the ACL was set
291 * with a value representable with mode bits. If there was
292 * an ACL before, reiserfs_xattr_del already dirtied the inode.
294 mark_inode_dirty(inode
);
303 /* Release the old one */
304 if (!IS_ERR(*p_acl
) && *p_acl
)
305 posix_acl_release(*p_acl
);
308 *p_acl
= ERR_PTR(-ENODATA
);
310 *p_acl
= posix_acl_dup(acl
);
317 * inode is new and not released into the wild yet */
319 reiserfs_inherit_default_acl(struct inode
*dir
, struct dentry
*dentry
,
322 struct posix_acl
*acl
;
325 /* ACLs only get applied to files and directories */
326 if (S_ISLNK(inode
->i_mode
))
329 /* ACLs can only be used on "new" objects, so if it's an old object
330 * there is nothing to inherit from */
331 if (get_inode_sd_version(dir
) == STAT_DATA_V1
)
334 /* Don't apply ACLs to objects in the .reiserfs_priv tree.. This
335 * would be useless since permissions are ignored, and a pain because
336 * it introduces locking cycles */
337 if (is_reiserfs_priv_object(dir
)) {
338 reiserfs_mark_inode_private(inode
);
342 acl
= reiserfs_get_acl(dir
, ACL_TYPE_DEFAULT
);
344 if (PTR_ERR(acl
) == -ENODATA
)
350 struct posix_acl
*acl_copy
;
351 mode_t mode
= inode
->i_mode
;
354 /* Copy the default ACL to the default ACL of a new directory */
355 if (S_ISDIR(inode
->i_mode
)) {
356 err
= reiserfs_set_acl(inode
, ACL_TYPE_DEFAULT
, acl
);
361 /* Now we reconcile the new ACL and the mode,
362 potentially modifying both */
363 acl_copy
= posix_acl_clone(acl
, GFP_NOFS
);
369 need_acl
= posix_acl_create_masq(acl_copy
, &mode
);
371 if (mode
!= inode
->i_mode
) {
372 inode
->i_mode
= mode
;
375 /* If we need an ACL.. */
378 reiserfs_set_acl(inode
, ACL_TYPE_ACCESS
,
385 posix_acl_release(acl_copy
);
387 posix_acl_release(acl
);
390 /* no ACL, apply umask */
391 inode
->i_mode
&= ~current
->fs
->umask
;
397 /* Looks up and caches the result of the default ACL.
398 * We do this so that we don't need to carry the xattr_sem into
399 * reiserfs_new_inode if we don't need to */
400 int reiserfs_cache_default_acl(struct inode
*inode
)
403 if (reiserfs_posixacl(inode
->i_sb
) && !is_reiserfs_priv_object(inode
)) {
404 struct posix_acl
*acl
;
405 reiserfs_read_lock_xattr_i(inode
);
406 reiserfs_read_lock_xattrs(inode
->i_sb
);
407 acl
= reiserfs_get_acl(inode
, ACL_TYPE_DEFAULT
);
408 reiserfs_read_unlock_xattrs(inode
->i_sb
);
409 reiserfs_read_unlock_xattr_i(inode
);
411 posix_acl_release(acl
);
417 int reiserfs_acl_chmod(struct inode
*inode
)
419 struct posix_acl
*acl
, *clone
;
422 if (S_ISLNK(inode
->i_mode
))
425 if (get_inode_sd_version(inode
) == STAT_DATA_V1
||
426 !reiserfs_posixacl(inode
->i_sb
)) {
430 reiserfs_read_lock_xattrs(inode
->i_sb
);
431 acl
= reiserfs_get_acl(inode
, ACL_TYPE_ACCESS
);
432 reiserfs_read_unlock_xattrs(inode
->i_sb
);
437 clone
= posix_acl_clone(acl
, GFP_NOFS
);
438 posix_acl_release(acl
);
441 error
= posix_acl_chmod_masq(clone
, inode
->i_mode
);
443 int lock
= !has_xattr_dir(inode
);
444 reiserfs_write_lock_xattr_i(inode
);
446 reiserfs_write_lock_xattrs(inode
->i_sb
);
448 reiserfs_read_lock_xattrs(inode
->i_sb
);
449 error
= reiserfs_set_acl(inode
, ACL_TYPE_ACCESS
, clone
);
451 reiserfs_write_unlock_xattrs(inode
->i_sb
);
453 reiserfs_read_unlock_xattrs(inode
->i_sb
);
454 reiserfs_write_unlock_xattr_i(inode
);
456 posix_acl_release(clone
);
461 posix_acl_access_get(struct inode
*inode
, const char *name
,
462 void *buffer
, size_t size
)
464 if (strlen(name
) != sizeof(POSIX_ACL_XATTR_ACCESS
) - 1)
466 return xattr_get_acl(inode
, ACL_TYPE_ACCESS
, buffer
, size
);
470 posix_acl_access_set(struct inode
*inode
, const char *name
,
471 const void *value
, size_t size
, int flags
)
473 if (strlen(name
) != sizeof(POSIX_ACL_XATTR_ACCESS
) - 1)
475 return xattr_set_acl(inode
, ACL_TYPE_ACCESS
, value
, size
);
478 static int posix_acl_access_del(struct inode
*inode
, const char *name
)
480 struct reiserfs_inode_info
*reiserfs_i
= REISERFS_I(inode
);
481 struct posix_acl
**acl
= &reiserfs_i
->i_acl_access
;
482 if (strlen(name
) != sizeof(POSIX_ACL_XATTR_ACCESS
) - 1)
484 if (!IS_ERR(*acl
) && *acl
) {
485 posix_acl_release(*acl
);
486 *acl
= ERR_PTR(-ENODATA
);
493 posix_acl_access_list(struct inode
*inode
, const char *name
, int namelen
,
497 if (!reiserfs_posixacl(inode
->i_sb
))
500 memcpy(out
, name
, len
);
505 struct reiserfs_xattr_handler posix_acl_access_handler
= {
506 .prefix
= POSIX_ACL_XATTR_ACCESS
,
507 .get
= posix_acl_access_get
,
508 .set
= posix_acl_access_set
,
509 .del
= posix_acl_access_del
,
510 .list
= posix_acl_access_list
,
514 posix_acl_default_get(struct inode
*inode
, const char *name
,
515 void *buffer
, size_t size
)
517 if (strlen(name
) != sizeof(POSIX_ACL_XATTR_DEFAULT
) - 1)
519 return xattr_get_acl(inode
, ACL_TYPE_DEFAULT
, buffer
, size
);
523 posix_acl_default_set(struct inode
*inode
, const char *name
,
524 const void *value
, size_t size
, int flags
)
526 if (strlen(name
) != sizeof(POSIX_ACL_XATTR_DEFAULT
) - 1)
528 return xattr_set_acl(inode
, ACL_TYPE_DEFAULT
, value
, size
);
531 static int posix_acl_default_del(struct inode
*inode
, const char *name
)
533 struct reiserfs_inode_info
*reiserfs_i
= REISERFS_I(inode
);
534 struct posix_acl
**acl
= &reiserfs_i
->i_acl_default
;
535 if (strlen(name
) != sizeof(POSIX_ACL_XATTR_DEFAULT
) - 1)
537 if (!IS_ERR(*acl
) && *acl
) {
538 posix_acl_release(*acl
);
539 *acl
= ERR_PTR(-ENODATA
);
546 posix_acl_default_list(struct inode
*inode
, const char *name
, int namelen
,
550 if (!reiserfs_posixacl(inode
->i_sb
))
553 memcpy(out
, name
, len
);
558 struct reiserfs_xattr_handler posix_acl_default_handler
= {
559 .prefix
= POSIX_ACL_XATTR_DEFAULT
,
560 .get
= posix_acl_default_get
,
561 .set
= posix_acl_default_set
,
562 .del
= posix_acl_default_del
,
563 .list
= posix_acl_default_list
,