1 // SPDX-License-Identifier: GPL-2.0
5 * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
8 #include <linux/quotaops.h>
15 * Convert from filesystem to in-memory representation.
17 static struct posix_acl
*
18 ext4_acl_from_disk(const void *value
, size_t size
)
20 const char *end
= (char *)value
+ size
;
22 struct posix_acl
*acl
;
26 if (size
< sizeof(ext4_acl_header
))
27 return ERR_PTR(-EINVAL
);
28 if (((ext4_acl_header
*)value
)->a_version
!=
29 cpu_to_le32(EXT4_ACL_VERSION
))
30 return ERR_PTR(-EINVAL
);
31 value
= (char *)value
+ sizeof(ext4_acl_header
);
32 count
= ext4_acl_count(size
);
34 return ERR_PTR(-EINVAL
);
37 acl
= posix_acl_alloc(count
, GFP_NOFS
);
39 return ERR_PTR(-ENOMEM
);
40 for (n
= 0; n
< count
; n
++) {
41 ext4_acl_entry
*entry
=
42 (ext4_acl_entry
*)value
;
43 if ((char *)value
+ sizeof(ext4_acl_entry_short
) > end
)
45 acl
->a_entries
[n
].e_tag
= le16_to_cpu(entry
->e_tag
);
46 acl
->a_entries
[n
].e_perm
= le16_to_cpu(entry
->e_perm
);
48 switch (acl
->a_entries
[n
].e_tag
) {
53 value
= (char *)value
+
54 sizeof(ext4_acl_entry_short
);
58 value
= (char *)value
+ sizeof(ext4_acl_entry
);
59 if ((char *)value
> end
)
61 acl
->a_entries
[n
].e_uid
=
62 make_kuid(&init_user_ns
,
63 le32_to_cpu(entry
->e_id
));
66 value
= (char *)value
+ sizeof(ext4_acl_entry
);
67 if ((char *)value
> end
)
69 acl
->a_entries
[n
].e_gid
=
70 make_kgid(&init_user_ns
,
71 le32_to_cpu(entry
->e_id
));
83 posix_acl_release(acl
);
84 return ERR_PTR(-EINVAL
);
88 * Convert from in-memory to filesystem representation.
91 ext4_acl_to_disk(const struct posix_acl
*acl
, size_t *size
)
93 ext4_acl_header
*ext_acl
;
97 *size
= ext4_acl_size(acl
->a_count
);
98 ext_acl
= kmalloc(sizeof(ext4_acl_header
) + acl
->a_count
*
99 sizeof(ext4_acl_entry
), GFP_NOFS
);
101 return ERR_PTR(-ENOMEM
);
102 ext_acl
->a_version
= cpu_to_le32(EXT4_ACL_VERSION
);
103 e
= (char *)ext_acl
+ sizeof(ext4_acl_header
);
104 for (n
= 0; n
< acl
->a_count
; n
++) {
105 const struct posix_acl_entry
*acl_e
= &acl
->a_entries
[n
];
106 ext4_acl_entry
*entry
= (ext4_acl_entry
*)e
;
107 entry
->e_tag
= cpu_to_le16(acl_e
->e_tag
);
108 entry
->e_perm
= cpu_to_le16(acl_e
->e_perm
);
109 switch (acl_e
->e_tag
) {
111 entry
->e_id
= cpu_to_le32(
112 from_kuid(&init_user_ns
, acl_e
->e_uid
));
113 e
+= sizeof(ext4_acl_entry
);
116 entry
->e_id
= cpu_to_le32(
117 from_kgid(&init_user_ns
, acl_e
->e_gid
));
118 e
+= sizeof(ext4_acl_entry
);
125 e
+= sizeof(ext4_acl_entry_short
);
132 return (char *)ext_acl
;
136 return ERR_PTR(-EINVAL
);
140 * Inode operation get_posix_acl().
142 * inode->i_mutex: don't care
145 ext4_get_acl(struct inode
*inode
, int type
)
149 struct posix_acl
*acl
;
153 case ACL_TYPE_ACCESS
:
154 name_index
= EXT4_XATTR_INDEX_POSIX_ACL_ACCESS
;
156 case ACL_TYPE_DEFAULT
:
157 name_index
= EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT
;
162 retval
= ext4_xattr_get(inode
, name_index
, "", NULL
, 0);
164 value
= kmalloc(retval
, GFP_NOFS
);
166 return ERR_PTR(-ENOMEM
);
167 retval
= ext4_xattr_get(inode
, name_index
, "", value
, retval
);
170 acl
= ext4_acl_from_disk(value
, retval
);
171 else if (retval
== -ENODATA
|| retval
== -ENOSYS
)
174 acl
= ERR_PTR(retval
);
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
, int xattr_flags
)
195 case ACL_TYPE_ACCESS
:
196 name_index
= EXT4_XATTR_INDEX_POSIX_ACL_ACCESS
;
199 case ACL_TYPE_DEFAULT
:
200 name_index
= EXT4_XATTR_INDEX_POSIX_ACL_DEFAULT
;
201 if (!S_ISDIR(inode
->i_mode
))
202 return acl
? -EACCES
: 0;
209 value
= ext4_acl_to_disk(acl
, &size
);
211 return (int)PTR_ERR(value
);
214 error
= ext4_xattr_set_handle(handle
, inode
, name_index
, "",
215 value
, size
, xattr_flags
);
219 set_cached_acl(inode
, type
, acl
);
225 ext4_set_acl(struct inode
*inode
, struct posix_acl
*acl
, int type
)
228 int error
, credits
, retries
= 0;
229 size_t acl_size
= acl
? ext4_acl_size(acl
->a_count
) : 0;
230 umode_t mode
= inode
->i_mode
;
233 error
= dquot_initialize(inode
);
237 error
= ext4_xattr_set_credits(inode
, acl_size
, false /* is_create */,
242 handle
= ext4_journal_start(inode
, EXT4_HT_XATTR
, credits
);
244 return PTR_ERR(handle
);
245 ext4_fc_start_update(inode
);
247 if ((type
== ACL_TYPE_ACCESS
) && acl
) {
248 error
= posix_acl_update_mode(inode
, &mode
, &acl
);
251 if (mode
!= inode
->i_mode
)
255 error
= __ext4_set_acl(handle
, inode
, type
, acl
, 0 /* xattr_flags */);
256 if (!error
&& update_mode
) {
257 inode
->i_mode
= mode
;
258 inode
->i_ctime
= current_time(inode
);
259 error
= ext4_mark_inode_dirty(handle
, inode
);
262 ext4_journal_stop(handle
);
263 ext4_fc_stop_update(inode
);
264 if (error
== -ENOSPC
&& ext4_should_retry_alloc(inode
->i_sb
, &retries
))
270 * Initialize the ACLs of a new inode. Called from ext4_new_inode.
273 * inode->i_mutex: up (access to inode is still exclusive)
276 ext4_init_acl(handle_t
*handle
, struct inode
*inode
, struct inode
*dir
)
278 struct posix_acl
*default_acl
, *acl
;
281 error
= posix_acl_create(dir
, &inode
->i_mode
, &default_acl
, &acl
);
286 error
= __ext4_set_acl(handle
, inode
, ACL_TYPE_DEFAULT
,
287 default_acl
, XATTR_CREATE
);
288 posix_acl_release(default_acl
);
290 inode
->i_default_acl
= NULL
;
294 error
= __ext4_set_acl(handle
, inode
, ACL_TYPE_ACCESS
,
296 posix_acl_release(acl
);