Branch data Line data Source code
1 : : // SPDX-License-Identifier: GPL-2.0
2 : : /*
3 : : * fs/f2fs/acl.c
4 : : *
5 : : * Copyright (c) 2012 Samsung Electronics Co., Ltd.
6 : : * http://www.samsung.com/
7 : : *
8 : : * Portions of this code from linux/fs/ext2/acl.c
9 : : *
10 : : * Copyright (C) 2001-2003 Andreas Gruenbacher, <agruen@suse.de>
11 : : */
12 : : #include <linux/f2fs_fs.h>
13 : : #include "f2fs.h"
14 : : #include "xattr.h"
15 : : #include "acl.h"
16 : :
17 : : static inline size_t f2fs_acl_size(int count)
18 : : {
19 [ # # ]: 0 : if (count <= 4) {
20 : 0 : return sizeof(struct f2fs_acl_header) +
21 : : count * sizeof(struct f2fs_acl_entry_short);
22 : : } else {
23 : 0 : return sizeof(struct f2fs_acl_header) +
24 : : 4 * sizeof(struct f2fs_acl_entry_short) +
25 : 0 : (count - 4) * sizeof(struct f2fs_acl_entry);
26 : : }
27 : : }
28 : :
29 : : static inline int f2fs_acl_count(size_t size)
30 : : {
31 : : ssize_t s;
32 : 0 : size -= sizeof(struct f2fs_acl_header);
33 : 0 : s = size - 4 * sizeof(struct f2fs_acl_entry_short);
34 [ # # ]: 0 : if (s < 0) {
35 [ # # ]: 0 : if (size % sizeof(struct f2fs_acl_entry_short))
36 : : return -1;
37 : 0 : return size / sizeof(struct f2fs_acl_entry_short);
38 : : } else {
39 [ # # ]: 0 : if (s % sizeof(struct f2fs_acl_entry))
40 : : return -1;
41 : 0 : return s / sizeof(struct f2fs_acl_entry) + 4;
42 : : }
43 : : }
44 : :
45 : 0 : static struct posix_acl *f2fs_acl_from_disk(const char *value, size_t size)
46 : : {
47 : : int i, count;
48 : : struct posix_acl *acl;
49 : : struct f2fs_acl_header *hdr = (struct f2fs_acl_header *)value;
50 : 0 : struct f2fs_acl_entry *entry = (struct f2fs_acl_entry *)(hdr + 1);
51 : 0 : const char *end = value + size;
52 : :
53 [ # # ]: 0 : if (size < sizeof(struct f2fs_acl_header))
54 : : return ERR_PTR(-EINVAL);
55 : :
56 [ # # ]: 0 : if (hdr->a_version != cpu_to_le32(F2FS_ACL_VERSION))
57 : : return ERR_PTR(-EINVAL);
58 : :
59 : : count = f2fs_acl_count(size);
60 [ # # ]: 0 : if (count < 0)
61 : : return ERR_PTR(-EINVAL);
62 [ # # ]: 0 : if (count == 0)
63 : : return NULL;
64 : :
65 : 0 : acl = posix_acl_alloc(count, GFP_NOFS);
66 [ # # ]: 0 : if (!acl)
67 : : return ERR_PTR(-ENOMEM);
68 : :
69 [ # # ]: 0 : for (i = 0; i < count; i++) {
70 : :
71 [ # # ]: 0 : if ((char *)entry > end)
72 : : goto fail;
73 : :
74 : 0 : acl->a_entries[i].e_tag = le16_to_cpu(entry->e_tag);
75 : 0 : acl->a_entries[i].e_perm = le16_to_cpu(entry->e_perm);
76 : :
77 [ # # # # ]: 0 : switch (acl->a_entries[i].e_tag) {
78 : : case ACL_USER_OBJ:
79 : : case ACL_GROUP_OBJ:
80 : : case ACL_MASK:
81 : : case ACL_OTHER:
82 : 0 : entry = (struct f2fs_acl_entry *)((char *)entry +
83 : : sizeof(struct f2fs_acl_entry_short));
84 : 0 : break;
85 : :
86 : : case ACL_USER:
87 : 0 : acl->a_entries[i].e_uid =
88 : 0 : make_kuid(&init_user_ns,
89 : : le32_to_cpu(entry->e_id));
90 : 0 : entry = (struct f2fs_acl_entry *)((char *)entry +
91 : : sizeof(struct f2fs_acl_entry));
92 : 0 : break;
93 : : case ACL_GROUP:
94 : 0 : acl->a_entries[i].e_gid =
95 : 0 : make_kgid(&init_user_ns,
96 : : le32_to_cpu(entry->e_id));
97 : 0 : entry = (struct f2fs_acl_entry *)((char *)entry +
98 : : sizeof(struct f2fs_acl_entry));
99 : 0 : break;
100 : : default:
101 : : goto fail;
102 : : }
103 : : }
104 [ # # ]: 0 : if ((char *)entry != end)
105 : : goto fail;
106 : : return acl;
107 : : fail:
108 : 0 : posix_acl_release(acl);
109 : 0 : return ERR_PTR(-EINVAL);
110 : : }
111 : :
112 : 0 : static void *f2fs_acl_to_disk(struct f2fs_sb_info *sbi,
113 : : const struct posix_acl *acl, size_t *size)
114 : : {
115 : : struct f2fs_acl_header *f2fs_acl;
116 : : struct f2fs_acl_entry *entry;
117 : : int i;
118 : :
119 : 0 : f2fs_acl = f2fs_kmalloc(sbi, sizeof(struct f2fs_acl_header) +
120 : 0 : acl->a_count * sizeof(struct f2fs_acl_entry),
121 : : GFP_NOFS);
122 [ # # ]: 0 : if (!f2fs_acl)
123 : : return ERR_PTR(-ENOMEM);
124 : :
125 : 0 : f2fs_acl->a_version = cpu_to_le32(F2FS_ACL_VERSION);
126 : 0 : entry = (struct f2fs_acl_entry *)(f2fs_acl + 1);
127 : :
128 [ # # ]: 0 : for (i = 0; i < acl->a_count; i++) {
129 : :
130 : 0 : entry->e_tag = cpu_to_le16(acl->a_entries[i].e_tag);
131 : 0 : entry->e_perm = cpu_to_le16(acl->a_entries[i].e_perm);
132 : :
133 [ # # # # ]: 0 : switch (acl->a_entries[i].e_tag) {
134 : : case ACL_USER:
135 : 0 : entry->e_id = cpu_to_le32(
136 : : from_kuid(&init_user_ns,
137 : : acl->a_entries[i].e_uid));
138 : 0 : entry = (struct f2fs_acl_entry *)((char *)entry +
139 : : sizeof(struct f2fs_acl_entry));
140 : 0 : break;
141 : : case ACL_GROUP:
142 : 0 : entry->e_id = cpu_to_le32(
143 : : from_kgid(&init_user_ns,
144 : : acl->a_entries[i].e_gid));
145 : 0 : entry = (struct f2fs_acl_entry *)((char *)entry +
146 : : sizeof(struct f2fs_acl_entry));
147 : 0 : break;
148 : : case ACL_USER_OBJ:
149 : : case ACL_GROUP_OBJ:
150 : : case ACL_MASK:
151 : : case ACL_OTHER:
152 : 0 : entry = (struct f2fs_acl_entry *)((char *)entry +
153 : : sizeof(struct f2fs_acl_entry_short));
154 : 0 : break;
155 : : default:
156 : : goto fail;
157 : : }
158 : : }
159 : 0 : *size = f2fs_acl_size(acl->a_count);
160 : 0 : return (void *)f2fs_acl;
161 : :
162 : : fail:
163 : 0 : kvfree(f2fs_acl);
164 : 0 : return ERR_PTR(-EINVAL);
165 : : }
166 : :
167 : 0 : static struct posix_acl *__f2fs_get_acl(struct inode *inode, int type,
168 : : struct page *dpage)
169 : : {
170 : : int name_index = F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT;
171 : : void *value = NULL;
172 : : struct posix_acl *acl;
173 : : int retval;
174 : :
175 [ # # ]: 0 : if (type == ACL_TYPE_ACCESS)
176 : : name_index = F2FS_XATTR_INDEX_POSIX_ACL_ACCESS;
177 : :
178 : 0 : retval = f2fs_getxattr(inode, name_index, "", NULL, 0, dpage);
179 [ # # ]: 0 : if (retval > 0) {
180 : 0 : value = f2fs_kmalloc(F2FS_I_SB(inode), retval, GFP_F2FS_ZERO);
181 [ # # ]: 0 : if (!value)
182 : : return ERR_PTR(-ENOMEM);
183 : 0 : retval = f2fs_getxattr(inode, name_index, "", value,
184 : : retval, dpage);
185 : : }
186 : :
187 [ # # ]: 0 : if (retval > 0)
188 : 0 : acl = f2fs_acl_from_disk(value, retval);
189 [ # # ]: 0 : else if (retval == -ENODATA)
190 : : acl = NULL;
191 : : else
192 : : acl = ERR_PTR(retval);
193 : 0 : kvfree(value);
194 : :
195 : 0 : return acl;
196 : : }
197 : :
198 : 0 : struct posix_acl *f2fs_get_acl(struct inode *inode, int type)
199 : : {
200 : 0 : return __f2fs_get_acl(inode, type, NULL);
201 : : }
202 : :
203 : 0 : static int __f2fs_set_acl(struct inode *inode, int type,
204 : : struct posix_acl *acl, struct page *ipage)
205 : : {
206 : : int name_index;
207 : : void *value = NULL;
208 : 0 : size_t size = 0;
209 : : int error;
210 : 0 : umode_t mode = inode->i_mode;
211 : :
212 [ # # # ]: 0 : switch (type) {
213 : : case ACL_TYPE_ACCESS:
214 : : name_index = F2FS_XATTR_INDEX_POSIX_ACL_ACCESS;
215 [ # # ]: 0 : if (acl && !ipage) {
216 : 0 : error = posix_acl_update_mode(inode, &mode, &acl);
217 [ # # ]: 0 : if (error)
218 : : return error;
219 : 0 : set_acl_inode(inode, mode);
220 : : }
221 : : break;
222 : :
223 : : case ACL_TYPE_DEFAULT:
224 : : name_index = F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT;
225 [ # # ]: 0 : if (!S_ISDIR(inode->i_mode))
226 [ # # ]: 0 : return acl ? -EACCES : 0;
227 : : break;
228 : :
229 : : default:
230 : : return -EINVAL;
231 : : }
232 : :
233 [ # # ]: 0 : if (acl) {
234 : 0 : value = f2fs_acl_to_disk(F2FS_I_SB(inode), acl, &size);
235 [ # # ]: 0 : if (IS_ERR(value)) {
236 : 0 : clear_inode_flag(inode, FI_ACL_MODE);
237 : 0 : return PTR_ERR(value);
238 : : }
239 : : }
240 : :
241 : 0 : error = f2fs_setxattr(inode, name_index, "", value, size, ipage, 0);
242 : :
243 : 0 : kvfree(value);
244 [ # # ]: 0 : if (!error)
245 : 0 : set_cached_acl(inode, type, acl);
246 : :
247 : 0 : clear_inode_flag(inode, FI_ACL_MODE);
248 : 0 : return error;
249 : : }
250 : :
251 : 0 : int f2fs_set_acl(struct inode *inode, struct posix_acl *acl, int type)
252 : : {
253 [ # # ]: 0 : if (unlikely(f2fs_cp_error(F2FS_I_SB(inode))))
254 : : return -EIO;
255 : :
256 : 0 : return __f2fs_set_acl(inode, type, acl, NULL);
257 : : }
258 : :
259 : : /*
260 : : * Most part of f2fs_acl_clone, f2fs_acl_create_masq, f2fs_acl_create
261 : : * are copied from posix_acl.c
262 : : */
263 : 0 : static struct posix_acl *f2fs_acl_clone(const struct posix_acl *acl,
264 : : gfp_t flags)
265 : : {
266 : : struct posix_acl *clone = NULL;
267 : :
268 [ # # ]: 0 : if (acl) {
269 : 0 : int size = sizeof(struct posix_acl) + acl->a_count *
270 : : sizeof(struct posix_acl_entry);
271 : 0 : clone = kmemdup(acl, size, flags);
272 [ # # ]: 0 : if (clone)
273 : : refcount_set(&clone->a_refcount, 1);
274 : : }
275 : 0 : return clone;
276 : : }
277 : :
278 : 0 : static int f2fs_acl_create_masq(struct posix_acl *acl, umode_t *mode_p)
279 : : {
280 : : struct posix_acl_entry *pa, *pe;
281 : : struct posix_acl_entry *group_obj = NULL, *mask_obj = NULL;
282 : 0 : umode_t mode = *mode_p;
283 : : int not_equiv = 0;
284 : :
285 : : /* assert(atomic_read(acl->a_refcount) == 1); */
286 : :
287 [ # # ]: 0 : FOREACH_ACL_ENTRY(pa, acl, pe) {
288 [ # # # # : 0 : switch (pa->e_tag) {
# # ]
289 : : case ACL_USER_OBJ:
290 : 0 : pa->e_perm &= (mode >> 6) | ~S_IRWXO;
291 : 0 : mode &= (pa->e_perm << 6) | ~S_IRWXU;
292 : 0 : break;
293 : :
294 : : case ACL_USER:
295 : : case ACL_GROUP:
296 : : not_equiv = 1;
297 : : break;
298 : :
299 : : case ACL_GROUP_OBJ:
300 : : group_obj = pa;
301 : 0 : break;
302 : :
303 : : case ACL_OTHER:
304 : 0 : pa->e_perm &= mode | ~S_IRWXO;
305 : 0 : mode &= pa->e_perm | ~S_IRWXO;
306 : 0 : break;
307 : :
308 : : case ACL_MASK:
309 : : mask_obj = pa;
310 : : not_equiv = 1;
311 : 0 : break;
312 : :
313 : : default:
314 : : return -EIO;
315 : : }
316 : : }
317 : :
318 [ # # ]: 0 : if (mask_obj) {
319 : 0 : mask_obj->e_perm &= (mode >> 3) | ~S_IRWXO;
320 : 0 : mode &= (mask_obj->e_perm << 3) | ~S_IRWXG;
321 : : } else {
322 [ # # ]: 0 : if (!group_obj)
323 : : return -EIO;
324 : 0 : group_obj->e_perm &= (mode >> 3) | ~S_IRWXO;
325 : 0 : mode &= (group_obj->e_perm << 3) | ~S_IRWXG;
326 : : }
327 : :
328 : 0 : *mode_p = (*mode_p & ~S_IRWXUGO) | mode;
329 : 0 : return not_equiv;
330 : : }
331 : :
332 : 0 : static int f2fs_acl_create(struct inode *dir, umode_t *mode,
333 : : struct posix_acl **default_acl, struct posix_acl **acl,
334 : : struct page *dpage)
335 : : {
336 : : struct posix_acl *p;
337 : : struct posix_acl *clone;
338 : : int ret;
339 : :
340 : 0 : *acl = NULL;
341 : 0 : *default_acl = NULL;
342 : :
343 [ # # # # ]: 0 : if (S_ISLNK(*mode) || !IS_POSIXACL(dir))
344 : : return 0;
345 : :
346 : 0 : p = __f2fs_get_acl(dir, ACL_TYPE_DEFAULT, dpage);
347 [ # # # # ]: 0 : if (!p || p == ERR_PTR(-EOPNOTSUPP)) {
348 : 0 : *mode &= ~current_umask();
349 : 0 : return 0;
350 : : }
351 [ # # ]: 0 : if (IS_ERR(p))
352 : 0 : return PTR_ERR(p);
353 : :
354 : 0 : clone = f2fs_acl_clone(p, GFP_NOFS);
355 [ # # ]: 0 : if (!clone) {
356 : : ret = -ENOMEM;
357 : : goto release_acl;
358 : : }
359 : :
360 : 0 : ret = f2fs_acl_create_masq(clone, mode);
361 [ # # ]: 0 : if (ret < 0)
362 : : goto release_clone;
363 : :
364 [ # # ]: 0 : if (ret == 0)
365 : 0 : posix_acl_release(clone);
366 : : else
367 : 0 : *acl = clone;
368 : :
369 [ # # ]: 0 : if (!S_ISDIR(*mode))
370 : 0 : posix_acl_release(p);
371 : : else
372 : 0 : *default_acl = p;
373 : :
374 : : return 0;
375 : :
376 : : release_clone:
377 : 0 : posix_acl_release(clone);
378 : : release_acl:
379 : 0 : posix_acl_release(p);
380 : 0 : return ret;
381 : : }
382 : :
383 : 0 : int f2fs_init_acl(struct inode *inode, struct inode *dir, struct page *ipage,
384 : : struct page *dpage)
385 : : {
386 : 0 : struct posix_acl *default_acl = NULL, *acl = NULL;
387 : : int error = 0;
388 : :
389 : 0 : error = f2fs_acl_create(dir, &inode->i_mode, &default_acl, &acl, dpage);
390 [ # # ]: 0 : if (error)
391 : : return error;
392 : :
393 : 0 : f2fs_mark_inode_dirty_sync(inode, true);
394 : :
395 [ # # ]: 0 : if (default_acl) {
396 : 0 : error = __f2fs_set_acl(inode, ACL_TYPE_DEFAULT, default_acl,
397 : : ipage);
398 : 0 : posix_acl_release(default_acl);
399 : : } else {
400 : 0 : inode->i_default_acl = NULL;
401 : : }
402 [ # # ]: 0 : if (acl) {
403 [ # # ]: 0 : if (!error)
404 : 0 : error = __f2fs_set_acl(inode, ACL_TYPE_ACCESS, acl,
405 : : ipage);
406 : 0 : posix_acl_release(acl);
407 : : } else {
408 : 0 : inode->i_acl = NULL;
409 : : }
410 : :
411 : 0 : return error;
412 : : }
|
