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>
10 #include <linux/capability.h>
12 #include <linux/ext3_jbd.h>
13 #include <linux/ext3_fs.h>
18 * Convert from filesystem to in-memory representation.
20 static struct posix_acl
*
21 ext3_acl_from_disk(const void *value
, size_t size
)
23 const char *end
= (char *)value
+ size
;
25 struct posix_acl
*acl
;
29 if (size
< sizeof(ext3_acl_header
))
30 return ERR_PTR(-EINVAL
);
31 if (((ext3_acl_header
*)value
)->a_version
!=
32 cpu_to_le32(EXT3_ACL_VERSION
))
33 return ERR_PTR(-EINVAL
);
34 value
= (char *)value
+ sizeof(ext3_acl_header
);
35 count
= ext3_acl_count(size
);
37 return ERR_PTR(-EINVAL
);
40 acl
= posix_acl_alloc(count
, GFP_NOFS
);
42 return ERR_PTR(-ENOMEM
);
43 for (n
=0; n
< count
; n
++) {
44 ext3_acl_entry
*entry
=
45 (ext3_acl_entry
*)value
;
46 if ((char *)value
+ sizeof(ext3_acl_entry_short
) > end
)
48 acl
->a_entries
[n
].e_tag
= le16_to_cpu(entry
->e_tag
);
49 acl
->a_entries
[n
].e_perm
= le16_to_cpu(entry
->e_perm
);
50 switch(acl
->a_entries
[n
].e_tag
) {
55 value
= (char *)value
+
56 sizeof(ext3_acl_entry_short
);
57 acl
->a_entries
[n
].e_id
= ACL_UNDEFINED_ID
;
62 value
= (char *)value
+ sizeof(ext3_acl_entry
);
63 if ((char *)value
> end
)
65 acl
->a_entries
[n
].e_id
=
66 le32_to_cpu(entry
->e_id
);
78 posix_acl_release(acl
);
79 return ERR_PTR(-EINVAL
);
83 * Convert from in-memory to filesystem representation.
86 ext3_acl_to_disk(const struct posix_acl
*acl
, size_t *size
)
88 ext3_acl_header
*ext_acl
;
92 *size
= ext3_acl_size(acl
->a_count
);
93 ext_acl
= kmalloc(sizeof(ext3_acl_header
) + acl
->a_count
*
94 sizeof(ext3_acl_entry
), GFP_NOFS
);
96 return ERR_PTR(-ENOMEM
);
97 ext_acl
->a_version
= cpu_to_le32(EXT3_ACL_VERSION
);
98 e
= (char *)ext_acl
+ sizeof(ext3_acl_header
);
99 for (n
=0; n
< acl
->a_count
; n
++) {
100 ext3_acl_entry
*entry
= (ext3_acl_entry
*)e
;
101 entry
->e_tag
= cpu_to_le16(acl
->a_entries
[n
].e_tag
);
102 entry
->e_perm
= cpu_to_le16(acl
->a_entries
[n
].e_perm
);
103 switch(acl
->a_entries
[n
].e_tag
) {
107 cpu_to_le32(acl
->a_entries
[n
].e_id
);
108 e
+= sizeof(ext3_acl_entry
);
115 e
+= sizeof(ext3_acl_entry_short
);
122 return (char *)ext_acl
;
126 return ERR_PTR(-EINVAL
);
129 static inline struct posix_acl
*
130 ext3_iget_acl(struct inode
*inode
, struct posix_acl
**i_acl
)
132 struct posix_acl
*acl
= ACCESS_ONCE(*i_acl
);
135 spin_lock(&inode
->i_lock
);
137 if (acl
!= ACL_NOT_CACHED
)
138 acl
= posix_acl_dup(acl
);
139 spin_unlock(&inode
->i_lock
);
146 ext3_iset_acl(struct inode
*inode
, struct posix_acl
**i_acl
,
147 struct posix_acl
*acl
)
149 spin_lock(&inode
->i_lock
);
150 if (*i_acl
!= ACL_NOT_CACHED
)
151 posix_acl_release(*i_acl
);
152 *i_acl
= posix_acl_dup(acl
);
153 spin_unlock(&inode
->i_lock
);
157 * Inode operation get_posix_acl().
159 * inode->i_mutex: don't care
161 static struct posix_acl
*
162 ext3_get_acl(struct inode
*inode
, int type
)
166 struct posix_acl
*acl
;
169 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
173 case ACL_TYPE_ACCESS
:
174 acl
= ext3_iget_acl(inode
, &inode
->i_acl
);
175 if (acl
!= ACL_NOT_CACHED
)
177 name_index
= EXT3_XATTR_INDEX_POSIX_ACL_ACCESS
;
180 case ACL_TYPE_DEFAULT
:
181 acl
= ext3_iget_acl(inode
, &inode
->i_default_acl
);
182 if (acl
!= ACL_NOT_CACHED
)
184 name_index
= EXT3_XATTR_INDEX_POSIX_ACL_DEFAULT
;
188 return ERR_PTR(-EINVAL
);
190 retval
= ext3_xattr_get(inode
, name_index
, "", NULL
, 0);
192 value
= kmalloc(retval
, GFP_NOFS
);
194 return ERR_PTR(-ENOMEM
);
195 retval
= ext3_xattr_get(inode
, name_index
, "", value
, retval
);
198 acl
= ext3_acl_from_disk(value
, retval
);
199 else if (retval
== -ENODATA
|| retval
== -ENOSYS
)
202 acl
= ERR_PTR(retval
);
207 case ACL_TYPE_ACCESS
:
208 ext3_iset_acl(inode
, &inode
->i_acl
, acl
);
211 case ACL_TYPE_DEFAULT
:
212 ext3_iset_acl(inode
, &inode
->i_default_acl
, acl
);
220 * Set the access or default ACL of an inode.
222 * inode->i_mutex: down unless called from ext3_new_inode
225 ext3_set_acl(handle_t
*handle
, struct inode
*inode
, int type
,
226 struct posix_acl
*acl
)
233 if (S_ISLNK(inode
->i_mode
))
237 case ACL_TYPE_ACCESS
:
238 name_index
= EXT3_XATTR_INDEX_POSIX_ACL_ACCESS
;
240 mode_t mode
= inode
->i_mode
;
241 error
= posix_acl_equiv_mode(acl
, &mode
);
245 inode
->i_mode
= mode
;
246 ext3_mark_inode_dirty(handle
, inode
);
253 case ACL_TYPE_DEFAULT
:
254 name_index
= EXT3_XATTR_INDEX_POSIX_ACL_DEFAULT
;
255 if (!S_ISDIR(inode
->i_mode
))
256 return acl
? -EACCES
: 0;
263 value
= ext3_acl_to_disk(acl
, &size
);
265 return (int)PTR_ERR(value
);
268 error
= ext3_xattr_set_handle(handle
, inode
, name_index
, "",
274 case ACL_TYPE_ACCESS
:
275 ext3_iset_acl(inode
, &inode
->i_acl
, acl
);
278 case ACL_TYPE_DEFAULT
:
279 ext3_iset_acl(inode
, &inode
->i_default_acl
, acl
);
287 ext3_check_acl(struct inode
*inode
, int mask
)
289 struct posix_acl
*acl
= ext3_get_acl(inode
, ACL_TYPE_ACCESS
);
294 int error
= posix_acl_permission(inode
, acl
, mask
);
295 posix_acl_release(acl
);
303 ext3_permission(struct inode
*inode
, int mask
)
305 return generic_permission(inode
, mask
, ext3_check_acl
);
309 * Initialize the ACLs of a new inode. Called from ext3_new_inode.
312 * inode->i_mutex: up (access to inode is still exclusive)
315 ext3_init_acl(handle_t
*handle
, struct inode
*inode
, struct inode
*dir
)
317 struct posix_acl
*acl
= NULL
;
320 if (!S_ISLNK(inode
->i_mode
)) {
321 if (test_opt(dir
->i_sb
, POSIX_ACL
)) {
322 acl
= ext3_get_acl(dir
, ACL_TYPE_DEFAULT
);
327 inode
->i_mode
&= ~current_umask();
329 if (test_opt(inode
->i_sb
, POSIX_ACL
) && acl
) {
330 struct posix_acl
*clone
;
333 if (S_ISDIR(inode
->i_mode
)) {
334 error
= ext3_set_acl(handle
, inode
,
335 ACL_TYPE_DEFAULT
, acl
);
339 clone
= posix_acl_clone(acl
, GFP_NOFS
);
344 mode
= inode
->i_mode
;
345 error
= posix_acl_create_masq(clone
, &mode
);
347 inode
->i_mode
= mode
;
349 /* This is an extended ACL */
350 error
= ext3_set_acl(handle
, inode
,
351 ACL_TYPE_ACCESS
, clone
);
354 posix_acl_release(clone
);
357 posix_acl_release(acl
);
362 * Does chmod for an inode that may have an Access Control List. The
363 * inode->i_mode field must be updated to the desired value by the caller
364 * before calling this function.
365 * Returns 0 on success, or a negative error number.
367 * We change the ACL rather than storing some ACL entries in the file
368 * mode permission bits (which would be more efficient), because that
369 * would break once additional permissions (like ACL_APPEND, ACL_DELETE
370 * for directories) are added. There are no more bits available in the
373 * inode->i_mutex: down
376 ext3_acl_chmod(struct inode
*inode
)
378 struct posix_acl
*acl
, *clone
;
381 if (S_ISLNK(inode
->i_mode
))
383 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
385 acl
= ext3_get_acl(inode
, ACL_TYPE_ACCESS
);
386 if (IS_ERR(acl
) || !acl
)
388 clone
= posix_acl_clone(acl
, GFP_KERNEL
);
389 posix_acl_release(acl
);
392 error
= posix_acl_chmod_masq(clone
, inode
->i_mode
);
398 handle
= ext3_journal_start(inode
,
399 EXT3_DATA_TRANS_BLOCKS(inode
->i_sb
));
400 if (IS_ERR(handle
)) {
401 error
= PTR_ERR(handle
);
402 ext3_std_error(inode
->i_sb
, error
);
405 error
= ext3_set_acl(handle
, inode
, ACL_TYPE_ACCESS
, clone
);
406 ext3_journal_stop(handle
);
407 if (error
== -ENOSPC
&&
408 ext3_should_retry_alloc(inode
->i_sb
, &retries
))
412 posix_acl_release(clone
);
417 * Extended attribute handlers
420 ext3_xattr_list_acl_access(struct inode
*inode
, char *list
, size_t list_len
,
421 const char *name
, size_t name_len
)
423 const size_t size
= sizeof(POSIX_ACL_XATTR_ACCESS
);
425 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
427 if (list
&& size
<= list_len
)
428 memcpy(list
, POSIX_ACL_XATTR_ACCESS
, size
);
433 ext3_xattr_list_acl_default(struct inode
*inode
, char *list
, size_t list_len
,
434 const char *name
, size_t name_len
)
436 const size_t size
= sizeof(POSIX_ACL_XATTR_DEFAULT
);
438 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
440 if (list
&& size
<= list_len
)
441 memcpy(list
, POSIX_ACL_XATTR_DEFAULT
, size
);
446 ext3_xattr_get_acl(struct inode
*inode
, int type
, void *buffer
, size_t size
)
448 struct posix_acl
*acl
;
451 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
454 acl
= ext3_get_acl(inode
, type
);
459 error
= posix_acl_to_xattr(acl
, buffer
, size
);
460 posix_acl_release(acl
);
466 ext3_xattr_get_acl_access(struct inode
*inode
, const char *name
,
467 void *buffer
, size_t size
)
469 if (strcmp(name
, "") != 0)
471 return ext3_xattr_get_acl(inode
, ACL_TYPE_ACCESS
, buffer
, size
);
475 ext3_xattr_get_acl_default(struct inode
*inode
, const char *name
,
476 void *buffer
, size_t size
)
478 if (strcmp(name
, "") != 0)
480 return ext3_xattr_get_acl(inode
, ACL_TYPE_DEFAULT
, buffer
, size
);
484 ext3_xattr_set_acl(struct inode
*inode
, int type
, const void *value
,
488 struct posix_acl
*acl
;
489 int error
, retries
= 0;
491 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
493 if (!is_owner_or_cap(inode
))
497 acl
= posix_acl_from_xattr(value
, size
);
501 error
= posix_acl_valid(acl
);
503 goto release_and_out
;
509 handle
= ext3_journal_start(inode
, EXT3_DATA_TRANS_BLOCKS(inode
->i_sb
));
511 return PTR_ERR(handle
);
512 error
= ext3_set_acl(handle
, inode
, type
, acl
);
513 ext3_journal_stop(handle
);
514 if (error
== -ENOSPC
&& ext3_should_retry_alloc(inode
->i_sb
, &retries
))
518 posix_acl_release(acl
);
523 ext3_xattr_set_acl_access(struct inode
*inode
, const char *name
,
524 const void *value
, size_t size
, int flags
)
526 if (strcmp(name
, "") != 0)
528 return ext3_xattr_set_acl(inode
, ACL_TYPE_ACCESS
, value
, size
);
532 ext3_xattr_set_acl_default(struct inode
*inode
, const char *name
,
533 const void *value
, size_t size
, int flags
)
535 if (strcmp(name
, "") != 0)
537 return ext3_xattr_set_acl(inode
, ACL_TYPE_DEFAULT
, value
, size
);
540 struct xattr_handler ext3_xattr_acl_access_handler
= {
541 .prefix
= POSIX_ACL_XATTR_ACCESS
,
542 .list
= ext3_xattr_list_acl_access
,
543 .get
= ext3_xattr_get_acl_access
,
544 .set
= ext3_xattr_set_acl_access
,
547 struct xattr_handler ext3_xattr_acl_default_handler
= {
548 .prefix
= POSIX_ACL_XATTR_DEFAULT
,
549 .list
= ext3_xattr_list_acl_default
,
550 .get
= ext3_xattr_get_acl_default
,
551 .set
= ext3_xattr_set_acl_default
,