Loading...
Note: File does not exist in v3.1.
1/*
2 * fs/f2fs/xattr.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/xattr.c
8 *
9 * Copyright (C) 2001-2003 Andreas Gruenbacher <agruen@suse.de>
10 *
11 * Fix by Harrison Xing <harrison@mountainviewdata.com>.
12 * Extended attributes for symlinks and special files added per
13 * suggestion of Luka Renko <luka.renko@hermes.si>.
14 * xattr consolidation Copyright (c) 2004 James Morris <jmorris@redhat.com>,
15 * Red Hat Inc.
16 *
17 * This program is free software; you can redistribute it and/or modify
18 * it under the terms of the GNU General Public License version 2 as
19 * published by the Free Software Foundation.
20 */
21#include <linux/rwsem.h>
22#include <linux/f2fs_fs.h>
23#include <linux/security.h>
24#include <linux/posix_acl_xattr.h>
25#include "f2fs.h"
26#include "xattr.h"
27
28static int f2fs_xattr_generic_get(const struct xattr_handler *handler,
29 struct dentry *dentry, const char *name, void *buffer,
30 size_t size)
31{
32 struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
33
34 switch (handler->flags) {
35 case F2FS_XATTR_INDEX_USER:
36 if (!test_opt(sbi, XATTR_USER))
37 return -EOPNOTSUPP;
38 break;
39 case F2FS_XATTR_INDEX_TRUSTED:
40 if (!capable(CAP_SYS_ADMIN))
41 return -EPERM;
42 break;
43 case F2FS_XATTR_INDEX_SECURITY:
44 break;
45 default:
46 return -EINVAL;
47 }
48 return f2fs_getxattr(d_inode(dentry), handler->flags, name,
49 buffer, size, NULL);
50}
51
52static int f2fs_xattr_generic_set(const struct xattr_handler *handler,
53 struct dentry *dentry, const char *name, const void *value,
54 size_t size, int flags)
55{
56 struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
57
58 switch (handler->flags) {
59 case F2FS_XATTR_INDEX_USER:
60 if (!test_opt(sbi, XATTR_USER))
61 return -EOPNOTSUPP;
62 break;
63 case F2FS_XATTR_INDEX_TRUSTED:
64 if (!capable(CAP_SYS_ADMIN))
65 return -EPERM;
66 break;
67 case F2FS_XATTR_INDEX_SECURITY:
68 break;
69 default:
70 return -EINVAL;
71 }
72 return f2fs_setxattr(d_inode(dentry), handler->flags, name,
73 value, size, NULL, flags);
74}
75
76static bool f2fs_xattr_user_list(struct dentry *dentry)
77{
78 struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
79
80 return test_opt(sbi, XATTR_USER);
81}
82
83static bool f2fs_xattr_trusted_list(struct dentry *dentry)
84{
85 return capable(CAP_SYS_ADMIN);
86}
87
88static int f2fs_xattr_advise_get(const struct xattr_handler *handler,
89 struct dentry *dentry, const char *name, void *buffer,
90 size_t size)
91{
92 struct inode *inode = d_inode(dentry);
93
94 if (buffer)
95 *((char *)buffer) = F2FS_I(inode)->i_advise;
96 return sizeof(char);
97}
98
99static int f2fs_xattr_advise_set(const struct xattr_handler *handler,
100 struct dentry *dentry, const char *name, const void *value,
101 size_t size, int flags)
102{
103 struct inode *inode = d_inode(dentry);
104
105 if (!inode_owner_or_capable(inode))
106 return -EPERM;
107 if (value == NULL)
108 return -EINVAL;
109
110 F2FS_I(inode)->i_advise |= *(char *)value;
111 mark_inode_dirty(inode);
112 return 0;
113}
114
115#ifdef CONFIG_F2FS_FS_SECURITY
116static int f2fs_initxattrs(struct inode *inode, const struct xattr *xattr_array,
117 void *page)
118{
119 const struct xattr *xattr;
120 int err = 0;
121
122 for (xattr = xattr_array; xattr->name != NULL; xattr++) {
123 err = f2fs_setxattr(inode, F2FS_XATTR_INDEX_SECURITY,
124 xattr->name, xattr->value,
125 xattr->value_len, (struct page *)page, 0);
126 if (err < 0)
127 break;
128 }
129 return err;
130}
131
132int f2fs_init_security(struct inode *inode, struct inode *dir,
133 const struct qstr *qstr, struct page *ipage)
134{
135 return security_inode_init_security(inode, dir, qstr,
136 &f2fs_initxattrs, ipage);
137}
138#endif
139
140const struct xattr_handler f2fs_xattr_user_handler = {
141 .prefix = XATTR_USER_PREFIX,
142 .flags = F2FS_XATTR_INDEX_USER,
143 .list = f2fs_xattr_user_list,
144 .get = f2fs_xattr_generic_get,
145 .set = f2fs_xattr_generic_set,
146};
147
148const struct xattr_handler f2fs_xattr_trusted_handler = {
149 .prefix = XATTR_TRUSTED_PREFIX,
150 .flags = F2FS_XATTR_INDEX_TRUSTED,
151 .list = f2fs_xattr_trusted_list,
152 .get = f2fs_xattr_generic_get,
153 .set = f2fs_xattr_generic_set,
154};
155
156const struct xattr_handler f2fs_xattr_advise_handler = {
157 .name = F2FS_SYSTEM_ADVISE_NAME,
158 .flags = F2FS_XATTR_INDEX_ADVISE,
159 .get = f2fs_xattr_advise_get,
160 .set = f2fs_xattr_advise_set,
161};
162
163const struct xattr_handler f2fs_xattr_security_handler = {
164 .prefix = XATTR_SECURITY_PREFIX,
165 .flags = F2FS_XATTR_INDEX_SECURITY,
166 .get = f2fs_xattr_generic_get,
167 .set = f2fs_xattr_generic_set,
168};
169
170static const struct xattr_handler *f2fs_xattr_handler_map[] = {
171 [F2FS_XATTR_INDEX_USER] = &f2fs_xattr_user_handler,
172#ifdef CONFIG_F2FS_FS_POSIX_ACL
173 [F2FS_XATTR_INDEX_POSIX_ACL_ACCESS] = &posix_acl_access_xattr_handler,
174 [F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT] = &posix_acl_default_xattr_handler,
175#endif
176 [F2FS_XATTR_INDEX_TRUSTED] = &f2fs_xattr_trusted_handler,
177#ifdef CONFIG_F2FS_FS_SECURITY
178 [F2FS_XATTR_INDEX_SECURITY] = &f2fs_xattr_security_handler,
179#endif
180 [F2FS_XATTR_INDEX_ADVISE] = &f2fs_xattr_advise_handler,
181};
182
183const struct xattr_handler *f2fs_xattr_handlers[] = {
184 &f2fs_xattr_user_handler,
185#ifdef CONFIG_F2FS_FS_POSIX_ACL
186 &posix_acl_access_xattr_handler,
187 &posix_acl_default_xattr_handler,
188#endif
189 &f2fs_xattr_trusted_handler,
190#ifdef CONFIG_F2FS_FS_SECURITY
191 &f2fs_xattr_security_handler,
192#endif
193 &f2fs_xattr_advise_handler,
194 NULL,
195};
196
197static inline const struct xattr_handler *f2fs_xattr_handler(int index)
198{
199 const struct xattr_handler *handler = NULL;
200
201 if (index > 0 && index < ARRAY_SIZE(f2fs_xattr_handler_map))
202 handler = f2fs_xattr_handler_map[index];
203 return handler;
204}
205
206static struct f2fs_xattr_entry *__find_xattr(void *base_addr, int index,
207 size_t len, const char *name)
208{
209 struct f2fs_xattr_entry *entry;
210
211 list_for_each_xattr(entry, base_addr) {
212 if (entry->e_name_index != index)
213 continue;
214 if (entry->e_name_len != len)
215 continue;
216 if (!memcmp(entry->e_name, name, len))
217 break;
218 }
219 return entry;
220}
221
222static void *read_all_xattrs(struct inode *inode, struct page *ipage)
223{
224 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
225 struct f2fs_xattr_header *header;
226 size_t size = PAGE_SIZE, inline_size = 0;
227 void *txattr_addr;
228
229 inline_size = inline_xattr_size(inode);
230
231 txattr_addr = kzalloc(inline_size + size, GFP_F2FS_ZERO);
232 if (!txattr_addr)
233 return NULL;
234
235 /* read from inline xattr */
236 if (inline_size) {
237 struct page *page = NULL;
238 void *inline_addr;
239
240 if (ipage) {
241 inline_addr = inline_xattr_addr(ipage);
242 } else {
243 page = get_node_page(sbi, inode->i_ino);
244 if (IS_ERR(page))
245 goto fail;
246 inline_addr = inline_xattr_addr(page);
247 }
248 memcpy(txattr_addr, inline_addr, inline_size);
249 f2fs_put_page(page, 1);
250 }
251
252 /* read from xattr node block */
253 if (F2FS_I(inode)->i_xattr_nid) {
254 struct page *xpage;
255 void *xattr_addr;
256
257 /* The inode already has an extended attribute block. */
258 xpage = get_node_page(sbi, F2FS_I(inode)->i_xattr_nid);
259 if (IS_ERR(xpage))
260 goto fail;
261
262 xattr_addr = page_address(xpage);
263 memcpy(txattr_addr + inline_size, xattr_addr, PAGE_SIZE);
264 f2fs_put_page(xpage, 1);
265 }
266
267 header = XATTR_HDR(txattr_addr);
268
269 /* never been allocated xattrs */
270 if (le32_to_cpu(header->h_magic) != F2FS_XATTR_MAGIC) {
271 header->h_magic = cpu_to_le32(F2FS_XATTR_MAGIC);
272 header->h_refcount = cpu_to_le32(1);
273 }
274 return txattr_addr;
275fail:
276 kzfree(txattr_addr);
277 return NULL;
278}
279
280static inline int write_all_xattrs(struct inode *inode, __u32 hsize,
281 void *txattr_addr, struct page *ipage)
282{
283 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
284 size_t inline_size = 0;
285 void *xattr_addr;
286 struct page *xpage;
287 nid_t new_nid = 0;
288 int err;
289
290 inline_size = inline_xattr_size(inode);
291
292 if (hsize > inline_size && !F2FS_I(inode)->i_xattr_nid)
293 if (!alloc_nid(sbi, &new_nid))
294 return -ENOSPC;
295
296 /* write to inline xattr */
297 if (inline_size) {
298 struct page *page = NULL;
299 void *inline_addr;
300
301 if (ipage) {
302 inline_addr = inline_xattr_addr(ipage);
303 f2fs_wait_on_page_writeback(ipage, NODE, true);
304 } else {
305 page = get_node_page(sbi, inode->i_ino);
306 if (IS_ERR(page)) {
307 alloc_nid_failed(sbi, new_nid);
308 return PTR_ERR(page);
309 }
310 inline_addr = inline_xattr_addr(page);
311 f2fs_wait_on_page_writeback(page, NODE, true);
312 }
313 memcpy(inline_addr, txattr_addr, inline_size);
314 f2fs_put_page(page, 1);
315
316 /* no need to use xattr node block */
317 if (hsize <= inline_size) {
318 err = truncate_xattr_node(inode, ipage);
319 alloc_nid_failed(sbi, new_nid);
320 return err;
321 }
322 }
323
324 /* write to xattr node block */
325 if (F2FS_I(inode)->i_xattr_nid) {
326 xpage = get_node_page(sbi, F2FS_I(inode)->i_xattr_nid);
327 if (IS_ERR(xpage)) {
328 alloc_nid_failed(sbi, new_nid);
329 return PTR_ERR(xpage);
330 }
331 f2fs_bug_on(sbi, new_nid);
332 f2fs_wait_on_page_writeback(xpage, NODE, true);
333 } else {
334 struct dnode_of_data dn;
335 set_new_dnode(&dn, inode, NULL, NULL, new_nid);
336 xpage = new_node_page(&dn, XATTR_NODE_OFFSET, ipage);
337 if (IS_ERR(xpage)) {
338 alloc_nid_failed(sbi, new_nid);
339 return PTR_ERR(xpage);
340 }
341 alloc_nid_done(sbi, new_nid);
342 }
343
344 xattr_addr = page_address(xpage);
345 memcpy(xattr_addr, txattr_addr + inline_size, PAGE_SIZE -
346 sizeof(struct node_footer));
347 set_page_dirty(xpage);
348 f2fs_put_page(xpage, 1);
349
350 /* need to checkpoint during fsync */
351 F2FS_I(inode)->xattr_ver = cur_cp_version(F2FS_CKPT(sbi));
352 return 0;
353}
354
355int f2fs_getxattr(struct inode *inode, int index, const char *name,
356 void *buffer, size_t buffer_size, struct page *ipage)
357{
358 struct f2fs_xattr_entry *entry;
359 void *base_addr;
360 int error = 0;
361 size_t size, len;
362
363 if (name == NULL)
364 return -EINVAL;
365
366 len = strlen(name);
367 if (len > F2FS_NAME_LEN)
368 return -ERANGE;
369
370 base_addr = read_all_xattrs(inode, ipage);
371 if (!base_addr)
372 return -ENOMEM;
373
374 entry = __find_xattr(base_addr, index, len, name);
375 if (IS_XATTR_LAST_ENTRY(entry)) {
376 error = -ENODATA;
377 goto cleanup;
378 }
379
380 size = le16_to_cpu(entry->e_value_size);
381
382 if (buffer && size > buffer_size) {
383 error = -ERANGE;
384 goto cleanup;
385 }
386
387 if (buffer) {
388 char *pval = entry->e_name + entry->e_name_len;
389 memcpy(buffer, pval, size);
390 }
391 error = size;
392
393cleanup:
394 kzfree(base_addr);
395 return error;
396}
397
398ssize_t f2fs_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
399{
400 struct inode *inode = d_inode(dentry);
401 struct f2fs_xattr_entry *entry;
402 void *base_addr;
403 int error = 0;
404 size_t rest = buffer_size;
405
406 base_addr = read_all_xattrs(inode, NULL);
407 if (!base_addr)
408 return -ENOMEM;
409
410 list_for_each_xattr(entry, base_addr) {
411 const struct xattr_handler *handler =
412 f2fs_xattr_handler(entry->e_name_index);
413 const char *prefix;
414 size_t prefix_len;
415 size_t size;
416
417 if (!handler || (handler->list && !handler->list(dentry)))
418 continue;
419
420 prefix = handler->prefix ?: handler->name;
421 prefix_len = strlen(prefix);
422 size = prefix_len + entry->e_name_len + 1;
423 if (buffer) {
424 if (size > rest) {
425 error = -ERANGE;
426 goto cleanup;
427 }
428 memcpy(buffer, prefix, prefix_len);
429 buffer += prefix_len;
430 memcpy(buffer, entry->e_name, entry->e_name_len);
431 buffer += entry->e_name_len;
432 *buffer++ = 0;
433 }
434 rest -= size;
435 }
436 error = buffer_size - rest;
437cleanup:
438 kzfree(base_addr);
439 return error;
440}
441
442static int __f2fs_setxattr(struct inode *inode, int index,
443 const char *name, const void *value, size_t size,
444 struct page *ipage, int flags)
445{
446 struct f2fs_inode_info *fi = F2FS_I(inode);
447 struct f2fs_xattr_entry *here, *last;
448 void *base_addr;
449 int found, newsize;
450 size_t len;
451 __u32 new_hsize;
452 int error = -ENOMEM;
453
454 if (name == NULL)
455 return -EINVAL;
456
457 if (value == NULL)
458 size = 0;
459
460 len = strlen(name);
461
462 if (len > F2FS_NAME_LEN)
463 return -ERANGE;
464
465 if (size > MAX_VALUE_LEN(inode))
466 return -E2BIG;
467
468 base_addr = read_all_xattrs(inode, ipage);
469 if (!base_addr)
470 goto exit;
471
472 /* find entry with wanted name. */
473 here = __find_xattr(base_addr, index, len, name);
474
475 found = IS_XATTR_LAST_ENTRY(here) ? 0 : 1;
476
477 if ((flags & XATTR_REPLACE) && !found) {
478 error = -ENODATA;
479 goto exit;
480 } else if ((flags & XATTR_CREATE) && found) {
481 error = -EEXIST;
482 goto exit;
483 }
484
485 last = here;
486 while (!IS_XATTR_LAST_ENTRY(last))
487 last = XATTR_NEXT_ENTRY(last);
488
489 newsize = XATTR_ALIGN(sizeof(struct f2fs_xattr_entry) + len + size);
490
491 /* 1. Check space */
492 if (value) {
493 int free;
494 /*
495 * If value is NULL, it is remove operation.
496 * In case of update operation, we calculate free.
497 */
498 free = MIN_OFFSET(inode) - ((char *)last - (char *)base_addr);
499 if (found)
500 free = free + ENTRY_SIZE(here);
501
502 if (unlikely(free < newsize)) {
503 error = -ENOSPC;
504 goto exit;
505 }
506 }
507
508 /* 2. Remove old entry */
509 if (found) {
510 /*
511 * If entry is found, remove old entry.
512 * If not found, remove operation is not needed.
513 */
514 struct f2fs_xattr_entry *next = XATTR_NEXT_ENTRY(here);
515 int oldsize = ENTRY_SIZE(here);
516
517 memmove(here, next, (char *)last - (char *)next);
518 last = (struct f2fs_xattr_entry *)((char *)last - oldsize);
519 memset(last, 0, oldsize);
520 }
521
522 new_hsize = (char *)last - (char *)base_addr;
523
524 /* 3. Write new entry */
525 if (value) {
526 char *pval;
527 /*
528 * Before we come here, old entry is removed.
529 * We just write new entry.
530 */
531 memset(last, 0, newsize);
532 last->e_name_index = index;
533 last->e_name_len = len;
534 memcpy(last->e_name, name, len);
535 pval = last->e_name + len;
536 memcpy(pval, value, size);
537 last->e_value_size = cpu_to_le16(size);
538 new_hsize += newsize;
539 }
540
541 error = write_all_xattrs(inode, new_hsize, base_addr, ipage);
542 if (error)
543 goto exit;
544
545 if (is_inode_flag_set(fi, FI_ACL_MODE)) {
546 inode->i_mode = fi->i_acl_mode;
547 inode->i_ctime = CURRENT_TIME;
548 clear_inode_flag(fi, FI_ACL_MODE);
549 }
550 if (index == F2FS_XATTR_INDEX_ENCRYPTION &&
551 !strcmp(name, F2FS_XATTR_NAME_ENCRYPTION_CONTEXT))
552 f2fs_set_encrypted_inode(inode);
553
554 if (ipage)
555 update_inode(inode, ipage);
556 else
557 update_inode_page(inode);
558exit:
559 kzfree(base_addr);
560 return error;
561}
562
563int f2fs_setxattr(struct inode *inode, int index, const char *name,
564 const void *value, size_t size,
565 struct page *ipage, int flags)
566{
567 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
568 int err;
569
570 /* this case is only from init_inode_metadata */
571 if (ipage)
572 return __f2fs_setxattr(inode, index, name, value,
573 size, ipage, flags);
574 f2fs_balance_fs(sbi, true);
575
576 f2fs_lock_op(sbi);
577 /* protect xattr_ver */
578 down_write(&F2FS_I(inode)->i_sem);
579 err = __f2fs_setxattr(inode, index, name, value, size, ipage, flags);
580 up_write(&F2FS_I(inode)->i_sem);
581 f2fs_unlock_op(sbi);
582
583 f2fs_update_time(sbi, REQ_TIME);
584 return err;
585}