fs/f2fs/inline.c

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