f2fs: add key function to handle inline dir
PATCH 3/5 f2fs: add key function to handle inline dir
Adds Functions to implement inline dir init/lookup/insert/delete/convert ops.
--- fs/f2fs/f2fs.h | 9 ++ fs/f2fs/inline.c | 388 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 397 insertions(+)
fs/f2fs/f2fs.h +9 -0
@@ -1450,4 +1450,13 @@ int f2fs_convert_inline_data(struct inode *, pgoff_t);int f2fs_write_inline_data (struct inode *,struct page *,unsigned int );void truncate_inline_data (struct inode *,u64 );int recover_inline_data (struct inode *,struct page *); +struct f2fs_dir_entry *find_in_inline_dir (struct inode *,struct qstr *, +struct page **); +struct f2fs_dir_entry *f2fs_parent_inline_dir (struct inode *,struct page **); +int make_empty_inline_dir (struct inode *inode,struct inode *,struct page *); +int f2fs_add_inline_entry (struct inode *,const struct qstr *,struct inode *); +void f2fs_delete_inline_entry (struct f2fs_dir_entry *,struct page *, +struct inode *,struct inode *); +bool f2fs_empty_inline_dir (struct inode *); +int f2fs_read_inline_dir (struct file *,struct dir_context *);#endif
fs/f2fs/inline.c +388 -0
391 lines not on this page · raw message
Signature · 1 line
2.0.1.474.g72c7794
Jaegeuk Kim
maintainerHi Chao,
Quoted 43 lines · Chao Yu
Adds Functions to implement inline dir
init/lookup/insert/delete/convertops.Signed-off-by Chao Yu <[email protected]>--- fs/f2fs/f2fs.h | 9 ++ fs/f2fs/inline.c | 388 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 397 insertions(+)fs/f2fs/f2fs.h +9
-0@@ -1450,4 +1450,13 @@ int f2fs_convert_inline_data(struct inode *, pgoff_t);int f2fs_write_inline_data (struct inode *,struct page *,unsigned int );void truncate_inline_data (struct inode *,u64 );int recover_inline_data (struct inode *,struct page *); +struct f2fs_dir_entry *find_in_inline_dir (struct inode *,struct qstr *, +struct page **); +struct f2fs_dir_entry *f2fs_parent_inline_dir (struct inode *,struct page **); +int make_empty_inline_dir (struct inode *inode,struct inode *,struct page *); +int f2fs_add_inline_entry (struct inode *,const struct qstr *,struct inode *); +void f2fs_delete_inline_entry (struct f2fs_dir_entry *,struct page *, +struct inode *,struct inode *); +bool f2fs_empty_inline_dir (struct inode *); +int f2fs_read_inline_dir (struct file *,struct dir_context *);#endif fs/f2fs/inline.c +9
-0@@ -249,3 +249,391 @@ process_inline: }return 0 ; } + +struct f2fs_dir_entry *find_in_inline_dir (struct inode *dir, +struct qstr *name,struct page **res_page) +{ +struct f2fs_sb_info *sbi =F2FS_SB (dir->i_sb); +struct page *ipage; +struct f2fs_dir_entry *de; +f2fs_hash_t namehash; +unsigned long bit_pos =0 ;
fs/f2fs/inline.c process_inline: · line 270
Quoted 10 lines
fs/f2fs/inline.c +10
-0+struct f2fs_inline_dentry *dentry_blk; +const void *dentry_bits; + + ipage =get_node_page (sbi, dir->i_ino); +if (IS_ERR (ipage)) +return NULL ; + + namehash =f2fs_dentry_hash (name); + +kmap (ipage);
Don't need kmap for ipage.
Quoted 19 lines
fs/f2fs/inline.c +19
-0+ dentry_blk =inline_data_addr (ipage); + dentry_bits = &dentry_blk->dentry_bitmap; + +while (bit_pos <NR_INLINE_DENTRY ) { +if (!test_bit_le (bit_pos, dentry_bits)) { + bit_pos++; +continue ; + } + de = &dentry_blk->dentry[bit_pos]; +if (early_match_name (name->len, namehash, de)) { +if (!memcmp (dentry_blk->filename[bit_pos], + name->name, + name->len)) { + *res_page = ipage; + goto found; + } + } + +/*
fs/f2fs/inline.c process_inline: · line 299
Quoted 10 lines
fs/f2fs/inline.c +10
-0+* For the most part, it should be a bug when name_len is zero. +* We stop here for figuring out where the bugs are occurred. +*/ +f2fs_bug_on (!de->name_len); + + bit_pos +=GET_DENTRY_SLOTS (le16_to_cpu (de->name_len)); + } + + de =NULL ; +kunmap (ipage);
Ditto.
Quoted 8 lines
fs/f2fs/inline.c +8
-0+found: +unlock_page (ipage); +return de; +} + +struct f2fs_dir_entry *f2fs_parent_inline_dir (struct inode *dir, +struct page **p) +{
fs/f2fs/inline.c process_inline: · line 317
Quoted 10 lines
fs/f2fs/inline.c +10
-0+struct f2fs_sb_info *sbi =F2FS_SB (dir->i_sb); +struct page *ipage; +struct f2fs_dir_entry *de; +struct f2fs_inline_dentry *dentry_blk; + + ipage =get_node_page (sbi, dir->i_ino); +if (IS_ERR (ipage)) +return NULL ; + +kmap (ipage);
Ditto.
Quoted 77 lines
fs/f2fs/inline.c +77
-0+ dentry_blk =inline_data_addr (ipage); + de = &dentry_blk->dentry[1 ]; + *p = ipage; +unlock_page (ipage); +return de; +} + +int make_empty_inline_dir (struct inode *inode,struct inode *parent, +struct page *ipage) +{ +struct f2fs_inline_dentry *dentry_blk; +struct f2fs_dir_entry *de; + + dentry_blk =inline_data_addr (ipage); + + de = &dentry_blk->dentry[0 ]; + de->name_len =cpu_to_le16 (1 ); + de->hash_code =0 ; + de->ino =cpu_to_le32 (inode->i_ino); +memcpy (dentry_blk->filename[0 ],"." ,1 ); +set_de_type (de, inode); + + de = &dentry_blk->dentry[1 ]; + de->hash_code =0 ; + de->name_len =cpu_to_le16 (2 ); + de->ino =cpu_to_le32 (parent->i_ino); +memcpy (dentry_blk->filename[1 ],".." ,2 ); +set_de_type (de, inode); + +test_and_set_bit_le (0 , &dentry_blk->dentry_bitmap); +test_and_set_bit_le (1 , &dentry_blk->dentry_bitmap); + +set_page_dirty (ipage); + +/* update i_size to MAX_INLINE_DATA */ +if (i_size_read (inode) <MAX_INLINE_DATA ) { +i_size_write (inode,MAX_INLINE_DATA ); +set_inode_flag (F2FS_I (inode),FI_UPDATE_DIR ); + } +return 0 ; +} + +int room_in_inline_dir (struct f2fs_inline_dentry *dentry_blk,int slots) +{ +int bit_start =0 ; +int zero_start, zero_end; +next: + zero_start =find_next_zero_bit_le (&dentry_blk->dentry_bitmap, +NR_INLINE_DENTRY , + bit_start); +if (zero_start >=NR_INLINE_DENTRY ) +return NR_INLINE_DENTRY ; + + zero_end =find_next_bit_le (&dentry_blk->dentry_bitmap, +NR_INLINE_DENTRY , + zero_start); +if (zero_end - zero_start >= slots) +return zero_start; + + bit_start = zero_end +1 ; + +if (zero_end +1 >=NR_INLINE_DENTRY ) +return NR_INLINE_DENTRY ; + goto next; +} + +int f2fs_convert_inline_dir (struct inode *dir,struct page *ipage, +struct f2fs_inline_dentry *inline_dentry) +{ +struct page *page; +struct dnode_of_data dn; +block_t new_blk_addr; +struct f2fs_dentry_block *dentry_blk; +struct f2fs_io_info fio = { + .type =DATA , + .rw =WRITE_SYNC |REQ_PRIO , + };
fs/f2fs/inline.c process_inline: · line 404
Quoted 10 lines
fs/f2fs/inline.c +10
-0+int err; + + page =grab_cache_page (dir->i_mapping,0 ); +if (!page) +return -ENOMEM ; + +set_new_dnode (&dn, dir, ipage,NULL ,0 ); + err =f2fs_reserve_block (&dn,0 ); +if (err) + goto out;
At a glance, we don't need to care about dentry blocks to sync, since checkpoint handles that.
It needs to consider about checkpoint and f2fs_sync_file.
The addition and deletion stuffs are almost same as the existing codes. Can we reuse those to avoid potential bugs?
And it'd be better to add inline_dentry mount option separately for now.
Thanks,
Quoted 237 lines
fs/f2fs/inline.c +235
-0+ +f2fs_wait_on_page_writeback (page,DATA ); +zero_user_segment (page,0 ,PAGE_CACHE_SIZE ); + + dentry_blk =kmap (page); + +/* copy data from inline dentry block to new dentry block */ +memcpy (dentry_blk->dentry_bitmap, inline_dentry->dentry_bitmap, +INLINE_DENTRY_BITMAP_SIZE ); +memcpy (dentry_blk->reserved, inline_dentry->reserved, +INLINE_RESERVED_SIZE ); +memcpy (dentry_blk->dentry, inline_dentry->dentry, +sizeof (struct f2fs_dir_entry ) *NR_INLINE_DENTRY ); +memcpy (dentry_blk->filename, inline_dentry->filename, +NR_INLINE_DENTRY *F2FS_SLOT_LEN ); + +kunmap (page); +SetPageUptodate (page); + +/* writeback dentry page to make data consistent */ +set_page_writeback (page); +write_data_page (page, &dn, &new_blk_addr, &fio); +update_extent_cache (new_blk_addr, &dn); +f2fs_wait_on_page_writeback (page,DATA ); + +/* clear inline dir and flag after data writeback */ +zero_user_segment (ipage,INLINE_DATA_OFFSET , +INLINE_DATA_OFFSET +MAX_INLINE_DATA ); +clear_inode_flag (F2FS_I (dir),FI_INLINE_DATA ); +stat_dec_inline_inode (dir); + +if (i_size_read (dir) <PAGE_CACHE_SIZE ) { +i_size_write (dir,PAGE_CACHE_SIZE ); +set_inode_flag (F2FS_I (dir),FI_UPDATE_DIR ); + } + +sync_inode_page (&dn); +out: + +f2fs_put_page (page,1 ); +return err; +} + +int f2fs_add_inline_entry (struct inode *dir,const struct qstr *name, +struct inode *inode) +{ +struct f2fs_sb_info *sbi =F2FS_SB (dir->i_sb); +struct page *ipage; +unsigned int bit_pos; +f2fs_hash_t name_hash; +struct f2fs_dir_entry *de; +size_t namelen = name->len; +struct f2fs_inline_dentry *dentry_blk =NULL ; +int slots =GET_DENTRY_SLOTS (namelen); +struct page *page; +int err =0 ; +int i; + + name_hash =f2fs_dentry_hash (name); + + ipage =get_node_page (sbi, dir->i_ino); +if (IS_ERR (ipage)) +return PTR_ERR (ipage); + +kmap (ipage); + dentry_blk =inline_data_addr (ipage); + bit_pos =room_in_inline_dir (dentry_blk, slots); +if (bit_pos >=NR_INLINE_DENTRY ) { + err =f2fs_convert_inline_dir (dir, ipage, dentry_blk); +if (!err) + err = -EAGAIN ; + goto out; + } + +f2fs_wait_on_page_writeback (ipage,DATA ); + +down_write (&F2FS_I (inode)->i_sem); + page =init_inode_metadata (inode, dir, name); +if (IS_ERR (page)) { + err =PTR_ERR (page); + goto fail; + } + de = &dentry_blk->dentry[bit_pos]; + de->hash_code = name_hash; + de->name_len =cpu_to_le16 (namelen); +memcpy (dentry_blk->filename[bit_pos], name->name, name->len); + de->ino =cpu_to_le32 (inode->i_ino); +set_de_type (de, inode); +for (i =0 ; i < slots; i++) +test_and_set_bit_le (bit_pos + i, &dentry_blk->dentry_bitmap); +set_page_dirty (ipage); + +/* we don't need to mark_inode_dirty now */ +F2FS_I (inode)->i_pino = dir->i_ino; +update_inode (inode, page); +f2fs_put_page (page,1 ); + +update_parent_metadata (dir, inode,0 ); +fail: +up_write (&F2FS_I (inode)->i_sem); + +if (is_inode_flag_set (F2FS_I (dir),FI_UPDATE_DIR )) { +update_inode (dir, ipage); +clear_inode_flag (F2FS_I (dir),FI_UPDATE_DIR ); + } +out: +kunmap (ipage); +f2fs_put_page (ipage,1 ); +return err; +} + +void f2fs_delete_inline_entry (struct f2fs_dir_entry *dentry,struct page *page, +struct inode *dir,struct inode *inode) +{ +struct f2fs_inline_dentry *inline_dentry; +int slots =GET_DENTRY_SLOTS (le16_to_cpu (dentry->name_len)); +unsigned int bit_pos; +int i; + +lock_page (page); +f2fs_wait_on_page_writeback (page,DATA ); + + inline_dentry =inline_data_addr (page); + bit_pos = dentry - inline_dentry->dentry; +for (i =0 ; i < slots; i++) +test_and_clear_bit_le (bit_pos + i, + &inline_dentry->dentry_bitmap); +kunmap (page); +set_page_dirty (page); + + dir->i_ctime = dir->i_mtime =CURRENT_TIME ; + +if (inode) { +struct f2fs_sb_info *sbi =F2FS_SB (dir->i_sb); + +down_write (&F2FS_I (inode)->i_sem); + +if (S_ISDIR (inode->i_mode)) { +drop_nlink (dir); +update_inode (dir, page); + } + inode->i_ctime =CURRENT_TIME ; + +drop_nlink (inode); +if (S_ISDIR (inode->i_mode)) { +drop_nlink (inode); +i_size_write (inode,0 ); + } +up_write (&F2FS_I (inode)->i_sem); +update_inode_page (inode); + +if (inode->i_nlink ==0 ) +add_orphan_inode (sbi, inode->i_ino); +else +release_orphan_inode (sbi); + } + +f2fs_put_page (page,1 ); +} + +bool f2fs_empty_inline_dir (struct inode *dir) +{ +struct f2fs_sb_info *sbi =F2FS_SB (dir->i_sb); +struct page *ipage; +unsigned int bit_pos =2 ; +struct f2fs_inline_dentry *dentry_blk; + + ipage =get_node_page (sbi, dir->i_ino); +if (IS_ERR (ipage)) +return false; + + dentry_blk =inline_data_addr (ipage); + bit_pos =find_next_bit_le (&dentry_blk->dentry_bitmap, +NR_INLINE_DENTRY , + bit_pos); + +f2fs_put_page (ipage,1 ); + +if (bit_pos <NR_INLINE_DENTRY ) +return false; + +return true; +} + +int f2fs_read_inline_dir (struct file *file,struct dir_context *ctx) +{ +struct inode *inode =file_inode (file); +struct f2fs_sb_info *sbi =F2FS_SB (inode->i_sb); +unsigned int bit_pos =0 ; +struct f2fs_inline_dentry *inline_dentry =NULL ; +struct f2fs_dir_entry *de =NULL ; +struct page *ipage =NULL ; +unsigned char d_type =DT_UNKNOWN ; + +if (ctx->pos ==NR_INLINE_DENTRY ) +return 0 ; + + ipage =get_node_page (sbi, inode->i_ino); +if (IS_ERR (ipage)) +return PTR_ERR (ipage); + + bit_pos = ((unsigned long )ctx->pos %NR_INLINE_DENTRY ); + + inline_dentry =inline_data_addr (ipage); +while (bit_pos <NR_INLINE_DENTRY ) { + bit_pos =find_next_bit_le (&inline_dentry->dentry_bitmap, +NR_INLINE_DENTRY , + bit_pos); +if (bit_pos >=NR_INLINE_DENTRY ) +break ; + + de = &inline_dentry->dentry[bit_pos]; +if (de->file_type <F2FS_FT_MAX ) + d_type = f2fs_filetype_table[de->file_type]; +else + d_type =DT_UNKNOWN ; + +if (!dir_emit (ctx, + inline_dentry->filename[bit_pos], +le16_to_cpu (de->name_len), +le32_to_cpu (de->ino), d_type)) + goto out; + +f2fs_bug_on (!de->name_len); + + bit_pos +=GET_DENTRY_SLOTS (le16_to_cpu (de->name_len)); + ctx->pos = bit_pos; + } + + ctx->pos =NR_INLINE_DENTRY ; +out: +f2fs_put_page (ipage,1 ); + +return 0 ; +}Signature · 1 line
2.0.1.474.g72c7794
Hi Jaegeuk,
Quoted 57 lines
-----Original Message-----
From: Jaegeuk Kim [mailto:[email protected]]
Sent: Friday, August 22, 2014 4:45 AM
To: Chao Yu
Cc: Changman Lee; [email protected]; [email protected]
Subject: Re: [f2fs-dev][PATCH 3/5] f2fs: add key function to handle inline dirHi Chao,
Quoted 47 lines · Chao Yu
Adds Functions to implement inline dir
init/lookup/insert/delete/convertops.Signed-off-by Chao Yu <[email protected]>--- fs/f2fs/f2fs.h | 9 ++ fs/f2fs/inline.c | 388 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 397 insertions(+)fs/f2fs/f2fs.h +9
-0@@ -1450,4 +1450,13 @@ int f2fs_convert_inline_data(struct inode *, pgoff_t);int f2fs_write_inline_data (struct inode *,struct page *,unsigned int );void truncate_inline_data (struct inode *,u64 );int recover_inline_data (struct inode *,struct page *); +struct f2fs_dir_entry *find_in_inline_dir (struct inode *,struct qstr *, +struct page **); +struct f2fs_dir_entry *f2fs_parent_inline_dir (struct inode *,struct page **); +int make_empty_inline_dir (struct inode *inode,struct inode *,struct page *); +int f2fs_add_inline_entry (struct inode *,const struct qstr *,struct inode *); +void f2fs_delete_inline_entry (struct f2fs_dir_entry *,struct page *, +struct inode *,struct inode *); +bool f2fs_empty_inline_dir (struct inode *); +int f2fs_read_inline_dir (struct file *,struct dir_context *);#endif fs/f2fs/inline.c +13
-0@@ -249,3 +249,391 @@ process_inline: }return 0 ; } + +struct f2fs_dir_entry *find_in_inline_dir (struct inode *dir, +struct qstr *name,struct page **res_page) +{ +struct f2fs_sb_info *sbi =F2FS_SB (dir->i_sb); +struct page *ipage; +struct f2fs_dir_entry *de; +f2fs_hash_t namehash; +unsigned long bit_pos =0 ; +struct f2fs_inline_dentry *dentry_blk; +const void *dentry_bits; + + ipage =get_node_page (sbi, dir->i_ino);
Quoted 8 lines
fs/f2fs/inline.c process_inline: · line 270
Quoted 6 lines
fs/f2fs/inline.c +6
-0+if (IS_ERR (ipage)) +return NULL ; + + namehash =f2fs_dentry_hash (name); + +kmap (ipage);Don't need kmap for ipage.
Will delete all 'kmap/kunmap' for ipage.
Quoted 61 lines
Quoted 20 lines
fs/f2fs/inline.c +19
-0+ dentry_blk =inline_data_addr (ipage); + dentry_bits = &dentry_blk->dentry_bitmap; + +while (bit_pos <NR_INLINE_DENTRY ) { +if (!test_bit_le (bit_pos, dentry_bits)) { + bit_pos++; +continue ; + } + de = &dentry_blk->dentry[bit_pos]; +if (early_match_name (name->len, namehash, de)) { +if (!memcmp (dentry_blk->filename[bit_pos], + name->name, + name->len)) { + *res_page = ipage; + goto found; + } + } + +/* fs/f2fs/inline.c process_inline: · line 299
Quoted 10 lines
fs/f2fs/inline.c +10
-0+* For the most part, it should be a bug when name_len is zero. +* We stop here for figuring out where the bugs are occurred. +*/ +f2fs_bug_on (!de->name_len); + + bit_pos +=GET_DENTRY_SLOTS (le16_to_cpu (de->name_len)); + } + + de =NULL ; +kunmap (ipage);Ditto.
Quoted 8 lines
fs/f2fs/inline.c +8
-0+found: +unlock_page (ipage); +return de; +} + +struct f2fs_dir_entry *f2fs_parent_inline_dir (struct inode *dir, +struct page **p) +{fs/f2fs/inline.c process_inline: · line 317
Quoted 10 lines
fs/f2fs/inline.c +10
-0+struct f2fs_sb_info *sbi =F2FS_SB (dir->i_sb); +struct page *ipage; +struct f2fs_dir_entry *de; +struct f2fs_inline_dentry *dentry_blk; + + ipage =get_node_page (sbi, dir->i_ino); +if (IS_ERR (ipage)) +return NULL ; + +kmap (ipage);Ditto.
Quoted 7 lines
fs/f2fs/inline.c +7
-0+ dentry_blk =inline_data_addr (ipage); + de = &dentry_blk->dentry[1 ]; + *p = ipage; +unlock_page (ipage); +return de; +} +
[snip]
Quoted 16 lines
Quoted 16 lines
fs/f2fs/inline.c +16
-0+int f2fs_convert_inline_dir (struct inode *dir,struct page *ipage, +struct f2fs_inline_dentry *inline_dentry) +{ +struct page *page; +struct dnode_of_data dn; +block_t new_blk_addr; +struct f2fs_dentry_block *dentry_blk; +struct f2fs_io_info fio = { + .type =DATA , + .rw =WRITE_SYNC |REQ_PRIO , + }; +int err; + + page =grab_cache_page (dir->i_mapping,0 ); +if (!page) +return -ENOMEM ;
Quoted 8 lines
fs/f2fs/inline.c process_inline: · line 404
Quoted 5 lines
fs/f2fs/inline.c +5
-0+ +set_new_dnode (&dn, dir, ipage,NULL ,0 ); + err =f2fs_reserve_block (&dn,0 ); +if (err) + goto out;At a glance, we don't need to care about dentry blocks to sync, since checkpoint handles that.
Yeah, agreed. Thanks for reminding me the issue! I got the reason why convert_inline_data should sync dentry blocks, but convert_inline_dir do not need to care about it from the scenario given from you to Huajun Li.
Quoted 1 line
It needs to consider about checkpoint and
f2fs_sync_file.
If this directory inode is being fsynced, do_checkpoint will be invoked for data consistent, is there any special case convert_inline_dir will encounter?
Quoted 3 lines
The addition and deletion stuffs are almost same as the existing codes. Can we reuse those to avoid potential bugs?
Yes, it could be, and I tried before, it seems not very clean to me when I implement f2fs_{add,delete}_inline_entry inside f2fs_{add,delete}_dentry.
I think it's better to introduce inner function including the same part of code between f2fs_add_entry and f2fs_add_inline_entry or between f2fs_inline_entry and f2fs_delete_inline_entry.
How do you think?
Quoted 2 lines
And it'd be better to add
inline_dentrymount option separately for now.
OK.
Thanks,
Yu
Quoted 46 lines
Thanks,
Quoted 43 lines
fs/f2fs/inline.c +43
-0+ +f2fs_wait_on_page_writeback (page,DATA ); +zero_user_segment (page,0 ,PAGE_CACHE_SIZE ); + + dentry_blk =kmap (page); + +/* copy data from inline dentry block to new dentry block */ +memcpy (dentry_blk->dentry_bitmap, inline_dentry->dentry_bitmap, +INLINE_DENTRY_BITMAP_SIZE ); +memcpy (dentry_blk->reserved, inline_dentry->reserved, +INLINE_RESERVED_SIZE ); +memcpy (dentry_blk->dentry, inline_dentry->dentry, +sizeof (struct f2fs_dir_entry ) *NR_INLINE_DENTRY ); +memcpy (dentry_blk->filename, inline_dentry->filename, +NR_INLINE_DENTRY *F2FS_SLOT_LEN ); + +kunmap (page); +SetPageUptodate (page); + +/* writeback dentry page to make data consistent */ +set_page_writeback (page); +write_data_page (page, &dn, &new_blk_addr, &fio); +update_extent_cache (new_blk_addr, &dn); +f2fs_wait_on_page_writeback (page,DATA ); + +/* clear inline dir and flag after data writeback */ +zero_user_segment (ipage,INLINE_DATA_OFFSET , +INLINE_DATA_OFFSET +MAX_INLINE_DATA ); +clear_inode_flag (F2FS_I (dir),FI_INLINE_DATA ); +stat_dec_inline_inode (dir); + +if (i_size_read (dir) <PAGE_CACHE_SIZE ) { +i_size_write (dir,PAGE_CACHE_SIZE ); +set_inode_flag (F2FS_I (dir),FI_UPDATE_DIR ); + } + +sync_inode_page (&dn); +out: + +f2fs_put_page (page,1 ); +return err; +} +
[snip]