fs/f2fs/inline.c

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * fs/f2fs/inline.c
0004  * Copyright (c) 2013, Intel Corporation
0005  * Authors: Huajun Li <huajun.li@intel.com>
0006  *          Haicheng Li <haicheng.li@intel.com>
0007  */
0008
0009 #include <linux/fs.h>
0010 #include <linux/f2fs_fs.h>
0011 #include <linux/fiemap.h>
0012
0013 #include "f2fs.h"
0014 #include "node.h"
0015 #include <trace/events/f2fs.h>
0016
0017 static bool support_inline_data(struct inode *inode)
0018 {
0019     if (f2fs_is_atomic_file(inode))
0020         return false;
0021     if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode))
0022         return false;
0023     if (i_size_read(inode) > MAX_INLINE_DATA(inode))
0024         return false;
0025     return true;
0026 }
0027
0028 bool f2fs_may_inline_data(struct inode *inode)
0029 {
0030     if (!support_inline_data(inode))
0031         return false;
0032
0033     return !f2fs_post_read_required(inode);
0034 }
0035
0036 bool f2fs_sanity_check_inline_data(struct inode *inode)
0037 {
0038     if (!f2fs_has_inline_data(inode))
0039         return false;
0040
0041     if (!support_inline_data(inode))
0042         return true;
0043
0044     /*
0045      * used by sanity_check_inode(), when disk layout fields has not
0046      * been synchronized to inmem fields.
0047      */
0048     return (S_ISREG(inode->i_mode) &&
0049         (file_is_encrypt(inode) || file_is_verity(inode) ||
0050         (F2FS_I(inode)->i_flags & F2FS_COMPR_FL)));
0051 }
0052
0053 bool f2fs_may_inline_dentry(struct inode *inode)
0054 {
0055     if (!test_opt(F2FS_I_SB(inode), INLINE_DENTRY))
0056         return false;
0057
0058     if (!S_ISDIR(inode->i_mode))
0059         return false;
0060
0061     return true;
0062 }
0063
0064 void f2fs_do_read_inline_data(struct page *page, struct page *ipage)
0065 {
0066     struct inode *inode = page->mapping->host;
0067     void *src_addr, *dst_addr;
0068
0069     if (PageUptodate(page))
0070         return;
0071
0072     f2fs_bug_on(F2FS_P_SB(page), page->index);
0073
0074     zero_user_segment(page, MAX_INLINE_DATA(inode), PAGE_SIZE);
0075
0076     /* Copy the whole inline data block */
0077     src_addr = inline_data_addr(inode, ipage);
0078     dst_addr = kmap_atomic(page);
0079     memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode));
0080     flush_dcache_page(page);
0081     kunmap_atomic(dst_addr);
0082     if (!PageUptodate(page))
0083         SetPageUptodate(page);
0084 }
0085
0086 void f2fs_truncate_inline_inode(struct inode *inode,
0087                     struct page *ipage, u64 from)
0088 {
0089     void *addr;
0090
0091     if (from >= MAX_INLINE_DATA(inode))
0092         return;
0093
0094     addr = inline_data_addr(inode, ipage);
0095
0096     f2fs_wait_on_page_writeback(ipage, NODE, true, true);
0097     memset(addr + from, 0, MAX_INLINE_DATA(inode) - from);
0098     set_page_dirty(ipage);
0099
0100     if (from == 0)
0101         clear_inode_flag(inode, FI_DATA_EXIST);
0102 }
0103
0104 int f2fs_read_inline_data(struct inode *inode, struct page *page)
0105 {
0106     struct page *ipage;
0107
0108     ipage = f2fs_get_node_page(F2FS_I_SB(inode), inode->i_ino);
0109     if (IS_ERR(ipage)) {
0110         unlock_page(page);
0111         return PTR_ERR(ipage);
0112     }
0113
0114     if (!f2fs_has_inline_data(inode)) {
0115         f2fs_put_page(ipage, 1);
0116         return -EAGAIN;
0117     }
0118
0119     if (page->index)
0120         zero_user_segment(page, 0, PAGE_SIZE);
0121     else
0122         f2fs_do_read_inline_data(page, ipage);
0123
0124     if (!PageUptodate(page))
0125         SetPageUptodate(page);
0126     f2fs_put_page(ipage, 1);
0127     unlock_page(page);
0128     return 0;
0129 }
0130
0131 int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page)
0132 {
0133     struct f2fs_io_info fio = {
0134         .sbi = F2FS_I_SB(dn->inode),
0135         .ino = dn->inode->i_ino,
0136         .type = DATA,
0137         .op = REQ_OP_WRITE,
0138         .op_flags = REQ_SYNC | REQ_PRIO,
0139         .page = page,
0140         .encrypted_page = NULL,
0141         .io_type = FS_DATA_IO,
0142     };
0143     struct node_info ni;
0144     int dirty, err;
0145
0146     if (!f2fs_exist_data(dn->inode))
0147         goto clear_out;
0148
0149     err = f2fs_reserve_block(dn, 0);
0150     if (err)
0151         return err;
0152
0153     err = f2fs_get_node_info(fio.sbi, dn->nid, &ni, false);
0154     if (err) {
0155         f2fs_truncate_data_blocks_range(dn, 1);
0156         f2fs_put_dnode(dn);
0157         return err;
0158     }
0159
0160     fio.version = ni.version;
0161
0162     if (unlikely(dn->data_blkaddr != NEW_ADDR)) {
0163         f2fs_put_dnode(dn);
0164         set_sbi_flag(fio.sbi, SBI_NEED_FSCK);
0165         f2fs_warn(fio.sbi, "%s: corrupted inline inode ino=%lx, i_addr[0]:0x%x, run fsck to fix.",
0166               __func__, dn->inode->i_ino, dn->data_blkaddr);
0167         return -EFSCORRUPTED;
0168     }
0169
0170     f2fs_bug_on(F2FS_P_SB(page), PageWriteback(page));
0171
0172     f2fs_do_read_inline_data(page, dn->inode_page);
0173     set_page_dirty(page);
0174
0175     /* clear dirty state */
0176     dirty = clear_page_dirty_for_io(page);
0177
0178     /* write data page to try to make data consistent */
0179     set_page_writeback(page);
0180     ClearPageError(page);
0181     fio.old_blkaddr = dn->data_blkaddr;
0182     set_inode_flag(dn->inode, FI_HOT_DATA);
0183     f2fs_outplace_write_data(dn, &fio);
0184     f2fs_wait_on_page_writeback(page, DATA, true, true);
0185     if (dirty) {
0186         inode_dec_dirty_pages(dn->inode);
0187         f2fs_remove_dirty_inode(dn->inode);
0188     }
0189
0190     /* this converted inline_data should be recovered. */
0191     set_inode_flag(dn->inode, FI_APPEND_WRITE);
0192
0193     /* clear inline data and flag after data writeback */
0194     f2fs_truncate_inline_inode(dn->inode, dn->inode_page, 0);
0195     clear_page_private_inline(dn->inode_page);
0196 clear_out:
0197     stat_dec_inline_inode(dn->inode);
0198     clear_inode_flag(dn->inode, FI_INLINE_DATA);
0199     f2fs_put_dnode(dn);
0200     return 0;
0201 }
0202
0203 int f2fs_convert_inline_inode(struct inode *inode)
0204 {
0205     struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
0206     struct dnode_of_data dn;
0207     struct page *ipage, *page;
0208     int err = 0;
0209
0210     if (!f2fs_has_inline_data(inode) ||
0211             f2fs_hw_is_readonly(sbi) || f2fs_readonly(sbi->sb))
0212         return 0;
0213
0214     err = f2fs_dquot_initialize(inode);
0215     if (err)
0216         return err;
0217
0218     page = f2fs_grab_cache_page(inode->i_mapping, 0, false);
0219     if (!page)
0220         return -ENOMEM;
0221
0222     f2fs_lock_op(sbi);
0223
0224     ipage = f2fs_get_node_page(sbi, inode->i_ino);
0225     if (IS_ERR(ipage)) {
0226         err = PTR_ERR(ipage);
0227         goto out;
0228     }
0229
0230     set_new_dnode(&dn, inode, ipage, ipage, 0);
0231
0232     if (f2fs_has_inline_data(inode))
0233         err = f2fs_convert_inline_page(&dn, page);
0234
0235     f2fs_put_dnode(&dn);
0236 out:
0237     f2fs_unlock_op(sbi);
0238
0239     f2fs_put_page(page, 1);
0240
0241     if (!err)
0242         f2fs_balance_fs(sbi, dn.node_changed);
0243
0244     return err;
0245 }
0246
0247 int f2fs_write_inline_data(struct inode *inode, struct page *page)
0248 {
0249     void *src_addr, *dst_addr;
0250     struct dnode_of_data dn;
0251     int err;
0252
0253     set_new_dnode(&dn, inode, NULL, NULL, 0);
0254     err = f2fs_get_dnode_of_data(&dn, 0, LOOKUP_NODE);
0255     if (err)
0256         return err;
0257
0258     if (!f2fs_has_inline_data(inode)) {
0259         f2fs_put_dnode(&dn);
0260         return -EAGAIN;
0261     }
0262
0263     f2fs_bug_on(F2FS_I_SB(inode), page->index);
0264
0265     f2fs_wait_on_page_writeback(dn.inode_page, NODE, true, true);
0266     src_addr = kmap_atomic(page);
0267     dst_addr = inline_data_addr(inode, dn.inode_page);
0268     memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode));
0269     kunmap_atomic(src_addr);
0270     set_page_dirty(dn.inode_page);
0271
0272     f2fs_clear_page_cache_dirty_tag(page);
0273
0274     set_inode_flag(inode, FI_APPEND_WRITE);
0275     set_inode_flag(inode, FI_DATA_EXIST);
0276
0277     clear_page_private_inline(dn.inode_page);
0278     f2fs_put_dnode(&dn);
0279     return 0;
0280 }
0281
0282 int f2fs_recover_inline_data(struct inode *inode, struct page *npage)
0283 {
0284     struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
0285     struct f2fs_inode *ri = NULL;
0286     void *src_addr, *dst_addr;
0287     struct page *ipage;
0288
0289     /*
0290      * The inline_data recovery policy is as follows.
0291      * [prev.] [next] of inline_data flag
0292      *    o       o  -> recover inline_data
0293      *    o       x  -> remove inline_data, and then recover data blocks
0294      *    x       o  -> remove data blocks, and then recover inline_data
0295      *    x       x  -> recover data blocks
0296      */
0297     if (IS_INODE(npage))
0298         ri = F2FS_INODE(npage);
0299
0300     if (f2fs_has_inline_data(inode) &&
0301             ri && (ri->i_inline & F2FS_INLINE_DATA)) {
0302 process_inline:
0303         ipage = f2fs_get_node_page(sbi, inode->i_ino);
0304         if (IS_ERR(ipage))
0305             return PTR_ERR(ipage);
0306
0307         f2fs_wait_on_page_writeback(ipage, NODE, true, true);
0308
0309         src_addr = inline_data_addr(inode, npage);
0310         dst_addr = inline_data_addr(inode, ipage);
0311         memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode));
0312
0313         set_inode_flag(inode, FI_INLINE_DATA);
0314         set_inode_flag(inode, FI_DATA_EXIST);
0315
0316         set_page_dirty(ipage);
0317         f2fs_put_page(ipage, 1);
0318         return 1;
0319     }
0320
0321     if (f2fs_has_inline_data(inode)) {
0322         ipage = f2fs_get_node_page(sbi, inode->i_ino);
0323         if (IS_ERR(ipage))
0324             return PTR_ERR(ipage);
0325         f2fs_truncate_inline_inode(inode, ipage, 0);
0326         stat_dec_inline_inode(inode);
0327         clear_inode_flag(inode, FI_INLINE_DATA);
0328         f2fs_put_page(ipage, 1);
0329     } else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) {
0330         int ret;
0331
0332         ret = f2fs_truncate_blocks(inode, 0, false);
0333         if (ret)
0334             return ret;
0335         stat_inc_inline_inode(inode);
0336         goto process_inline;
0337     }
0338     return 0;
0339 }
0340
0341 struct f2fs_dir_entry *f2fs_find_in_inline_dir(struct inode *dir,
0342                     const struct f2fs_filename *fname,
0343                     struct page **res_page)
0344 {
0345     struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb);
0346     struct f2fs_dir_entry *de;
0347     struct f2fs_dentry_ptr d;
0348     struct page *ipage;
0349     void *inline_dentry;
0350
0351     ipage = f2fs_get_node_page(sbi, dir->i_ino);
0352     if (IS_ERR(ipage)) {
0353         *res_page = ipage;
0354         return NULL;
0355     }
0356
0357     inline_dentry = inline_data_addr(dir, ipage);
0358
0359     make_dentry_ptr_inline(dir, &d, inline_dentry);
0360     de = f2fs_find_target_dentry(&d, fname, NULL);
0361     unlock_page(ipage);
0362     if (IS_ERR(de)) {
0363         *res_page = ERR_CAST(de);
0364         de = NULL;
0365     }
0366     if (de)
0367         *res_page = ipage;
0368     else
0369         f2fs_put_page(ipage, 0);
0370
0371     return de;
0372 }
0373
0374 int f2fs_make_empty_inline_dir(struct inode *inode, struct inode *parent,
0375                             struct page *ipage)
0376 {
0377     struct f2fs_dentry_ptr d;
0378     void *inline_dentry;
0379
0380     inline_dentry = inline_data_addr(inode, ipage);
0381
0382     make_dentry_ptr_inline(inode, &d, inline_dentry);
0383     f2fs_do_make_empty_dir(inode, parent, &d);
0384
0385     set_page_dirty(ipage);
0386
0387     /* update i_size to MAX_INLINE_DATA */
0388     if (i_size_read(inode) < MAX_INLINE_DATA(inode))
0389         f2fs_i_size_write(inode, MAX_INLINE_DATA(inode));
0390     return 0;
0391 }
0392
0393 /*
0394  * NOTE: ipage is grabbed by caller, but if any error occurs, we should
0395  * release ipage in this function.
0396  */
0397 static int f2fs_move_inline_dirents(struct inode *dir, struct page *ipage,
0398                             void *inline_dentry)
0399 {
0400     struct page *page;
0401     struct dnode_of_data dn;
0402     struct f2fs_dentry_block *dentry_blk;
0403     struct f2fs_dentry_ptr src, dst;
0404     int err;
0405
0406     page = f2fs_grab_cache_page(dir->i_mapping, 0, true);
0407     if (!page) {
0408         f2fs_put_page(ipage, 1);
0409         return -ENOMEM;
0410     }
0411
0412     set_new_dnode(&dn, dir, ipage, NULL, 0);
0413     err = f2fs_reserve_block(&dn, 0);
0414     if (err)
0415         goto out;
0416
0417     if (unlikely(dn.data_blkaddr != NEW_ADDR)) {
0418         f2fs_put_dnode(&dn);
0419         set_sbi_flag(F2FS_P_SB(page), SBI_NEED_FSCK);
0420         f2fs_warn(F2FS_P_SB(page), "%s: corrupted inline inode ino=%lx, i_addr[0]:0x%x, run fsck to fix.",
0421               __func__, dir->i_ino, dn.data_blkaddr);
0422         err = -EFSCORRUPTED;
0423         goto out;
0424     }
0425
0426     f2fs_wait_on_page_writeback(page, DATA, true, true);
0427
0428     dentry_blk = page_address(page);
0429
0430     make_dentry_ptr_inline(dir, &src, inline_dentry);
0431     make_dentry_ptr_block(dir, &dst, dentry_blk);
0432
0433     /* copy data from inline dentry block to new dentry block */
0434     memcpy(dst.bitmap, src.bitmap, src.nr_bitmap);
0435     memset(dst.bitmap + src.nr_bitmap, 0, dst.nr_bitmap - src.nr_bitmap);
0436     /*
0437      * we do not need to zero out remainder part of dentry and filename
0438      * field, since we have used bitmap for marking the usage status of
0439      * them, besides, we can also ignore copying/zeroing reserved space
0440      * of dentry block, because them haven't been used so far.
0441      */
0442     memcpy(dst.dentry, src.dentry, SIZE_OF_DIR_ENTRY * src.max);
0443     memcpy(dst.filename, src.filename, src.max * F2FS_SLOT_LEN);
0444
0445     if (!PageUptodate(page))
0446         SetPageUptodate(page);
0447     set_page_dirty(page);
0448
0449     /* clear inline dir and flag after data writeback */
0450     f2fs_truncate_inline_inode(dir, ipage, 0);
0451
0452     stat_dec_inline_dir(dir);
0453     clear_inode_flag(dir, FI_INLINE_DENTRY);
0454
0455     /*
0456      * should retrieve reserved space which was used to keep
0457      * inline_dentry's structure for backward compatibility.
0458      */
0459     if (!f2fs_sb_has_flexible_inline_xattr(F2FS_I_SB(dir)) &&
0460             !f2fs_has_inline_xattr(dir))
0461         F2FS_I(dir)->i_inline_xattr_size = 0;
0462
0463     f2fs_i_depth_write(dir, 1);
0464     if (i_size_read(dir) < PAGE_SIZE)
0465         f2fs_i_size_write(dir, PAGE_SIZE);
0466 out:
0467     f2fs_put_page(page, 1);
0468     return err;
0469 }
0470
0471 static int f2fs_add_inline_entries(struct inode *dir, void *inline_dentry)
0472 {
0473     struct f2fs_dentry_ptr d;
0474     unsigned long bit_pos = 0;
0475     int err = 0;
0476
0477     make_dentry_ptr_inline(dir, &d, inline_dentry);
0478
0479     while (bit_pos < d.max) {
0480         struct f2fs_dir_entry *de;
0481         struct f2fs_filename fname;
0482         nid_t ino;
0483         umode_t fake_mode;
0484
0485         if (!test_bit_le(bit_pos, d.bitmap)) {
0486             bit_pos++;
0487             continue;
0488         }
0489
0490         de = &d.dentry[bit_pos];
0491
0492         if (unlikely(!de->name_len)) {
0493             bit_pos++;
0494             continue;
0495         }
0496
0497         /*
0498          * We only need the disk_name and hash to move the dentry.
0499          * We don't need the original or casefolded filenames.
0500          */
0501         memset(&fname, 0, sizeof(fname));
0502         fname.disk_name.name = d.filename[bit_pos];
0503         fname.disk_name.len = le16_to_cpu(de->name_len);
0504         fname.hash = de->hash_code;
0505
0506         ino = le32_to_cpu(de->ino);
0507         fake_mode = f2fs_get_de_type(de) << S_SHIFT;
0508
0509         err = f2fs_add_regular_entry(dir, &fname, NULL, ino, fake_mode);
0510         if (err)
0511             goto punch_dentry_pages;
0512
0513         bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len));
0514     }
0515     return 0;
0516 punch_dentry_pages:
0517     truncate_inode_pages(&dir->i_data, 0);
0518     f2fs_truncate_blocks(dir, 0, false);
0519     f2fs_remove_dirty_inode(dir);
0520     return err;
0521 }
0522
0523 static int f2fs_move_rehashed_dirents(struct inode *dir, struct page *ipage,
0524                             void *inline_dentry)
0525 {
0526     void *backup_dentry;
0527     int err;
0528
0529     backup_dentry = f2fs_kmalloc(F2FS_I_SB(dir),
0530                 MAX_INLINE_DATA(dir), GFP_F2FS_ZERO);
0531     if (!backup_dentry) {
0532         f2fs_put_page(ipage, 1);
0533         return -ENOMEM;
0534     }
0535
0536     memcpy(backup_dentry, inline_dentry, MAX_INLINE_DATA(dir));
0537     f2fs_truncate_inline_inode(dir, ipage, 0);
0538
0539     unlock_page(ipage);
0540
0541     err = f2fs_add_inline_entries(dir, backup_dentry);
0542     if (err)
0543         goto recover;
0544
0545     lock_page(ipage);
0546
0547     stat_dec_inline_dir(dir);
0548     clear_inode_flag(dir, FI_INLINE_DENTRY);
0549
0550     /*
0551      * should retrieve reserved space which was used to keep
0552      * inline_dentry's structure for backward compatibility.
0553      */
0554     if (!f2fs_sb_has_flexible_inline_xattr(F2FS_I_SB(dir)) &&
0555             !f2fs_has_inline_xattr(dir))
0556         F2FS_I(dir)->i_inline_xattr_size = 0;
0557
0558     kfree(backup_dentry);
0559     return 0;
0560 recover:
0561     lock_page(ipage);
0562     f2fs_wait_on_page_writeback(ipage, NODE, true, true);
0563     memcpy(inline_dentry, backup_dentry, MAX_INLINE_DATA(dir));
0564     f2fs_i_depth_write(dir, 0);
0565     f2fs_i_size_write(dir, MAX_INLINE_DATA(dir));
0566     set_page_dirty(ipage);
0567     f2fs_put_page(ipage, 1);
0568
0569     kfree(backup_dentry);
0570     return err;
0571 }
0572
0573 static int do_convert_inline_dir(struct inode *dir, struct page *ipage,
0574                             void *inline_dentry)
0575 {
0576     if (!F2FS_I(dir)->i_dir_level)
0577         return f2fs_move_inline_dirents(dir, ipage, inline_dentry);
0578     else
0579         return f2fs_move_rehashed_dirents(dir, ipage, inline_dentry);
0580 }
0581
0582 int f2fs_try_convert_inline_dir(struct inode *dir, struct dentry *dentry)
0583 {
0584     struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
0585     struct page *ipage;
0586     struct f2fs_filename fname;
0587     void *inline_dentry = NULL;
0588     int err = 0;
0589
0590     if (!f2fs_has_inline_dentry(dir))
0591         return 0;
0592
0593     f2fs_lock_op(sbi);
0594
0595     err = f2fs_setup_filename(dir, &dentry->d_name, 0, &fname);
0596     if (err)
0597         goto out;
0598
0599     ipage = f2fs_get_node_page(sbi, dir->i_ino);
0600     if (IS_ERR(ipage)) {
0601         err = PTR_ERR(ipage);
0602         goto out_fname;
0603     }
0604
0605     if (f2fs_has_enough_room(dir, ipage, &fname)) {
0606         f2fs_put_page(ipage, 1);
0607         goto out_fname;
0608     }
0609
0610     inline_dentry = inline_data_addr(dir, ipage);
0611
0612     err = do_convert_inline_dir(dir, ipage, inline_dentry);
0613     if (!err)
0614         f2fs_put_page(ipage, 1);
0615 out_fname:
0616     f2fs_free_filename(&fname);
0617 out:
0618     f2fs_unlock_op(sbi);
0619     return err;
0620 }
0621
0622 int f2fs_add_inline_entry(struct inode *dir, const struct f2fs_filename *fname,
0623               struct inode *inode, nid_t ino, umode_t mode)
0624 {
0625     struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
0626     struct page *ipage;
0627     unsigned int bit_pos;
0628     void *inline_dentry = NULL;
0629     struct f2fs_dentry_ptr d;
0630     int slots = GET_DENTRY_SLOTS(fname->disk_name.len);
0631     struct page *page = NULL;
0632     int err = 0;
0633
0634     ipage = f2fs_get_node_page(sbi, dir->i_ino);
0635     if (IS_ERR(ipage))
0636         return PTR_ERR(ipage);
0637
0638     inline_dentry = inline_data_addr(dir, ipage);
0639     make_dentry_ptr_inline(dir, &d, inline_dentry);
0640
0641     bit_pos = f2fs_room_for_filename(d.bitmap, slots, d.max);
0642     if (bit_pos >= d.max) {
0643         err = do_convert_inline_dir(dir, ipage, inline_dentry);
0644         if (err)
0645             return err;
0646         err = -EAGAIN;
0647         goto out;
0648     }
0649
0650     if (inode) {
0651         f2fs_down_write(&F2FS_I(inode)->i_sem);
0652         page = f2fs_init_inode_metadata(inode, dir, fname, ipage);
0653         if (IS_ERR(page)) {
0654             err = PTR_ERR(page);
0655             goto fail;
0656         }
0657     }
0658
0659     f2fs_wait_on_page_writeback(ipage, NODE, true, true);
0660
0661     f2fs_update_dentry(ino, mode, &d, &fname->disk_name, fname->hash,
0662                bit_pos);
0663
0664     set_page_dirty(ipage);
0665
0666     /* we don't need to mark_inode_dirty now */
0667     if (inode) {
0668         f2fs_i_pino_write(inode, dir->i_ino);
0669
0670         /* synchronize inode page's data from inode cache */
0671         if (is_inode_flag_set(inode, FI_NEW_INODE))
0672             f2fs_update_inode(inode, page);
0673
0674         f2fs_put_page(page, 1);
0675     }
0676
0677     f2fs_update_parent_metadata(dir, inode, 0);
0678 fail:
0679     if (inode)
0680         f2fs_up_write(&F2FS_I(inode)->i_sem);
0681 out:
0682     f2fs_put_page(ipage, 1);
0683     return err;
0684 }
0685
0686 void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page,
0687                     struct inode *dir, struct inode *inode)
0688 {
0689     struct f2fs_dentry_ptr d;
0690     void *inline_dentry;
0691     int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));
0692     unsigned int bit_pos;
0693     int i;
0694
0695     lock_page(page);
0696     f2fs_wait_on_page_writeback(page, NODE, true, true);
0697
0698     inline_dentry = inline_data_addr(dir, page);
0699     make_dentry_ptr_inline(dir, &d, inline_dentry);
0700
0701     bit_pos = dentry - d.dentry;
0702     for (i = 0; i < slots; i++)
0703         __clear_bit_le(bit_pos + i, d.bitmap);
0704
0705     set_page_dirty(page);
0706     f2fs_put_page(page, 1);
0707
0708     dir->i_ctime = dir->i_mtime = current_time(dir);
0709     f2fs_mark_inode_dirty_sync(dir, false);
0710
0711     if (inode)
0712         f2fs_drop_nlink(dir, inode);
0713 }
0714
0715 bool f2fs_empty_inline_dir(struct inode *dir)
0716 {
0717     struct f2fs_sb_info *sbi = F2FS_I_SB(dir);
0718     struct page *ipage;
0719     unsigned int bit_pos = 2;
0720     void *inline_dentry;
0721     struct f2fs_dentry_ptr d;
0722
0723     ipage = f2fs_get_node_page(sbi, dir->i_ino);
0724     if (IS_ERR(ipage))
0725         return false;
0726
0727     inline_dentry = inline_data_addr(dir, ipage);
0728     make_dentry_ptr_inline(dir, &d, inline_dentry);
0729
0730     bit_pos = find_next_bit_le(d.bitmap, d.max, bit_pos);
0731
0732     f2fs_put_page(ipage, 1);
0733
0734     if (bit_pos < d.max)
0735         return false;
0736
0737     return true;
0738 }
0739
0740 int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx,
0741                 struct fscrypt_str *fstr)
0742 {
0743     struct inode *inode = file_inode(file);
0744     struct page *ipage = NULL;
0745     struct f2fs_dentry_ptr d;
0746     void *inline_dentry = NULL;
0747     int err;
0748
0749     make_dentry_ptr_inline(inode, &d, inline_dentry);
0750
0751     if (ctx->pos == d.max)
0752         return 0;
0753
0754     ipage = f2fs_get_node_page(F2FS_I_SB(inode), inode->i_ino);
0755     if (IS_ERR(ipage))
0756         return PTR_ERR(ipage);
0757
0758     /*
0759      * f2fs_readdir was protected by inode.i_rwsem, it is safe to access
0760      * ipage without page's lock held.
0761      */
0762     unlock_page(ipage);
0763
0764     inline_dentry = inline_data_addr(inode, ipage);
0765
0766     make_dentry_ptr_inline(inode, &d, inline_dentry);
0767
0768     err = f2fs_fill_dentries(ctx, &d, 0, fstr);
0769     if (!err)
0770         ctx->pos = d.max;
0771
0772     f2fs_put_page(ipage, 0);
0773     return err < 0 ? err : 0;
0774 }
0775
0776 int f2fs_inline_data_fiemap(struct inode *inode,
0777         struct fiemap_extent_info *fieinfo, __u64 start, __u64 len)
0778 {
0779     __u64 byteaddr, ilen;
0780     __u32 flags = FIEMAP_EXTENT_DATA_INLINE | FIEMAP_EXTENT_NOT_ALIGNED |
0781         FIEMAP_EXTENT_LAST;
0782     struct node_info ni;
0783     struct page *ipage;
0784     int err = 0;
0785
0786     ipage = f2fs_get_node_page(F2FS_I_SB(inode), inode->i_ino);
0787     if (IS_ERR(ipage))
0788         return PTR_ERR(ipage);
0789
0790     if ((S_ISREG(inode->i_mode) || S_ISLNK(inode->i_mode)) &&
0791                 !f2fs_has_inline_data(inode)) {
0792         err = -EAGAIN;
0793         goto out;
0794     }
0795
0796     if (S_ISDIR(inode->i_mode) && !f2fs_has_inline_dentry(inode)) {
0797         err = -EAGAIN;
0798         goto out;
0799     }
0800
0801     ilen = min_t(size_t, MAX_INLINE_DATA(inode), i_size_read(inode));
0802     if (start >= ilen)
0803         goto out;
0804     if (start + len < ilen)
0805         ilen = start + len;
0806     ilen -= start;
0807
0808     err = f2fs_get_node_info(F2FS_I_SB(inode), inode->i_ino, &ni, false);
0809     if (err)
0810         goto out;
0811
0812     byteaddr = (__u64)ni.blk_addr << inode->i_sb->s_blocksize_bits;
0813     byteaddr += (char *)inline_data_addr(inode, ipage) -
0814                     (char *)F2FS_INODE(ipage);
0815     err = fiemap_fill_next_extent(fieinfo, start, byteaddr, ilen, flags);
0816     trace_f2fs_fiemap(inode, start, byteaddr, ilen, flags, err);
0817 out:
0818     f2fs_put_page(ipage, 1);
0819     return err;
0820 }