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