f2fs: refactor f2fs_convert_inline_data

Change log from v1:
 o handle NULL pointer of grab_cache_page_write_begin() pointed by Chao Yu.

This patch refactors f2fs_convert_inline_data to check a couple of conditions
internally for deciding whether it needs to convert inline_data or not.

So, the new f2fs_convert_inline_data initially checks:
1) f2fs_has_inline_data(), and
2) the data size to be changed.

If the inode has inline_data but the size to fill is less than MAX_INLINE_DATA,
then we don't need to convert the inline_data with data allocation.

Signed-off-by: Jaegeuk Kim <jaegeuk.kim@samsung.com>

4 files changed, 28 insertions, 41 deletions

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 253e6633dbf6..fc7a28c5ad23 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -906,21 +906,17 @@ static int f2fs_write_begin(struct file *file, struct address_space *mapping,
 
         f2fs_balance_fs(sbi);
 repeat:
+        err = f2fs_convert_inline_data(inode, pos + len);
+        if (err)
+                return err;
+
         page = grab_cache_page_write_begin(mapping, index, flags);
         if (!page)
                 return -ENOMEM;
         *pagep = page;
 
-        if ((pos + len) < MAX_INLINE_DATA) {
-                if (f2fs_has_inline_data(inode))
-                        goto inline_data;
-        } else if (f2fs_has_inline_data(inode)) {
-                err = f2fs_convert_inline_data(inode, page, flags);
-                if (err) {
-                        f2fs_put_page(page, 1);
-                        return err;
-                }
-        }
+        if (f2fs_has_inline_data(inode) && (pos + len) <= MAX_INLINE_DATA)
+                goto inline_data;
 
         f2fs_lock_op(sbi);
         set_new_dnode(&dn, inode, NULL, NULL, 0);
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index b01ccaa73b23..af35039c38f8 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1302,6 +1302,6 @@ extern const struct inode_operations f2fs_special_inode_operations;
 inline int f2fs_has_inline_data(struct inode *);
 bool f2fs_may_inline(struct inode *);
 int f2fs_read_inline_data(struct inode *, struct page *);
-int f2fs_convert_inline_data(struct inode *, struct page *, unsigned);
+int f2fs_convert_inline_data(struct inode *, pgoff_t);
 int f2fs_write_inline_data(struct inode *, struct page *, unsigned int);
 #endif
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index f64a1c8291af..68dd7bfce1a1 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -370,17 +370,12 @@ int f2fs_setattr(struct dentry *dentry, struct iattr *attr)
 
         if ((attr->ia_valid & ATTR_SIZE) &&
                         attr->ia_size != i_size_read(inode)) {
-                if (f2fs_has_inline_data(inode) &&
-                                (attr->ia_size > MAX_INLINE_DATA)) {
-                        unsigned flags = AOP_FLAG_NOFS;
-                        err = f2fs_convert_inline_data(inode, NULL, flags);
-                        if (err)
-                                return err;
-                }
+                err = f2fs_convert_inline_data(inode, attr->ia_size);
+                if (err)
+                        return err;
 
                 truncate_setsize(inode, attr->ia_size);
-                if (!f2fs_has_inline_data(inode))
-                        f2fs_truncate(inode);
+                f2fs_truncate(inode);
                 f2fs_balance_fs(F2FS_SB(inode->i_sb));
         }
 
@@ -462,7 +457,7 @@ static int punch_hole(struct inode *inode, loff_t offset, loff_t len)
         loff_t off_start, off_end;
         int ret = 0;
 
-        ret = f2fs_convert_inline_data(inode, NULL, AOP_FLAG_NOFS);
+        ret = f2fs_convert_inline_data(inode, MAX_INLINE_DATA + 1);
         if (ret)
                 return ret;
 
@@ -512,16 +507,14 @@ static int expand_inode_data(struct inode *inode, loff_t offset,
         loff_t off_start, off_end;
         int ret = 0;
 
-        if (f2fs_has_inline_data(inode) && (offset + len > MAX_INLINE_DATA)) {
-                ret = f2fs_convert_inline_data(inode, NULL, AOP_FLAG_NOFS);
-                if (ret)
-                        return ret;
-        }
-
         ret = inode_newsize_ok(inode, (len + offset));
         if (ret)
                 return ret;
 
+        ret = f2fs_convert_inline_data(inode, offset + len);
+        if (ret)
+                return ret;
+
         pg_start = ((unsigned long long) offset) >> PAGE_CACHE_SHIFT;
         pg_end = ((unsigned long long) offset + len) >> PAGE_CACHE_SHIFT;
 
diff --git a/fs/f2fs/inline.c b/fs/f2fs/inline.c
index 62c72aa84acc..e8891aa3ab8c 100644
--- a/fs/f2fs/inline.c
+++ b/fs/f2fs/inline.c
@@ -101,6 +101,7 @@ static int __f2fs_convert_inline_data(struct inode *inode, struct page *page)
         dst_addr = kmap(page);
         memcpy(dst_addr, src_addr, MAX_INLINE_DATA);
         kunmap(page);
+        SetPageUptodate(page);
 
         /* write data page to try to make data consistent */
         set_page_writeback(page);
@@ -120,25 +121,22 @@ static int __f2fs_convert_inline_data(struct inode *inode, struct page *page)
         return err;
 }
 
-int f2fs_convert_inline_data(struct inode *inode,
-                             struct page *p, unsigned flags)
+int f2fs_convert_inline_data(struct inode *inode, pgoff_t to_size)
 {
-        int err;
         struct page *page;
+        int err;
 
-        if (!p || p->index) {
-                page = grab_cache_page_write_begin(inode->i_mapping, 0, flags);
-                if (IS_ERR(page))
-                        return PTR_ERR(page);
-        } else {
-                page = p;
-        }
-
-        err = __f2fs_convert_inline_data(inode, page);
+        if (!f2fs_has_inline_data(inode))
+                return 0;
+        else if (to_size <= MAX_INLINE_DATA)
+                return 0;
 
-        if (!p || p->index)
-                f2fs_put_page(page, 1);
+        page = grab_cache_page_write_begin(inode->i_mapping, 0, AOP_FLAG_NOFS);
+        if (!page)
+                return -ENOMEM;
 
+        err = __f2fs_convert_inline_data(inode, page);
+        f2fs_put_page(page, 1);
         return err;
 }