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 "ext4_jbd2.h"
18 * Convert from filesystem to in-memory representation.
20 static struct posix_acl
*
21 ext4_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(ext4_acl_header
))
30 return ERR_PTR(-EINVAL
);
31 if (((ext4_acl_header
*)value
)->a_version
!=
32 cpu_to_le32(EXT4_ACL_VERSION
))
33 return ERR_PTR(-EINVAL
);
34 value
= (char *)value
+ sizeof(ext4_acl_header
);
35 count
= ext4_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 ext4_acl_entry
*entry
=
45 (ext4_acl_entry
*)value
;
46 if ((char *)value
+ sizeof(ext4_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
);
51 switch (acl
->a_entries
[n
].e_tag
) {
56 value
= (char *)value
+
57 sizeof(ext4_acl_entry_short
);
58 acl
->a_entries
[n
].e_id
= ACL_UNDEFINED_ID
;
63 value
= (char *)value
+ sizeof(ext4_acl_entry
);
64 if ((char *)value
> end
)
66 acl
->a_entries
[n
].e_id
=
67 le32_to_cpu(entry
->e_id
);
79 posix_acl_release(acl
);
80 return ERR_PTR(-EINVAL
);
84 * Convert from in-memory to filesystem representation.
87 ext4_acl_to_disk(const struct posix_acl
*acl
, size_t *size
)
89 ext4_acl_header
*ext_acl
;
93 *size
= ext4_acl_size(acl
->a_count
);
94 ext_acl
= kmalloc(sizeof(ext4_acl_header
) + acl
->a_count
*
95 sizeof(ext4_acl_entry
), GFP_NOFS
);
97 return ERR_PTR(-ENOMEM
);
98 ext_acl
->a_version
= cpu_to_le32(EXT4_ACL_VERSION
);
99 e
= (char *)ext_acl
+ sizeof(ext4_acl_header
);
100 for (n
= 0; n
< acl
->a_count
; n
++) {
101 ext4_acl_entry
*entry
= (ext4_acl_entry
*)e
;
102 entry
->e_tag
= cpu_to_le16(acl
->a_entries
[n
].e_tag
);
103 entry
->e_perm
= cpu_to_le16(acl
->a_entries
[n
].e_perm
);
104 switch (acl
->a_entries
[n
].e_tag
) {
107 entry
->e_id
= cpu_to_le32(acl
->a_entries
[n
].e_id
);
108 e
+= sizeof(ext4_acl_entry
);
115 e
+= sizeof(ext4_acl_entry_short
);
122 return (char *)ext_acl
;
126 return ERR_PTR(-EINVAL
);
129 static inline struct posix_acl
*
130 ext4_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
!= EXT4_ACL_NOT_CACHED
)
138 acl
= posix_acl_dup(acl
);
139 spin_unlock(&inode
->i_lock
);
146 ext4_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
!= EXT4_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 ext4_get_acl(struct inode
*inode
, int type
)
164 struct ext4_inode_info
*ei
= EXT4_I(inode
);
167 struct posix_acl
*acl
;
170 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
174 case ACL_TYPE_ACCESS
:
175 acl
= ext4_iget_acl(inode
, &ei
->i_acl
);
176 if (acl
!= EXT4_ACL_NOT_CACHED
)
178 name_index
= EXT4_XATTR_INDEX_POSIX_ACL_ACCESS
;
181 case ACL_TYPE_DEFAULT
:
182 acl
= ext4_iget_acl(inode
, &ei
->i_default_acl
);
183 if (acl
!= EXT4_ACL_NOT_CACHED
)
185 name_index
= EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT
;
189 return ERR_PTR(-EINVAL
);
191 retval
= ext4_xattr_get(inode
, name_index
, "", NULL
, 0);
193 value
= kmalloc(retval
, GFP_NOFS
);
195 return ERR_PTR(-ENOMEM
);
196 retval
= ext4_xattr_get(inode
, name_index
, "", value
, retval
);
199 acl
= ext4_acl_from_disk(value
, retval
);
200 else if (retval
== -ENODATA
|| retval
== -ENOSYS
)
203 acl
= ERR_PTR(retval
);
208 case ACL_TYPE_ACCESS
:
209 ext4_iset_acl(inode
, &ei
->i_acl
, acl
);
212 case ACL_TYPE_DEFAULT
:
213 ext4_iset_acl(inode
, &ei
->i_default_acl
, acl
);
221 * Set the access or default ACL of an inode.
223 * inode->i_mutex: down unless called from ext4_new_inode
226 ext4_set_acl(handle_t
*handle
, struct inode
*inode
, int type
,
227 struct posix_acl
*acl
)
229 struct ext4_inode_info
*ei
= EXT4_I(inode
);
235 if (S_ISLNK(inode
->i_mode
))
239 case ACL_TYPE_ACCESS
:
240 name_index
= EXT4_XATTR_INDEX_POSIX_ACL_ACCESS
;
242 mode_t mode
= inode
->i_mode
;
243 error
= posix_acl_equiv_mode(acl
, &mode
);
247 inode
->i_mode
= mode
;
248 ext4_mark_inode_dirty(handle
, inode
);
255 case ACL_TYPE_DEFAULT
:
256 name_index
= EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT
;
257 if (!S_ISDIR(inode
->i_mode
))
258 return acl
? -EACCES
: 0;
265 value
= ext4_acl_to_disk(acl
, &size
);
267 return (int)PTR_ERR(value
);
270 error
= ext4_xattr_set_handle(handle
, inode
, name_index
, "",
276 case ACL_TYPE_ACCESS
:
277 ext4_iset_acl(inode
, &ei
->i_acl
, acl
);
280 case ACL_TYPE_DEFAULT
:
281 ext4_iset_acl(inode
, &ei
->i_default_acl
, acl
);
289 ext4_check_acl(struct inode
*inode
, int mask
)
291 struct posix_acl
*acl
= ext4_get_acl(inode
, ACL_TYPE_ACCESS
);
296 int error
= posix_acl_permission(inode
, acl
, mask
);
297 posix_acl_release(acl
);
305 ext4_permission(struct inode
*inode
, int mask
)
307 return generic_permission(inode
, mask
, ext4_check_acl
);
311 * Initialize the ACLs of a new inode. Called from ext4_new_inode.
314 * inode->i_mutex: up (access to inode is still exclusive)
317 ext4_init_acl(handle_t
*handle
, struct inode
*inode
, struct inode
*dir
)
319 struct posix_acl
*acl
= NULL
;
322 if (!S_ISLNK(inode
->i_mode
)) {
323 if (test_opt(dir
->i_sb
, POSIX_ACL
)) {
324 acl
= ext4_get_acl(dir
, ACL_TYPE_DEFAULT
);
329 inode
->i_mode
&= ~current_umask();
331 if (test_opt(inode
->i_sb
, POSIX_ACL
) && acl
) {
332 struct posix_acl
*clone
;
335 if (S_ISDIR(inode
->i_mode
)) {
336 error
= ext4_set_acl(handle
, inode
,
337 ACL_TYPE_DEFAULT
, acl
);
341 clone
= posix_acl_clone(acl
, GFP_NOFS
);
346 mode
= inode
->i_mode
;
347 error
= posix_acl_create_masq(clone
, &mode
);
349 inode
->i_mode
= mode
;
351 /* This is an extended ACL */
352 error
= ext4_set_acl(handle
, inode
,
353 ACL_TYPE_ACCESS
, clone
);
356 posix_acl_release(clone
);
359 posix_acl_release(acl
);
364 * Does chmod for an inode that may have an Access Control List. The
365 * inode->i_mode field must be updated to the desired value by the caller
366 * before calling this function.
367 * Returns 0 on success, or a negative error number.
369 * We change the ACL rather than storing some ACL entries in the file
370 * mode permission bits (which would be more efficient), because that
371 * would break once additional permissions (like ACL_APPEND, ACL_DELETE
372 * for directories) are added. There are no more bits available in the
375 * inode->i_mutex: down
378 ext4_acl_chmod(struct inode
*inode
)
380 struct posix_acl
*acl
, *clone
;
383 if (S_ISLNK(inode
->i_mode
))
385 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
387 acl
= ext4_get_acl(inode
, ACL_TYPE_ACCESS
);
388 if (IS_ERR(acl
) || !acl
)
390 clone
= posix_acl_clone(acl
, GFP_KERNEL
);
391 posix_acl_release(acl
);
394 error
= posix_acl_chmod_masq(clone
, inode
->i_mode
);
400 handle
= ext4_journal_start(inode
,
401 EXT4_DATA_TRANS_BLOCKS(inode
->i_sb
));
402 if (IS_ERR(handle
)) {
403 error
= PTR_ERR(handle
);
404 ext4_std_error(inode
->i_sb
, error
);
407 error
= ext4_set_acl(handle
, inode
, ACL_TYPE_ACCESS
, clone
);
408 ext4_journal_stop(handle
);
409 if (error
== -ENOSPC
&&
410 ext4_should_retry_alloc(inode
->i_sb
, &retries
))
414 posix_acl_release(clone
);
419 * Extended attribute handlers
422 ext4_xattr_list_acl_access(struct inode
*inode
, char *list
, size_t list_len
,
423 const char *name
, size_t name_len
)
425 const size_t size
= sizeof(POSIX_ACL_XATTR_ACCESS
);
427 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
429 if (list
&& size
<= list_len
)
430 memcpy(list
, POSIX_ACL_XATTR_ACCESS
, size
);
435 ext4_xattr_list_acl_default(struct inode
*inode
, char *list
, size_t list_len
,
436 const char *name
, size_t name_len
)
438 const size_t size
= sizeof(POSIX_ACL_XATTR_DEFAULT
);
440 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
442 if (list
&& size
<= list_len
)
443 memcpy(list
, POSIX_ACL_XATTR_DEFAULT
, size
);
448 ext4_xattr_get_acl(struct inode
*inode
, int type
, void *buffer
, size_t size
)
450 struct posix_acl
*acl
;
453 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
456 acl
= ext4_get_acl(inode
, type
);
461 error
= posix_acl_to_xattr(acl
, buffer
, size
);
462 posix_acl_release(acl
);
468 ext4_xattr_get_acl_access(struct inode
*inode
, const char *name
,
469 void *buffer
, size_t size
)
471 if (strcmp(name
, "") != 0)
473 return ext4_xattr_get_acl(inode
, ACL_TYPE_ACCESS
, buffer
, size
);
477 ext4_xattr_get_acl_default(struct inode
*inode
, const char *name
,
478 void *buffer
, size_t size
)
480 if (strcmp(name
, "") != 0)
482 return ext4_xattr_get_acl(inode
, ACL_TYPE_DEFAULT
, buffer
, size
);
486 ext4_xattr_set_acl(struct inode
*inode
, int type
, const void *value
,
490 struct posix_acl
*acl
;
491 int error
, retries
= 0;
493 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
495 if (!is_owner_or_cap(inode
))
499 acl
= posix_acl_from_xattr(value
, size
);
503 error
= posix_acl_valid(acl
);
505 goto release_and_out
;
511 handle
= ext4_journal_start(inode
, EXT4_DATA_TRANS_BLOCKS(inode
->i_sb
));
513 return PTR_ERR(handle
);
514 error
= ext4_set_acl(handle
, inode
, type
, acl
);
515 ext4_journal_stop(handle
);
516 if (error
== -ENOSPC
&& ext4_should_retry_alloc(inode
->i_sb
, &retries
))
520 posix_acl_release(acl
);
525 ext4_xattr_set_acl_access(struct inode
*inode
, const char *name
,
526 const void *value
, size_t size
, int flags
)
528 if (strcmp(name
, "") != 0)
530 return ext4_xattr_set_acl(inode
, ACL_TYPE_ACCESS
, value
, size
);
534 ext4_xattr_set_acl_default(struct inode
*inode
, const char *name
,
535 const void *value
, size_t size
, int flags
)
537 if (strcmp(name
, "") != 0)
539 return ext4_xattr_set_acl(inode
, ACL_TYPE_DEFAULT
, value
, size
);
542 struct xattr_handler ext4_xattr_acl_access_handler
= {
543 .prefix
= POSIX_ACL_XATTR_ACCESS
,
544 .list
= ext4_xattr_list_acl_access
,
545 .get
= ext4_xattr_get_acl_access
,
546 .set
= ext4_xattr_set_acl_access
,
549 struct xattr_handler ext4_xattr_acl_default_handler
= {
550 .prefix
= POSIX_ACL_XATTR_DEFAULT
,
551 .list
= ext4_xattr_list_acl_default
,
552 .get
= ext4_xattr_get_acl_default
,
553 .set
= ext4_xattr_set_acl_default
,