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