1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * fs/f2fs/inline.c 4 * Copyright (c) 2013, Intel Corporation 5 * Authors: Huajun Li <huajun.li@intel.com> 6 * Haicheng Li <haicheng.li@intel.com> 7 */ 8 9 #include <linux/fs.h> 10 #include <linux/f2fs_fs.h> 11 #include <linux/fiemap.h> 12 #include <linux/fserror.h> 13 14 #include "f2fs.h" 15 #include "node.h" 16 #include <trace/events/f2fs.h> 17 18 static bool support_inline_data(struct inode *inode) 19 { 20 if (f2fs_used_in_atomic_write(inode)) 21 return false; 22 if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode)) 23 return false; 24 if (i_size_read(inode) > MAX_INLINE_DATA(inode)) 25 return false; 26 return true; 27 } 28 29 bool f2fs_may_inline_data(struct inode *inode) 30 { 31 if (!support_inline_data(inode)) 32 return false; 33 34 return !f2fs_post_read_required(inode); 35 } 36 37 static bool inode_has_blocks(struct inode *inode, struct folio *ifolio) 38 { 39 struct f2fs_inode *ri = F2FS_INODE(ifolio); 40 int i; 41 42 if (F2FS_HAS_BLOCKS(inode)) 43 return true; 44 45 for (i = 0; i < DEF_NIDS_PER_INODE; i++) { 46 if (ri->i_nid[i]) 47 return true; 48 } 49 return false; 50 } 51 52 bool f2fs_sanity_check_inline_data(struct inode *inode, struct folio *ifolio) 53 { 54 if (!f2fs_has_inline_data(inode)) 55 return false; 56 57 if (inode_has_blocks(inode, ifolio)) 58 return false; 59 60 if (!support_inline_data(inode)) 61 return true; 62 63 /* 64 * used by sanity_check_inode(), when disk layout fields has not 65 * been synchronized to inmem fields. 66 */ 67 return (S_ISREG(inode->i_mode) && 68 (file_is_encrypt(inode) || file_is_verity(inode) || 69 (F2FS_I(inode)->i_flags & F2FS_COMPR_FL))); 70 } 71 72 bool f2fs_may_inline_dentry(struct inode *inode) 73 { 74 if (!test_opt(F2FS_I_SB(inode), INLINE_DENTRY)) 75 return false; 76 77 if (!S_ISDIR(inode->i_mode)) 78 return false; 79 80 return true; 81 } 82 83 void f2fs_do_read_inline_data(struct folio *folio, struct folio *ifolio) 84 { 85 struct inode *inode = folio->mapping->host; 86 87 if (folio_test_uptodate(folio)) 88 return; 89 90 f2fs_bug_on(F2FS_I_SB(inode), folio->index); 91 92 folio_zero_segment(folio, MAX_INLINE_DATA(inode), folio_size(folio)); 93 94 /* Copy the whole inline data block */ 95 memcpy_to_folio(folio, 0, inline_data_addr(inode, ifolio), 96 MAX_INLINE_DATA(inode)); 97 if (!folio_test_uptodate(folio)) 98 folio_mark_uptodate(folio); 99 } 100 101 void f2fs_truncate_inline_inode(struct inode *inode, struct folio *ifolio, 102 u64 from) 103 { 104 void *addr; 105 106 if (from >= MAX_INLINE_DATA(inode)) 107 return; 108 109 addr = inline_data_addr(inode, ifolio); 110 111 f2fs_folio_wait_writeback(ifolio, NODE, true, true); 112 memset(addr + from, 0, MAX_INLINE_DATA(inode) - from); 113 folio_mark_dirty(ifolio); 114 115 if (from == 0) 116 clear_inode_flag(inode, FI_DATA_EXIST); 117 } 118 119 int f2fs_read_inline_data(struct inode *inode, struct folio *folio) 120 { 121 struct folio *ifolio; 122 123 ifolio = f2fs_get_inode_folio(F2FS_I_SB(inode), inode->i_ino); 124 if (IS_ERR(ifolio)) { 125 folio_unlock(folio); 126 return PTR_ERR(ifolio); 127 } 128 129 if (!f2fs_has_inline_data(inode)) { 130 f2fs_folio_put(ifolio, true); 131 return -EAGAIN; 132 } 133 134 if (folio->index) 135 folio_zero_segment(folio, 0, folio_size(folio)); 136 else 137 f2fs_do_read_inline_data(folio, ifolio); 138 139 if (!folio_test_uptodate(folio)) 140 folio_mark_uptodate(folio); 141 f2fs_folio_put(ifolio, true); 142 folio_unlock(folio); 143 return 0; 144 } 145 146 int f2fs_convert_inline_folio(struct dnode_of_data *dn, struct folio *folio) 147 { 148 struct f2fs_io_info fio = { 149 .sbi = F2FS_I_SB(dn->inode), 150 .ino = dn->inode->i_ino, 151 .type = DATA, 152 .op = REQ_OP_WRITE, 153 .op_flags = REQ_SYNC | REQ_PRIO, 154 .folio = folio, 155 .encrypted_page = NULL, 156 .io_type = FS_DATA_IO, 157 }; 158 struct node_info ni; 159 int dirty, err; 160 161 if (!f2fs_exist_data(dn->inode)) 162 goto clear_out; 163 164 err = f2fs_reserve_block(dn, 0); 165 if (err) 166 return err; 167 168 err = f2fs_get_node_info(fio.sbi, dn->nid, &ni, false); 169 if (err) { 170 f2fs_truncate_data_blocks_range(dn, 1); 171 f2fs_put_dnode(dn); 172 return err; 173 } 174 175 fio.version = ni.version; 176 177 if (unlikely(dn->data_blkaddr != NEW_ADDR)) { 178 f2fs_put_dnode(dn); 179 set_sbi_flag(fio.sbi, SBI_NEED_FSCK); 180 f2fs_warn(fio.sbi, "%s: corrupted inline inode ino=%llu, i_addr[0]:0x%x, run fsck to fix.", 181 __func__, dn->inode->i_ino, dn->data_blkaddr); 182 f2fs_handle_error(fio.sbi, ERROR_INVALID_BLKADDR); 183 fserror_report_file_metadata(dn->inode, -EFSCORRUPTED, GFP_NOFS); 184 return -EFSCORRUPTED; 185 } 186 187 f2fs_bug_on(F2FS_F_SB(folio), folio_test_writeback(folio)); 188 189 f2fs_do_read_inline_data(folio, dn->inode_folio); 190 folio_mark_dirty(folio); 191 192 /* clear dirty state */ 193 dirty = folio_clear_dirty_for_io(folio); 194 195 /* write data page to try to make data consistent */ 196 folio_start_writeback(folio); 197 fio.old_blkaddr = dn->data_blkaddr; 198 set_inode_flag(dn->inode, FI_HOT_DATA); 199 f2fs_outplace_write_data(dn, &fio); 200 f2fs_folio_wait_writeback(folio, DATA, true, true); 201 if (dirty) { 202 inode_dec_dirty_pages(dn->inode); 203 f2fs_remove_dirty_inode(dn->inode); 204 } 205 206 /* this converted inline_data should be recovered. */ 207 set_inode_flag(dn->inode, FI_APPEND_WRITE); 208 209 /* clear inline data and flag after data writeback */ 210 f2fs_truncate_inline_inode(dn->inode, dn->inode_folio, 0); 211 folio_clear_f2fs_inline(dn->inode_folio); 212 clear_out: 213 stat_dec_inline_inode(dn->inode); 214 clear_inode_flag(dn->inode, FI_INLINE_DATA); 215 f2fs_put_dnode(dn); 216 return 0; 217 } 218 219 int f2fs_convert_inline_inode(struct inode *inode) 220 { 221 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 222 struct dnode_of_data dn; 223 struct f2fs_lock_context lc; 224 struct folio *ifolio, *folio; 225 int err = 0; 226 227 if (f2fs_hw_is_readonly(sbi) || f2fs_readonly(sbi->sb)) 228 return -EROFS; 229 230 if (!f2fs_has_inline_data(inode)) 231 return 0; 232 233 err = f2fs_dquot_initialize(inode); 234 if (err) 235 return err; 236 237 folio = f2fs_grab_cache_folio(inode->i_mapping, 0, false); 238 if (IS_ERR(folio)) 239 return PTR_ERR(folio); 240 241 f2fs_lock_op(sbi, &lc); 242 243 ifolio = f2fs_get_inode_folio(sbi, inode->i_ino); 244 if (IS_ERR(ifolio)) { 245 err = PTR_ERR(ifolio); 246 goto out; 247 } 248 249 set_new_dnode(&dn, inode, ifolio, ifolio, 0); 250 251 if (f2fs_has_inline_data(inode)) 252 err = f2fs_convert_inline_folio(&dn, folio); 253 254 f2fs_put_dnode(&dn); 255 out: 256 f2fs_unlock_op(sbi, &lc); 257 258 f2fs_folio_put(folio, true); 259 260 if (!err) 261 f2fs_balance_fs(sbi, dn.node_changed); 262 263 return err; 264 } 265 266 int f2fs_write_inline_data(struct inode *inode, struct folio *folio) 267 { 268 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 269 struct folio *ifolio; 270 271 ifolio = f2fs_get_inode_folio(sbi, inode->i_ino); 272 if (IS_ERR(ifolio)) 273 return PTR_ERR(ifolio); 274 275 if (!f2fs_has_inline_data(inode)) { 276 f2fs_folio_put(ifolio, true); 277 return -EAGAIN; 278 } 279 280 f2fs_bug_on(F2FS_I_SB(inode), folio->index); 281 282 f2fs_folio_wait_writeback(ifolio, NODE, true, true); 283 memcpy_from_folio(inline_data_addr(inode, ifolio), 284 folio, 0, MAX_INLINE_DATA(inode)); 285 folio_mark_dirty(ifolio); 286 287 f2fs_clear_page_cache_dirty_tag(folio); 288 289 set_inode_flag(inode, FI_APPEND_WRITE); 290 set_inode_flag(inode, FI_DATA_EXIST); 291 292 folio_clear_f2fs_inline(ifolio); 293 f2fs_folio_put(ifolio, true); 294 return 0; 295 } 296 297 int f2fs_recover_inline_data(struct inode *inode, struct folio *nfolio) 298 { 299 struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 300 struct f2fs_inode *ri = NULL; 301 void *src_addr, *dst_addr; 302 303 /* 304 * The inline_data recovery policy is as follows. 305 * [prev.] [next] of inline_data flag 306 * o o -> recover inline_data 307 * o x -> remove inline_data, and then recover data blocks 308 * x o -> remove data blocks, and then recover inline_data 309 * x x -> recover data blocks 310 */ 311 if (IS_INODE(nfolio)) 312 ri = F2FS_INODE(nfolio); 313 314 if (f2fs_has_inline_data(inode) && 315 ri && (ri->i_inline & F2FS_INLINE_DATA)) { 316 struct folio *ifolio; 317 process_inline: 318 ifolio = f2fs_get_inode_folio(sbi, inode->i_ino); 319 if (IS_ERR(ifolio)) 320 return PTR_ERR(ifolio); 321 322 f2fs_folio_wait_writeback(ifolio, NODE, true, true); 323 324 src_addr = inline_data_addr(inode, nfolio); 325 dst_addr = inline_data_addr(inode, ifolio); 326 memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode)); 327 328 set_inode_flag(inode, FI_INLINE_DATA); 329 set_inode_flag(inode, FI_DATA_EXIST); 330 331 folio_mark_dirty(ifolio); 332 f2fs_folio_put(ifolio, true); 333 return 1; 334 } 335 336 if (f2fs_has_inline_data(inode)) { 337 struct folio *ifolio = f2fs_get_inode_folio(sbi, inode->i_ino); 338 if (IS_ERR(ifolio)) 339 return PTR_ERR(ifolio); 340 f2fs_truncate_inline_inode(inode, ifolio, 0); 341 stat_dec_inline_inode(inode); 342 clear_inode_flag(inode, FI_INLINE_DATA); 343 f2fs_folio_put(ifolio, true); 344 } else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) { 345 int ret; 346 347 ret = f2fs_truncate_blocks(inode, 0, false); 348 if (ret) 349 return ret; 350 stat_inc_inline_inode(inode); 351 goto process_inline; 352 } 353 return 0; 354 } 355 356 struct f2fs_dir_entry *f2fs_find_in_inline_dir(struct inode *dir, 357 const struct f2fs_filename *fname, 358 struct folio **res_folio, 359 bool use_hash) 360 { 361 struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb); 362 struct f2fs_dir_entry *de; 363 struct f2fs_dentry_ptr d; 364 struct folio *ifolio; 365 void *inline_dentry; 366 367 ifolio = f2fs_get_inode_folio(sbi, dir->i_ino); 368 if (IS_ERR(ifolio)) { 369 *res_folio = ifolio; 370 return NULL; 371 } 372 373 inline_dentry = inline_data_addr(dir, ifolio); 374 375 make_dentry_ptr_inline(dir, &d, inline_dentry); 376 de = f2fs_find_target_dentry(&d, fname, NULL, use_hash); 377 folio_unlock(ifolio); 378 if (IS_ERR(de)) { 379 *res_folio = ERR_CAST(de); 380 de = NULL; 381 } 382 if (de) 383 *res_folio = ifolio; 384 else 385 f2fs_folio_put(ifolio, false); 386 387 return de; 388 } 389 390 int f2fs_make_empty_inline_dir(struct inode *inode, struct inode *parent, 391 struct folio *ifolio) 392 { 393 struct f2fs_dentry_ptr d; 394 void *inline_dentry; 395 396 inline_dentry = inline_data_addr(inode, ifolio); 397 398 make_dentry_ptr_inline(inode, &d, inline_dentry); 399 f2fs_do_make_empty_dir(inode, parent, &d); 400 401 folio_mark_dirty(ifolio); 402 403 /* update i_size to MAX_INLINE_DATA */ 404 if (i_size_read(inode) < MAX_INLINE_DATA(inode)) 405 f2fs_i_size_write(inode, MAX_INLINE_DATA(inode)); 406 return 0; 407 } 408 409 /* 410 * NOTE: ipage is grabbed by caller, but if any error occurs, we should 411 * release ipage in this function. 412 */ 413 static int f2fs_move_inline_dirents(struct inode *dir, struct folio *ifolio, 414 void *inline_dentry) 415 { 416 struct folio *folio; 417 struct dnode_of_data dn; 418 struct f2fs_dentry_block *dentry_blk; 419 struct f2fs_dentry_ptr src, dst; 420 int err; 421 422 folio = f2fs_grab_cache_folio(dir->i_mapping, 0, true); 423 if (IS_ERR(folio)) { 424 f2fs_folio_put(ifolio, true); 425 return PTR_ERR(folio); 426 } 427 428 set_new_dnode(&dn, dir, ifolio, NULL, 0); 429 err = f2fs_reserve_block(&dn, 0); 430 if (err) 431 goto out; 432 433 if (unlikely(dn.data_blkaddr != NEW_ADDR)) { 434 f2fs_put_dnode(&dn); 435 set_sbi_flag(F2FS_F_SB(folio), SBI_NEED_FSCK); 436 f2fs_warn(F2FS_F_SB(folio), "%s: corrupted inline inode ino=%llu, i_addr[0]:0x%x, run fsck to fix.", 437 __func__, dir->i_ino, dn.data_blkaddr); 438 f2fs_handle_error(F2FS_F_SB(folio), ERROR_INVALID_BLKADDR); 439 err = -EFSCORRUPTED; 440 fserror_report_file_metadata(dn.inode, err, GFP_NOFS); 441 goto out; 442 } 443 444 f2fs_folio_wait_writeback(folio, DATA, true, true); 445 446 dentry_blk = folio_address(folio); 447 448 /* 449 * Start by zeroing the full block, to ensure that all unused space is 450 * zeroed and no uninitialized memory is leaked to disk. 451 */ 452 memset(dentry_blk, 0, F2FS_BLKSIZE); 453 454 make_dentry_ptr_inline(dir, &src, inline_dentry); 455 make_dentry_ptr_block(dir, &dst, dentry_blk); 456 457 /* copy data from inline dentry block to new dentry block */ 458 memcpy(dst.bitmap, src.bitmap, src.nr_bitmap); 459 memcpy(dst.dentry, src.dentry, SIZE_OF_DIR_ENTRY * src.max); 460 memcpy(dst.filename, src.filename, src.max * F2FS_SLOT_LEN); 461 462 if (!folio_test_uptodate(folio)) 463 folio_mark_uptodate(folio); 464 folio_mark_dirty(folio); 465 466 /* clear inline dir and flag after data writeback */ 467 f2fs_truncate_inline_inode(dir, ifolio, 0); 468 469 stat_dec_inline_dir(dir); 470 clear_inode_flag(dir, FI_INLINE_DENTRY); 471 472 /* 473 * should retrieve reserved space which was used to keep 474 * inline_dentry's structure for backward compatibility. 475 */ 476 if (!f2fs_sb_has_flexible_inline_xattr(F2FS_I_SB(dir)) && 477 !f2fs_has_inline_xattr(dir)) 478 F2FS_I(dir)->i_inline_xattr_size = 0; 479 480 f2fs_i_depth_write(dir, 1); 481 if (i_size_read(dir) < PAGE_SIZE) 482 f2fs_i_size_write(dir, PAGE_SIZE); 483 out: 484 f2fs_folio_put(folio, true); 485 return err; 486 } 487 488 static int f2fs_add_inline_entries(struct inode *dir, void *inline_dentry) 489 { 490 struct f2fs_dentry_ptr d; 491 unsigned long bit_pos = 0; 492 int err = 0; 493 494 make_dentry_ptr_inline(dir, &d, inline_dentry); 495 496 while (bit_pos < d.max) { 497 struct f2fs_dir_entry *de; 498 struct f2fs_filename fname; 499 nid_t ino; 500 umode_t fake_mode; 501 502 if (!test_bit_le(bit_pos, d.bitmap)) { 503 bit_pos++; 504 continue; 505 } 506 507 de = &d.dentry[bit_pos]; 508 509 if (unlikely(!de->name_len)) { 510 bit_pos++; 511 continue; 512 } 513 if (unlikely(le16_to_cpu(de->name_len) > F2FS_NAME_LEN || 514 bit_pos + GET_DENTRY_SLOTS(le16_to_cpu(de->name_len)) > 515 d.max)) { 516 err = -EFSCORRUPTED; 517 goto punch_dentry_pages; 518 } 519 520 /* 521 * We only need the disk_name and hash to move the dentry. 522 * We don't need the original or casefolded filenames. 523 */ 524 memset(&fname, 0, sizeof(fname)); 525 fname.disk_name.name = d.filename[bit_pos]; 526 fname.disk_name.len = le16_to_cpu(de->name_len); 527 fname.hash = de->hash_code; 528 529 ino = le32_to_cpu(de->ino); 530 fake_mode = fs_ftype_to_dtype(de->file_type) << S_DT_SHIFT; 531 532 err = f2fs_add_regular_entry(dir, &fname, NULL, ino, fake_mode); 533 if (err) 534 goto punch_dentry_pages; 535 536 bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len)); 537 } 538 return 0; 539 540 punch_dentry_pages: 541 truncate_inode_pages(&dir->i_data, 0); 542 f2fs_truncate_blocks(dir, 0, false); 543 f2fs_remove_dirty_inode(dir); 544 return err; 545 } 546 547 static int f2fs_move_rehashed_dirents(struct inode *dir, struct folio *ifolio, 548 void *inline_dentry) 549 { 550 void *backup_dentry; 551 int err; 552 553 backup_dentry = f2fs_kmalloc(F2FS_I_SB(dir), 554 MAX_INLINE_DATA(dir), GFP_F2FS_ZERO); 555 if (!backup_dentry) { 556 f2fs_folio_put(ifolio, true); 557 return -ENOMEM; 558 } 559 560 memcpy(backup_dentry, inline_dentry, MAX_INLINE_DATA(dir)); 561 f2fs_truncate_inline_inode(dir, ifolio, 0); 562 563 folio_unlock(ifolio); 564 565 err = f2fs_add_inline_entries(dir, backup_dentry); 566 if (err) 567 goto recover; 568 569 folio_lock(ifolio); 570 571 stat_dec_inline_dir(dir); 572 clear_inode_flag(dir, FI_INLINE_DENTRY); 573 574 /* 575 * should retrieve reserved space which was used to keep 576 * inline_dentry's structure for backward compatibility. 577 */ 578 if (!f2fs_sb_has_flexible_inline_xattr(F2FS_I_SB(dir)) && 579 !f2fs_has_inline_xattr(dir)) 580 F2FS_I(dir)->i_inline_xattr_size = 0; 581 582 kfree(backup_dentry); 583 return 0; 584 recover: 585 folio_lock(ifolio); 586 f2fs_folio_wait_writeback(ifolio, NODE, true, true); 587 memcpy(inline_dentry, backup_dentry, MAX_INLINE_DATA(dir)); 588 f2fs_i_depth_write(dir, 0); 589 f2fs_i_size_write(dir, MAX_INLINE_DATA(dir)); 590 folio_mark_dirty(ifolio); 591 f2fs_folio_put(ifolio, true); 592 593 kfree(backup_dentry); 594 return err; 595 } 596 597 static int do_convert_inline_dir(struct inode *dir, struct folio *ifolio, 598 void *inline_dentry) 599 { 600 if (!F2FS_I(dir)->i_dir_level) 601 return f2fs_move_inline_dirents(dir, ifolio, inline_dentry); 602 else 603 return f2fs_move_rehashed_dirents(dir, ifolio, inline_dentry); 604 } 605 606 int f2fs_try_convert_inline_dir(struct inode *dir, struct dentry *dentry) 607 { 608 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 609 struct folio *ifolio; 610 struct f2fs_filename fname; 611 struct f2fs_lock_context lc; 612 void *inline_dentry = NULL; 613 int err = 0; 614 615 if (!f2fs_has_inline_dentry(dir)) 616 return 0; 617 618 f2fs_lock_op(sbi, &lc); 619 620 err = f2fs_setup_filename(dir, &dentry->d_name, 0, &fname); 621 if (err) 622 goto out; 623 624 ifolio = f2fs_get_inode_folio(sbi, dir->i_ino); 625 if (IS_ERR(ifolio)) { 626 err = PTR_ERR(ifolio); 627 goto out_fname; 628 } 629 630 if (f2fs_has_enough_room(dir, ifolio, &fname)) { 631 f2fs_folio_put(ifolio, true); 632 goto out_fname; 633 } 634 635 inline_dentry = inline_data_addr(dir, ifolio); 636 637 err = do_convert_inline_dir(dir, ifolio, inline_dentry); 638 if (!err) 639 f2fs_folio_put(ifolio, true); 640 out_fname: 641 f2fs_free_filename(&fname); 642 out: 643 f2fs_unlock_op(sbi, &lc); 644 return err; 645 } 646 647 int f2fs_add_inline_entry(struct inode *dir, const struct f2fs_filename *fname, 648 struct inode *inode, nid_t ino, umode_t mode) 649 { 650 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 651 struct folio *ifolio; 652 unsigned int bit_pos; 653 void *inline_dentry = NULL; 654 struct f2fs_dentry_ptr d; 655 int slots = GET_DENTRY_SLOTS(fname->disk_name.len); 656 struct folio *folio = NULL; 657 int err = 0; 658 659 ifolio = f2fs_get_inode_folio(sbi, dir->i_ino); 660 if (IS_ERR(ifolio)) 661 return PTR_ERR(ifolio); 662 663 inline_dentry = inline_data_addr(dir, ifolio); 664 make_dentry_ptr_inline(dir, &d, inline_dentry); 665 666 bit_pos = f2fs_room_for_filename(d.bitmap, slots, d.max); 667 if (bit_pos >= d.max) { 668 err = do_convert_inline_dir(dir, ifolio, inline_dentry); 669 if (err) 670 return err; 671 err = -EAGAIN; 672 goto out; 673 } 674 675 if (inode) { 676 f2fs_down_write_nested(&F2FS_I(inode)->i_sem, 677 SINGLE_DEPTH_NESTING); 678 folio = f2fs_init_inode_metadata(inode, dir, fname, ifolio); 679 if (IS_ERR(folio)) { 680 err = PTR_ERR(folio); 681 goto fail; 682 } 683 } 684 685 f2fs_folio_wait_writeback(ifolio, NODE, true, true); 686 687 f2fs_update_dentry(ino, mode, &d, &fname->disk_name, fname->hash, 688 bit_pos); 689 690 folio_mark_dirty(ifolio); 691 692 /* we don't need to mark_inode_dirty now */ 693 if (inode) { 694 f2fs_i_pino_write(inode, dir->i_ino); 695 696 /* synchronize inode page's data from inode cache */ 697 if (is_inode_flag_set(inode, FI_NEW_INODE)) 698 f2fs_update_inode(inode, folio); 699 700 f2fs_folio_put(folio, true); 701 } 702 703 f2fs_update_parent_metadata(dir, inode, 0); 704 fail: 705 if (inode) 706 f2fs_up_write(&F2FS_I(inode)->i_sem); 707 out: 708 f2fs_folio_put(ifolio, true); 709 return err; 710 } 711 712 void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, 713 struct folio *folio, struct inode *dir, struct inode *inode) 714 { 715 struct f2fs_dentry_ptr d; 716 void *inline_dentry; 717 int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len)); 718 unsigned int bit_pos; 719 int i; 720 721 folio_lock(folio); 722 f2fs_folio_wait_writeback(folio, NODE, true, true); 723 724 inline_dentry = inline_data_addr(dir, folio); 725 make_dentry_ptr_inline(dir, &d, inline_dentry); 726 727 bit_pos = dentry - d.dentry; 728 for (i = 0; i < slots; i++) 729 __clear_bit_le(bit_pos + i, d.bitmap); 730 731 folio_mark_dirty(folio); 732 f2fs_folio_put(folio, true); 733 734 inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir)); 735 f2fs_mark_inode_dirty_sync(dir, false); 736 737 if (inode) 738 f2fs_drop_nlink(dir, inode); 739 } 740 741 bool f2fs_empty_inline_dir(struct inode *dir) 742 { 743 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 744 struct folio *ifolio; 745 unsigned int bit_pos = 2; 746 void *inline_dentry; 747 struct f2fs_dentry_ptr d; 748 749 ifolio = f2fs_get_inode_folio(sbi, dir->i_ino); 750 if (IS_ERR(ifolio)) 751 return false; 752 753 inline_dentry = inline_data_addr(dir, ifolio); 754 make_dentry_ptr_inline(dir, &d, inline_dentry); 755 756 bit_pos = find_next_bit_le(d.bitmap, d.max, bit_pos); 757 758 f2fs_folio_put(ifolio, true); 759 760 if (bit_pos < d.max) 761 return false; 762 763 return true; 764 } 765 766 int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx, 767 struct fscrypt_str *fstr) 768 { 769 struct inode *inode = file_inode(file); 770 struct folio *ifolio = NULL; 771 struct f2fs_dentry_ptr d; 772 void *inline_dentry = NULL; 773 int err; 774 775 make_dentry_ptr_inline(inode, &d, inline_dentry); 776 777 if (ctx->pos == d.max) 778 return 0; 779 780 ifolio = f2fs_get_inode_folio(F2FS_I_SB(inode), inode->i_ino); 781 if (IS_ERR(ifolio)) 782 return PTR_ERR(ifolio); 783 784 /* 785 * f2fs_readdir was protected by inode.i_rwsem, it is safe to access 786 * ipage without page's lock held. 787 */ 788 folio_unlock(ifolio); 789 790 inline_dentry = inline_data_addr(inode, ifolio); 791 792 make_dentry_ptr_inline(inode, &d, inline_dentry); 793 794 err = f2fs_fill_dentries(ctx, &d, 0, fstr); 795 if (!err) 796 ctx->pos = d.max; 797 798 f2fs_folio_put(ifolio, false); 799 return err < 0 ? err : 0; 800 } 801 802 int f2fs_inline_data_fiemap(struct inode *inode, 803 struct fiemap_extent_info *fieinfo, __u64 start, __u64 len) 804 { 805 __u64 byteaddr = 0, ilen; 806 __u32 flags = FIEMAP_EXTENT_DATA_INLINE | FIEMAP_EXTENT_NOT_ALIGNED | 807 FIEMAP_EXTENT_LAST; 808 struct node_info ni; 809 struct folio *ifolio; 810 int err = 0; 811 812 ifolio = f2fs_get_inode_folio(F2FS_I_SB(inode), inode->i_ino); 813 if (IS_ERR(ifolio)) 814 return PTR_ERR(ifolio); 815 816 if ((S_ISREG(inode->i_mode) || S_ISLNK(inode->i_mode)) && 817 !f2fs_has_inline_data(inode)) { 818 err = -EAGAIN; 819 goto out; 820 } 821 822 if (S_ISDIR(inode->i_mode) && !f2fs_has_inline_dentry(inode)) { 823 err = -EAGAIN; 824 goto out; 825 } 826 827 if (fieinfo->fi_flags & FIEMAP_FLAG_SYNC) { 828 err = f2fs_write_single_node_folio(ifolio, true, false, FS_NODE_IO); 829 if (err) 830 return err; 831 ifolio = f2fs_get_inode_folio(F2FS_I_SB(inode), inode->i_ino); 832 if (IS_ERR(ifolio)) 833 return PTR_ERR(ifolio); 834 f2fs_folio_wait_writeback(ifolio, NODE, true, true); 835 } 836 ilen = min_t(size_t, MAX_INLINE_DATA(inode), i_size_read(inode)); 837 if (start >= ilen) 838 goto out; 839 if (start + len < ilen) 840 ilen = start + len; 841 ilen -= start; 842 843 err = f2fs_get_node_info(F2FS_I_SB(inode), inode->i_ino, &ni, false); 844 if (err) 845 goto out; 846 847 if (__is_valid_data_blkaddr(ni.blk_addr)) { 848 byteaddr = (__u64)ni.blk_addr << inode->i_sb->s_blocksize_bits; 849 byteaddr += (char *)inline_data_addr(inode, ifolio) - 850 (char *)F2FS_INODE(ifolio); 851 } else { 852 f2fs_bug_on(F2FS_I_SB(inode), ni.blk_addr != NEW_ADDR); 853 flags |= FIEMAP_EXTENT_DELALLOC | FIEMAP_EXTENT_UNKNOWN; 854 } 855 err = fiemap_fill_next_extent(fieinfo, start, byteaddr, ilen, flags); 856 trace_f2fs_fiemap(inode, start, byteaddr, ilen, flags, err); 857 out: 858 f2fs_folio_put(ifolio, true); 859 return err; 860 } 861