4 * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
13 * Convert from filesystem to in-memory representation.
15 static struct posix_acl
*
16 ext4_acl_from_disk(struct super_block
*sb
, const void *value
, size_t size
)
18 const char *end
= (char *)value
+ size
;
20 struct posix_acl
*acl
;
24 if (size
< sizeof(ext4_acl_header
))
25 return ERR_PTR(-EINVAL
);
26 if (((ext4_acl_header
*)value
)->a_version
!=
27 cpu_to_le32(EXT4_ACL_VERSION
))
28 return ERR_PTR(-EINVAL
);
29 value
= (char *)value
+ sizeof(ext4_acl_header
);
30 count
= ext4_acl_count(size
);
32 return ERR_PTR(-EINVAL
);
35 acl
= posix_acl_alloc(count
, GFP_NOFS
);
37 return ERR_PTR(-ENOMEM
);
38 for (n
= 0; n
< count
; n
++) {
39 ext4_acl_entry
*entry
=
40 (ext4_acl_entry
*)value
;
41 if ((char *)value
+ sizeof(ext4_acl_entry_short
) > end
)
43 acl
->a_entries
[n
].e_tag
= le16_to_cpu(entry
->e_tag
);
44 acl
->a_entries
[n
].e_perm
= le16_to_cpu(entry
->e_perm
);
46 switch (acl
->a_entries
[n
].e_tag
) {
51 value
= (char *)value
+
52 sizeof(ext4_acl_entry_short
);
56 value
= (char *)value
+ sizeof(ext4_acl_entry
);
57 if ((char *)value
> end
)
59 acl
->a_entries
[n
].e_uid
=
60 make_kuid(sb
->s_user_ns
,
61 le32_to_cpu(entry
->e_id
));
62 if (!uid_valid(acl
->a_entries
[n
].e_uid
))
66 value
= (char *)value
+ sizeof(ext4_acl_entry
);
67 if ((char *)value
> end
)
69 acl
->a_entries
[n
].e_gid
=
70 make_kgid(sb
->s_user_ns
,
71 le32_to_cpu(entry
->e_id
));
72 if (!gid_valid(acl
->a_entries
[n
].e_gid
))
85 posix_acl_release(acl
);
86 return ERR_PTR(-EINVAL
);
90 * Convert from in-memory to filesystem representation.
93 ext4_acl_to_disk(struct super_block
*sb
, const struct posix_acl
*acl
,
96 ext4_acl_header
*ext_acl
;
102 *size
= ext4_acl_size(acl
->a_count
);
103 ext_acl
= kmalloc(sizeof(ext4_acl_header
) + acl
->a_count
*
104 sizeof(ext4_acl_entry
), GFP_NOFS
);
106 return ERR_PTR(-ENOMEM
);
107 ext_acl
->a_version
= cpu_to_le32(EXT4_ACL_VERSION
);
108 e
= (char *)ext_acl
+ sizeof(ext4_acl_header
);
109 for (n
= 0; n
< acl
->a_count
; n
++) {
110 const struct posix_acl_entry
*acl_e
= &acl
->a_entries
[n
];
111 ext4_acl_entry
*entry
= (ext4_acl_entry
*)e
;
112 entry
->e_tag
= cpu_to_le16(acl_e
->e_tag
);
113 entry
->e_perm
= cpu_to_le16(acl_e
->e_perm
);
114 switch (acl_e
->e_tag
) {
116 uid
= from_kuid(sb
->s_user_ns
, acl_e
->e_uid
);
117 if (uid
== (uid_t
)-1)
119 entry
->e_id
= cpu_to_le32(uid
);
120 e
+= sizeof(ext4_acl_entry
);
123 gid
= from_kgid(sb
->s_user_ns
, acl_e
->e_gid
);
124 if (gid
== (gid_t
)-1)
126 entry
->e_id
= cpu_to_le32(gid
);
127 e
+= sizeof(ext4_acl_entry
);
134 e
+= sizeof(ext4_acl_entry_short
);
141 return (char *)ext_acl
;
145 return ERR_PTR(-EINVAL
);
149 * Inode operation get_posix_acl().
151 * inode->i_mutex: don't care
154 ext4_get_acl(struct inode
*inode
, int type
)
158 struct posix_acl
*acl
;
162 case ACL_TYPE_ACCESS
:
163 name_index
= EXT4_XATTR_INDEX_POSIX_ACL_ACCESS
;
165 case ACL_TYPE_DEFAULT
:
166 name_index
= EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT
;
171 retval
= ext4_xattr_get(inode
, name_index
, "", NULL
, 0);
173 value
= kmalloc(retval
, GFP_NOFS
);
175 return ERR_PTR(-ENOMEM
);
176 retval
= ext4_xattr_get(inode
, name_index
, "", value
, retval
);
179 acl
= ext4_acl_from_disk(inode
->i_sb
, value
, retval
);
180 else if (retval
== -ENODATA
|| retval
== -ENOSYS
)
183 acl
= ERR_PTR(retval
);
190 * Set the access or default ACL of an inode.
192 * inode->i_mutex: down unless called from ext4_new_inode
195 __ext4_set_acl(handle_t
*handle
, struct inode
*inode
, int type
,
196 struct posix_acl
*acl
)
204 case ACL_TYPE_ACCESS
:
205 name_index
= EXT4_XATTR_INDEX_POSIX_ACL_ACCESS
;
207 error
= posix_acl_update_mode(inode
, &inode
->i_mode
, &acl
);
210 inode
->i_ctime
= current_time(inode
);
211 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(inode
->i_sb
, 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_set_acl(struct inode
*inode
, struct posix_acl
*acl
, int type
)
244 int error
, retries
= 0;
247 handle
= ext4_journal_start(inode
, EXT4_HT_XATTR
,
248 ext4_jbd2_credits_xattr(inode
));
250 return PTR_ERR(handle
);
252 error
= __ext4_set_acl(handle
, inode
, type
, acl
);
253 ext4_journal_stop(handle
);
254 if (error
== -ENOSPC
&& ext4_should_retry_alloc(inode
->i_sb
, &retries
))
260 * Initialize the ACLs of a new inode. Called from ext4_new_inode.
263 * inode->i_mutex: up (access to inode is still exclusive)
266 ext4_init_acl(handle_t
*handle
, struct inode
*inode
, struct inode
*dir
)
268 struct posix_acl
*default_acl
, *acl
;
271 error
= posix_acl_create(dir
, &inode
->i_mode
, &default_acl
, &acl
);
276 error
= __ext4_set_acl(handle
, inode
, ACL_TYPE_DEFAULT
,
278 posix_acl_release(default_acl
);
282 error
= __ext4_set_acl(handle
, inode
, ACL_TYPE_ACCESS
,
284 posix_acl_release(acl
);