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>

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 5b80adac898509eabe35ac2bc2edd29b6d9cc0a2..973fd7770d56499a9a80f77e8fe591fcbccc4a7b 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -257,9 +257,6 @@ int f2fs_reserve_block(struct dnode_of_data *dn, pgoff_t index)
        bool need_put = dn->inode_page ? false : true;
        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);
        if (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 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;
        struct dnode_of_data dn;
        int err = 0;
@@ -979,13 +976,26 @@ repeat:
                goto inline_data;
 
        f2fs_lock_op(sbi);
-       set_new_dnode(&dn, inode, NULL, NULL, 0);
-       err = f2fs_reserve_block(&dn, index);
-       f2fs_unlock_op(sbi);
-       if (err) {
+
+       /* check inline_data */
+       ipage = get_node_page(sbi, inode->i_ino);
+       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);
-               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:
        lock_page(page);
        if (unlikely(page->mapping != mapping)) {
@@ -1038,6 +1048,10 @@ out:
        SetPageUptodate(page);
        clear_cold_data(page);
        return 0;
+
+unlock_fail:
+       f2fs_unlock_op(sbi);
+       f2fs_put_page(page, 0);
 fail:
        f2fs_write_failed(mapping, pos + len);
        return err;

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 543d8c6303450ed23a671ab2771a452d7d54af72..456df07f19cb2a71c035246fdb5c77bd2d8149fd 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -35,12 +35,13 @@ static int f2fs_vm_page_mkwrite(struct vm_area_struct *vma,
        struct inode *inode = file_inode(vma->vm_file);
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        struct dnode_of_data dn;
+       struct page *ipage;
        int err;
 
        f2fs_balance_fs(sbi);
 
        sb_start_pagefault(inode->i_sb);
-
+retry:
        /* force to convert with normal data indices */
        err = f2fs_convert_inline_data(inode, MAX_INLINE_DATA + 1, page);
        if (err)
@@ -48,11 +49,28 @@ static int f2fs_vm_page_mkwrite(struct vm_area_struct *vma,
 
        /* block allocation */
        f2fs_lock_op(sbi);
-       set_new_dnode(&dn, inode, NULL, NULL, 0);
+
+       /* check inline_data */
+       ipage = get_node_page(sbi, inode->i_ino);
+       if (IS_ERR(ipage)) {
+               f2fs_unlock_op(sbi);
+               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);
-       f2fs_unlock_op(sbi);
-       if (err)
+       if (err) {
+               f2fs_unlock_op(sbi);
                goto out;
+       }
+       f2fs_put_dnode(&dn);
+       f2fs_unlock_op(sbi);
 
        file_update_time(vma->vm_file);
        lock_page(page);