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