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