fs/f2fs/inline.c

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