1e18c65b2SHuajun Li /* 2e18c65b2SHuajun Li * fs/f2fs/inline.c 3e18c65b2SHuajun Li * Copyright (c) 2013, Intel Corporation 4e18c65b2SHuajun Li * Authors: Huajun Li <huajun.li@intel.com> 5e18c65b2SHuajun Li * Haicheng Li <haicheng.li@intel.com> 6e18c65b2SHuajun Li * This program is free software; you can redistribute it and/or modify 7e18c65b2SHuajun Li * it under the terms of the GNU General Public License version 2 as 8e18c65b2SHuajun Li * published by the Free Software Foundation. 9e18c65b2SHuajun Li */ 10e18c65b2SHuajun Li 11e18c65b2SHuajun Li #include <linux/fs.h> 12e18c65b2SHuajun Li #include <linux/f2fs_fs.h> 13e18c65b2SHuajun Li 14e18c65b2SHuajun Li #include "f2fs.h" 1567f8cf3cSJaegeuk Kim #include "node.h" 16e18c65b2SHuajun Li 1701b960e9SJaegeuk Kim bool f2fs_may_inline_data(struct inode *inode) 18e18c65b2SHuajun Li { 1988b88a66SJaegeuk Kim if (f2fs_is_atomic_file(inode)) 2088b88a66SJaegeuk Kim return false; 2188b88a66SJaegeuk Kim 22368a0e40SWanpeng Li if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode)) 23e18c65b2SHuajun Li return false; 24e18c65b2SHuajun Li 25f2470371SChao Yu if (i_size_read(inode) > MAX_INLINE_DATA(inode)) 2692dffd01SJaegeuk Kim return false; 2792dffd01SJaegeuk Kim 286dbb1796SEric Biggers if (f2fs_post_read_required(inode)) 29fcc85a4dSJaegeuk Kim return false; 30fcc85a4dSJaegeuk Kim 31e18c65b2SHuajun Li return true; 32e18c65b2SHuajun Li } 33e18c65b2SHuajun Li 3401b960e9SJaegeuk Kim bool f2fs_may_inline_dentry(struct inode *inode) 3501b960e9SJaegeuk Kim { 3601b960e9SJaegeuk Kim if (!test_opt(F2FS_I_SB(inode), INLINE_DENTRY)) 3701b960e9SJaegeuk Kim return false; 3801b960e9SJaegeuk Kim 3901b960e9SJaegeuk Kim if (!S_ISDIR(inode->i_mode)) 4001b960e9SJaegeuk Kim return false; 4101b960e9SJaegeuk Kim 4201b960e9SJaegeuk Kim return true; 4301b960e9SJaegeuk Kim } 4401b960e9SJaegeuk Kim 454d57b86dSChao Yu void f2fs_do_read_inline_data(struct page *page, struct page *ipage) 46e18c65b2SHuajun Li { 47f2470371SChao Yu struct inode *inode = page->mapping->host; 48e18c65b2SHuajun Li void *src_addr, *dst_addr; 49e18c65b2SHuajun Li 50b3d208f9SJaegeuk Kim if (PageUptodate(page)) 51b3d208f9SJaegeuk Kim return; 5204a17fb1SChao Yu 53b3d208f9SJaegeuk Kim f2fs_bug_on(F2FS_P_SB(page), page->index); 54e18c65b2SHuajun Li 55f2470371SChao Yu zero_user_segment(page, MAX_INLINE_DATA(inode), PAGE_SIZE); 56e18c65b2SHuajun Li 57e18c65b2SHuajun Li /* Copy the whole inline data block */ 58f2470371SChao Yu src_addr = inline_data_addr(inode, ipage); 59f1e33a04SJaegeuk Kim dst_addr = kmap_atomic(page); 60f2470371SChao Yu memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode)); 61427a45c8SJaegeuk Kim flush_dcache_page(page); 62f1e33a04SJaegeuk Kim kunmap_atomic(dst_addr); 63237c0790SJaegeuk Kim if (!PageUptodate(page)) 64e18c65b2SHuajun Li SetPageUptodate(page); 65b3d208f9SJaegeuk Kim } 66e18c65b2SHuajun Li 674d57b86dSChao Yu void f2fs_truncate_inline_inode(struct inode *inode, 684d57b86dSChao Yu struct page *ipage, u64 from) 69feeb0debSChao Yu { 700bfcfccaSChao Yu void *addr; 710bfcfccaSChao Yu 72f2470371SChao Yu if (from >= MAX_INLINE_DATA(inode)) 73bd4667cbSKinglong Mee return; 740bfcfccaSChao Yu 75f2470371SChao Yu addr = inline_data_addr(inode, ipage); 760bfcfccaSChao Yu 77fec1d657SJaegeuk Kim f2fs_wait_on_page_writeback(ipage, NODE, true); 78f2470371SChao Yu memset(addr + from, 0, MAX_INLINE_DATA(inode) - from); 79ee6d182fSJaegeuk Kim set_page_dirty(ipage); 80bd4667cbSKinglong Mee 81bd4667cbSKinglong Mee if (from == 0) 82bd4667cbSKinglong Mee clear_inode_flag(inode, FI_DATA_EXIST); 83feeb0debSChao Yu } 84feeb0debSChao Yu 85b3d208f9SJaegeuk Kim int f2fs_read_inline_data(struct inode *inode, struct page *page) 86b3d208f9SJaegeuk Kim { 87b3d208f9SJaegeuk Kim struct page *ipage; 88b3d208f9SJaegeuk Kim 894d57b86dSChao Yu ipage = f2fs_get_node_page(F2FS_I_SB(inode), inode->i_ino); 90b3d208f9SJaegeuk Kim if (IS_ERR(ipage)) { 91b3d208f9SJaegeuk Kim unlock_page(page); 92b3d208f9SJaegeuk Kim return PTR_ERR(ipage); 93b3d208f9SJaegeuk Kim } 94b3d208f9SJaegeuk Kim 95b3d208f9SJaegeuk Kim if (!f2fs_has_inline_data(inode)) { 96b3d208f9SJaegeuk Kim f2fs_put_page(ipage, 1); 97b3d208f9SJaegeuk Kim return -EAGAIN; 98b3d208f9SJaegeuk Kim } 99b3d208f9SJaegeuk Kim 100b3d208f9SJaegeuk Kim if (page->index) 10109cbfeafSKirill A. Shutemov zero_user_segment(page, 0, PAGE_SIZE); 102b3d208f9SJaegeuk Kim else 1034d57b86dSChao Yu f2fs_do_read_inline_data(page, ipage); 104b3d208f9SJaegeuk Kim 105237c0790SJaegeuk Kim if (!PageUptodate(page)) 106b3d208f9SJaegeuk Kim SetPageUptodate(page); 107b3d208f9SJaegeuk Kim f2fs_put_page(ipage, 1); 108b3d208f9SJaegeuk Kim unlock_page(page); 109e18c65b2SHuajun Li return 0; 110e18c65b2SHuajun Li } 111e18c65b2SHuajun Li 112b3d208f9SJaegeuk Kim int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page) 113e18c65b2SHuajun Li { 114e18c65b2SHuajun Li struct f2fs_io_info fio = { 11505ca3632SJaegeuk Kim .sbi = F2FS_I_SB(dn->inode), 11639d787beSChao Yu .ino = dn->inode->i_ino, 117e18c65b2SHuajun Li .type = DATA, 11804d328deSMike Christie .op = REQ_OP_WRITE, 11970fd7614SChristoph Hellwig .op_flags = REQ_SYNC | REQ_PRIO, 12005ca3632SJaegeuk Kim .page = page, 1214375a336SJaegeuk Kim .encrypted_page = NULL, 122b0af6d49SChao Yu .io_type = FS_DATA_IO, 123e18c65b2SHuajun Li }; 124158c194cSJaegeuk Kim int dirty, err; 125e18c65b2SHuajun Li 126b3d208f9SJaegeuk Kim if (!f2fs_exist_data(dn->inode)) 127b3d208f9SJaegeuk Kim goto clear_out; 128ec4e7af4SJaegeuk Kim 129b3d208f9SJaegeuk Kim err = f2fs_reserve_block(dn, 0); 13015c6e3aaSJaegeuk Kim if (err) 131b3d208f9SJaegeuk Kim return err; 132e18c65b2SHuajun Li 13385ead818SYunlei He f2fs_bug_on(F2FS_P_SB(page), PageWriteback(page)); 134b3d208f9SJaegeuk Kim 1354d57b86dSChao Yu f2fs_do_read_inline_data(page, dn->inode_page); 1366282adbfSJaegeuk Kim set_page_dirty(page); 1376282adbfSJaegeuk Kim 138158c194cSJaegeuk Kim /* clear dirty state */ 139158c194cSJaegeuk Kim dirty = clear_page_dirty_for_io(page); 140158c194cSJaegeuk Kim 141e18c65b2SHuajun Li /* write data page to try to make data consistent */ 142e18c65b2SHuajun Li set_page_writeback(page); 14317c50035SJaegeuk Kim ClearPageError(page); 1447a9d7548SChao Yu fio.old_blkaddr = dn->data_blkaddr; 145ef095d19SJaegeuk Kim set_inode_flag(dn->inode, FI_HOT_DATA); 1464d57b86dSChao Yu f2fs_outplace_write_data(dn, &fio); 147fec1d657SJaegeuk Kim f2fs_wait_on_page_writeback(page, DATA, true); 148933439c8SChao Yu if (dirty) { 149158c194cSJaegeuk Kim inode_dec_dirty_pages(dn->inode); 1504d57b86dSChao Yu f2fs_remove_dirty_inode(dn->inode); 151933439c8SChao Yu } 152e18c65b2SHuajun Li 15395f5b0fcSJaegeuk Kim /* this converted inline_data should be recovered. */ 15491942321SJaegeuk Kim set_inode_flag(dn->inode, FI_APPEND_WRITE); 15595f5b0fcSJaegeuk Kim 156e18c65b2SHuajun Li /* clear inline data and flag after data writeback */ 1574d57b86dSChao Yu f2fs_truncate_inline_inode(dn->inode, dn->inode_page, 0); 1582049d4fcSJaegeuk Kim clear_inline_node(dn->inode_page); 159b3d208f9SJaegeuk Kim clear_out: 160b3d208f9SJaegeuk Kim stat_dec_inline_inode(dn->inode); 161bd4667cbSKinglong Mee clear_inode_flag(dn->inode, FI_INLINE_DATA); 162b3d208f9SJaegeuk Kim f2fs_put_dnode(dn); 163b3d208f9SJaegeuk Kim return 0; 164e18c65b2SHuajun Li } 165e18c65b2SHuajun Li 166b3d208f9SJaegeuk Kim int f2fs_convert_inline_inode(struct inode *inode) 167e18c65b2SHuajun Li { 168b3d208f9SJaegeuk Kim struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 169b3d208f9SJaegeuk Kim struct dnode_of_data dn; 170b3d208f9SJaegeuk Kim struct page *ipage, *page; 171b3d208f9SJaegeuk Kim int err = 0; 172e18c65b2SHuajun Li 173b9d777b8SJaegeuk Kim if (!f2fs_has_inline_data(inode)) 174b9d777b8SJaegeuk Kim return 0; 175b9d777b8SJaegeuk Kim 176300e129cSJaegeuk Kim page = f2fs_grab_cache_page(inode->i_mapping, 0, false); 177b3d208f9SJaegeuk Kim if (!page) 1789e09fc85SJaegeuk Kim return -ENOMEM; 179b3d208f9SJaegeuk Kim 180b3d208f9SJaegeuk Kim f2fs_lock_op(sbi); 181b3d208f9SJaegeuk Kim 1824d57b86dSChao Yu ipage = f2fs_get_node_page(sbi, inode->i_ino); 183b3d208f9SJaegeuk Kim if (IS_ERR(ipage)) { 1846d20aff8SJaegeuk Kim err = PTR_ERR(ipage); 1856d20aff8SJaegeuk Kim goto out; 186b067ba1fSJaegeuk Kim } 187e18c65b2SHuajun Li 188b3d208f9SJaegeuk Kim set_new_dnode(&dn, inode, ipage, ipage, 0); 189b3d208f9SJaegeuk Kim 190b3d208f9SJaegeuk Kim if (f2fs_has_inline_data(inode)) 191b3d208f9SJaegeuk Kim err = f2fs_convert_inline_page(&dn, page); 192b3d208f9SJaegeuk Kim 193b3d208f9SJaegeuk Kim f2fs_put_dnode(&dn); 1946d20aff8SJaegeuk Kim out: 195b3d208f9SJaegeuk Kim f2fs_unlock_op(sbi); 196b3d208f9SJaegeuk Kim 197b3d208f9SJaegeuk Kim f2fs_put_page(page, 1); 1982a340760SJaegeuk Kim 1992c4db1a6SJaegeuk Kim f2fs_balance_fs(sbi, dn.node_changed); 2002a340760SJaegeuk Kim 201e18c65b2SHuajun Li return err; 202e18c65b2SHuajun Li } 203e18c65b2SHuajun Li 204b3d208f9SJaegeuk Kim int f2fs_write_inline_data(struct inode *inode, struct page *page) 205e18c65b2SHuajun Li { 206e18c65b2SHuajun Li void *src_addr, *dst_addr; 207e18c65b2SHuajun Li struct dnode_of_data dn; 208e18c65b2SHuajun Li int err; 209e18c65b2SHuajun Li 210e18c65b2SHuajun Li set_new_dnode(&dn, inode, NULL, NULL, 0); 2114d57b86dSChao Yu err = f2fs_get_dnode_of_data(&dn, 0, LOOKUP_NODE); 212e18c65b2SHuajun Li if (err) 213e18c65b2SHuajun Li return err; 214e18c65b2SHuajun Li 215c08a690bSJaegeuk Kim if (!f2fs_has_inline_data(inode)) { 216b3d208f9SJaegeuk Kim f2fs_put_dnode(&dn); 217b3d208f9SJaegeuk Kim return -EAGAIN; 218c08a690bSJaegeuk Kim } 219c08a690bSJaegeuk Kim 220b3d208f9SJaegeuk Kim f2fs_bug_on(F2FS_I_SB(inode), page->index); 221b3d208f9SJaegeuk Kim 222fec1d657SJaegeuk Kim f2fs_wait_on_page_writeback(dn.inode_page, NODE, true); 223f1e33a04SJaegeuk Kim src_addr = kmap_atomic(page); 224f2470371SChao Yu dst_addr = inline_data_addr(inode, dn.inode_page); 225f2470371SChao Yu memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode)); 226f1e33a04SJaegeuk Kim kunmap_atomic(src_addr); 227ee6d182fSJaegeuk Kim set_page_dirty(dn.inode_page); 228e18c65b2SHuajun Li 2294d57b86dSChao Yu f2fs_clear_radix_tree_dirty_tag(page); 2300abd8e70SDaeho Jeong 23191942321SJaegeuk Kim set_inode_flag(inode, FI_APPEND_WRITE); 23291942321SJaegeuk Kim set_inode_flag(inode, FI_DATA_EXIST); 233b3d208f9SJaegeuk Kim 2342049d4fcSJaegeuk Kim clear_inline_node(dn.inode_page); 235e18c65b2SHuajun Li f2fs_put_dnode(&dn); 236e18c65b2SHuajun Li return 0; 237e18c65b2SHuajun Li } 2381e1bb4baSJaegeuk Kim 2394d57b86dSChao Yu bool f2fs_recover_inline_data(struct inode *inode, struct page *npage) 2401e1bb4baSJaegeuk Kim { 2414081363fSJaegeuk Kim struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 2421e1bb4baSJaegeuk Kim struct f2fs_inode *ri = NULL; 2431e1bb4baSJaegeuk Kim void *src_addr, *dst_addr; 2441e1bb4baSJaegeuk Kim struct page *ipage; 2451e1bb4baSJaegeuk Kim 2461e1bb4baSJaegeuk Kim /* 2471e1bb4baSJaegeuk Kim * The inline_data recovery policy is as follows. 2481e1bb4baSJaegeuk Kim * [prev.] [next] of inline_data flag 2491e1bb4baSJaegeuk Kim * o o -> recover inline_data 2501e1bb4baSJaegeuk Kim * o x -> remove inline_data, and then recover data blocks 2511e1bb4baSJaegeuk Kim * x o -> remove inline_data, and then recover inline_data 2521e1bb4baSJaegeuk Kim * x x -> recover data blocks 2531e1bb4baSJaegeuk Kim */ 2541e1bb4baSJaegeuk Kim if (IS_INODE(npage)) 2551e1bb4baSJaegeuk Kim ri = F2FS_INODE(npage); 2561e1bb4baSJaegeuk Kim 2571e1bb4baSJaegeuk Kim if (f2fs_has_inline_data(inode) && 2580342fd30SJaegeuk Kim ri && (ri->i_inline & F2FS_INLINE_DATA)) { 2591e1bb4baSJaegeuk Kim process_inline: 2604d57b86dSChao Yu ipage = f2fs_get_node_page(sbi, inode->i_ino); 2619850cf4aSJaegeuk Kim f2fs_bug_on(sbi, IS_ERR(ipage)); 2621e1bb4baSJaegeuk Kim 263fec1d657SJaegeuk Kim f2fs_wait_on_page_writeback(ipage, NODE, true); 26454b591dfSJaegeuk Kim 265f2470371SChao Yu src_addr = inline_data_addr(inode, npage); 266f2470371SChao Yu dst_addr = inline_data_addr(inode, ipage); 267f2470371SChao Yu memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode)); 268b3d208f9SJaegeuk Kim 26991942321SJaegeuk Kim set_inode_flag(inode, FI_INLINE_DATA); 27091942321SJaegeuk Kim set_inode_flag(inode, FI_DATA_EXIST); 271b3d208f9SJaegeuk Kim 272ee6d182fSJaegeuk Kim set_page_dirty(ipage); 2731e1bb4baSJaegeuk Kim f2fs_put_page(ipage, 1); 2740342fd30SJaegeuk Kim return true; 2751e1bb4baSJaegeuk Kim } 2761e1bb4baSJaegeuk Kim 2771e1bb4baSJaegeuk Kim if (f2fs_has_inline_data(inode)) { 2784d57b86dSChao Yu ipage = f2fs_get_node_page(sbi, inode->i_ino); 2799850cf4aSJaegeuk Kim f2fs_bug_on(sbi, IS_ERR(ipage)); 2804d57b86dSChao Yu f2fs_truncate_inline_inode(inode, ipage, 0); 281bd4667cbSKinglong Mee clear_inode_flag(inode, FI_INLINE_DATA); 2821e1bb4baSJaegeuk Kim f2fs_put_page(ipage, 1); 2830342fd30SJaegeuk Kim } else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) { 2844d57b86dSChao Yu if (f2fs_truncate_blocks(inode, 0, false)) 285545fe421SNicholas Krause return false; 2861e1bb4baSJaegeuk Kim goto process_inline; 2871e1bb4baSJaegeuk Kim } 2880342fd30SJaegeuk Kim return false; 2891e1bb4baSJaegeuk Kim } 290201a05beSChao Yu 2914d57b86dSChao Yu struct f2fs_dir_entry *f2fs_find_in_inline_dir(struct inode *dir, 2920b81d077SJaegeuk Kim struct fscrypt_name *fname, struct page **res_page) 293201a05beSChao Yu { 294201a05beSChao Yu struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb); 2956e22c691SJaegeuk Kim struct qstr name = FSTR_TO_QSTR(&fname->disk_name); 296201a05beSChao Yu struct f2fs_dir_entry *de; 2977b3cd7d6SJaegeuk Kim struct f2fs_dentry_ptr d; 2984e6ebf6dSJaegeuk Kim struct page *ipage; 299f2470371SChao Yu void *inline_dentry; 3006e22c691SJaegeuk Kim f2fs_hash_t namehash; 301201a05beSChao Yu 3024d57b86dSChao Yu ipage = f2fs_get_node_page(sbi, dir->i_ino); 30342d96401SJaegeuk Kim if (IS_ERR(ipage)) { 30442d96401SJaegeuk Kim *res_page = ipage; 305201a05beSChao Yu return NULL; 30642d96401SJaegeuk Kim } 307201a05beSChao Yu 3086332cd32SJaegeuk Kim namehash = f2fs_dentry_hash(&name, fname); 3096e22c691SJaegeuk Kim 310f2470371SChao Yu inline_dentry = inline_data_addr(dir, ipage); 311201a05beSChao Yu 312f2470371SChao Yu make_dentry_ptr_inline(dir, &d, inline_dentry); 3134d57b86dSChao Yu de = f2fs_find_target_dentry(fname, namehash, NULL, &d); 3144e6ebf6dSJaegeuk Kim unlock_page(ipage); 3154e6ebf6dSJaegeuk Kim if (de) 316201a05beSChao Yu *res_page = ipage; 3174e6ebf6dSJaegeuk Kim else 3184e6ebf6dSJaegeuk Kim f2fs_put_page(ipage, 0); 319201a05beSChao Yu 320201a05beSChao Yu return de; 321201a05beSChao Yu } 322201a05beSChao Yu 3234d57b86dSChao Yu int f2fs_make_empty_inline_dir(struct inode *inode, struct inode *parent, 324201a05beSChao Yu struct page *ipage) 325201a05beSChao Yu { 326062a3e7bSJaegeuk Kim struct f2fs_dentry_ptr d; 327f2470371SChao Yu void *inline_dentry; 328201a05beSChao Yu 329f2470371SChao Yu inline_dentry = inline_data_addr(inode, ipage); 330201a05beSChao Yu 331f2470371SChao Yu make_dentry_ptr_inline(inode, &d, inline_dentry); 3324d57b86dSChao Yu f2fs_do_make_empty_dir(inode, parent, &d); 333201a05beSChao Yu 334201a05beSChao Yu set_page_dirty(ipage); 335201a05beSChao Yu 336201a05beSChao Yu /* update i_size to MAX_INLINE_DATA */ 337f2470371SChao Yu if (i_size_read(inode) < MAX_INLINE_DATA(inode)) 338f2470371SChao Yu f2fs_i_size_write(inode, MAX_INLINE_DATA(inode)); 339201a05beSChao Yu return 0; 340201a05beSChao Yu } 341201a05beSChao Yu 342470f00e9SChao Yu /* 343470f00e9SChao Yu * NOTE: ipage is grabbed by caller, but if any error occurs, we should 344470f00e9SChao Yu * release ipage in this function. 345470f00e9SChao Yu */ 346675f10bdSChao Yu static int f2fs_move_inline_dirents(struct inode *dir, struct page *ipage, 347f2470371SChao Yu void *inline_dentry) 348201a05beSChao Yu { 349201a05beSChao Yu struct page *page; 350201a05beSChao Yu struct dnode_of_data dn; 351201a05beSChao Yu struct f2fs_dentry_block *dentry_blk; 35276a9dd85SChao Yu struct f2fs_dentry_ptr src, dst; 353201a05beSChao Yu int err; 354201a05beSChao Yu 355300e129cSJaegeuk Kim page = f2fs_grab_cache_page(dir->i_mapping, 0, false); 356470f00e9SChao Yu if (!page) { 357470f00e9SChao Yu f2fs_put_page(ipage, 1); 358201a05beSChao Yu return -ENOMEM; 359470f00e9SChao Yu } 360201a05beSChao Yu 361201a05beSChao Yu set_new_dnode(&dn, dir, ipage, NULL, 0); 362201a05beSChao Yu err = f2fs_reserve_block(&dn, 0); 363201a05beSChao Yu if (err) 364201a05beSChao Yu goto out; 365201a05beSChao Yu 366fec1d657SJaegeuk Kim f2fs_wait_on_page_writeback(page, DATA, true); 367201a05beSChao Yu 368bdbc90faSYunlong Song dentry_blk = page_address(page); 369201a05beSChao Yu 370f2470371SChao Yu make_dentry_ptr_inline(dir, &src, inline_dentry); 371f2470371SChao Yu make_dentry_ptr_block(dir, &dst, dentry_blk); 37276a9dd85SChao Yu 373201a05beSChao Yu /* copy data from inline dentry block to new dentry block */ 37476a9dd85SChao Yu memcpy(dst.bitmap, src.bitmap, src.nr_bitmap); 37576a9dd85SChao Yu memset(dst.bitmap + src.nr_bitmap, 0, dst.nr_bitmap - src.nr_bitmap); 3764ec17d68SChao Yu /* 3774ec17d68SChao Yu * we do not need to zero out remainder part of dentry and filename 3784ec17d68SChao Yu * field, since we have used bitmap for marking the usage status of 3794ec17d68SChao Yu * them, besides, we can also ignore copying/zeroing reserved space 3804ec17d68SChao Yu * of dentry block, because them haven't been used so far. 3814ec17d68SChao Yu */ 38276a9dd85SChao Yu memcpy(dst.dentry, src.dentry, SIZE_OF_DIR_ENTRY * src.max); 38376a9dd85SChao Yu memcpy(dst.filename, src.filename, src.max * F2FS_SLOT_LEN); 384201a05beSChao Yu 385237c0790SJaegeuk Kim if (!PageUptodate(page)) 386201a05beSChao Yu SetPageUptodate(page); 387201a05beSChao Yu set_page_dirty(page); 388201a05beSChao Yu 389201a05beSChao Yu /* clear inline dir and flag after data writeback */ 3904d57b86dSChao Yu f2fs_truncate_inline_inode(dir, ipage, 0); 391b3d208f9SJaegeuk Kim 3923289c061SJaegeuk Kim stat_dec_inline_dir(dir); 39391942321SJaegeuk Kim clear_inode_flag(dir, FI_INLINE_DENTRY); 394201a05beSChao Yu 395205b9822SJaegeuk Kim f2fs_i_depth_write(dir, 1); 396ee6d182fSJaegeuk Kim if (i_size_read(dir) < PAGE_SIZE) 397fc9581c8SJaegeuk Kim f2fs_i_size_write(dir, PAGE_SIZE); 398201a05beSChao Yu out: 399201a05beSChao Yu f2fs_put_page(page, 1); 400201a05beSChao Yu return err; 401201a05beSChao Yu } 402201a05beSChao Yu 403f2470371SChao Yu static int f2fs_add_inline_entries(struct inode *dir, void *inline_dentry) 404675f10bdSChao Yu { 405675f10bdSChao Yu struct f2fs_dentry_ptr d; 406675f10bdSChao Yu unsigned long bit_pos = 0; 407675f10bdSChao Yu int err = 0; 408675f10bdSChao Yu 409f2470371SChao Yu make_dentry_ptr_inline(dir, &d, inline_dentry); 410675f10bdSChao Yu 411675f10bdSChao Yu while (bit_pos < d.max) { 412675f10bdSChao Yu struct f2fs_dir_entry *de; 413675f10bdSChao Yu struct qstr new_name; 414675f10bdSChao Yu nid_t ino; 415675f10bdSChao Yu umode_t fake_mode; 416675f10bdSChao Yu 417675f10bdSChao Yu if (!test_bit_le(bit_pos, d.bitmap)) { 418675f10bdSChao Yu bit_pos++; 419675f10bdSChao Yu continue; 420675f10bdSChao Yu } 421675f10bdSChao Yu 422675f10bdSChao Yu de = &d.dentry[bit_pos]; 423a4a13f58SChao Yu 424a4a13f58SChao Yu if (unlikely(!de->name_len)) { 425a4a13f58SChao Yu bit_pos++; 426a4a13f58SChao Yu continue; 427a4a13f58SChao Yu } 428a4a13f58SChao Yu 429675f10bdSChao Yu new_name.name = d.filename[bit_pos]; 4300c0b471eSEric Biggers new_name.len = le16_to_cpu(de->name_len); 431675f10bdSChao Yu 432675f10bdSChao Yu ino = le32_to_cpu(de->ino); 4334d57b86dSChao Yu fake_mode = f2fs_get_de_type(de) << S_SHIFT; 434675f10bdSChao Yu 4359421d570SChao Yu err = f2fs_add_regular_entry(dir, &new_name, NULL, NULL, 436675f10bdSChao Yu ino, fake_mode); 437675f10bdSChao Yu if (err) 438675f10bdSChao Yu goto punch_dentry_pages; 439675f10bdSChao Yu 440675f10bdSChao Yu bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len)); 441675f10bdSChao Yu } 442675f10bdSChao Yu return 0; 443675f10bdSChao Yu punch_dentry_pages: 444675f10bdSChao Yu truncate_inode_pages(&dir->i_data, 0); 4454d57b86dSChao Yu f2fs_truncate_blocks(dir, 0, false); 4464d57b86dSChao Yu f2fs_remove_dirty_inode(dir); 447675f10bdSChao Yu return err; 448675f10bdSChao Yu } 449675f10bdSChao Yu 450675f10bdSChao Yu static int f2fs_move_rehashed_dirents(struct inode *dir, struct page *ipage, 451f2470371SChao Yu void *inline_dentry) 452675f10bdSChao Yu { 453f2470371SChao Yu void *backup_dentry; 454675f10bdSChao Yu int err; 455675f10bdSChao Yu 4561ecc0c5cSChao Yu backup_dentry = f2fs_kmalloc(F2FS_I_SB(dir), 457f2470371SChao Yu MAX_INLINE_DATA(dir), GFP_F2FS_ZERO); 4588975bdf4SChao Yu if (!backup_dentry) { 4598975bdf4SChao Yu f2fs_put_page(ipage, 1); 460675f10bdSChao Yu return -ENOMEM; 4618975bdf4SChao Yu } 462675f10bdSChao Yu 463f2470371SChao Yu memcpy(backup_dentry, inline_dentry, MAX_INLINE_DATA(dir)); 4644d57b86dSChao Yu f2fs_truncate_inline_inode(dir, ipage, 0); 465675f10bdSChao Yu 466675f10bdSChao Yu unlock_page(ipage); 467675f10bdSChao Yu 468675f10bdSChao Yu err = f2fs_add_inline_entries(dir, backup_dentry); 469675f10bdSChao Yu if (err) 470675f10bdSChao Yu goto recover; 471675f10bdSChao Yu 472675f10bdSChao Yu lock_page(ipage); 473675f10bdSChao Yu 474675f10bdSChao Yu stat_dec_inline_dir(dir); 47591942321SJaegeuk Kim clear_inode_flag(dir, FI_INLINE_DENTRY); 476675f10bdSChao Yu kfree(backup_dentry); 477675f10bdSChao Yu return 0; 478675f10bdSChao Yu recover: 479675f10bdSChao Yu lock_page(ipage); 480f2470371SChao Yu memcpy(inline_dentry, backup_dentry, MAX_INLINE_DATA(dir)); 481205b9822SJaegeuk Kim f2fs_i_depth_write(dir, 0); 482f2470371SChao Yu f2fs_i_size_write(dir, MAX_INLINE_DATA(dir)); 483ee6d182fSJaegeuk Kim set_page_dirty(ipage); 484675f10bdSChao Yu f2fs_put_page(ipage, 1); 485675f10bdSChao Yu 486675f10bdSChao Yu kfree(backup_dentry); 487675f10bdSChao Yu return err; 488675f10bdSChao Yu } 489675f10bdSChao Yu 490675f10bdSChao Yu static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage, 491f2470371SChao Yu void *inline_dentry) 492675f10bdSChao Yu { 493675f10bdSChao Yu if (!F2FS_I(dir)->i_dir_level) 494675f10bdSChao Yu return f2fs_move_inline_dirents(dir, ipage, inline_dentry); 495675f10bdSChao Yu else 496675f10bdSChao Yu return f2fs_move_rehashed_dirents(dir, ipage, inline_dentry); 497675f10bdSChao Yu } 498675f10bdSChao Yu 4999421d570SChao Yu int f2fs_add_inline_entry(struct inode *dir, const struct qstr *new_name, 5009421d570SChao Yu const struct qstr *orig_name, 501510022a8SJaegeuk Kim struct inode *inode, nid_t ino, umode_t mode) 502201a05beSChao Yu { 503201a05beSChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 504201a05beSChao Yu struct page *ipage; 505201a05beSChao Yu unsigned int bit_pos; 506201a05beSChao Yu f2fs_hash_t name_hash; 507f2470371SChao Yu void *inline_dentry = NULL; 5083b4d732aSChao Yu struct f2fs_dentry_ptr d; 5099421d570SChao Yu int slots = GET_DENTRY_SLOTS(new_name->len); 510510022a8SJaegeuk Kim struct page *page = NULL; 511201a05beSChao Yu int err = 0; 512201a05beSChao Yu 5134d57b86dSChao Yu ipage = f2fs_get_node_page(sbi, dir->i_ino); 514201a05beSChao Yu if (IS_ERR(ipage)) 515201a05beSChao Yu return PTR_ERR(ipage); 516201a05beSChao Yu 517f2470371SChao Yu inline_dentry = inline_data_addr(dir, ipage); 518f2470371SChao Yu make_dentry_ptr_inline(dir, &d, inline_dentry); 51976a9dd85SChao Yu 5204d57b86dSChao Yu bit_pos = f2fs_room_for_filename(d.bitmap, slots, d.max); 52176a9dd85SChao Yu if (bit_pos >= d.max) { 522a005774cSTiezhu Yang err = f2fs_convert_inline_dir(dir, ipage, inline_dentry); 523470f00e9SChao Yu if (err) 524470f00e9SChao Yu return err; 525201a05beSChao Yu err = -EAGAIN; 526201a05beSChao Yu goto out; 527201a05beSChao Yu } 528201a05beSChao Yu 529510022a8SJaegeuk Kim if (inode) { 530201a05beSChao Yu down_write(&F2FS_I(inode)->i_sem); 5314d57b86dSChao Yu page = f2fs_init_inode_metadata(inode, dir, new_name, 5329421d570SChao Yu orig_name, ipage); 533201a05beSChao Yu if (IS_ERR(page)) { 534201a05beSChao Yu err = PTR_ERR(page); 535201a05beSChao Yu goto fail; 536201a05beSChao Yu } 537510022a8SJaegeuk Kim } 538bce8d112SJaegeuk Kim 539fec1d657SJaegeuk Kim f2fs_wait_on_page_writeback(ipage, NODE, true); 5403b4d732aSChao Yu 5416332cd32SJaegeuk Kim name_hash = f2fs_dentry_hash(new_name, NULL); 5429421d570SChao Yu f2fs_update_dentry(ino, mode, &d, new_name, name_hash, bit_pos); 5433b4d732aSChao Yu 544201a05beSChao Yu set_page_dirty(ipage); 545201a05beSChao Yu 546201a05beSChao Yu /* we don't need to mark_inode_dirty now */ 547510022a8SJaegeuk Kim if (inode) { 548205b9822SJaegeuk Kim f2fs_i_pino_write(inode, dir->i_ino); 549201a05beSChao Yu f2fs_put_page(page, 1); 550510022a8SJaegeuk Kim } 551201a05beSChao Yu 5524d57b86dSChao Yu f2fs_update_parent_metadata(dir, inode, 0); 553201a05beSChao Yu fail: 554510022a8SJaegeuk Kim if (inode) 555201a05beSChao Yu up_write(&F2FS_I(inode)->i_sem); 556201a05beSChao Yu out: 557201a05beSChao Yu f2fs_put_page(ipage, 1); 558201a05beSChao Yu return err; 559201a05beSChao Yu } 560201a05beSChao Yu 561201a05beSChao Yu void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page, 562201a05beSChao Yu struct inode *dir, struct inode *inode) 563201a05beSChao Yu { 56476a9dd85SChao Yu struct f2fs_dentry_ptr d; 565f2470371SChao Yu void *inline_dentry; 566201a05beSChao Yu int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len)); 567201a05beSChao Yu unsigned int bit_pos; 568201a05beSChao Yu int i; 569201a05beSChao Yu 570201a05beSChao Yu lock_page(page); 571fec1d657SJaegeuk Kim f2fs_wait_on_page_writeback(page, NODE, true); 572201a05beSChao Yu 573f2470371SChao Yu inline_dentry = inline_data_addr(dir, page); 574f2470371SChao Yu make_dentry_ptr_inline(dir, &d, inline_dentry); 57576a9dd85SChao Yu 57676a9dd85SChao Yu bit_pos = dentry - d.dentry; 577201a05beSChao Yu for (i = 0; i < slots; i++) 57876a9dd85SChao Yu __clear_bit_le(bit_pos + i, d.bitmap); 579201a05beSChao Yu 580201a05beSChao Yu set_page_dirty(page); 5819f7c45ccSJaegeuk Kim f2fs_put_page(page, 1); 582201a05beSChao Yu 583078cd827SDeepa Dinamani dir->i_ctime = dir->i_mtime = current_time(dir); 5847c45729aSJaegeuk Kim f2fs_mark_inode_dirty_sync(dir, false); 585201a05beSChao Yu 586201a05beSChao Yu if (inode) 5879f7c45ccSJaegeuk Kim f2fs_drop_nlink(dir, inode); 588201a05beSChao Yu } 589201a05beSChao Yu 590201a05beSChao Yu bool f2fs_empty_inline_dir(struct inode *dir) 591201a05beSChao Yu { 592201a05beSChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 593201a05beSChao Yu struct page *ipage; 594201a05beSChao Yu unsigned int bit_pos = 2; 595f2470371SChao Yu void *inline_dentry; 59676a9dd85SChao Yu struct f2fs_dentry_ptr d; 597201a05beSChao Yu 5984d57b86dSChao Yu ipage = f2fs_get_node_page(sbi, dir->i_ino); 599201a05beSChao Yu if (IS_ERR(ipage)) 600201a05beSChao Yu return false; 601201a05beSChao Yu 602f2470371SChao Yu inline_dentry = inline_data_addr(dir, ipage); 603f2470371SChao Yu make_dentry_ptr_inline(dir, &d, inline_dentry); 60476a9dd85SChao Yu 60576a9dd85SChao Yu bit_pos = find_next_bit_le(d.bitmap, d.max, bit_pos); 606201a05beSChao Yu 607201a05beSChao Yu f2fs_put_page(ipage, 1); 608201a05beSChao Yu 60976a9dd85SChao Yu if (bit_pos < d.max) 610201a05beSChao Yu return false; 611201a05beSChao Yu 612201a05beSChao Yu return true; 613201a05beSChao Yu } 614201a05beSChao Yu 615d8c6822aSJaegeuk Kim int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx, 6160b81d077SJaegeuk Kim struct fscrypt_str *fstr) 617201a05beSChao Yu { 618201a05beSChao Yu struct inode *inode = file_inode(file); 619201a05beSChao Yu struct page *ipage = NULL; 6207b3cd7d6SJaegeuk Kim struct f2fs_dentry_ptr d; 621f2470371SChao Yu void *inline_dentry = NULL; 622ed6bd4b1SChao Yu int err; 623201a05beSChao Yu 62476a9dd85SChao Yu make_dentry_ptr_inline(inode, &d, inline_dentry); 62576a9dd85SChao Yu 62676a9dd85SChao Yu if (ctx->pos == d.max) 627201a05beSChao Yu return 0; 628201a05beSChao Yu 6294d57b86dSChao Yu ipage = f2fs_get_node_page(F2FS_I_SB(inode), inode->i_ino); 630201a05beSChao Yu if (IS_ERR(ipage)) 631201a05beSChao Yu return PTR_ERR(ipage); 632201a05beSChao Yu 633f2470371SChao Yu inline_dentry = inline_data_addr(inode, ipage); 634201a05beSChao Yu 63564c24ecbSTomohiro Kusumi make_dentry_ptr_inline(inode, &d, inline_dentry); 6367b3cd7d6SJaegeuk Kim 637ed6bd4b1SChao Yu err = f2fs_fill_dentries(ctx, &d, 0, fstr); 638ed6bd4b1SChao Yu if (!err) 63976a9dd85SChao Yu ctx->pos = d.max; 640201a05beSChao Yu 64138594de7SJaegeuk Kim f2fs_put_page(ipage, 1); 642ed6bd4b1SChao Yu return err < 0 ? err : 0; 643201a05beSChao Yu } 64467f8cf3cSJaegeuk Kim 64567f8cf3cSJaegeuk Kim int f2fs_inline_data_fiemap(struct inode *inode, 64667f8cf3cSJaegeuk Kim struct fiemap_extent_info *fieinfo, __u64 start, __u64 len) 64767f8cf3cSJaegeuk Kim { 64867f8cf3cSJaegeuk Kim __u64 byteaddr, ilen; 64967f8cf3cSJaegeuk Kim __u32 flags = FIEMAP_EXTENT_DATA_INLINE | FIEMAP_EXTENT_NOT_ALIGNED | 65067f8cf3cSJaegeuk Kim FIEMAP_EXTENT_LAST; 65167f8cf3cSJaegeuk Kim struct node_info ni; 65267f8cf3cSJaegeuk Kim struct page *ipage; 65367f8cf3cSJaegeuk Kim int err = 0; 65467f8cf3cSJaegeuk Kim 6554d57b86dSChao Yu ipage = f2fs_get_node_page(F2FS_I_SB(inode), inode->i_ino); 65667f8cf3cSJaegeuk Kim if (IS_ERR(ipage)) 65767f8cf3cSJaegeuk Kim return PTR_ERR(ipage); 65867f8cf3cSJaegeuk Kim 65967f8cf3cSJaegeuk Kim if (!f2fs_has_inline_data(inode)) { 66067f8cf3cSJaegeuk Kim err = -EAGAIN; 66167f8cf3cSJaegeuk Kim goto out; 66267f8cf3cSJaegeuk Kim } 66367f8cf3cSJaegeuk Kim 664f2470371SChao Yu ilen = min_t(size_t, MAX_INLINE_DATA(inode), i_size_read(inode)); 66567f8cf3cSJaegeuk Kim if (start >= ilen) 66667f8cf3cSJaegeuk Kim goto out; 66767f8cf3cSJaegeuk Kim if (start + len < ilen) 66867f8cf3cSJaegeuk Kim ilen = start + len; 66967f8cf3cSJaegeuk Kim ilen -= start; 67067f8cf3cSJaegeuk Kim 6714d57b86dSChao Yu f2fs_get_node_info(F2FS_I_SB(inode), inode->i_ino, &ni); 67267f8cf3cSJaegeuk Kim byteaddr = (__u64)ni.blk_addr << inode->i_sb->s_blocksize_bits; 673f2470371SChao Yu byteaddr += (char *)inline_data_addr(inode, ipage) - 674f2470371SChao Yu (char *)F2FS_INODE(ipage); 67567f8cf3cSJaegeuk Kim err = fiemap_fill_next_extent(fieinfo, start, byteaddr, ilen, flags); 67667f8cf3cSJaegeuk Kim out: 67767f8cf3cSJaegeuk Kim f2fs_put_page(ipage, 1); 67867f8cf3cSJaegeuk Kim return err; 67967f8cf3cSJaegeuk Kim } 680