fs/f2fs/xattr.c

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