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