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
);
130 * Inode operation get_posix_acl().
132 * inode->i_mutex: don't care
134 static struct posix_acl
*
135 ext4_get_acl(struct inode
*inode
, int type
)
139 struct posix_acl
*acl
;
142 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
145 acl
= get_cached_acl(inode
, type
);
146 if (acl
!= ACL_NOT_CACHED
)
150 case ACL_TYPE_ACCESS
:
151 name_index
= EXT4_XATTR_INDEX_POSIX_ACL_ACCESS
;
153 case ACL_TYPE_DEFAULT
:
154 name_index
= EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT
;
159 retval
= ext4_xattr_get(inode
, name_index
, "", NULL
, 0);
161 value
= kmalloc(retval
, GFP_NOFS
);
163 return ERR_PTR(-ENOMEM
);
164 retval
= ext4_xattr_get(inode
, name_index
, "", value
, retval
);
167 acl
= ext4_acl_from_disk(value
, retval
);
168 else if (retval
== -ENODATA
|| retval
== -ENOSYS
)
171 acl
= ERR_PTR(retval
);
175 set_cached_acl(inode
, type
, acl
);
181 * Set the access or default ACL of an inode.
183 * inode->i_mutex: down unless called from ext4_new_inode
186 ext4_set_acl(handle_t
*handle
, struct inode
*inode
, int type
,
187 struct posix_acl
*acl
)
194 if (S_ISLNK(inode
->i_mode
))
198 case ACL_TYPE_ACCESS
:
199 name_index
= EXT4_XATTR_INDEX_POSIX_ACL_ACCESS
;
201 mode_t mode
= inode
->i_mode
;
202 error
= posix_acl_equiv_mode(acl
, &mode
);
206 inode
->i_mode
= mode
;
207 inode
->i_ctime
= ext4_current_time(inode
);
208 ext4_mark_inode_dirty(handle
, inode
);
215 case ACL_TYPE_DEFAULT
:
216 name_index
= EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT
;
217 if (!S_ISDIR(inode
->i_mode
))
218 return acl
? -EACCES
: 0;
225 value
= ext4_acl_to_disk(acl
, &size
);
227 return (int)PTR_ERR(value
);
230 error
= ext4_xattr_set_handle(handle
, inode
, name_index
, "",
235 set_cached_acl(inode
, type
, acl
);
241 ext4_check_acl(struct inode
*inode
, int mask
, unsigned int flags
)
243 struct posix_acl
*acl
;
245 if (flags
& IPERM_FLAG_RCU
)
248 acl
= ext4_get_acl(inode
, ACL_TYPE_ACCESS
);
252 int error
= posix_acl_permission(inode
, acl
, mask
);
253 posix_acl_release(acl
);
261 * Initialize the ACLs of a new inode. Called from ext4_new_inode.
264 * inode->i_mutex: up (access to inode is still exclusive)
267 ext4_init_acl(handle_t
*handle
, struct inode
*inode
, struct inode
*dir
)
269 struct posix_acl
*acl
= NULL
;
272 if (!S_ISLNK(inode
->i_mode
)) {
273 if (test_opt(dir
->i_sb
, POSIX_ACL
)) {
274 acl
= ext4_get_acl(dir
, ACL_TYPE_DEFAULT
);
279 inode
->i_mode
&= ~current_umask();
281 if (test_opt(inode
->i_sb
, POSIX_ACL
) && acl
) {
282 struct posix_acl
*clone
;
285 if (S_ISDIR(inode
->i_mode
)) {
286 error
= ext4_set_acl(handle
, inode
,
287 ACL_TYPE_DEFAULT
, acl
);
291 clone
= posix_acl_clone(acl
, GFP_NOFS
);
296 mode
= inode
->i_mode
;
297 error
= posix_acl_create_masq(clone
, &mode
);
299 inode
->i_mode
= mode
;
301 /* This is an extended ACL */
302 error
= ext4_set_acl(handle
, inode
,
303 ACL_TYPE_ACCESS
, clone
);
306 posix_acl_release(clone
);
309 posix_acl_release(acl
);
314 * Does chmod for an inode that may have an Access Control List. The
315 * inode->i_mode field must be updated to the desired value by the caller
316 * before calling this function.
317 * Returns 0 on success, or a negative error number.
319 * We change the ACL rather than storing some ACL entries in the file
320 * mode permission bits (which would be more efficient), because that
321 * would break once additional permissions (like ACL_APPEND, ACL_DELETE
322 * for directories) are added. There are no more bits available in the
325 * inode->i_mutex: down
328 ext4_acl_chmod(struct inode
*inode
)
330 struct posix_acl
*acl
, *clone
;
333 if (S_ISLNK(inode
->i_mode
))
335 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
337 acl
= ext4_get_acl(inode
, ACL_TYPE_ACCESS
);
338 if (IS_ERR(acl
) || !acl
)
340 clone
= posix_acl_clone(acl
, GFP_KERNEL
);
341 posix_acl_release(acl
);
344 error
= posix_acl_chmod_masq(clone
, inode
->i_mode
);
350 handle
= ext4_journal_start(inode
,
351 EXT4_DATA_TRANS_BLOCKS(inode
->i_sb
));
352 if (IS_ERR(handle
)) {
353 error
= PTR_ERR(handle
);
354 ext4_std_error(inode
->i_sb
, error
);
357 error
= ext4_set_acl(handle
, inode
, ACL_TYPE_ACCESS
, clone
);
358 ext4_journal_stop(handle
);
359 if (error
== -ENOSPC
&&
360 ext4_should_retry_alloc(inode
->i_sb
, &retries
))
364 posix_acl_release(clone
);
369 * Extended attribute handlers
372 ext4_xattr_list_acl_access(struct dentry
*dentry
, char *list
, size_t list_len
,
373 const char *name
, size_t name_len
, int type
)
375 const size_t size
= sizeof(POSIX_ACL_XATTR_ACCESS
);
377 if (!test_opt(dentry
->d_sb
, POSIX_ACL
))
379 if (list
&& size
<= list_len
)
380 memcpy(list
, POSIX_ACL_XATTR_ACCESS
, size
);
385 ext4_xattr_list_acl_default(struct dentry
*dentry
, char *list
, size_t list_len
,
386 const char *name
, size_t name_len
, int type
)
388 const size_t size
= sizeof(POSIX_ACL_XATTR_DEFAULT
);
390 if (!test_opt(dentry
->d_sb
, POSIX_ACL
))
392 if (list
&& size
<= list_len
)
393 memcpy(list
, POSIX_ACL_XATTR_DEFAULT
, size
);
398 ext4_xattr_get_acl(struct dentry
*dentry
, const char *name
, void *buffer
,
399 size_t size
, int type
)
401 struct posix_acl
*acl
;
404 if (strcmp(name
, "") != 0)
406 if (!test_opt(dentry
->d_sb
, POSIX_ACL
))
409 acl
= ext4_get_acl(dentry
->d_inode
, type
);
414 error
= posix_acl_to_xattr(acl
, buffer
, size
);
415 posix_acl_release(acl
);
421 ext4_xattr_set_acl(struct dentry
*dentry
, const char *name
, const void *value
,
422 size_t size
, int flags
, int type
)
424 struct inode
*inode
= dentry
->d_inode
;
426 struct posix_acl
*acl
;
427 int error
, retries
= 0;
429 if (strcmp(name
, "") != 0)
431 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
433 if (!is_owner_or_cap(inode
))
437 acl
= posix_acl_from_xattr(value
, size
);
441 error
= posix_acl_valid(acl
);
443 goto release_and_out
;
449 handle
= ext4_journal_start(inode
, EXT4_DATA_TRANS_BLOCKS(inode
->i_sb
));
451 return PTR_ERR(handle
);
452 error
= ext4_set_acl(handle
, inode
, type
, acl
);
453 ext4_journal_stop(handle
);
454 if (error
== -ENOSPC
&& ext4_should_retry_alloc(inode
->i_sb
, &retries
))
458 posix_acl_release(acl
);
462 const struct xattr_handler ext4_xattr_acl_access_handler
= {
463 .prefix
= POSIX_ACL_XATTR_ACCESS
,
464 .flags
= ACL_TYPE_ACCESS
,
465 .list
= ext4_xattr_list_acl_access
,
466 .get
= ext4_xattr_get_acl
,
467 .set
= ext4_xattr_set_acl
,
470 const struct xattr_handler ext4_xattr_acl_default_handler
= {
471 .prefix
= POSIX_ACL_XATTR_DEFAULT
,
472 .flags
= ACL_TYPE_DEFAULT
,
473 .list
= ext4_xattr_list_acl_default
,
474 .get
= ext4_xattr_get_acl
,
475 .set
= ext4_xattr_set_acl
,