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
f2fs_xattr_generic_list(const struct xattr_handler * handler,struct dentry * dentry,char * list,size_t list_size,const char * name,size_t len)28 static size_t f2fs_xattr_generic_list(const struct xattr_handler *handler,
29 struct dentry *dentry, char *list, size_t list_size,
30 const char *name, size_t len)
31 {
32 struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
33 int total_len, prefix_len;
34
35 switch (handler->flags) {
36 case F2FS_XATTR_INDEX_USER:
37 if (!test_opt(sbi, XATTR_USER))
38 return -EOPNOTSUPP;
39 break;
40 case F2FS_XATTR_INDEX_TRUSTED:
41 if (!capable(CAP_SYS_ADMIN))
42 return -EPERM;
43 break;
44 case F2FS_XATTR_INDEX_SECURITY:
45 break;
46 default:
47 return -EINVAL;
48 }
49
50 prefix_len = strlen(handler->prefix);
51 total_len = prefix_len + len + 1;
52 if (list && total_len <= list_size) {
53 memcpy(list, handler->prefix, prefix_len);
54 memcpy(list + prefix_len, name, len);
55 list[prefix_len + len] = '\0';
56 }
57 return total_len;
58 }
59
f2fs_xattr_generic_get(const struct xattr_handler * handler,struct dentry * dentry,const char * name,void * buffer,size_t size)60 static int f2fs_xattr_generic_get(const struct xattr_handler *handler,
61 struct dentry *dentry, const char *name, void *buffer,
62 size_t size)
63 {
64 struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
65
66 switch (handler->flags) {
67 case F2FS_XATTR_INDEX_USER:
68 if (!test_opt(sbi, XATTR_USER))
69 return -EOPNOTSUPP;
70 break;
71 case F2FS_XATTR_INDEX_TRUSTED:
72 if (!capable(CAP_SYS_ADMIN))
73 return -EPERM;
74 break;
75 case F2FS_XATTR_INDEX_SECURITY:
76 break;
77 default:
78 return -EINVAL;
79 }
80 if (strcmp(name, "") == 0)
81 return -EINVAL;
82 return f2fs_getxattr(d_inode(dentry), handler->flags, name,
83 buffer, size, NULL);
84 }
85
f2fs_xattr_generic_set(const struct xattr_handler * handler,struct dentry * dentry,const char * name,const void * value,size_t size,int flags)86 static int f2fs_xattr_generic_set(const struct xattr_handler *handler,
87 struct dentry *dentry, const char *name, const void *value,
88 size_t size, int flags)
89 {
90 struct f2fs_sb_info *sbi = F2FS_SB(dentry->d_sb);
91
92 switch (handler->flags) {
93 case F2FS_XATTR_INDEX_USER:
94 if (!test_opt(sbi, XATTR_USER))
95 return -EOPNOTSUPP;
96 break;
97 case F2FS_XATTR_INDEX_TRUSTED:
98 if (!capable(CAP_SYS_ADMIN))
99 return -EPERM;
100 break;
101 case F2FS_XATTR_INDEX_SECURITY:
102 break;
103 default:
104 return -EINVAL;
105 }
106 if (strcmp(name, "") == 0)
107 return -EINVAL;
108
109 return f2fs_setxattr(d_inode(dentry), handler->flags, name,
110 value, size, NULL, flags);
111 }
112
f2fs_xattr_advise_list(const struct xattr_handler * handler,struct dentry * dentry,char * list,size_t list_size,const char * name,size_t len)113 static size_t f2fs_xattr_advise_list(const struct xattr_handler *handler,
114 struct dentry *dentry, char *list, size_t list_size,
115 const char *name, size_t len)
116 {
117 const char *xname = F2FS_SYSTEM_ADVISE_PREFIX;
118 size_t size;
119
120 size = strlen(xname) + 1;
121 if (list && size <= list_size)
122 memcpy(list, xname, size);
123 return size;
124 }
125
f2fs_xattr_advise_get(const struct xattr_handler * handler,struct dentry * dentry,const char * name,void * buffer,size_t size)126 static int f2fs_xattr_advise_get(const struct xattr_handler *handler,
127 struct dentry *dentry, const char *name, void *buffer,
128 size_t size)
129 {
130 struct inode *inode = d_inode(dentry);
131
132 if (strcmp(name, "") != 0)
133 return -EINVAL;
134
135 if (buffer)
136 *((char *)buffer) = F2FS_I(inode)->i_advise;
137 return sizeof(char);
138 }
139
f2fs_xattr_advise_set(const struct xattr_handler * handler,struct dentry * dentry,const char * name,const void * value,size_t size,int flags)140 static int f2fs_xattr_advise_set(const struct xattr_handler *handler,
141 struct dentry *dentry, const char *name, const void *value,
142 size_t size, int flags)
143 {
144 struct inode *inode = d_inode(dentry);
145
146 if (strcmp(name, "") != 0)
147 return -EINVAL;
148 if (!inode_owner_or_capable(inode))
149 return -EPERM;
150 if (value == NULL)
151 return -EINVAL;
152
153 F2FS_I(inode)->i_advise |= *(char *)value;
154 f2fs_mark_inode_dirty_sync(inode, true);
155 return 0;
156 }
157
158 #ifdef CONFIG_F2FS_FS_SECURITY
f2fs_initxattrs(struct inode * inode,const struct xattr * xattr_array,void * page)159 static int f2fs_initxattrs(struct inode *inode, const struct xattr *xattr_array,
160 void *page)
161 {
162 const struct xattr *xattr;
163 int err = 0;
164
165 for (xattr = xattr_array; xattr->name != NULL; xattr++) {
166 err = f2fs_setxattr(inode, F2FS_XATTR_INDEX_SECURITY,
167 xattr->name, xattr->value,
168 xattr->value_len, (struct page *)page, 0);
169 if (err < 0)
170 break;
171 }
172 return err;
173 }
174
f2fs_init_security(struct inode * inode,struct inode * dir,const struct qstr * qstr,struct page * ipage)175 int f2fs_init_security(struct inode *inode, struct inode *dir,
176 const struct qstr *qstr, struct page *ipage)
177 {
178 return security_inode_init_security(inode, dir, qstr,
179 &f2fs_initxattrs, ipage);
180 }
181 #endif
182
183 const struct xattr_handler f2fs_xattr_user_handler = {
184 .prefix = XATTR_USER_PREFIX,
185 .flags = F2FS_XATTR_INDEX_USER,
186 .list = f2fs_xattr_generic_list,
187 .get = f2fs_xattr_generic_get,
188 .set = f2fs_xattr_generic_set,
189 };
190
191 const struct xattr_handler f2fs_xattr_trusted_handler = {
192 .prefix = XATTR_TRUSTED_PREFIX,
193 .flags = F2FS_XATTR_INDEX_TRUSTED,
194 .list = f2fs_xattr_generic_list,
195 .get = f2fs_xattr_generic_get,
196 .set = f2fs_xattr_generic_set,
197 };
198
199 const struct xattr_handler f2fs_xattr_advise_handler = {
200 .prefix = F2FS_SYSTEM_ADVISE_PREFIX,
201 .flags = F2FS_XATTR_INDEX_ADVISE,
202 .list = f2fs_xattr_advise_list,
203 .get = f2fs_xattr_advise_get,
204 .set = f2fs_xattr_advise_set,
205 };
206
207 const struct xattr_handler f2fs_xattr_security_handler = {
208 .prefix = XATTR_SECURITY_PREFIX,
209 .flags = F2FS_XATTR_INDEX_SECURITY,
210 .list = f2fs_xattr_generic_list,
211 .get = f2fs_xattr_generic_get,
212 .set = f2fs_xattr_generic_set,
213 };
214
215 static const struct xattr_handler *f2fs_xattr_handler_map[] = {
216 [F2FS_XATTR_INDEX_USER] = &f2fs_xattr_user_handler,
217 #ifdef CONFIG_F2FS_FS_POSIX_ACL
218 [F2FS_XATTR_INDEX_POSIX_ACL_ACCESS] = &posix_acl_access_xattr_handler,
219 [F2FS_XATTR_INDEX_POSIX_ACL_DEFAULT] = &posix_acl_default_xattr_handler,
220 #endif
221 [F2FS_XATTR_INDEX_TRUSTED] = &f2fs_xattr_trusted_handler,
222 #ifdef CONFIG_F2FS_FS_SECURITY
223 [F2FS_XATTR_INDEX_SECURITY] = &f2fs_xattr_security_handler,
224 #endif
225 [F2FS_XATTR_INDEX_ADVISE] = &f2fs_xattr_advise_handler,
226 };
227
228 const struct xattr_handler *f2fs_xattr_handlers[] = {
229 &f2fs_xattr_user_handler,
230 #ifdef CONFIG_F2FS_FS_POSIX_ACL
231 &posix_acl_access_xattr_handler,
232 &posix_acl_default_xattr_handler,
233 #endif
234 &f2fs_xattr_trusted_handler,
235 #ifdef CONFIG_F2FS_FS_SECURITY
236 &f2fs_xattr_security_handler,
237 #endif
238 &f2fs_xattr_advise_handler,
239 NULL,
240 };
241
f2fs_xattr_handler(int index)242 static inline const struct xattr_handler *f2fs_xattr_handler(int index)
243 {
244 const struct xattr_handler *handler = NULL;
245
246 if (index > 0 && index < ARRAY_SIZE(f2fs_xattr_handler_map))
247 handler = f2fs_xattr_handler_map[index];
248 return handler;
249 }
250
__find_xattr(void * base_addr,int index,size_t len,const char * name)251 static struct f2fs_xattr_entry *__find_xattr(void *base_addr, int index,
252 size_t len, const char *name)
253 {
254 struct f2fs_xattr_entry *entry;
255
256 list_for_each_xattr(entry, base_addr) {
257 if (entry->e_name_index != index)
258 continue;
259 if (entry->e_name_len != len)
260 continue;
261 if (!memcmp(entry->e_name, name, len))
262 break;
263 }
264 return entry;
265 }
266
__find_inline_xattr(struct inode * inode,void * base_addr,void ** last_addr,int index,size_t len,const char * name)267 static struct f2fs_xattr_entry *__find_inline_xattr(struct inode *inode,
268 void *base_addr, void **last_addr, int index,
269 size_t len, const char *name)
270 {
271 struct f2fs_xattr_entry *entry;
272 unsigned int inline_size = inline_xattr_size(inode);
273
274 list_for_each_xattr(entry, base_addr) {
275 if ((void *)entry + sizeof(__u32) > base_addr + inline_size ||
276 (void *)XATTR_NEXT_ENTRY(entry) + sizeof(__u32) >
277 base_addr + inline_size) {
278 *last_addr = entry;
279 return NULL;
280 }
281 if (entry->e_name_index != index)
282 continue;
283 if (entry->e_name_len != len)
284 continue;
285 if (!memcmp(entry->e_name, name, len))
286 break;
287 }
288 return entry;
289 }
290
read_inline_xattr(struct inode * inode,struct page * ipage,void * txattr_addr)291 static int read_inline_xattr(struct inode *inode, struct page *ipage,
292 void *txattr_addr)
293 {
294 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
295 unsigned int inline_size = inline_xattr_size(inode);
296 struct page *page = NULL;
297 void *inline_addr;
298
299 if (ipage) {
300 inline_addr = inline_xattr_addr(inode, ipage);
301 } else {
302 page = get_node_page(sbi, inode->i_ino);
303 if (IS_ERR(page))
304 return PTR_ERR(page);
305
306 inline_addr = inline_xattr_addr(inode, page);
307 }
308 memcpy(txattr_addr, inline_addr, inline_size);
309 f2fs_put_page(page, 1);
310
311 return 0;
312 }
313
read_xattr_block(struct inode * inode,void * txattr_addr)314 static int read_xattr_block(struct inode *inode, void *txattr_addr)
315 {
316 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
317 nid_t xnid = F2FS_I(inode)->i_xattr_nid;
318 unsigned int inline_size = inline_xattr_size(inode);
319 struct page *xpage;
320 void *xattr_addr;
321
322 /* The inode already has an extended attribute block. */
323 xpage = get_node_page(sbi, xnid);
324 if (IS_ERR(xpage))
325 return PTR_ERR(xpage);
326
327 xattr_addr = page_address(xpage);
328 memcpy(txattr_addr + inline_size, xattr_addr, VALID_XATTR_BLOCK_SIZE);
329 f2fs_put_page(xpage, 1);
330
331 return 0;
332 }
333
lookup_all_xattrs(struct inode * inode,struct page * ipage,unsigned int index,unsigned int len,const char * name,struct f2fs_xattr_entry ** xe,void ** base_addr)334 static int lookup_all_xattrs(struct inode *inode, struct page *ipage,
335 unsigned int index, unsigned int len,
336 const char *name, struct f2fs_xattr_entry **xe,
337 void **base_addr)
338 {
339 void *cur_addr, *txattr_addr, *last_addr = NULL;
340 nid_t xnid = F2FS_I(inode)->i_xattr_nid;
341 unsigned int size = xnid ? VALID_XATTR_BLOCK_SIZE : 0;
342 unsigned int inline_size = inline_xattr_size(inode);
343 int err = 0;
344
345 if (!size && !inline_size)
346 return -ENODATA;
347
348 txattr_addr = f2fs_kzalloc(F2FS_I_SB(inode),
349 inline_size + size + XATTR_PADDING_SIZE, GFP_NOFS);
350 if (!txattr_addr)
351 return -ENOMEM;
352
353 /* read from inline xattr */
354 if (inline_size) {
355 err = read_inline_xattr(inode, ipage, txattr_addr);
356 if (err)
357 goto out;
358
359 *xe = __find_inline_xattr(inode, txattr_addr, &last_addr,
360 index, len, name);
361 if (*xe)
362 goto check;
363 }
364
365 /* read from xattr node block */
366 if (xnid) {
367 err = read_xattr_block(inode, txattr_addr);
368 if (err)
369 goto out;
370 }
371
372 if (last_addr)
373 cur_addr = XATTR_HDR(last_addr) - 1;
374 else
375 cur_addr = txattr_addr;
376
377 *xe = __find_xattr(cur_addr, index, len, name);
378 check:
379 if (IS_XATTR_LAST_ENTRY(*xe)) {
380 err = -ENODATA;
381 goto out;
382 }
383
384 *base_addr = txattr_addr;
385 return 0;
386 out:
387 kzfree(txattr_addr);
388 return err;
389 }
390
read_all_xattrs(struct inode * inode,struct page * ipage,void ** base_addr)391 static int read_all_xattrs(struct inode *inode, struct page *ipage,
392 void **base_addr)
393 {
394 struct f2fs_xattr_header *header;
395 nid_t xnid = F2FS_I(inode)->i_xattr_nid;
396 unsigned int size = VALID_XATTR_BLOCK_SIZE;
397 unsigned int inline_size = inline_xattr_size(inode);
398 void *txattr_addr;
399 int err;
400
401 txattr_addr = f2fs_kzalloc(F2FS_I_SB(inode),
402 inline_size + size + XATTR_PADDING_SIZE, GFP_NOFS);
403 if (!txattr_addr)
404 return -ENOMEM;
405
406 /* read from inline xattr */
407 if (inline_size) {
408 err = read_inline_xattr(inode, ipage, txattr_addr);
409 if (err)
410 goto fail;
411 }
412
413 /* read from xattr node block */
414 if (xnid) {
415 err = read_xattr_block(inode, txattr_addr);
416 if (err)
417 goto fail;
418 }
419
420 header = XATTR_HDR(txattr_addr);
421
422 /* never been allocated xattrs */
423 if (le32_to_cpu(header->h_magic) != F2FS_XATTR_MAGIC) {
424 header->h_magic = cpu_to_le32(F2FS_XATTR_MAGIC);
425 header->h_refcount = cpu_to_le32(1);
426 }
427 *base_addr = txattr_addr;
428 return 0;
429 fail:
430 kzfree(txattr_addr);
431 return err;
432 }
433
write_all_xattrs(struct inode * inode,__u32 hsize,void * txattr_addr,struct page * ipage)434 static inline int write_all_xattrs(struct inode *inode, __u32 hsize,
435 void *txattr_addr, struct page *ipage)
436 {
437 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
438 size_t inline_size = inline_xattr_size(inode);
439 struct page *in_page = NULL;
440 void *xattr_addr;
441 void *inline_addr = NULL;
442 struct page *xpage;
443 nid_t new_nid = 0;
444 int err = 0;
445
446 if (hsize > inline_size && !F2FS_I(inode)->i_xattr_nid)
447 if (!alloc_nid(sbi, &new_nid))
448 return -ENOSPC;
449
450 /* write to inline xattr */
451 if (inline_size) {
452 if (ipage) {
453 inline_addr = inline_xattr_addr(inode, ipage);
454 } else {
455 in_page = get_node_page(sbi, inode->i_ino);
456 if (IS_ERR(in_page)) {
457 alloc_nid_failed(sbi, new_nid);
458 return PTR_ERR(in_page);
459 }
460 inline_addr = inline_xattr_addr(inode, in_page);
461 }
462
463 f2fs_wait_on_page_writeback(ipage ? ipage : in_page,
464 NODE, true);
465 /* no need to use xattr node block */
466 if (hsize <= inline_size) {
467 err = truncate_xattr_node(inode);
468 alloc_nid_failed(sbi, new_nid);
469 if (err) {
470 f2fs_put_page(in_page, 1);
471 return err;
472 }
473 memcpy(inline_addr, txattr_addr, inline_size);
474 set_page_dirty(ipage ? ipage : in_page);
475 goto in_page_out;
476 }
477 }
478
479 /* write to xattr node block */
480 if (F2FS_I(inode)->i_xattr_nid) {
481 xpage = get_node_page(sbi, F2FS_I(inode)->i_xattr_nid);
482 if (IS_ERR(xpage)) {
483 err = PTR_ERR(xpage);
484 alloc_nid_failed(sbi, new_nid);
485 goto in_page_out;
486 }
487 f2fs_bug_on(sbi, new_nid);
488 f2fs_wait_on_page_writeback(xpage, NODE, true);
489 } else {
490 struct dnode_of_data dn;
491 set_new_dnode(&dn, inode, NULL, NULL, new_nid);
492 xpage = new_node_page(&dn, XATTR_NODE_OFFSET);
493 if (IS_ERR(xpage)) {
494 err = PTR_ERR(xpage);
495 alloc_nid_failed(sbi, new_nid);
496 goto in_page_out;
497 }
498 alloc_nid_done(sbi, new_nid);
499 }
500 xattr_addr = page_address(xpage);
501
502 if (inline_size)
503 memcpy(inline_addr, txattr_addr, inline_size);
504 memcpy(xattr_addr, txattr_addr + inline_size, VALID_XATTR_BLOCK_SIZE);
505
506 if (inline_size)
507 set_page_dirty(ipage ? ipage : in_page);
508 set_page_dirty(xpage);
509
510 f2fs_put_page(xpage, 1);
511 in_page_out:
512 f2fs_put_page(in_page, 1);
513 return err;
514 }
515
f2fs_getxattr(struct inode * inode,int index,const char * name,void * buffer,size_t buffer_size,struct page * ipage)516 int f2fs_getxattr(struct inode *inode, int index, const char *name,
517 void *buffer, size_t buffer_size, struct page *ipage)
518 {
519 struct f2fs_xattr_entry *entry = NULL;
520 int error = 0;
521 unsigned int size, len;
522 void *base_addr = NULL;
523
524 if (name == NULL)
525 return -EINVAL;
526
527 len = strlen(name);
528 if (len > F2FS_NAME_LEN)
529 return -ERANGE;
530
531 down_read(&F2FS_I(inode)->i_xattr_sem);
532 error = lookup_all_xattrs(inode, ipage, index, len, name,
533 &entry, &base_addr);
534 up_read(&F2FS_I(inode)->i_xattr_sem);
535 if (error)
536 return error;
537
538 size = le16_to_cpu(entry->e_value_size);
539
540 if (buffer && size > buffer_size) {
541 error = -ERANGE;
542 goto out;
543 }
544
545 if (buffer) {
546 char *pval = entry->e_name + entry->e_name_len;
547 memcpy(buffer, pval, size);
548 }
549 error = size;
550 out:
551 kzfree(base_addr);
552 return error;
553 }
554
f2fs_listxattr(struct dentry * dentry,char * buffer,size_t buffer_size)555 ssize_t f2fs_listxattr(struct dentry *dentry, char *buffer, size_t buffer_size)
556 {
557 struct inode *inode = d_inode(dentry);
558 struct f2fs_xattr_entry *entry;
559 void *base_addr;
560 int error = 0;
561 size_t rest = buffer_size;
562
563 down_read(&F2FS_I(inode)->i_xattr_sem);
564 error = read_all_xattrs(inode, NULL, &base_addr);
565 up_read(&F2FS_I(inode)->i_xattr_sem);
566 if (error)
567 return error;
568
569 list_for_each_xattr(entry, base_addr) {
570 const struct xattr_handler *handler =
571 f2fs_xattr_handler(entry->e_name_index);
572 size_t size;
573
574 if (!handler)
575 continue;
576
577 size = handler->list(handler, dentry, buffer, rest,
578 entry->e_name, entry->e_name_len);
579 if (buffer && size > rest) {
580 error = -ERANGE;
581 goto cleanup;
582 }
583
584 if (buffer)
585 buffer += size;
586 rest -= size;
587 }
588 error = buffer_size - rest;
589 cleanup:
590 kzfree(base_addr);
591 return error;
592 }
593
f2fs_xattr_value_same(struct f2fs_xattr_entry * entry,const void * value,size_t size)594 static bool f2fs_xattr_value_same(struct f2fs_xattr_entry *entry,
595 const void *value, size_t size)
596 {
597 void *pval = entry->e_name + entry->e_name_len;
598
599 return (le16_to_cpu(entry->e_value_size) == size) &&
600 !memcmp(pval, value, size);
601 }
602
__f2fs_setxattr(struct inode * inode,int index,const char * name,const void * value,size_t size,struct page * ipage,int flags)603 static int __f2fs_setxattr(struct inode *inode, int index,
604 const char *name, const void *value, size_t size,
605 struct page *ipage, int flags)
606 {
607 struct f2fs_xattr_entry *here, *last;
608 void *base_addr;
609 int found, newsize;
610 size_t len;
611 __u32 new_hsize;
612 int error = 0;
613
614 if (name == NULL)
615 return -EINVAL;
616
617 if (value == NULL)
618 size = 0;
619
620 len = strlen(name);
621
622 if (len > F2FS_NAME_LEN)
623 return -ERANGE;
624
625 if (size > MAX_VALUE_LEN(inode))
626 return -E2BIG;
627
628 error = read_all_xattrs(inode, ipage, &base_addr);
629 if (error)
630 return error;
631
632 /* find entry with wanted name. */
633 here = __find_xattr(base_addr, index, len, name);
634
635 found = IS_XATTR_LAST_ENTRY(here) ? 0 : 1;
636
637 if (found) {
638 if ((flags & XATTR_CREATE)) {
639 error = -EEXIST;
640 goto exit;
641 }
642
643 if (value && f2fs_xattr_value_same(here, value, size))
644 goto exit;
645 } else if ((flags & XATTR_REPLACE)) {
646 error = -ENODATA;
647 goto exit;
648 }
649
650 last = here;
651 while (!IS_XATTR_LAST_ENTRY(last))
652 last = XATTR_NEXT_ENTRY(last);
653
654 newsize = XATTR_ALIGN(sizeof(struct f2fs_xattr_entry) + len + size);
655
656 /* 1. Check space */
657 if (value) {
658 int free;
659 /*
660 * If value is NULL, it is remove operation.
661 * In case of update operation, we calculate free.
662 */
663 free = MIN_OFFSET(inode) - ((char *)last - (char *)base_addr);
664 if (found)
665 free = free + ENTRY_SIZE(here);
666
667 if (unlikely(free < newsize)) {
668 error = -E2BIG;
669 goto exit;
670 }
671 }
672
673 /* 2. Remove old entry */
674 if (found) {
675 /*
676 * If entry is found, remove old entry.
677 * If not found, remove operation is not needed.
678 */
679 struct f2fs_xattr_entry *next = XATTR_NEXT_ENTRY(here);
680 int oldsize = ENTRY_SIZE(here);
681
682 memmove(here, next, (char *)last - (char *)next);
683 last = (struct f2fs_xattr_entry *)((char *)last - oldsize);
684 memset(last, 0, oldsize);
685 }
686
687 new_hsize = (char *)last - (char *)base_addr;
688
689 /* 3. Write new entry */
690 if (value) {
691 char *pval;
692 /*
693 * Before we come here, old entry is removed.
694 * We just write new entry.
695 */
696 last->e_name_index = index;
697 last->e_name_len = len;
698 memcpy(last->e_name, name, len);
699 pval = last->e_name + len;
700 memcpy(pval, value, size);
701 last->e_value_size = cpu_to_le16(size);
702 new_hsize += newsize;
703 }
704
705 error = write_all_xattrs(inode, new_hsize, base_addr, ipage);
706 if (error)
707 goto exit;
708
709 if (is_inode_flag_set(inode, FI_ACL_MODE)) {
710 inode->i_mode = F2FS_I(inode)->i_acl_mode;
711 inode->i_ctime = current_time(inode);
712 clear_inode_flag(inode, FI_ACL_MODE);
713 }
714 if (index == F2FS_XATTR_INDEX_ENCRYPTION &&
715 !strcmp(name, F2FS_XATTR_NAME_ENCRYPTION_CONTEXT))
716 f2fs_set_encrypted_inode(inode);
717 f2fs_mark_inode_dirty_sync(inode, true);
718 if (!error && S_ISDIR(inode->i_mode))
719 set_sbi_flag(F2FS_I_SB(inode), SBI_NEED_CP);
720 exit:
721 kzfree(base_addr);
722 return error;
723 }
724
f2fs_setxattr(struct inode * inode,int index,const char * name,const void * value,size_t size,struct page * ipage,int flags)725 int f2fs_setxattr(struct inode *inode, int index, const char *name,
726 const void *value, size_t size,
727 struct page *ipage, int flags)
728 {
729 struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
730 int err;
731
732 err = dquot_initialize(inode);
733 if (err)
734 return err;
735
736 /* this case is only from init_inode_metadata */
737 if (ipage)
738 return __f2fs_setxattr(inode, index, name, value,
739 size, ipage, flags);
740 f2fs_balance_fs(sbi, true);
741
742 f2fs_lock_op(sbi);
743 /* protect xattr_ver */
744 down_write(&F2FS_I(inode)->i_sem);
745 down_write(&F2FS_I(inode)->i_xattr_sem);
746 err = __f2fs_setxattr(inode, index, name, value, size, ipage, flags);
747 up_write(&F2FS_I(inode)->i_xattr_sem);
748 up_write(&F2FS_I(inode)->i_sem);
749 f2fs_unlock_op(sbi);
750
751 f2fs_update_time(sbi, REQ_TIME);
752 return err;
753 }
754