4 * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
7 #include <linux/init.h>
8 #include <linux/sched.h>
9 #include <linux/slab.h>
16 * Convert from filesystem to in-memory representation.
18 static struct posix_acl
*
19 ext2_acl_from_disk(const void *value
, size_t size
)
21 const char *end
= (char *)value
+ size
;
23 struct posix_acl
*acl
;
27 if (size
< sizeof(ext2_acl_header
))
28 return ERR_PTR(-EINVAL
);
29 if (((ext2_acl_header
*)value
)->a_version
!=
30 cpu_to_le32(EXT2_ACL_VERSION
))
31 return ERR_PTR(-EINVAL
);
32 value
= (char *)value
+ sizeof(ext2_acl_header
);
33 count
= ext2_acl_count(size
);
35 return ERR_PTR(-EINVAL
);
38 acl
= posix_acl_alloc(count
, GFP_KERNEL
);
40 return ERR_PTR(-ENOMEM
);
41 for (n
=0; n
< count
; n
++) {
42 ext2_acl_entry
*entry
=
43 (ext2_acl_entry
*)value
;
44 if ((char *)value
+ sizeof(ext2_acl_entry_short
) > end
)
46 acl
->a_entries
[n
].e_tag
= le16_to_cpu(entry
->e_tag
);
47 acl
->a_entries
[n
].e_perm
= le16_to_cpu(entry
->e_perm
);
48 switch(acl
->a_entries
[n
].e_tag
) {
53 value
= (char *)value
+
54 sizeof(ext2_acl_entry_short
);
55 acl
->a_entries
[n
].e_id
= ACL_UNDEFINED_ID
;
60 value
= (char *)value
+ sizeof(ext2_acl_entry
);
61 if ((char *)value
> end
)
63 acl
->a_entries
[n
].e_id
=
64 le32_to_cpu(entry
->e_id
);
76 posix_acl_release(acl
);
77 return ERR_PTR(-EINVAL
);
81 * Convert from in-memory to filesystem representation.
84 ext2_acl_to_disk(const struct posix_acl
*acl
, size_t *size
)
86 ext2_acl_header
*ext_acl
;
90 *size
= ext2_acl_size(acl
->a_count
);
91 ext_acl
= (ext2_acl_header
*)kmalloc(sizeof(ext2_acl_header
) +
92 acl
->a_count
* sizeof(ext2_acl_entry
), GFP_KERNEL
);
94 return ERR_PTR(-ENOMEM
);
95 ext_acl
->a_version
= cpu_to_le32(EXT2_ACL_VERSION
);
96 e
= (char *)ext_acl
+ sizeof(ext2_acl_header
);
97 for (n
=0; n
< acl
->a_count
; n
++) {
98 ext2_acl_entry
*entry
= (ext2_acl_entry
*)e
;
99 entry
->e_tag
= cpu_to_le16(acl
->a_entries
[n
].e_tag
);
100 entry
->e_perm
= cpu_to_le16(acl
->a_entries
[n
].e_perm
);
101 switch(acl
->a_entries
[n
].e_tag
) {
105 cpu_to_le32(acl
->a_entries
[n
].e_id
);
106 e
+= sizeof(ext2_acl_entry
);
113 e
+= sizeof(ext2_acl_entry_short
);
120 return (char *)ext_acl
;
124 return ERR_PTR(-EINVAL
);
127 static inline struct posix_acl
*
128 ext2_iget_acl(struct inode
*inode
, struct posix_acl
**i_acl
)
130 struct posix_acl
*acl
= EXT2_ACL_NOT_CACHED
;
132 spin_lock(&inode
->i_lock
);
133 if (*i_acl
!= EXT2_ACL_NOT_CACHED
)
134 acl
= posix_acl_dup(*i_acl
);
135 spin_unlock(&inode
->i_lock
);
141 ext2_iset_acl(struct inode
*inode
, struct posix_acl
**i_acl
,
142 struct posix_acl
*acl
)
144 spin_lock(&inode
->i_lock
);
145 if (*i_acl
!= EXT2_ACL_NOT_CACHED
)
146 posix_acl_release(*i_acl
);
147 *i_acl
= posix_acl_dup(acl
);
148 spin_unlock(&inode
->i_lock
);
152 * inode->i_sem: don't care
154 static struct posix_acl
*
155 ext2_get_acl(struct inode
*inode
, int type
)
157 struct ext2_inode_info
*ei
= EXT2_I(inode
);
160 struct posix_acl
*acl
;
163 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
167 case ACL_TYPE_ACCESS
:
168 acl
= ext2_iget_acl(inode
, &ei
->i_acl
);
169 if (acl
!= EXT2_ACL_NOT_CACHED
)
171 name_index
= EXT2_XATTR_INDEX_POSIX_ACL_ACCESS
;
174 case ACL_TYPE_DEFAULT
:
175 acl
= ext2_iget_acl(inode
, &ei
->i_default_acl
);
176 if (acl
!= EXT2_ACL_NOT_CACHED
)
178 name_index
= EXT2_XATTR_INDEX_POSIX_ACL_DEFAULT
;
182 return ERR_PTR(-EINVAL
);
184 retval
= ext2_xattr_get(inode
, name_index
, "", NULL
, 0);
186 value
= kmalloc(retval
, GFP_KERNEL
);
188 return ERR_PTR(-ENOMEM
);
189 retval
= ext2_xattr_get(inode
, name_index
, "", value
, retval
);
192 acl
= ext2_acl_from_disk(value
, retval
);
193 else if (retval
== -ENODATA
|| retval
== -ENOSYS
)
196 acl
= ERR_PTR(retval
);
201 case ACL_TYPE_ACCESS
:
202 ext2_iset_acl(inode
, &ei
->i_acl
, acl
);
205 case ACL_TYPE_DEFAULT
:
206 ext2_iset_acl(inode
, &ei
->i_default_acl
, acl
);
217 ext2_set_acl(struct inode
*inode
, int type
, struct posix_acl
*acl
)
219 struct ext2_inode_info
*ei
= EXT2_I(inode
);
225 if (S_ISLNK(inode
->i_mode
))
227 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
231 case ACL_TYPE_ACCESS
:
232 name_index
= EXT2_XATTR_INDEX_POSIX_ACL_ACCESS
;
234 mode_t mode
= inode
->i_mode
;
235 error
= posix_acl_equiv_mode(acl
, &mode
);
239 inode
->i_mode
= mode
;
240 mark_inode_dirty(inode
);
247 case ACL_TYPE_DEFAULT
:
248 name_index
= EXT2_XATTR_INDEX_POSIX_ACL_DEFAULT
;
249 if (!S_ISDIR(inode
->i_mode
))
250 return acl
? -EACCES
: 0;
257 value
= ext2_acl_to_disk(acl
, &size
);
259 return (int)PTR_ERR(value
);
262 error
= ext2_xattr_set(inode
, name_index
, "", value
, size
, 0);
267 case ACL_TYPE_ACCESS
:
268 ext2_iset_acl(inode
, &ei
->i_acl
, acl
);
271 case ACL_TYPE_DEFAULT
:
272 ext2_iset_acl(inode
, &ei
->i_default_acl
, acl
);
280 ext2_check_acl(struct inode
*inode
, int mask
)
282 struct posix_acl
*acl
= ext2_get_acl(inode
, ACL_TYPE_ACCESS
);
287 int error
= posix_acl_permission(inode
, acl
, mask
);
288 posix_acl_release(acl
);
296 ext2_permission(struct inode
*inode
, int mask
, struct nameidata
*nd
)
298 return generic_permission(inode
, mask
, ext2_check_acl
);
302 * Initialize the ACLs of a new inode. Called from ext2_new_inode.
305 * inode->i_sem: up (access to inode is still exclusive)
308 ext2_init_acl(struct inode
*inode
, struct inode
*dir
)
310 struct posix_acl
*acl
= NULL
;
313 if (!S_ISLNK(inode
->i_mode
)) {
314 if (test_opt(dir
->i_sb
, POSIX_ACL
)) {
315 acl
= ext2_get_acl(dir
, ACL_TYPE_DEFAULT
);
320 inode
->i_mode
&= ~current
->fs
->umask
;
322 if (test_opt(inode
->i_sb
, POSIX_ACL
) && acl
) {
323 struct posix_acl
*clone
;
326 if (S_ISDIR(inode
->i_mode
)) {
327 error
= ext2_set_acl(inode
, ACL_TYPE_DEFAULT
, acl
);
331 clone
= posix_acl_clone(acl
, GFP_KERNEL
);
335 mode
= inode
->i_mode
;
336 error
= posix_acl_create_masq(clone
, &mode
);
338 inode
->i_mode
= mode
;
340 /* This is an extended ACL */
341 error
= ext2_set_acl(inode
,
342 ACL_TYPE_ACCESS
, clone
);
345 posix_acl_release(clone
);
348 posix_acl_release(acl
);
353 * Does chmod for an inode that may have an Access Control List. The
354 * inode->i_mode field must be updated to the desired value by the caller
355 * before calling this function.
356 * Returns 0 on success, or a negative error number.
358 * We change the ACL rather than storing some ACL entries in the file
359 * mode permission bits (which would be more efficient), because that
360 * would break once additional permissions (like ACL_APPEND, ACL_DELETE
361 * for directories) are added. There are no more bits available in the
367 ext2_acl_chmod(struct inode
*inode
)
369 struct posix_acl
*acl
, *clone
;
372 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
374 if (S_ISLNK(inode
->i_mode
))
376 acl
= ext2_get_acl(inode
, ACL_TYPE_ACCESS
);
377 if (IS_ERR(acl
) || !acl
)
379 clone
= posix_acl_clone(acl
, GFP_KERNEL
);
380 posix_acl_release(acl
);
383 error
= posix_acl_chmod_masq(clone
, inode
->i_mode
);
385 error
= ext2_set_acl(inode
, ACL_TYPE_ACCESS
, clone
);
386 posix_acl_release(clone
);
391 * Extended attribut handlers
394 ext2_xattr_list_acl_access(struct inode
*inode
, char *list
, size_t list_size
,
395 const char *name
, size_t name_len
)
397 const size_t size
= sizeof(POSIX_ACL_XATTR_ACCESS
);
399 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
401 if (list
&& size
<= list_size
)
402 memcpy(list
, POSIX_ACL_XATTR_ACCESS
, size
);
407 ext2_xattr_list_acl_default(struct inode
*inode
, char *list
, size_t list_size
,
408 const char *name
, size_t name_len
)
410 const size_t size
= sizeof(POSIX_ACL_XATTR_DEFAULT
);
412 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
414 if (list
&& size
<= list_size
)
415 memcpy(list
, POSIX_ACL_XATTR_DEFAULT
, size
);
420 ext2_xattr_get_acl(struct inode
*inode
, int type
, void *buffer
, size_t size
)
422 struct posix_acl
*acl
;
425 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
428 acl
= ext2_get_acl(inode
, type
);
433 error
= posix_acl_to_xattr(acl
, buffer
, size
);
434 posix_acl_release(acl
);
440 ext2_xattr_get_acl_access(struct inode
*inode
, const char *name
,
441 void *buffer
, size_t size
)
443 if (strcmp(name
, "") != 0)
445 return ext2_xattr_get_acl(inode
, ACL_TYPE_ACCESS
, buffer
, size
);
449 ext2_xattr_get_acl_default(struct inode
*inode
, const char *name
,
450 void *buffer
, size_t size
)
452 if (strcmp(name
, "") != 0)
454 return ext2_xattr_get_acl(inode
, ACL_TYPE_DEFAULT
, buffer
, size
);
458 ext2_xattr_set_acl(struct inode
*inode
, int type
, const void *value
,
461 struct posix_acl
*acl
;
464 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
466 if ((current
->fsuid
!= inode
->i_uid
) && !capable(CAP_FOWNER
))
470 acl
= posix_acl_from_xattr(value
, size
);
474 error
= posix_acl_valid(acl
);
476 goto release_and_out
;
481 error
= ext2_set_acl(inode
, type
, acl
);
484 posix_acl_release(acl
);
489 ext2_xattr_set_acl_access(struct inode
*inode
, const char *name
,
490 const void *value
, size_t size
, int flags
)
492 if (strcmp(name
, "") != 0)
494 return ext2_xattr_set_acl(inode
, ACL_TYPE_ACCESS
, value
, size
);
498 ext2_xattr_set_acl_default(struct inode
*inode
, const char *name
,
499 const void *value
, size_t size
, int flags
)
501 if (strcmp(name
, "") != 0)
503 return ext2_xattr_set_acl(inode
, ACL_TYPE_DEFAULT
, value
, size
);
506 struct xattr_handler ext2_xattr_acl_access_handler
= {
507 .prefix
= POSIX_ACL_XATTR_ACCESS
,
508 .list
= ext2_xattr_list_acl_access
,
509 .get
= ext2_xattr_get_acl_access
,
510 .set
= ext2_xattr_set_acl_access
,
513 struct xattr_handler ext2_xattr_acl_default_handler
= {
514 .prefix
= POSIX_ACL_XATTR_DEFAULT
,
515 .list
= ext2_xattr_list_acl_default
,
516 .get
= ext2_xattr_get_acl_default
,
517 .set
= ext2_xattr_set_acl_default
,