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
)
243 struct posix_acl
*acl
;
245 acl
= ext4_get_acl(inode
, ACL_TYPE_ACCESS
);
249 int error
= posix_acl_permission(inode
, acl
, mask
);
250 posix_acl_release(acl
);
258 * Initialize the ACLs of a new inode. Called from ext4_new_inode.
261 * inode->i_mutex: up (access to inode is still exclusive)
264 ext4_init_acl(handle_t
*handle
, struct inode
*inode
, struct inode
*dir
)
266 struct posix_acl
*acl
= NULL
;
269 if (!S_ISLNK(inode
->i_mode
)) {
270 if (test_opt(dir
->i_sb
, POSIX_ACL
)) {
271 acl
= ext4_get_acl(dir
, ACL_TYPE_DEFAULT
);
276 inode
->i_mode
&= ~current_umask();
278 if (test_opt(inode
->i_sb
, POSIX_ACL
) && acl
) {
279 struct posix_acl
*clone
;
282 if (S_ISDIR(inode
->i_mode
)) {
283 error
= ext4_set_acl(handle
, inode
,
284 ACL_TYPE_DEFAULT
, acl
);
288 clone
= posix_acl_clone(acl
, GFP_NOFS
);
293 mode
= inode
->i_mode
;
294 error
= posix_acl_create_masq(clone
, &mode
);
296 inode
->i_mode
= mode
;
298 /* This is an extended ACL */
299 error
= ext4_set_acl(handle
, inode
,
300 ACL_TYPE_ACCESS
, clone
);
303 posix_acl_release(clone
);
306 posix_acl_release(acl
);
311 * Does chmod for an inode that may have an Access Control List. The
312 * inode->i_mode field must be updated to the desired value by the caller
313 * before calling this function.
314 * Returns 0 on success, or a negative error number.
316 * We change the ACL rather than storing some ACL entries in the file
317 * mode permission bits (which would be more efficient), because that
318 * would break once additional permissions (like ACL_APPEND, ACL_DELETE
319 * for directories) are added. There are no more bits available in the
322 * inode->i_mutex: down
325 ext4_acl_chmod(struct inode
*inode
)
327 struct posix_acl
*acl
;
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 error
= posix_acl_chmod(&acl
, GFP_KERNEL
, inode
->i_mode
);
344 handle
= ext4_journal_start(inode
,
345 EXT4_DATA_TRANS_BLOCKS(inode
->i_sb
));
346 if (IS_ERR(handle
)) {
347 error
= PTR_ERR(handle
);
348 ext4_std_error(inode
->i_sb
, error
);
351 error
= ext4_set_acl(handle
, inode
, ACL_TYPE_ACCESS
, acl
);
352 ext4_journal_stop(handle
);
353 if (error
== -ENOSPC
&&
354 ext4_should_retry_alloc(inode
->i_sb
, &retries
))
357 posix_acl_release(acl
);
362 * Extended attribute handlers
365 ext4_xattr_list_acl_access(struct dentry
*dentry
, char *list
, size_t list_len
,
366 const char *name
, size_t name_len
, int type
)
368 const size_t size
= sizeof(POSIX_ACL_XATTR_ACCESS
);
370 if (!test_opt(dentry
->d_sb
, POSIX_ACL
))
372 if (list
&& size
<= list_len
)
373 memcpy(list
, POSIX_ACL_XATTR_ACCESS
, size
);
378 ext4_xattr_list_acl_default(struct dentry
*dentry
, char *list
, size_t list_len
,
379 const char *name
, size_t name_len
, int type
)
381 const size_t size
= sizeof(POSIX_ACL_XATTR_DEFAULT
);
383 if (!test_opt(dentry
->d_sb
, POSIX_ACL
))
385 if (list
&& size
<= list_len
)
386 memcpy(list
, POSIX_ACL_XATTR_DEFAULT
, size
);
391 ext4_xattr_get_acl(struct dentry
*dentry
, const char *name
, void *buffer
,
392 size_t size
, int type
)
394 struct posix_acl
*acl
;
397 if (strcmp(name
, "") != 0)
399 if (!test_opt(dentry
->d_sb
, POSIX_ACL
))
402 acl
= ext4_get_acl(dentry
->d_inode
, type
);
407 error
= posix_acl_to_xattr(acl
, buffer
, size
);
408 posix_acl_release(acl
);
414 ext4_xattr_set_acl(struct dentry
*dentry
, const char *name
, const void *value
,
415 size_t size
, int flags
, int type
)
417 struct inode
*inode
= dentry
->d_inode
;
419 struct posix_acl
*acl
;
420 int error
, retries
= 0;
422 if (strcmp(name
, "") != 0)
424 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
426 if (!inode_owner_or_capable(inode
))
430 acl
= posix_acl_from_xattr(value
, size
);
434 error
= posix_acl_valid(acl
);
436 goto release_and_out
;
442 handle
= ext4_journal_start(inode
, EXT4_DATA_TRANS_BLOCKS(inode
->i_sb
));
444 return PTR_ERR(handle
);
445 error
= ext4_set_acl(handle
, inode
, type
, acl
);
446 ext4_journal_stop(handle
);
447 if (error
== -ENOSPC
&& ext4_should_retry_alloc(inode
->i_sb
, &retries
))
451 posix_acl_release(acl
);
455 const struct xattr_handler ext4_xattr_acl_access_handler
= {
456 .prefix
= POSIX_ACL_XATTR_ACCESS
,
457 .flags
= ACL_TYPE_ACCESS
,
458 .list
= ext4_xattr_list_acl_access
,
459 .get
= ext4_xattr_get_acl
,
460 .set
= ext4_xattr_set_acl
,
463 const struct xattr_handler ext4_xattr_acl_default_handler
= {
464 .prefix
= POSIX_ACL_XATTR_DEFAULT
,
465 .flags
= ACL_TYPE_DEFAULT
,
466 .list
= ext4_xattr_list_acl_default
,
467 .get
= ext4_xattr_get_acl
,
468 .set
= ext4_xattr_set_acl
,