hollalinux
/
linux-sg2042
mirror of https://github.com/sophgo/linux-riscv.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

f2fs: avoid to allocate when inline_data was written 

The sceanrio is like this.
inline_data   i_size     page                 write_begin/vm_page_mkwrite
  X             30       dirty_page
  X             30                            write to #4096 position
  X             30       get_dnode_of_data    wait for get_dnode_of_data
  O             30       write inline_data
  O             30                            get_dnode_of_data
  O             30                            reserve data block
..

In this case, we have #0 = NEW_ADDR and inline_data as well.
We should not allow this condition for further access.

Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
This commit is contained in:
Jaegeuk Kim 2014-10-17 20:33:55 -07:00
parent a78186ebe5
commit 9ba69cf987
2 changed files with 46 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

32
fs/f2fs/data.c
View File

@ -257,9 +257,6 @@ int f2fs_reserve_block(struct dnode_of_data *dn, pgoff_t index)
bool need_put = dn->inode_page ? false : true; bool need_put = dn->inode_page ? false : true;
int err; int err;
/* if inode_page exists, index should be zero */
f2fs_bug_on(F2FS_I_SB(dn->inode), !need_put && index);
err = get_dnode_of_data(dn, index, ALLOC_NODE); err = get_dnode_of_data(dn, index, ALLOC_NODE);
if (err) if (err)
return err; return err;
@ -951,7 +948,7 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping,
{ {
struct inode *inode = mapping->host; struct inode *inode = mapping->host;
struct f2fs_sb_info *sbi = F2FS_I_SB(inode); struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
struct page *page; struct page *page, *ipage;
pgoff_t index = ((unsigned long long) pos) >> PAGE_CACHE_SHIFT; pgoff_t index = ((unsigned long long) pos) >> PAGE_CACHE_SHIFT;
struct dnode_of_data dn; struct dnode_of_data dn;
int err = 0; int err = 0;
@ -979,13 +976,26 @@ repeat:
goto inline_data; goto inline_data;
f2fs_lock_op(sbi); f2fs_lock_op(sbi);
set_new_dnode(&dn, inode, NULL, NULL, 0);
err = f2fs_reserve_block(&dn, index); /* check inline_data */
f2fs_unlock_op(sbi); ipage = get_node_page(sbi, inode->i_ino);
if (err) { if (IS_ERR(ipage))
goto unlock_fail;
if (f2fs_has_inline_data(inode)) {
f2fs_put_page(ipage, 1);
f2fs_unlock_op(sbi);
f2fs_put_page(page, 0); f2fs_put_page(page, 0);
goto fail; goto repeat;
} }
set_new_dnode(&dn, inode, ipage, NULL, 0);
err = f2fs_reserve_block(&dn, index);
if (err)
goto unlock_fail;
f2fs_put_dnode(&dn);
f2fs_unlock_op(sbi);
inline_data: inline_data:
lock_page(page); lock_page(page);
if (unlikely(page->mapping != mapping)) { if (unlikely(page->mapping != mapping)) {
@ -1038,6 +1048,10 @@ out:
SetPageUptodate(page); SetPageUptodate(page);
clear_cold_data(page); clear_cold_data(page);
return 0; return 0;
unlock_fail:
f2fs_unlock_op(sbi);
f2fs_put_page(page, 0);
fail: fail:
f2fs_write_failed(mapping, pos + len); f2fs_write_failed(mapping, pos + len);
return err; return err;

28
fs/f2fs/file.c
View File

@ -35,12 +35,13 @@ static int f2fs_vm_page_mkwrite(struct vm_area_struct *vma,
struct inode *inode = file_inode(vma->vm_file); struct inode *inode = file_inode(vma->vm_file);
struct f2fs_sb_info *sbi = F2FS_I_SB(inode); struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
struct dnode_of_data dn; struct dnode_of_data dn;
struct page *ipage;
int err; int err;
f2fs_balance_fs(sbi); f2fs_balance_fs(sbi);
sb_start_pagefault(inode->i_sb); sb_start_pagefault(inode->i_sb);
retry:
/* force to convert with normal data indices */ /* force to convert with normal data indices */
err = f2fs_convert_inline_data(inode, MAX_INLINE_DATA + 1, page); err = f2fs_convert_inline_data(inode, MAX_INLINE_DATA + 1, page);
if (err) if (err)
@ -48,11 +49,28 @@ static int f2fs_vm_page_mkwrite(struct vm_area_struct *vma,
/* block allocation */ /* block allocation */
f2fs_lock_op(sbi); f2fs_lock_op(sbi);
set_new_dnode(&dn, inode, NULL, NULL, 0);
err = f2fs_reserve_block(&dn, page->index); /* check inline_data */
f2fs_unlock_op(sbi); ipage = get_node_page(sbi, inode->i_ino);
if (err) if (IS_ERR(ipage)) {
f2fs_unlock_op(sbi);
goto out; goto out;
}
if (f2fs_has_inline_data(inode)) {
f2fs_put_page(ipage, 1);
f2fs_unlock_op(sbi);
goto retry;
}
set_new_dnode(&dn, inode, ipage, NULL, 0);
err = f2fs_reserve_block(&dn, page->index);
if (err) {
f2fs_unlock_op(sbi);
goto out;
}
f2fs_put_dnode(&dn);
f2fs_unlock_op(sbi);
file_update_time(vma->vm_file); file_update_time(vma->vm_file);
lock_page(page); lock_page(page);