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