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
);
61 value
= (char *)value
+ sizeof(ext4_acl_entry
);
62 if ((char *)value
> end
)
64 acl
->a_entries
[n
].e_uid
=
65 make_kuid(&init_user_ns
,
66 le32_to_cpu(entry
->e_id
));
69 value
= (char *)value
+ sizeof(ext4_acl_entry
);
70 if ((char *)value
> end
)
72 acl
->a_entries
[n
].e_gid
=
73 make_kgid(&init_user_ns
,
74 le32_to_cpu(entry
->e_id
));
86 posix_acl_release(acl
);
87 return ERR_PTR(-EINVAL
);
91 * Convert from in-memory to filesystem representation.
94 ext4_acl_to_disk(const struct posix_acl
*acl
, size_t *size
)
96 ext4_acl_header
*ext_acl
;
100 *size
= ext4_acl_size(acl
->a_count
);
101 ext_acl
= kmalloc(sizeof(ext4_acl_header
) + acl
->a_count
*
102 sizeof(ext4_acl_entry
), GFP_NOFS
);
104 return ERR_PTR(-ENOMEM
);
105 ext_acl
->a_version
= cpu_to_le32(EXT4_ACL_VERSION
);
106 e
= (char *)ext_acl
+ sizeof(ext4_acl_header
);
107 for (n
= 0; n
< acl
->a_count
; n
++) {
108 const struct posix_acl_entry
*acl_e
= &acl
->a_entries
[n
];
109 ext4_acl_entry
*entry
= (ext4_acl_entry
*)e
;
110 entry
->e_tag
= cpu_to_le16(acl_e
->e_tag
);
111 entry
->e_perm
= cpu_to_le16(acl_e
->e_perm
);
112 switch (acl_e
->e_tag
) {
114 entry
->e_id
= cpu_to_le32(
115 from_kuid(&init_user_ns
, acl_e
->e_uid
));
116 e
+= sizeof(ext4_acl_entry
);
119 entry
->e_id
= cpu_to_le32(
120 from_kgid(&init_user_ns
, acl_e
->e_gid
));
121 e
+= sizeof(ext4_acl_entry
);
128 e
+= sizeof(ext4_acl_entry_short
);
135 return (char *)ext_acl
;
139 return ERR_PTR(-EINVAL
);
143 * Inode operation get_posix_acl().
145 * inode->i_mutex: don't care
148 ext4_get_acl(struct inode
*inode
, int type
)
152 struct posix_acl
*acl
;
155 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
158 acl
= get_cached_acl(inode
, type
);
159 if (acl
!= ACL_NOT_CACHED
)
163 case ACL_TYPE_ACCESS
:
164 name_index
= EXT4_XATTR_INDEX_POSIX_ACL_ACCESS
;
166 case ACL_TYPE_DEFAULT
:
167 name_index
= EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT
;
172 retval
= ext4_xattr_get(inode
, name_index
, "", NULL
, 0);
174 value
= kmalloc(retval
, GFP_NOFS
);
176 return ERR_PTR(-ENOMEM
);
177 retval
= ext4_xattr_get(inode
, name_index
, "", value
, retval
);
180 acl
= ext4_acl_from_disk(value
, retval
);
181 else if (retval
== -ENODATA
|| retval
== -ENOSYS
)
184 acl
= ERR_PTR(retval
);
188 set_cached_acl(inode
, type
, acl
);
194 * Set the access or default ACL of an inode.
196 * inode->i_mutex: down unless called from ext4_new_inode
199 ext4_set_acl(handle_t
*handle
, struct inode
*inode
, int type
,
200 struct posix_acl
*acl
)
207 if (S_ISLNK(inode
->i_mode
))
211 case ACL_TYPE_ACCESS
:
212 name_index
= EXT4_XATTR_INDEX_POSIX_ACL_ACCESS
;
214 error
= posix_acl_update_mode(inode
, &inode
->i_mode
, &acl
);
217 inode
->i_ctime
= ext4_current_time(inode
);
218 ext4_mark_inode_dirty(handle
, inode
);
222 case ACL_TYPE_DEFAULT
:
223 name_index
= EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT
;
224 if (!S_ISDIR(inode
->i_mode
))
225 return acl
? -EACCES
: 0;
232 value
= ext4_acl_to_disk(acl
, &size
);
234 return (int)PTR_ERR(value
);
237 error
= ext4_xattr_set_handle(handle
, inode
, name_index
, "",
242 set_cached_acl(inode
, type
, acl
);
248 * Initialize the ACLs of a new inode. Called from ext4_new_inode.
251 * inode->i_mutex: up (access to inode is still exclusive)
254 ext4_init_acl(handle_t
*handle
, struct inode
*inode
, struct inode
*dir
)
256 struct posix_acl
*acl
= NULL
;
259 if (!S_ISLNK(inode
->i_mode
)) {
260 if (test_opt(dir
->i_sb
, POSIX_ACL
)) {
261 acl
= ext4_get_acl(dir
, ACL_TYPE_DEFAULT
);
266 inode
->i_mode
&= ~current_umask();
268 if (test_opt(inode
->i_sb
, POSIX_ACL
) && acl
) {
269 if (S_ISDIR(inode
->i_mode
)) {
270 error
= ext4_set_acl(handle
, inode
,
271 ACL_TYPE_DEFAULT
, acl
);
275 error
= posix_acl_create(&acl
, GFP_NOFS
, &inode
->i_mode
);
280 /* This is an extended ACL */
281 error
= ext4_set_acl(handle
, inode
, ACL_TYPE_ACCESS
, acl
);
285 posix_acl_release(acl
);
290 * Does chmod for an inode that may have an Access Control List. The
291 * inode->i_mode field must be updated to the desired value by the caller
292 * before calling this function.
293 * Returns 0 on success, or a negative error number.
295 * We change the ACL rather than storing some ACL entries in the file
296 * mode permission bits (which would be more efficient), because that
297 * would break once additional permissions (like ACL_APPEND, ACL_DELETE
298 * for directories) are added. There are no more bits available in the
301 * inode->i_mutex: down
304 ext4_acl_chmod(struct inode
*inode
)
306 struct posix_acl
*acl
;
312 if (S_ISLNK(inode
->i_mode
))
314 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
316 acl
= ext4_get_acl(inode
, ACL_TYPE_ACCESS
);
317 if (IS_ERR(acl
) || !acl
)
319 error
= posix_acl_chmod(&acl
, GFP_KERNEL
, inode
->i_mode
);
323 handle
= ext4_journal_start(inode
, EXT4_HT_XATTR
,
324 ext4_jbd2_credits_xattr(inode
));
325 if (IS_ERR(handle
)) {
326 error
= PTR_ERR(handle
);
327 ext4_std_error(inode
->i_sb
, error
);
330 error
= ext4_set_acl(handle
, inode
, ACL_TYPE_ACCESS
, acl
);
331 ext4_journal_stop(handle
);
332 if (error
== -ENOSPC
&&
333 ext4_should_retry_alloc(inode
->i_sb
, &retries
))
336 posix_acl_release(acl
);
341 * Extended attribute handlers
344 ext4_xattr_list_acl_access(struct dentry
*dentry
, char *list
, size_t list_len
,
345 const char *name
, size_t name_len
, int type
)
347 const size_t size
= sizeof(POSIX_ACL_XATTR_ACCESS
);
349 if (!test_opt(dentry
->d_sb
, POSIX_ACL
))
351 if (list
&& size
<= list_len
)
352 memcpy(list
, POSIX_ACL_XATTR_ACCESS
, size
);
357 ext4_xattr_list_acl_default(struct dentry
*dentry
, char *list
, size_t list_len
,
358 const char *name
, size_t name_len
, int type
)
360 const size_t size
= sizeof(POSIX_ACL_XATTR_DEFAULT
);
362 if (!test_opt(dentry
->d_sb
, POSIX_ACL
))
364 if (list
&& size
<= list_len
)
365 memcpy(list
, POSIX_ACL_XATTR_DEFAULT
, size
);
370 ext4_xattr_get_acl(struct dentry
*dentry
, const char *name
, void *buffer
,
371 size_t size
, int type
)
373 struct posix_acl
*acl
;
376 if (strcmp(name
, "") != 0)
378 if (!test_opt(dentry
->d_sb
, POSIX_ACL
))
381 acl
= ext4_get_acl(dentry
->d_inode
, type
);
386 error
= posix_acl_to_xattr(&init_user_ns
, acl
, buffer
, size
);
387 posix_acl_release(acl
);
393 ext4_xattr_set_acl(struct dentry
*dentry
, const char *name
, const void *value
,
394 size_t size
, int flags
, int type
)
396 struct inode
*inode
= dentry
->d_inode
;
398 struct posix_acl
*acl
;
399 int error
, retries
= 0;
401 if (strcmp(name
, "") != 0)
403 if (!test_opt(inode
->i_sb
, POSIX_ACL
))
405 if (!inode_owner_or_capable(inode
))
409 acl
= posix_acl_from_xattr(&init_user_ns
, value
, size
);
413 error
= posix_acl_valid(acl
);
415 goto release_and_out
;
421 handle
= ext4_journal_start(inode
, EXT4_HT_XATTR
,
422 ext4_jbd2_credits_xattr(inode
));
423 if (IS_ERR(handle
)) {
424 error
= PTR_ERR(handle
);
425 goto release_and_out
;
427 error
= ext4_set_acl(handle
, inode
, type
, acl
);
428 ext4_journal_stop(handle
);
429 if (error
== -ENOSPC
&& ext4_should_retry_alloc(inode
->i_sb
, &retries
))
433 posix_acl_release(acl
);
437 const struct xattr_handler ext4_xattr_acl_access_handler
= {
438 .prefix
= POSIX_ACL_XATTR_ACCESS
,
439 .flags
= ACL_TYPE_ACCESS
,
440 .list
= ext4_xattr_list_acl_access
,
441 .get
= ext4_xattr_get_acl
,
442 .set
= ext4_xattr_set_acl
,
445 const struct xattr_handler ext4_xattr_acl_default_handler
= {
446 .prefix
= POSIX_ACL_XATTR_DEFAULT
,
447 .flags
= ACL_TYPE_DEFAULT
,
448 .list
= ext4_xattr_list_acl_default
,
449 .get
= ext4_xattr_get_acl
,
450 .set
= ext4_xattr_set_acl
,