199127Sobrien// SPDX-License-Identifier: GPL-2.0 299127Sobrien/* 399127Sobrien * fs/f2fs/inline.c 499127Sobrien * Copyright (c) 2013, Intel Corporation 599127Sobrien * Authors: Huajun Li <huajun.li@intel.com> 699127Sobrien * Haicheng Li <haicheng.li@intel.com> 799127Sobrien */ 899127Sobrien 999127Sobrien#include <linux/fs.h> 10133819Stjr#include <linux/f2fs_fs.h> 11133819Stjr#include <linux/fiemap.h> 12133819Stjr 13133819Stjr#include "f2fs.h" 14133819Stjr#include "node.h" 15133819Stjr#include <trace/events/f2fs.h> 16133819Stjr 17133819Stjrstatic bool support_inline_data(struct inode *inode) 18133819Stjr{ 19133819Stjr if (f2fs_is_atomic_file(inode)) 20133819Stjr return false; 21133819Stjr if (!S_ISREG(inode->i_mode) && !S_ISLNK(inode->i_mode)) 22133819Stjr return false; 23293514Sdchagin if (i_size_read(inode) > MAX_INLINE_DATA(inode)) 24293514Sdchagin return false; 25293514Sdchagin return true; 26293514Sdchagin} 27293514Sdchagin 28293514Sdchaginbool f2fs_may_inline_data(struct inode *inode) 29293514Sdchagin{ 30293514Sdchagin if (!support_inline_data(inode)) 31293599Sdchagin return false; 32293514Sdchagin 33293514Sdchagin return !f2fs_post_read_required(inode); 34293514Sdchagin} 35122849Speter 36119341Speterbool f2fs_sanity_check_inline_data(struct inode *inode) 37114987Speter{ 38114987Speter if (!f2fs_has_inline_data(inode)) 39114987Speter return false; 40114987Speter 41122849Speter if (!support_inline_data(inode)) 42114987Speter return true; 43139099Sobrien 44114987Speter /* 45114987Speter * used by sanity_check_inode(), when disk layout fields has not 46114987Speter * been synchronized to inmem fields. 47126545Sobrien */ 48126545Sobrien return (S_ISREG(inode->i_mode) && 49126545Sobrien (file_is_encrypt(inode) || file_is_verity(inode) || 50126545Sobrien (F2FS_I(inode)->i_flags & F2FS_COMPR_FL))); 51126545Sobrien} 52126545Sobrien 53126545Sobrienbool f2fs_may_inline_dentry(struct inode *inode) 54126545Sobrien{ 55126545Sobrien if (!test_opt(F2FS_I_SB(inode), INLINE_DENTRY)) 56126545Sobrien return false; 57126545Sobrien 58126545Sobrien if (!S_ISDIR(inode->i_mode)) 59126545Sobrien return false; 60126545Sobrien 61126545Sobrien return true; 62143442Sobrien} 63143442Sobrien 64143442Sobrienvoid f2fs_do_read_inline_data(struct page *page, struct page *ipage) 65172967Sobrien{ 66143442Sobrien struct inode *inode = page->mapping->host; 67143442Sobrien 68143442Sobrien if (PageUptodate(page)) 69143442Sobrien return; 70145415Sru 71145415Sru f2fs_bug_on(F2FS_P_SB(page), page->index); 72143442Sobrien 73228940Sdelphij zero_user_segment(page, MAX_INLINE_DATA(inode), PAGE_SIZE); 74228940Sdelphij 75228940Sdelphij /* Copy the whole inline data block */ 76228940Sdelphij memcpy_to_page(page, 0, inline_data_addr(inode, ipage), 77252867Sdelphij MAX_INLINE_DATA(inode)); 78149873Sscottl if (!PageUptodate(page)) 79149873Sscottl SetPageUptodate(page); 80149873Sscottl} 81149873Sscottl 82252867Sdelphijvoid f2fs_truncate_inline_inode(struct inode *inode, 83252867Sdelphij struct page *ipage, u64 from) 84252867Sdelphij{ 85252867Sdelphij void *addr; 86252867Sdelphij 87252867Sdelphij if (from >= MAX_INLINE_DATA(inode)) 88174604Sscottl return; 89174604Sscottl 90174604Sscottl addr = inline_data_addr(inode, ipage); 91174604Sscottl 92174604Sscottl f2fs_wait_on_page_writeback(ipage, NODE, true, true); 93115428Speter memset(addr + from, 0, MAX_INLINE_DATA(inode) - from); 94209957Sjkim set_page_dirty(ipage); 95209957Sjkim 96209957Sjkim if (from == 0) 97189903Sjkim clear_inode_flag(inode, FI_DATA_EXIST); 98209957Sjkim} 99209957Sjkim 100209957Sjkimint f2fs_read_inline_data(struct inode *inode, struct page *page) 101240400Sobrien{ 102209957Sjkim struct page *ipage; 103209957Sjkim 104209957Sjkim ipage = f2fs_get_node_page(F2FS_I_SB(inode), inode->i_ino); 105209957Sjkim if (IS_ERR(ipage)) { 106209957Sjkim unlock_page(page); 107209957Sjkim return PTR_ERR(ipage); 108209957Sjkim } 109209957Sjkim 110209957Sjkim if (!f2fs_has_inline_data(inode)) { 111213884Sjkim f2fs_put_page(ipage, 1); 112209957Sjkim return -EAGAIN; 113209957Sjkim } 114189903Sjkim 115135871Smarkm if (page->index) 116129653Sbde zero_user_segment(page, 0, PAGE_SIZE); 117122849Speter else 118114370Speter f2fs_do_read_inline_data(page, ipage); 119135690Speter 120153213Sjkim if (!PageUptodate(page)) 121114563Speter SetPageUptodate(page); 122115405Speter f2fs_put_page(ipage, 1); 123115405Speter unlock_page(page); 124115405Speter return 0; 125114370Speter} 126114558Speter 127122849Speterint f2fs_convert_inline_page(struct dnode_of_data *dn, struct page *page) 128131951Smarcel{ 129220885Sbz struct f2fs_io_info fio = { 130114370Speter .sbi = F2FS_I_SB(dn->inode), 131132956Smarkm .ino = dn->inode->i_ino, 132114558Speter .type = DATA, 133114370Speter .op = REQ_OP_WRITE, 134132956Smarkm .op_flags = REQ_SYNC | REQ_PRIO, 135157908Speter .page = page, 136122849Speter .encrypted_page = NULL, 137134553Speter .io_type = FS_DATA_IO, 138122849Speter }; 139174496Salc struct node_info ni; 140129627Sbde int dirty, err; 141230426Skib 142114558Speter if (!f2fs_exist_data(dn->inode)) 143174195Srwatson goto clear_out; 144114558Speter 145114370Speter err = f2fs_reserve_block(dn, 0); 146114370Speter if (err) 147127236Salc return err; 148121081Salc 149114370Speter err = f2fs_get_node_info(fio.sbi, dn->nid, &ni, false); 150114370Speter if (err) { 151233578Speter f2fs_truncate_data_blocks_range(dn, 1); 152210409Skib f2fs_put_dnode(dn); 153210409Skib return err; 154255187Sjmg } 155255187Sjmg 156255452Sobrien fio.version = ni.version; 157255187Sjmg 158255187Sjmg if (unlikely(dn->data_blkaddr != NEW_ADDR)) { 159240420Sjimharris f2fs_put_dnode(dn); 160252356Sdavide set_sbi_flag(fio.sbi, SBI_NEED_FSCK); 161187112Sjkim f2fs_warn(fio.sbi, "%s: corrupted inline inode ino=%lx, i_addr[0]:0x%x, run fsck to fix.", 162187112Sjkim __func__, dn->inode->i_ino, dn->data_blkaddr); 163187112Sjkim f2fs_handle_error(fio.sbi, ERROR_INVALID_BLKADDR); 164139098Sobrien return -EFSCORRUPTED; 165194701Srpaulo } 166187633Sjkim 167187633Sjkim f2fs_bug_on(F2FS_P_SB(page), PageWriteback(page)); 168187633Sjkim 169199969Savg f2fs_do_read_inline_data(page, dn->inode_page); 170189768Srpaulo set_page_dirty(page); 171144500Sscottl 172173427Srpaulo /* clear dirty state */ 173147271Smarius dirty = clear_page_dirty_for_io(page); 174147271Smarius 175147271Smarius /* write data page to try to make data consistent */ 176147271Smarius set_page_writeback(page); 177147271Smarius fio.old_blkaddr = dn->data_blkaddr; 178147271Smarius set_inode_flag(dn->inode, FI_HOT_DATA); 179255736Sdavidch f2fs_outplace_write_data(dn, &fio); 180255736Sdavidch f2fs_wait_on_page_writeback(page, DATA, true, true); 181255736Sdavidch if (dirty) { 182255736Sdavidch inode_dec_dirty_pages(dn->inode); 183255736Sdavidch f2fs_remove_dirty_inode(dn->inode); 184255736Sdavidch } 185255736Sdavidch 186255736Sdavidch /* this converted inline_data should be recovered. */ 187171854Sdes set_inode_flag(dn->inode, FI_APPEND_WRITE); 188181430Sstas 189197380Sdelphij /* clear inline data and flag after data writeback */ 190148263Speter f2fs_truncate_inline_inode(dn->inode, dn->inode_page, 0); 191148263Speter clear_page_private_inline(dn->inode_page); 192148263Speterclear_out: 193148263Speter stat_dec_inline_inode(dn->inode); 194148263Speter clear_inode_flag(dn->inode, FI_INLINE_DATA); 195148263Speter f2fs_put_dnode(dn); 196152862Sru return 0; 197197379Sdelphij} 198197380Sdelphij 199114370Speterint f2fs_convert_inline_inode(struct inode *inode) 200147687Speter{ 201141963Swpaul struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 202141963Swpaul struct dnode_of_data dn; 203152862Sru struct page *ipage, *page; 204145485Swpaul int err = 0; 205132956Smarkm 206155607Sambrisko if (!f2fs_has_inline_data(inode) || 207162562Sjhb f2fs_hw_is_readonly(sbi) || f2fs_readonly(sbi->sb)) 208162562Sjhb return 0; 209162562Sjhb 210162562Sjhb err = f2fs_dquot_initialize(inode); 211162562Sjhb if (err) 212162562Sjhb return err; 213162562Sjhb 214155607Sambrisko page = f2fs_grab_cache_page(inode->i_mapping, 0, false); 215190453Sambrisko if (!page) 216272313Sbz return -ENOMEM; 217272313Sbz 218272313Sbz f2fs_lock_op(sbi); 219272313Sbz 220272313Sbz ipage = f2fs_get_node_page(sbi, inode->i_ino); 221272313Sbz if (IS_ERR(ipage)) { 222272313Sbz err = PTR_ERR(ipage); 223272313Sbz goto out; 224272313Sbz } 225272313Sbz 226272313Sbz set_new_dnode(&dn, inode, ipage, ipage, 0); 227272313Sbz 228272313Sbz if (f2fs_has_inline_data(inode)) 229272313Sbz err = f2fs_convert_inline_page(&dn, page); 230272313Sbz 231272313Sbz f2fs_put_dnode(&dn); 232272313Sbzout: 233272313Sbz f2fs_unlock_op(sbi); 234272313Sbz 235272313Sbz f2fs_put_page(page, 1); 236131854Simp 237132217Snjl if (!err) 238131766Simp f2fs_balance_fs(sbi, dn.node_changed); 239131766Simp 240250840Smarcel return err; 241252867Sdelphij} 242252867Sdelphij 243228940Sdelphijint f2fs_write_inline_data(struct inode *inode, struct page *page) 244149873Sscottl{ 245149873Sscottl struct dnode_of_data dn; 246149873Sscottl int err; 247149873Sscottl 248149873Sscottl set_new_dnode(&dn, inode, NULL, NULL, 0); 249252867Sdelphij err = f2fs_get_dnode_of_data(&dn, 0, LOOKUP_NODE); 250252867Sdelphij if (err) 251252867Sdelphij return err; 252174604Sscottl 253174604Sscottl if (!f2fs_has_inline_data(inode)) { 254174604Sscottl f2fs_put_dnode(&dn); 255145653Sscottl return -EAGAIN; 256184802Sjkoshy } 257185363Sjkoshy 258206089Sfabient f2fs_bug_on(F2FS_I_SB(inode), page->index); 259147191Sjkoshy 260184802Sjkoshy f2fs_wait_on_page_writeback(dn.inode_page, NODE, true, true); 261147191Sjkoshy memcpy_from_page(inline_data_addr(inode, dn.inode_page), 262255524Sgrehan page, 0, MAX_INLINE_DATA(inode)); 263255524Sgrehan set_page_dirty(dn.inode_page); 264255524Sgrehan 265255524Sgrehan f2fs_clear_page_cache_dirty_tag(page); 266272322Sdelphij 267255524Sgrehan set_inode_flag(inode, FI_APPEND_WRITE); 268255524Sgrehan set_inode_flag(inode, FI_DATA_EXIST); 269255524Sgrehan 270255524Sgrehan clear_page_private_inline(dn.inode_page); 271255524Sgrehan f2fs_put_dnode(&dn); 272295789Ssephe return 0; 273255524Sgrehan} 274255524Sgrehan 275262861Sjhbint f2fs_recover_inline_data(struct inode *inode, struct page *npage) 276197518Sbz{ 277197518Sbz struct f2fs_sb_info *sbi = F2FS_I_SB(inode); 278159967Sobrien struct f2fs_inode *ri = NULL; 279250079Scarl void *src_addr, *dst_addr; 280250079Scarl struct page *ipage; 281240618Sjimharris 282143442Sobrien /* 283240618Sjimharris * The inline_data recovery policy is as follows. 284240618Sjimharris * [prev.] [next] of inline_data flag 285240618Sjimharris * o o -> recover inline_data 286240618Sjimharris * o x -> remove inline_data, and then recover data blocks 287240618Sjimharris * x o -> remove data blocks, and then recover inline_data 288240618Sjimharris * x x -> recover data blocks 289240618Sjimharris */ 290240618Sjimharris if (IS_INODE(npage)) 291253476Sjimharris ri = F2FS_INODE(npage); 292172998Speter 293256381Smarkm if (f2fs_has_inline_data(inode) && 294256381Smarkm ri && (ri->i_inline & F2FS_INLINE_DATA)) { 295252206Sdavidcsprocess_inline: 296252206Sdavidcs ipage = f2fs_get_node_page(sbi, inode->i_ino); 297252206Sdavidcs if (IS_ERR(ipage)) 298252206Sdavidcs return PTR_ERR(ipage); 299252206Sdavidcs 300252206Sdavidcs f2fs_wait_on_page_writeback(ipage, NODE, true, true); 301227064Sbz 302227064Sbz src_addr = inline_data_addr(inode, npage); 303227064Sbz dst_addr = inline_data_addr(inode, ipage); 304227064Sbz memcpy(dst_addr, src_addr, MAX_INLINE_DATA(inode)); 305227064Sbz 306227064Sbz set_inode_flag(inode, FI_INLINE_DATA); 307250661Sdavidcs set_inode_flag(inode, FI_DATA_EXIST); 308250661Sdavidcs 309250661Sdavidcs set_page_dirty(ipage); 310250661Sdavidcs f2fs_put_page(ipage, 1); 311250661Sdavidcs return 1; 312250661Sdavidcs } 313250661Sdavidcs 314284555Sarybchik if (f2fs_has_inline_data(inode)) { 315284555Sarybchik ipage = f2fs_get_node_page(sbi, inode->i_ino); 316284555Sarybchik if (IS_ERR(ipage)) 317284555Sarybchik return PTR_ERR(ipage); 318284555Sarybchik f2fs_truncate_inline_inode(inode, ipage, 0); 319284555Sarybchik stat_dec_inline_inode(inode); 320294386Sarybchik clear_inode_flag(inode, FI_INLINE_DATA); 321284555Sarybchik f2fs_put_page(ipage, 1); 322284555Sarybchik } else if (ri && (ri->i_inline & F2FS_INLINE_DATA)) { 323284555Sarybchik int ret; 324284555Sarybchik 325284555Sarybchik ret = f2fs_truncate_blocks(inode, 0, false); 326284555Sarybchik if (ret) 327284555Sarybchik return ret; 328284555Sarybchik stat_inc_inline_inode(inode); 329284555Sarybchik goto process_inline; 330284555Sarybchik } 331284555Sarybchik return 0; 332284555Sarybchik} 333284555Sarybchik 334284555Sarybchikstruct f2fs_dir_entry *f2fs_find_in_inline_dir(struct inode *dir, 335284555Sarybchik const struct f2fs_filename *fname, 336284555Sarybchik struct page **res_page) 337284555Sarybchik{ 338284555Sarybchik struct f2fs_sb_info *sbi = F2FS_SB(dir->i_sb); 339284555Sarybchik struct f2fs_dir_entry *de; 340284555Sarybchik struct f2fs_dentry_ptr d; 341284555Sarybchik struct page *ipage; 342284555Sarybchik void *inline_dentry; 343284555Sarybchik 344284555Sarybchik ipage = f2fs_get_node_page(sbi, dir->i_ino); 345293980Sarybchik if (IS_ERR(ipage)) { 346284555Sarybchik *res_page = ipage; 347284555Sarybchik return NULL; 348284555Sarybchik } 349284555Sarybchik 350284555Sarybchik inline_dentry = inline_data_addr(dir, ipage); 351284555Sarybchik 352284555Sarybchik make_dentry_ptr_inline(dir, &d, inline_dentry); 353284555Sarybchik de = f2fs_find_target_dentry(&d, fname, NULL); 354284555Sarybchik unlock_page(ipage); 355284555Sarybchik if (IS_ERR(de)) { 356284555Sarybchik *res_page = ERR_CAST(de); 357284555Sarybchik de = NULL; 358284555Sarybchik } 359284555Sarybchik if (de) 360284555Sarybchik *res_page = ipage; 361284555Sarybchik else 362122849Speter f2fs_put_page(ipage, 0); 363122849Speter 364160813Smarcel return de; 365160813Smarcel} 366160813Smarcel 367152306Sruint f2fs_make_empty_inline_dir(struct inode *inode, struct inode *parent, 368122849Speter struct page *ipage) 369186681Sed{ 370197380Sdelphij struct f2fs_dentry_ptr d; 371114370Speter void *inline_dentry; 372114370Speter 373212861Snork inline_dentry = inline_data_addr(inode, ipage); 374212861Snork 375212861Snork make_dentry_ptr_inline(inode, &d, inline_dentry); 376234118Smarcel f2fs_do_make_empty_dir(inode, parent, &d); 377228431Sfabient 378254738Sbryanv set_page_dirty(ipage); 379232614Sbz 380173491Sbenjsc /* update i_size to MAX_INLINE_DATA */ 381230843Sjimharris if (i_size_read(inode) < MAX_INLINE_DATA(inode)) 382230843Sjimharris f2fs_i_size_write(inode, MAX_INLINE_DATA(inode)); 383230843Sjimharris return 0; 384230843Sjimharris} 385230843Sjimharris 386230843Sjimharris/* 387230843Sjimharris * NOTE: ipage is grabbed by caller, but if any error occurs, we should 388230843Sjimharris * release ipage in this function. 389230843Sjimharris */ 390230843Sjimharrisstatic int f2fs_move_inline_dirents(struct inode *dir, struct page *ipage, 391230843Sjimharris void *inline_dentry) 392230843Sjimharris{ 393230843Sjimharris struct page *page; 394230843Sjimharris struct dnode_of_data dn; 395230843Sjimharris struct f2fs_dentry_block *dentry_blk; 396230843Sjimharris struct f2fs_dentry_ptr src, dst; 397230843Sjimharris int err; 398230843Sjimharris 399230843Sjimharris page = f2fs_grab_cache_page(dir->i_mapping, 0, true); 400230843Sjimharris if (!page) { 401230843Sjimharris f2fs_put_page(ipage, 1); 402230843Sjimharris return -ENOMEM; 403230843Sjimharris } 404230843Sjimharris 405230843Sjimharris set_new_dnode(&dn, dir, ipage, NULL, 0); 406230843Sjimharris err = f2fs_reserve_block(&dn, 0); 407230843Sjimharris if (err) 408230843Sjimharris goto out; 409230843Sjimharris 410230843Sjimharris if (unlikely(dn.data_blkaddr != NEW_ADDR)) { 411230843Sjimharris f2fs_put_dnode(&dn); 412230843Sjimharris set_sbi_flag(F2FS_P_SB(page), SBI_NEED_FSCK); 413230843Sjimharris f2fs_warn(F2FS_P_SB(page), "%s: corrupted inline inode ino=%lx, i_addr[0]:0x%x, run fsck to fix.", 414230843Sjimharris __func__, dir->i_ino, dn.data_blkaddr); 415230843Sjimharris f2fs_handle_error(F2FS_P_SB(page), ERROR_INVALID_BLKADDR); 416230843Sjimharris err = -EFSCORRUPTED; 417230843Sjimharris goto out; 418230843Sjimharris } 419230843Sjimharris 420230843Sjimharris f2fs_wait_on_page_writeback(page, DATA, true, true); 421230843Sjimharris 422230843Sjimharris dentry_blk = page_address(page); 423230843Sjimharris 424230843Sjimharris /* 425230843Sjimharris * Start by zeroing the full block, to ensure that all unused space is 426230843Sjimharris * zeroed and no uninitialized memory is leaked to disk. 427230843Sjimharris */ 428230843Sjimharris memset(dentry_blk, 0, F2FS_BLKSIZE); 429230843Sjimharris 430230843Sjimharris make_dentry_ptr_inline(dir, &src, inline_dentry); 431230843Sjimharris make_dentry_ptr_block(dir, &dst, dentry_blk); 432230843Sjimharris 433230843Sjimharris /* copy data from inline dentry block to new dentry block */ 434230843Sjimharris memcpy(dst.bitmap, src.bitmap, src.nr_bitmap); 435230843Sjimharris memcpy(dst.dentry, src.dentry, SIZE_OF_DIR_ENTRY * src.max); 436230843Sjimharris memcpy(dst.filename, src.filename, src.max * F2FS_SLOT_LEN); 437230843Sjimharris 438230843Sjimharris if (!PageUptodate(page)) 439230843Sjimharris SetPageUptodate(page); 440230843Sjimharris set_page_dirty(page); 441230843Sjimharris 442230843Sjimharris /* clear inline dir and flag after data writeback */ 443230843Sjimharris f2fs_truncate_inline_inode(dir, ipage, 0); 444230843Sjimharris 445230843Sjimharris stat_dec_inline_dir(dir); 446230843Sjimharris clear_inode_flag(dir, FI_INLINE_DENTRY); 447230843Sjimharris 448230843Sjimharris /* 449230843Sjimharris * should retrieve reserved space which was used to keep 450230843Sjimharris * inline_dentry's structure for backward compatibility. 451230843Sjimharris */ 452230843Sjimharris if (!f2fs_sb_has_flexible_inline_xattr(F2FS_I_SB(dir)) && 453230843Sjimharris !f2fs_has_inline_xattr(dir)) 454230843Sjimharris F2FS_I(dir)->i_inline_xattr_size = 0; 455230843Sjimharris 456230843Sjimharris f2fs_i_depth_write(dir, 1); 457230843Sjimharris if (i_size_read(dir) < PAGE_SIZE) 458230843Sjimharris f2fs_i_size_write(dir, PAGE_SIZE); 459230843Sjimharrisout: 460230843Sjimharris f2fs_put_page(page, 1); 461230843Sjimharris return err; 462230843Sjimharris} 463230843Sjimharris 464230843Sjimharrisstatic int f2fs_add_inline_entries(struct inode *dir, void *inline_dentry) 465230843Sjimharris{ 466230843Sjimharris struct f2fs_dentry_ptr d; 467230843Sjimharris unsigned long bit_pos = 0; 468230843Sjimharris int err = 0; 469230843Sjimharris 470230843Sjimharris make_dentry_ptr_inline(dir, &d, inline_dentry); 471230843Sjimharris 472230843Sjimharris while (bit_pos < d.max) { 473230843Sjimharris struct f2fs_dir_entry *de; 474230843Sjimharris struct f2fs_filename fname; 475230843Sjimharris nid_t ino; 476230843Sjimharris umode_t fake_mode; 477230843Sjimharris 478230843Sjimharris if (!test_bit_le(bit_pos, d.bitmap)) { 479230843Sjimharris bit_pos++; 480230843Sjimharris continue; 481230843Sjimharris } 482230843Sjimharris 483230843Sjimharris de = &d.dentry[bit_pos]; 484230843Sjimharris 485230843Sjimharris if (unlikely(!de->name_len)) { 486230843Sjimharris bit_pos++; 487230843Sjimharris continue; 488230843Sjimharris } 489230843Sjimharris 490245362Sbryanv /* 491245362Sbryanv * We only need the disk_name and hash to move the dentry. 492245362Sbryanv * We don't need the original or casefolded filenames. 493245362Sbryanv */ 494247870Sbryanv memset(&fname, 0, sizeof(fname)); 495247870Sbryanv fname.disk_name.name = d.filename[bit_pos]; 496247870Sbryanv fname.disk_name.len = le16_to_cpu(de->name_len); 497247870Sbryanv fname.hash = de->hash_code; 498247870Sbryanv 499268933Sjhb ino = le32_to_cpu(de->ino); 500275273Sbryanv fake_mode = fs_ftype_to_dtype(de->file_type) << S_DT_SHIFT; 501114370Speter 502114370Speter err = f2fs_add_regular_entry(dir, &fname, NULL, ino, fake_mode); 503266272Ssbruno if (err) 504210069Smav goto punch_dentry_pages; 505129283Speter 506122849Speter bit_pos += GET_DENTRY_SLOTS(le16_to_cpu(de->name_len)); 507122849Speter } 508122849Speter return 0; 509205014Snwhitehornpunch_dentry_pages: 510205014Snwhitehorn truncate_inode_pages(&dir->i_data, 0); 511205014Snwhitehorn f2fs_truncate_blocks(dir, 0, false); 512205014Snwhitehorn f2fs_remove_dirty_inode(dir); 513205014Snwhitehorn return err; 514205014Snwhitehorn} 515205014Snwhitehorn 516158349Snetchildstatic int f2fs_move_rehashed_dirents(struct inode *dir, struct page *ipage, 517158381Sambrisko void *inline_dentry) 518133819Stjr{ 519133819Stjr void *backup_dentry; 520133819Stjr int err; 521133819Stjr 522133819Stjr backup_dentry = f2fs_kmalloc(F2FS_I_SB(dir), 523169903Skib MAX_INLINE_DATA(dir), GFP_F2FS_ZERO); 524169903Skib if (!backup_dentry) { 525133819Stjr f2fs_put_page(ipage, 1); 526133819Stjr return -ENOMEM; 527169895Skib } 528133819Stjr 529218616Sdchagin memcpy(backup_dentry, inline_dentry, MAX_INLINE_DATA(dir)); 530161310Snetchild f2fs_truncate_inline_inode(dir, ipage, 0); 531133819Stjr 532133819Stjr unlock_page(ipage); 533133819Stjr 534133819Stjr err = f2fs_add_inline_entries(dir, backup_dentry); 535133819Stjr if (err) 536133819Stjr goto recover; 537133819Stjr 538133819Stjr lock_page(ipage); 539133819Stjr 540161310Snetchild stat_dec_inline_dir(dir); 541272020Sbz clear_inode_flag(dir, FI_INLINE_DENTRY); 542133819Stjr 543133819Stjr /* 544293514Sdchagin * should retrieve reserved space which was used to keep 545293527Sdchagin * inline_dentry's structure for backward compatibility. 546293546Sdchagin */ 547293575Sdchagin if (!f2fs_sb_has_flexible_inline_xattr(F2FS_I_SB(dir)) && 548154789Sambrisko !f2fs_has_inline_xattr(dir)) 549158737Sambrisko F2FS_I(dir)->i_inline_xattr_size = 0; 550141963Swpaul 551141963Swpaul kfree(backup_dentry); 552141963Swpaul return 0; 553141963Swpaulrecover: 554141963Swpaul lock_page(ipage); 555141963Swpaul f2fs_wait_on_page_writeback(ipage, NODE, true, true); 556141963Swpaul memcpy(inline_dentry, backup_dentry, MAX_INLINE_DATA(dir)); 557141963Swpaul f2fs_i_depth_write(dir, 0); 558141963Swpaul f2fs_i_size_write(dir, MAX_INLINE_DATA(dir)); 559142399Swpaul set_page_dirty(ipage); 560141963Swpaul f2fs_put_page(ipage, 1); 561168414Skan 562189170Sed kfree(backup_dentry); 563168414Skan return err; 564197399Sdelphij} 565283219Sroyger 566197399Sdelphijstatic int do_convert_inline_dir(struct inode *dir, struct page *ipage, 567283219Sroyger void *inline_dentry) 568283219Sroyger{ 569204309Sattilio if (!F2FS_I(dir)->i_dir_level) 570245652Sneel return f2fs_move_inline_dirents(dir, ipage, inline_dentry); 571245652Sneel else 572245652Sneel return f2fs_move_rehashed_dirents(dir, ipage, inline_dentry); 573245652Sneel} 574245652Sneel 575204309Sattilioint f2fs_try_convert_inline_dir(struct inode *dir, struct dentry *dentry) 576204309Sattilio{ 577215024Sjkim struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 578215072Sjkim struct page *ipage; 579236830Siwasaki struct f2fs_filename fname; 580215012Sjhb void *inline_dentry = NULL; 581210552Sjhb int err = 0; 582204309Sattilio 583204309Sattilio if (!f2fs_has_inline_dentry(dir)) 584204309Sattilio return 0; 585204309Sattilio 586204309Sattilio f2fs_lock_op(sbi); 587204309Sattilio 588259512Skib err = f2fs_setup_filename(dir, &dentry->d_name, 0, &fname); 589259512Skib if (err) 590259512Skib goto out; 591259512Skib 592259512Skib ipage = f2fs_get_node_page(sbi, dir->i_ino); 593259512Skib if (IS_ERR(ipage)) { 594259512Skib err = PTR_ERR(ipage); 595259512Skib goto out_fname; 596259512Skib } 597204309Sattilio 598204313Sattilio if (f2fs_has_enough_room(dir, ipage, &fname)) { 599204309Sattilio f2fs_put_page(ipage, 1); 600232744Sjhb goto out_fname; 601204309Sattilio } 602204309Sattilio 603204309Sattilio inline_dentry = inline_data_addr(dir, ipage); 604204309Sattilio 605223440Sjhb err = do_convert_inline_dir(dir, ipage, inline_dentry); 606223440Sjhb if (!err) 607287126Smarcel f2fs_put_page(ipage, 1); 608259511Skibout_fname: 609216316Scperciva f2fs_free_filename(&fname); 610214373Sattilioout: 611250840Smarcel f2fs_unlock_op(sbi); 612276070Sjhb return err; 613232747Sjhb} 614208919Sjhb 615233707Sjhbint f2fs_add_inline_entry(struct inode *dir, const struct f2fs_filename *fname, 616208919Sjhb struct inode *inode, nid_t ino, umode_t mode) 617208921Sjhb{ 618214446Sattilio struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 619214446Sattilio struct page *ipage; 620208922Sjhb unsigned int bit_pos; 621214457Sattilio void *inline_dentry = NULL; 622216283Sjkim struct f2fs_dentry_ptr d; 623255040Sgibbs int slots = GET_DENTRY_SLOTS(fname->disk_name.len); 624255040Sgibbs struct page *page = NULL; 625 int err = 0; 626 627 ipage = f2fs_get_node_page(sbi, dir->i_ino); 628 if (IS_ERR(ipage)) 629 return PTR_ERR(ipage); 630 631 inline_dentry = inline_data_addr(dir, ipage); 632 make_dentry_ptr_inline(dir, &d, inline_dentry); 633 634 bit_pos = f2fs_room_for_filename(d.bitmap, slots, d.max); 635 if (bit_pos >= d.max) { 636 err = do_convert_inline_dir(dir, ipage, inline_dentry); 637 if (err) 638 return err; 639 err = -EAGAIN; 640 goto out; 641 } 642 643 if (inode) { 644 f2fs_down_write_nested(&F2FS_I(inode)->i_sem, 645 SINGLE_DEPTH_NESTING); 646 page = f2fs_init_inode_metadata(inode, dir, fname, ipage); 647 if (IS_ERR(page)) { 648 err = PTR_ERR(page); 649 goto fail; 650 } 651 } 652 653 f2fs_wait_on_page_writeback(ipage, NODE, true, true); 654 655 f2fs_update_dentry(ino, mode, &d, &fname->disk_name, fname->hash, 656 bit_pos); 657 658 set_page_dirty(ipage); 659 660 /* we don't need to mark_inode_dirty now */ 661 if (inode) { 662 f2fs_i_pino_write(inode, dir->i_ino); 663 664 /* synchronize inode page's data from inode cache */ 665 if (is_inode_flag_set(inode, FI_NEW_INODE)) 666 f2fs_update_inode(inode, page); 667 668 f2fs_put_page(page, 1); 669 } 670 671 f2fs_update_parent_metadata(dir, inode, 0); 672fail: 673 if (inode) 674 f2fs_up_write(&F2FS_I(inode)->i_sem); 675out: 676 f2fs_put_page(ipage, 1); 677 return err; 678} 679 680void f2fs_delete_inline_entry(struct f2fs_dir_entry *dentry, struct page *page, 681 struct inode *dir, struct inode *inode) 682{ 683 struct f2fs_dentry_ptr d; 684 void *inline_dentry; 685 int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len)); 686 unsigned int bit_pos; 687 int i; 688 689 lock_page(page); 690 f2fs_wait_on_page_writeback(page, NODE, true, true); 691 692 inline_dentry = inline_data_addr(dir, page); 693 make_dentry_ptr_inline(dir, &d, inline_dentry); 694 695 bit_pos = dentry - d.dentry; 696 for (i = 0; i < slots; i++) 697 __clear_bit_le(bit_pos + i, d.bitmap); 698 699 set_page_dirty(page); 700 f2fs_put_page(page, 1); 701 702 inode_set_mtime_to_ts(dir, inode_set_ctime_current(dir)); 703 f2fs_mark_inode_dirty_sync(dir, false); 704 705 if (inode) 706 f2fs_drop_nlink(dir, inode); 707} 708 709bool f2fs_empty_inline_dir(struct inode *dir) 710{ 711 struct f2fs_sb_info *sbi = F2FS_I_SB(dir); 712 struct page *ipage; 713 unsigned int bit_pos = 2; 714 void *inline_dentry; 715 struct f2fs_dentry_ptr d; 716 717 ipage = f2fs_get_node_page(sbi, dir->i_ino); 718 if (IS_ERR(ipage)) 719 return false; 720 721 inline_dentry = inline_data_addr(dir, ipage); 722 make_dentry_ptr_inline(dir, &d, inline_dentry); 723 724 bit_pos = find_next_bit_le(d.bitmap, d.max, bit_pos); 725 726 f2fs_put_page(ipage, 1); 727 728 if (bit_pos < d.max) 729 return false; 730 731 return true; 732} 733 734int f2fs_read_inline_dir(struct file *file, struct dir_context *ctx, 735 struct fscrypt_str *fstr) 736{ 737 struct inode *inode = file_inode(file); 738 struct page *ipage = NULL; 739 struct f2fs_dentry_ptr d; 740 void *inline_dentry = NULL; 741 int err; 742 743 make_dentry_ptr_inline(inode, &d, inline_dentry); 744 745 if (ctx->pos == d.max) 746 return 0; 747 748 ipage = f2fs_get_node_page(F2FS_I_SB(inode), inode->i_ino); 749 if (IS_ERR(ipage)) 750 return PTR_ERR(ipage); 751 752 /* 753 * f2fs_readdir was protected by inode.i_rwsem, it is safe to access 754 * ipage without page's lock held. 755 */ 756 unlock_page(ipage); 757 758 inline_dentry = inline_data_addr(inode, ipage); 759 760 make_dentry_ptr_inline(inode, &d, inline_dentry); 761 762 err = f2fs_fill_dentries(ctx, &d, 0, fstr); 763 if (!err) 764 ctx->pos = d.max; 765 766 f2fs_put_page(ipage, 0); 767 return err < 0 ? err : 0; 768} 769 770int f2fs_inline_data_fiemap(struct inode *inode, 771 struct fiemap_extent_info *fieinfo, __u64 start, __u64 len) 772{ 773 __u64 byteaddr, ilen; 774 __u32 flags = FIEMAP_EXTENT_DATA_INLINE | FIEMAP_EXTENT_NOT_ALIGNED | 775 FIEMAP_EXTENT_LAST; 776 struct node_info ni; 777 struct page *ipage; 778 int err = 0; 779 780 ipage = f2fs_get_node_page(F2FS_I_SB(inode), inode->i_ino); 781 if (IS_ERR(ipage)) 782 return PTR_ERR(ipage); 783 784 if ((S_ISREG(inode->i_mode) || S_ISLNK(inode->i_mode)) && 785 !f2fs_has_inline_data(inode)) { 786 err = -EAGAIN; 787 goto out; 788 } 789 790 if (S_ISDIR(inode->i_mode) && !f2fs_has_inline_dentry(inode)) { 791 err = -EAGAIN; 792 goto out; 793 } 794 795 ilen = min_t(size_t, MAX_INLINE_DATA(inode), i_size_read(inode)); 796 if (start >= ilen) 797 goto out; 798 if (start + len < ilen) 799 ilen = start + len; 800 ilen -= start; 801 802 err = f2fs_get_node_info(F2FS_I_SB(inode), inode->i_ino, &ni, false); 803 if (err) 804 goto out; 805 806 byteaddr = (__u64)ni.blk_addr << inode->i_sb->s_blocksize_bits; 807 byteaddr += (char *)inline_data_addr(inode, ipage) - 808 (char *)F2FS_INODE(ipage); 809 err = fiemap_fill_next_extent(fieinfo, start, byteaddr, ilen, flags); 810 trace_f2fs_fiemap(inode, start, byteaddr, ilen, flags, err); 811out: 812 f2fs_put_page(ipage, 1); 813 return err; 814} 815