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 28fcc85a4dSJaegeuk Kim if (f2fs_encrypted_inode(inode) && S_ISREG(inode->i_mode)) 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 45b3d208f9SJaegeuk Kim void 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 67bd4667cbSKinglong Mee void truncate_inline_inode(struct inode *inode, struct page *ipage, u64 from) 68feeb0debSChao Yu { 690bfcfccaSChao Yu void *addr; 700bfcfccaSChao Yu 71f2470371SChao Yu if (from >= MAX_INLINE_DATA(inode)) 72bd4667cbSKinglong Mee return; 730bfcfccaSChao Yu 74f2470371SChao Yu addr = inline_data_addr(inode, ipage); 750bfcfccaSChao Yu 76fec1d657SJaegeuk Kim f2fs_wait_on_page_writeback(ipage, NODE, true); 77f2470371SChao Yu memset(addr + from, 0, MAX_INLINE_DATA(inode) - from); 78ee6d182fSJaegeuk Kim set_page_dirty(ipage); 79bd4667cbSKinglong Mee 80bd4667cbSKinglong Mee if (from == 0) 81bd4667cbSKinglong Mee clear_inode_flag(inode, FI_DATA_EXIST); 82feeb0debSChao Yu } 83feeb0debSChao Yu 84b3d208f9SJaegeuk Kim int f2fs_read_inline_data(struct inode *inode, struct page *page) 85b3d208f9SJaegeuk Kim { 86b3d208f9SJaegeuk Kim struct page *ipage; 87b3d208f9SJaegeuk Kim 88b3d208f9SJaegeuk Kim ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino); 89b3d208f9SJaegeuk Kim if (IS_ERR(ipage)) { 90b3d208f9SJaegeuk Kim unlock_page(page); 91b3d208f9SJaegeuk Kim return PTR_ERR(ipage); 92b3d208f9SJaegeuk Kim } 93b3d208f9SJaegeuk Kim 94b3d208f9SJaegeuk Kim if (!f2fs_has_inline_data(inode)) { 95b3d208f9SJaegeuk Kim f2fs_put_page(ipage, 1); 96b3d208f9SJaegeuk Kim return -EAGAIN; 97b3d208f9SJaegeuk Kim } 98b3d208f9SJaegeuk Kim 99b3d208f9SJaegeuk Kim if (page->index) 10009cbfeafSKirill A. Shutemov zero_user_segment(page, 0, PAGE_SIZE); 101b3d208f9SJaegeuk Kim else 102b3d208f9SJaegeuk Kim read_inline_data(page, ipage); 103b3d208f9SJaegeuk Kim 104237c0790SJaegeuk Kim if (!PageUptodate(page)) 105b3d208f9SJaegeuk Kim SetPageUptodate(page); 106b3d208f9SJaegeuk Kim f2fs_put_page(ipage, 1); 107b3d208f9SJaegeuk Kim unlock_page(page); 108e18c65b2SHuajun Li return 0; 109e18c65b2SHuajun Li } 110e18c65b2SHuajun Li 111b3d208f9SJaegeuk Kim int f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page) 112e18c65b2SHuajun Li { 113e18c65b2SHuajun Li struct f2fs_io_info fio = { 11405ca3632SJaegeuk Kim .sbi = F2FS_I_SB(dn->inode), 115e18c65b2SHuajun Li .type = DATA, 11604d328deSMike Christie .op = REQ_OP_WRITE, 11770fd7614SChristoph Hellwig .op_flags = REQ_SYNC | REQ_PRIO, 11805ca3632SJaegeuk Kim .page = page, 1194375a336SJaegeuk Kim .encrypted_page = NULL, 120e18c65b2SHuajun Li }; 121158c194cSJaegeuk Kim int dirty, err; 122e18c65b2SHuajun Li 123b3d208f9SJaegeuk Kim if (!f2fs_exist_data(dn->inode)) 124b3d208f9SJaegeuk Kim goto clear_out; 125ec4e7af4SJaegeuk Kim 126b3d208f9SJaegeuk Kim err = f2fs_reserve_block(dn, 0); 12715c6e3aaSJaegeuk Kim if (err) 128b3d208f9SJaegeuk Kim return err; 129e18c65b2SHuajun Li 13085ead818SYunlei He f2fs_bug_on(F2FS_P_SB(page), PageWriteback(page)); 131b3d208f9SJaegeuk Kim 1328060656aSShawn Lin read_inline_data(page, dn->inode_page); 1336282adbfSJaegeuk Kim set_page_dirty(page); 1346282adbfSJaegeuk Kim 135158c194cSJaegeuk Kim /* clear dirty state */ 136158c194cSJaegeuk Kim dirty = clear_page_dirty_for_io(page); 137158c194cSJaegeuk Kim 138e18c65b2SHuajun Li /* write data page to try to make data consistent */ 139e18c65b2SHuajun Li set_page_writeback(page); 1407a9d7548SChao Yu fio.old_blkaddr = dn->data_blkaddr; 141ef095d19SJaegeuk Kim set_inode_flag(dn->inode, FI_HOT_DATA); 14205ca3632SJaegeuk Kim write_data_page(dn, &fio); 143fec1d657SJaegeuk Kim f2fs_wait_on_page_writeback(page, DATA, true); 144933439c8SChao Yu if (dirty) { 145158c194cSJaegeuk Kim inode_dec_dirty_pages(dn->inode); 146933439c8SChao Yu remove_dirty_inode(dn->inode); 147933439c8SChao Yu } 148e18c65b2SHuajun Li 14995f5b0fcSJaegeuk Kim /* this converted inline_data should be recovered. */ 15091942321SJaegeuk Kim set_inode_flag(dn->inode, FI_APPEND_WRITE); 15195f5b0fcSJaegeuk Kim 152e18c65b2SHuajun Li /* clear inline data and flag after data writeback */ 153bd4667cbSKinglong Mee truncate_inline_inode(dn->inode, dn->inode_page, 0); 1542049d4fcSJaegeuk Kim clear_inline_node(dn->inode_page); 155b3d208f9SJaegeuk Kim clear_out: 156b3d208f9SJaegeuk Kim stat_dec_inline_inode(dn->inode); 157bd4667cbSKinglong Mee clear_inode_flag(dn->inode, FI_INLINE_DATA); 158b3d208f9SJaegeuk Kim f2fs_put_dnode(dn); 159b3d208f9SJaegeuk Kim return 0; 160e18c65b2SHuajun Li } 161e18c65b2SHuajun Li 162b3d208f9SJaegeuk Kim int f2fs_convert_inline_inode(struct inode *inode) 163e18c65b2SHuajun Li { 164b3d208f9SJaegeuk Kim struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 165b3d208f9SJaegeuk Kim struct dnode_of_data dn; 166b3d208f9SJaegeuk Kim struct page *ipage, *page; 167b3d208f9SJaegeuk Kim int err = 0; 168e18c65b2SHuajun Li 169b9d777b8SJaegeuk Kim if (!f2fs_has_inline_data(inode)) 170b9d777b8SJaegeuk Kim return 0; 171b9d777b8SJaegeuk Kim 172300e129cSJaegeuk Kim page = f2fs_grab_cache_page(inode->i_mapping, 0, false); 173b3d208f9SJaegeuk Kim if (!page) 1749e09fc85SJaegeuk Kim return -ENOMEM; 175b3d208f9SJaegeuk Kim 176b3d208f9SJaegeuk Kim f2fs_lock_op(sbi); 177b3d208f9SJaegeuk Kim 178b3d208f9SJaegeuk Kim ipage = get_node_page(sbi, inode->i_ino); 179b3d208f9SJaegeuk Kim if (IS_ERR(ipage)) { 1806d20aff8SJaegeuk Kim err = PTR_ERR(ipage); 1816d20aff8SJaegeuk Kim goto out; 182b067ba1fSJaegeuk Kim } 183e18c65b2SHuajun Li 184b3d208f9SJaegeuk Kim set_new_dnode(&dn, inode, ipage, ipage, 0); 185b3d208f9SJaegeuk Kim 186b3d208f9SJaegeuk Kim if (f2fs_has_inline_data(inode)) 187b3d208f9SJaegeuk Kim err = f2fs_convert_inline_page(&dn, page); 188b3d208f9SJaegeuk Kim 189b3d208f9SJaegeuk Kim f2fs_put_dnode(&dn); 1906d20aff8SJaegeuk Kim out: 191b3d208f9SJaegeuk Kim f2fs_unlock_op(sbi); 192b3d208f9SJaegeuk Kim 193b3d208f9SJaegeuk Kim f2fs_put_page(page, 1); 1942a340760SJaegeuk Kim 1952c4db1a6SJaegeuk Kim f2fs_balance_fs(sbi, dn.node_changed); 1962a340760SJaegeuk Kim 197e18c65b2SHuajun Li return err; 198e18c65b2SHuajun Li } 199e18c65b2SHuajun Li 200b3d208f9SJaegeuk Kim int f2fs_write_inline_data(struct inode *inode, struct page *page) 201e18c65b2SHuajun Li { 202e18c65b2SHuajun Li void *src_addr, *dst_addr; 203e18c65b2SHuajun Li struct dnode_of_data dn; 204e18c65b2SHuajun Li int err; 205e18c65b2SHuajun Li 206e18c65b2SHuajun Li set_new_dnode(&dn, inode, NULL, NULL, 0); 207e18c65b2SHuajun Li err = get_dnode_of_data(&dn, 0, LOOKUP_NODE); 208e18c65b2SHuajun Li if (err) 209e18c65b2SHuajun Li return err; 210e18c65b2SHuajun Li 211c08a690bSJaegeuk Kim if (!f2fs_has_inline_data(inode)) { 212b3d208f9SJaegeuk Kim f2fs_put_dnode(&dn); 213b3d208f9SJaegeuk Kim return -EAGAIN; 214c08a690bSJaegeuk Kim } 215c08a690bSJaegeuk Kim 216b3d208f9SJaegeuk Kim f2fs_bug_on(F2FS_I_SB(inode), page->index); 217b3d208f9SJaegeuk Kim 218fec1d657SJaegeuk Kim f2fs_wait_on_page_writeback(dn.inode_page, NODE, true); 219f1e33a04SJaegeuk Kim src_addr = kmap_atomic(page); 220f2470371SChao Yu dst_addr = inline_data_addr(inode, dn.inode_page); 221f2470371SChao Yu memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode)); 222f1e33a04SJaegeuk Kim kunmap_atomic(src_addr); 223ee6d182fSJaegeuk Kim set_page_dirty(dn.inode_page); 224e18c65b2SHuajun Li 22591942321SJaegeuk Kim set_inode_flag(inode, FI_APPEND_WRITE); 22691942321SJaegeuk Kim set_inode_flag(inode, FI_DATA_EXIST); 227b3d208f9SJaegeuk Kim 2282049d4fcSJaegeuk Kim clear_inline_node(dn.inode_page); 229e18c65b2SHuajun Li f2fs_put_dnode(&dn); 230e18c65b2SHuajun Li return 0; 231e18c65b2SHuajun Li } 2321e1bb4baSJaegeuk Kim 2330342fd30SJaegeuk Kim bool recover_inline_data(struct inode *inode, struct page *npage) 2341e1bb4baSJaegeuk Kim { 2354081363fSJaegeuk Kim struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 2361e1bb4baSJaegeuk Kim struct f2fs_inode *ri = NULL; 2371e1bb4baSJaegeuk Kim void *src_addr, *dst_addr; 2381e1bb4baSJaegeuk Kim struct page *ipage; 2391e1bb4baSJaegeuk Kim 2401e1bb4baSJaegeuk Kim /* 2411e1bb4baSJaegeuk Kim * The inline_data recovery policy is as follows. 2421e1bb4baSJaegeuk Kim * [prev.] [next] of inline_data flag 2431e1bb4baSJaegeuk Kim * o o -> recover inline_data 2441e1bb4baSJaegeuk Kim * o x -> remove inline_data, and then recover data blocks 2451e1bb4baSJaegeuk Kim * x o -> remove inline_data, and then recover inline_data 2461e1bb4baSJaegeuk Kim * x x -> recover data blocks 2471e1bb4baSJaegeuk Kim */ 2481e1bb4baSJaegeuk Kim if (IS_INODE(npage)) 2491e1bb4baSJaegeuk Kim ri = F2FS_INODE(npage); 2501e1bb4baSJaegeuk Kim 2511e1bb4baSJaegeuk Kim if (f2fs_has_inline_data(inode) && 2520342fd30SJaegeuk Kim ri && (ri->i_inline & F2FS_INLINE_DATA)) { 2531e1bb4baSJaegeuk Kim process_inline: 2541e1bb4baSJaegeuk Kim ipage = get_node_page(sbi, inode->i_ino); 2559850cf4aSJaegeuk Kim f2fs_bug_on(sbi, IS_ERR(ipage)); 2561e1bb4baSJaegeuk Kim 257fec1d657SJaegeuk Kim f2fs_wait_on_page_writeback(ipage, NODE, true); 25854b591dfSJaegeuk Kim 259f2470371SChao Yu src_addr = inline_data_addr(inode, npage); 260f2470371SChao Yu dst_addr = inline_data_addr(inode, ipage); 261f2470371SChao Yu memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode)); 262b3d208f9SJaegeuk Kim 26391942321SJaegeuk Kim set_inode_flag(inode, FI_INLINE_DATA); 26491942321SJaegeuk Kim set_inode_flag(inode, FI_DATA_EXIST); 265b3d208f9SJaegeuk Kim 266ee6d182fSJaegeuk Kim set_page_dirty(ipage); 2671e1bb4baSJaegeuk Kim f2fs_put_page(ipage, 1); 2680342fd30SJaegeuk Kim return true; 2691e1bb4baSJaegeuk Kim } 2701e1bb4baSJaegeuk Kim 2711e1bb4baSJaegeuk Kim if (f2fs_has_inline_data(inode)) { 2721e1bb4baSJaegeuk Kim ipage = get_node_page(sbi, inode->i_ino); 2739850cf4aSJaegeuk Kim f2fs_bug_on(sbi, IS_ERR(ipage)); 274bd4667cbSKinglong Mee truncate_inline_inode(inode, ipage, 0); 275bd4667cbSKinglong Mee clear_inode_flag(inode, FI_INLINE_DATA); 2761e1bb4baSJaegeuk Kim f2fs_put_page(ipage, 1); 2770342fd30SJaegeuk Kim } else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) { 278545fe421SNicholas Krause if (truncate_blocks(inode, 0, false)) 279545fe421SNicholas Krause return false; 2801e1bb4baSJaegeuk Kim goto process_inline; 2811e1bb4baSJaegeuk Kim } 2820342fd30SJaegeuk Kim return false; 2831e1bb4baSJaegeuk Kim } 284201a05beSChao Yu 285201a05beSChao Yu struct f2fs_dir_entry *find_in_inline_dir(struct inode *dir, 2860b81d077SJaegeuk Kim struct fscrypt_name *fname, struct page **res_page) 287201a05beSChao Yu { 288201a05beSChao Yu struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb); 2896e22c691SJaegeuk Kim struct qstr name = FSTR_TO_QSTR(&fname->disk_name); 290201a05beSChao Yu struct f2fs_dir_entry *de; 2917b3cd7d6SJaegeuk Kim struct f2fs_dentry_ptr d; 2924e6ebf6dSJaegeuk Kim struct page *ipage; 293f2470371SChao Yu void *inline_dentry; 2946e22c691SJaegeuk Kim f2fs_hash_t namehash; 295201a05beSChao Yu 296201a05beSChao Yu ipage = get_node_page(sbi, dir->i_ino); 29742d96401SJaegeuk Kim if (IS_ERR(ipage)) { 29842d96401SJaegeuk Kim *res_page = ipage; 299201a05beSChao Yu return NULL; 30042d96401SJaegeuk Kim } 301201a05beSChao Yu 3026332cd32SJaegeuk Kim namehash = f2fs_dentry_hash(&name, fname); 3036e22c691SJaegeuk Kim 304f2470371SChao Yu inline_dentry = inline_data_addr(dir, ipage); 305201a05beSChao Yu 306f2470371SChao Yu make_dentry_ptr_inline(dir, &d, inline_dentry); 3076e22c691SJaegeuk Kim de = find_target_dentry(fname, namehash, NULL, &d); 3084e6ebf6dSJaegeuk Kim unlock_page(ipage); 3094e6ebf6dSJaegeuk Kim if (de) 310201a05beSChao Yu *res_page = ipage; 3114e6ebf6dSJaegeuk Kim else 3124e6ebf6dSJaegeuk Kim f2fs_put_page(ipage, 0); 313201a05beSChao Yu 314201a05beSChao Yu return de; 315201a05beSChao Yu } 316201a05beSChao Yu 317201a05beSChao Yu int make_empty_inline_dir(struct inode *inode, struct inode *parent, 318201a05beSChao Yu struct page *ipage) 319201a05beSChao Yu { 320062a3e7bSJaegeuk Kim struct f2fs_dentry_ptr d; 321f2470371SChao Yu void *inline_dentry; 322201a05beSChao Yu 323f2470371SChao Yu inline_dentry = inline_data_addr(inode, ipage); 324201a05beSChao Yu 325f2470371SChao Yu make_dentry_ptr_inline(inode, &d, inline_dentry); 326062a3e7bSJaegeuk Kim do_make_empty_dir(inode, parent, &d); 327201a05beSChao Yu 328201a05beSChao Yu set_page_dirty(ipage); 329201a05beSChao Yu 330201a05beSChao Yu /* update i_size to MAX_INLINE_DATA */ 331f2470371SChao Yu if (i_size_read(inode) < MAX_INLINE_DATA(inode)) 332f2470371SChao Yu f2fs_i_size_write(inode, MAX_INLINE_DATA(inode)); 333201a05beSChao Yu return 0; 334201a05beSChao Yu } 335201a05beSChao Yu 336470f00e9SChao Yu /* 337470f00e9SChao Yu * NOTE: ipage is grabbed by caller, but if any error occurs, we should 338470f00e9SChao Yu * release ipage in this function. 339470f00e9SChao Yu */ 340675f10bdSChao Yu static int f2fs_move_inline_dirents(struct inode *dir, struct page *ipage, 341f2470371SChao Yu void *inline_dentry) 342201a05beSChao Yu { 343201a05beSChao Yu struct page *page; 344201a05beSChao Yu struct dnode_of_data dn; 345201a05beSChao Yu struct f2fs_dentry_block *dentry_blk; 34676a9dd85SChao Yu struct f2fs_dentry_ptr src, dst; 347201a05beSChao Yu int err; 348201a05beSChao Yu 349300e129cSJaegeuk Kim page = f2fs_grab_cache_page(dir->i_mapping, 0, false); 350470f00e9SChao Yu if (!page) { 351470f00e9SChao Yu f2fs_put_page(ipage, 1); 352201a05beSChao Yu return -ENOMEM; 353470f00e9SChao Yu } 354201a05beSChao Yu 355201a05beSChao Yu set_new_dnode(&dn, dir, ipage, NULL, 0); 356201a05beSChao Yu err = f2fs_reserve_block(&dn, 0); 357201a05beSChao Yu if (err) 358201a05beSChao Yu goto out; 359201a05beSChao Yu 360fec1d657SJaegeuk Kim f2fs_wait_on_page_writeback(page, DATA, true); 361f2470371SChao Yu zero_user_segment(page, MAX_INLINE_DATA(dir), PAGE_SIZE); 362201a05beSChao Yu 363f1e33a04SJaegeuk Kim dentry_blk = kmap_atomic(page); 364201a05beSChao Yu 365f2470371SChao Yu make_dentry_ptr_inline(dir, &src, inline_dentry); 366f2470371SChao Yu make_dentry_ptr_block(dir, &dst, dentry_blk); 36776a9dd85SChao Yu 368201a05beSChao Yu /* copy data from inline dentry block to new dentry block */ 36976a9dd85SChao Yu memcpy(dst.bitmap, src.bitmap, src.nr_bitmap); 37076a9dd85SChao Yu memset(dst.bitmap + src.nr_bitmap, 0, dst.nr_bitmap - src.nr_bitmap); 3714ec17d68SChao Yu /* 3724ec17d68SChao Yu * we do not need to zero out remainder part of dentry and filename 3734ec17d68SChao Yu * field, since we have used bitmap for marking the usage status of 3744ec17d68SChao Yu * them, besides, we can also ignore copying/zeroing reserved space 3754ec17d68SChao Yu * of dentry block, because them haven't been used so far. 3764ec17d68SChao Yu */ 37776a9dd85SChao Yu memcpy(dst.dentry, src.dentry, SIZE_OF_DIR_ENTRY * src.max); 37876a9dd85SChao Yu memcpy(dst.filename, src.filename, src.max * F2FS_SLOT_LEN); 379201a05beSChao Yu 380f1e33a04SJaegeuk Kim kunmap_atomic(dentry_blk); 381237c0790SJaegeuk Kim if (!PageUptodate(page)) 382201a05beSChao Yu SetPageUptodate(page); 383201a05beSChao Yu set_page_dirty(page); 384201a05beSChao Yu 385201a05beSChao Yu /* clear inline dir and flag after data writeback */ 386bd4667cbSKinglong Mee truncate_inline_inode(dir, ipage, 0); 387b3d208f9SJaegeuk Kim 3883289c061SJaegeuk Kim stat_dec_inline_dir(dir); 38991942321SJaegeuk Kim clear_inode_flag(dir, FI_INLINE_DENTRY); 390201a05beSChao Yu 391205b9822SJaegeuk Kim f2fs_i_depth_write(dir, 1); 392ee6d182fSJaegeuk Kim if (i_size_read(dir) < PAGE_SIZE) 393fc9581c8SJaegeuk Kim f2fs_i_size_write(dir, PAGE_SIZE); 394201a05beSChao Yu out: 395201a05beSChao Yu f2fs_put_page(page, 1); 396201a05beSChao Yu return err; 397201a05beSChao Yu } 398201a05beSChao Yu 399f2470371SChao Yu static int f2fs_add_inline_entries(struct inode *dir, void *inline_dentry) 400675f10bdSChao Yu { 401675f10bdSChao Yu struct f2fs_dentry_ptr d; 402675f10bdSChao Yu unsigned long bit_pos = 0; 403675f10bdSChao Yu int err = 0; 404675f10bdSChao Yu 405f2470371SChao Yu make_dentry_ptr_inline(dir, &d, inline_dentry); 406675f10bdSChao Yu 407675f10bdSChao Yu while (bit_pos < d.max) { 408675f10bdSChao Yu struct f2fs_dir_entry *de; 409675f10bdSChao Yu struct qstr new_name; 410675f10bdSChao Yu nid_t ino; 411675f10bdSChao Yu umode_t fake_mode; 412675f10bdSChao Yu 413675f10bdSChao Yu if (!test_bit_le(bit_pos, d.bitmap)) { 414675f10bdSChao Yu bit_pos++; 415675f10bdSChao Yu continue; 416675f10bdSChao Yu } 417675f10bdSChao Yu 418675f10bdSChao Yu de = &d.dentry[bit_pos]; 419a4a13f58SChao Yu 420a4a13f58SChao Yu if (unlikely(!de->name_len)) { 421a4a13f58SChao Yu bit_pos++; 422a4a13f58SChao Yu continue; 423a4a13f58SChao Yu } 424a4a13f58SChao Yu 425675f10bdSChao Yu new_name.name = d.filename[bit_pos]; 4260c0b471eSEric Biggers new_name.len = le16_to_cpu(de->name_len); 427675f10bdSChao Yu 428675f10bdSChao Yu ino = le32_to_cpu(de->ino); 429675f10bdSChao Yu fake_mode = get_de_type(de) << S_SHIFT; 430675f10bdSChao Yu 4319421d570SChao Yu err = f2fs_add_regular_entry(dir, &new_name, NULL, NULL, 432675f10bdSChao Yu ino, fake_mode); 433675f10bdSChao Yu if (err) 434675f10bdSChao Yu goto punch_dentry_pages; 435675f10bdSChao Yu 436675f10bdSChao Yu bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len)); 437675f10bdSChao Yu } 438675f10bdSChao Yu return 0; 439675f10bdSChao Yu punch_dentry_pages: 440675f10bdSChao Yu truncate_inode_pages(&dir->i_data, 0); 441675f10bdSChao Yu truncate_blocks(dir, 0, false); 442675f10bdSChao Yu remove_dirty_inode(dir); 443675f10bdSChao Yu return err; 444675f10bdSChao Yu } 445675f10bdSChao Yu 446675f10bdSChao Yu static int f2fs_move_rehashed_dirents(struct inode *dir, struct page *ipage, 447f2470371SChao Yu void *inline_dentry) 448675f10bdSChao Yu { 449f2470371SChao Yu void *backup_dentry; 450675f10bdSChao Yu int err; 451675f10bdSChao Yu 4521ecc0c5cSChao Yu backup_dentry = f2fs_kmalloc(F2FS_I_SB(dir), 453f2470371SChao Yu MAX_INLINE_DATA(dir), GFP_F2FS_ZERO); 4548975bdf4SChao Yu if (!backup_dentry) { 4558975bdf4SChao Yu f2fs_put_page(ipage, 1); 456675f10bdSChao Yu return -ENOMEM; 4578975bdf4SChao Yu } 458675f10bdSChao Yu 459f2470371SChao Yu memcpy(backup_dentry, inline_dentry, MAX_INLINE_DATA(dir)); 460bd4667cbSKinglong Mee truncate_inline_inode(dir, ipage, 0); 461675f10bdSChao Yu 462675f10bdSChao Yu unlock_page(ipage); 463675f10bdSChao Yu 464675f10bdSChao Yu err = f2fs_add_inline_entries(dir, backup_dentry); 465675f10bdSChao Yu if (err) 466675f10bdSChao Yu goto recover; 467675f10bdSChao Yu 468675f10bdSChao Yu lock_page(ipage); 469675f10bdSChao Yu 470675f10bdSChao Yu stat_dec_inline_dir(dir); 47191942321SJaegeuk Kim clear_inode_flag(dir, FI_INLINE_DENTRY); 472675f10bdSChao Yu kfree(backup_dentry); 473675f10bdSChao Yu return 0; 474675f10bdSChao Yu recover: 475675f10bdSChao Yu lock_page(ipage); 476f2470371SChao Yu memcpy(inline_dentry, backup_dentry, MAX_INLINE_DATA(dir)); 477205b9822SJaegeuk Kim f2fs_i_depth_write(dir, 0); 478f2470371SChao Yu f2fs_i_size_write(dir, MAX_INLINE_DATA(dir)); 479ee6d182fSJaegeuk Kim set_page_dirty(ipage); 480675f10bdSChao Yu f2fs_put_page(ipage, 1); 481675f10bdSChao Yu 482675f10bdSChao Yu kfree(backup_dentry); 483675f10bdSChao Yu return err; 484675f10bdSChao Yu } 485675f10bdSChao Yu 486675f10bdSChao Yu static int f2fs_convert_inline_dir(struct inode *dir, struct page *ipage, 487f2470371SChao Yu void *inline_dentry) 488675f10bdSChao Yu { 489675f10bdSChao Yu if (!F2FS_I(dir)->i_dir_level) 490675f10bdSChao Yu return f2fs_move_inline_dirents(dir, ipage, inline_dentry); 491675f10bdSChao Yu else 492675f10bdSChao Yu return f2fs_move_rehashed_dirents(dir, ipage, inline_dentry); 493675f10bdSChao Yu } 494675f10bdSChao Yu 4959421d570SChao Yu int f2fs_add_inline_entry(struct inode *dir, const struct qstr *new_name, 4969421d570SChao Yu const struct qstr *orig_name, 497510022a8SJaegeuk Kim struct inode *inode, nid_t ino, umode_t mode) 498201a05beSChao Yu { 499201a05beSChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 500201a05beSChao Yu struct page *ipage; 501201a05beSChao Yu unsigned int bit_pos; 502201a05beSChao Yu f2fs_hash_t name_hash; 503f2470371SChao Yu void *inline_dentry = NULL; 5043b4d732aSChao Yu struct f2fs_dentry_ptr d; 5059421d570SChao Yu int slots = GET_DENTRY_SLOTS(new_name->len); 506510022a8SJaegeuk Kim struct page *page = NULL; 507201a05beSChao Yu int err = 0; 508201a05beSChao Yu 509201a05beSChao Yu ipage = get_node_page(sbi, dir->i_ino); 510201a05beSChao Yu if (IS_ERR(ipage)) 511201a05beSChao Yu return PTR_ERR(ipage); 512201a05beSChao Yu 513f2470371SChao Yu inline_dentry = inline_data_addr(dir, ipage); 514f2470371SChao Yu make_dentry_ptr_inline(dir, &d, inline_dentry); 51576a9dd85SChao Yu 51676a9dd85SChao Yu bit_pos = room_for_filename(d.bitmap, slots, d.max); 51776a9dd85SChao Yu if (bit_pos >= d.max) { 518a005774cSTiezhu Yang err = f2fs_convert_inline_dir(dir, ipage, inline_dentry); 519470f00e9SChao Yu if (err) 520470f00e9SChao Yu return err; 521201a05beSChao Yu err = -EAGAIN; 522201a05beSChao Yu goto out; 523201a05beSChao Yu } 524201a05beSChao Yu 525510022a8SJaegeuk Kim if (inode) { 526201a05beSChao Yu down_write(&F2FS_I(inode)->i_sem); 5279421d570SChao Yu page = init_inode_metadata(inode, dir, new_name, 5289421d570SChao Yu orig_name, ipage); 529201a05beSChao Yu if (IS_ERR(page)) { 530201a05beSChao Yu err = PTR_ERR(page); 531201a05beSChao Yu goto fail; 532201a05beSChao Yu } 533510022a8SJaegeuk Kim } 534bce8d112SJaegeuk Kim 535fec1d657SJaegeuk Kim f2fs_wait_on_page_writeback(ipage, NODE, true); 5363b4d732aSChao Yu 5376332cd32SJaegeuk Kim name_hash = f2fs_dentry_hash(new_name, NULL); 5389421d570SChao Yu f2fs_update_dentry(ino, mode, &d, new_name, name_hash, bit_pos); 5393b4d732aSChao Yu 540201a05beSChao Yu set_page_dirty(ipage); 541201a05beSChao Yu 542201a05beSChao Yu /* we don't need to mark_inode_dirty now */ 543510022a8SJaegeuk Kim if (inode) { 544205b9822SJaegeuk Kim f2fs_i_pino_write(inode, dir->i_ino); 545201a05beSChao Yu f2fs_put_page(page, 1); 546510022a8SJaegeuk Kim } 547201a05beSChao Yu 548201a05beSChao Yu update_parent_metadata(dir, inode, 0); 549201a05beSChao Yu fail: 550510022a8SJaegeuk Kim if (inode) 551201a05beSChao Yu up_write(&F2FS_I(inode)->i_sem); 552201a05beSChao Yu out: 553201a05beSChao Yu f2fs_put_page(ipage, 1); 554201a05beSChao Yu return err; 555201a05beSChao Yu } 556201a05beSChao Yu 557201a05beSChao Yu void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page, 558201a05beSChao Yu struct inode *dir, struct inode *inode) 559201a05beSChao Yu { 56076a9dd85SChao Yu struct f2fs_dentry_ptr d; 561f2470371SChao Yu void *inline_dentry; 562201a05beSChao Yu int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len)); 563201a05beSChao Yu unsigned int bit_pos; 564201a05beSChao Yu int i; 565201a05beSChao Yu 566201a05beSChao Yu lock_page(page); 567fec1d657SJaegeuk Kim f2fs_wait_on_page_writeback(page, NODE, true); 568201a05beSChao Yu 569f2470371SChao Yu inline_dentry = inline_data_addr(dir, page); 570f2470371SChao Yu make_dentry_ptr_inline(dir, &d, inline_dentry); 57176a9dd85SChao Yu 57276a9dd85SChao Yu bit_pos = dentry - d.dentry; 573201a05beSChao Yu for (i = 0; i < slots; i++) 57476a9dd85SChao Yu __clear_bit_le(bit_pos + i, d.bitmap); 575201a05beSChao Yu 576201a05beSChao Yu set_page_dirty(page); 5779f7c45ccSJaegeuk Kim f2fs_put_page(page, 1); 578201a05beSChao Yu 579078cd827SDeepa Dinamani dir->i_ctime = dir->i_mtime = current_time(dir); 5807c45729aSJaegeuk Kim f2fs_mark_inode_dirty_sync(dir, false); 581201a05beSChao Yu 582201a05beSChao Yu if (inode) 5839f7c45ccSJaegeuk Kim f2fs_drop_nlink(dir, inode); 584201a05beSChao Yu } 585201a05beSChao Yu 586201a05beSChao Yu bool f2fs_empty_inline_dir(struct inode *dir) 587201a05beSChao Yu { 588201a05beSChao Yu struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 589201a05beSChao Yu struct page *ipage; 590201a05beSChao Yu unsigned int bit_pos = 2; 591f2470371SChao Yu void *inline_dentry; 59276a9dd85SChao Yu struct f2fs_dentry_ptr d; 593201a05beSChao Yu 594201a05beSChao Yu ipage = get_node_page(sbi, dir->i_ino); 595201a05beSChao Yu if (IS_ERR(ipage)) 596201a05beSChao Yu return false; 597201a05beSChao Yu 598f2470371SChao Yu inline_dentry = inline_data_addr(dir, ipage); 599f2470371SChao Yu make_dentry_ptr_inline(dir, &d, inline_dentry); 60076a9dd85SChao Yu 60176a9dd85SChao Yu bit_pos = find_next_bit_le(d.bitmap, d.max, bit_pos); 602201a05beSChao Yu 603201a05beSChao Yu f2fs_put_page(ipage, 1); 604201a05beSChao Yu 60576a9dd85SChao Yu if (bit_pos < d.max) 606201a05beSChao Yu return false; 607201a05beSChao Yu 608201a05beSChao Yu return true; 609201a05beSChao Yu } 610201a05beSChao Yu 611d8c6822aSJaegeuk Kim int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx, 6120b81d077SJaegeuk Kim struct fscrypt_str *fstr) 613201a05beSChao Yu { 614201a05beSChao Yu struct inode *inode = file_inode(file); 615201a05beSChao Yu struct page *ipage = NULL; 6167b3cd7d6SJaegeuk Kim struct f2fs_dentry_ptr d; 617f2470371SChao Yu void *inline_dentry = NULL; 618ed6bd4b1SChao Yu int err; 619201a05beSChao Yu 62076a9dd85SChao Yu make_dentry_ptr_inline(inode, &d, inline_dentry); 62176a9dd85SChao Yu 62276a9dd85SChao Yu if (ctx->pos == d.max) 623201a05beSChao Yu return 0; 624201a05beSChao Yu 62538594de7SJaegeuk Kim ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino); 626201a05beSChao Yu if (IS_ERR(ipage)) 627201a05beSChao Yu return PTR_ERR(ipage); 628201a05beSChao Yu 629f2470371SChao Yu inline_dentry = inline_data_addr(inode, ipage); 630201a05beSChao Yu 63164c24ecbSTomohiro Kusumi make_dentry_ptr_inline(inode, &d, inline_dentry); 6327b3cd7d6SJaegeuk Kim 633ed6bd4b1SChao Yu err = f2fs_fill_dentries(ctx, &d, 0, fstr); 634ed6bd4b1SChao Yu if (!err) 63576a9dd85SChao Yu ctx->pos = d.max; 636201a05beSChao Yu 63738594de7SJaegeuk Kim f2fs_put_page(ipage, 1); 638ed6bd4b1SChao Yu return err < 0 ? err : 0; 639201a05beSChao Yu } 64067f8cf3cSJaegeuk Kim 64167f8cf3cSJaegeuk Kim int f2fs_inline_data_fiemap(struct inode *inode, 64267f8cf3cSJaegeuk Kim struct fiemap_extent_info *fieinfo, __u64 start, __u64 len) 64367f8cf3cSJaegeuk Kim { 64467f8cf3cSJaegeuk Kim __u64 byteaddr, ilen; 64567f8cf3cSJaegeuk Kim __u32 flags = FIEMAP_EXTENT_DATA_INLINE | FIEMAP_EXTENT_NOT_ALIGNED | 64667f8cf3cSJaegeuk Kim FIEMAP_EXTENT_LAST; 64767f8cf3cSJaegeuk Kim struct node_info ni; 64867f8cf3cSJaegeuk Kim struct page *ipage; 64967f8cf3cSJaegeuk Kim int err = 0; 65067f8cf3cSJaegeuk Kim 65167f8cf3cSJaegeuk Kim ipage = get_node_page(F2FS_I_SB(inode), inode->i_ino); 65267f8cf3cSJaegeuk Kim if (IS_ERR(ipage)) 65367f8cf3cSJaegeuk Kim return PTR_ERR(ipage); 65467f8cf3cSJaegeuk Kim 65567f8cf3cSJaegeuk Kim if (!f2fs_has_inline_data(inode)) { 65667f8cf3cSJaegeuk Kim err = -EAGAIN; 65767f8cf3cSJaegeuk Kim goto out; 65867f8cf3cSJaegeuk Kim } 65967f8cf3cSJaegeuk Kim 660f2470371SChao Yu ilen = min_t(size_t, MAX_INLINE_DATA(inode), i_size_read(inode)); 66167f8cf3cSJaegeuk Kim if (start >= ilen) 66267f8cf3cSJaegeuk Kim goto out; 66367f8cf3cSJaegeuk Kim if (start + len < ilen) 66467f8cf3cSJaegeuk Kim ilen = start + len; 66567f8cf3cSJaegeuk Kim ilen -= start; 66667f8cf3cSJaegeuk Kim 66767f8cf3cSJaegeuk Kim get_node_info(F2FS_I_SB(inode), inode->i_ino, &ni); 66867f8cf3cSJaegeuk Kim byteaddr = (__u64)ni.blk_addr << inode->i_sb->s_blocksize_bits; 669f2470371SChao Yu byteaddr += (char *)inline_data_addr(inode, ipage) - 670f2470371SChao Yu (char *)F2FS_INODE(ipage); 67167f8cf3cSJaegeuk Kim err = fiemap_fill_next_extent(fieinfo, start, byteaddr, ilen, flags); 67267f8cf3cSJaegeuk Kim out: 67367f8cf3cSJaegeuk Kim f2fs_put_page(ipage, 1); 67467f8cf3cSJaegeuk Kim return err; 67567f8cf3cSJaegeuk Kim } 676