f2fs: split drop_inmem_pages from commit_inmem_pages

Split drop_inmem_pages from commit_inmem_pages for code readability,
and prepare for the following modification.

Signed-off-by: Chao Yu <chao2.yu@samsung.com>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 66a87cb039bb11bf313adae791739629a8fdac55..d8caf0c86593a7a0c708f72537407bf5efa37c8a 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -1830,7 +1830,8 @@ void destroy_node_manager_caches(void);
  * segment.c
  */
 void register_inmem_page(struct inode *, struct page *);
-int commit_inmem_pages(struct inode *, bool);
+void drop_inmem_pages(struct inode *);
+int commit_inmem_pages(struct inode *);
 void f2fs_balance_fs(struct f2fs_sb_info *, bool);
 void f2fs_balance_fs_bg(struct f2fs_sb_info *);
 int f2fs_issue_flush(struct f2fs_sb_info *);

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index a4362d4d714b09f838bf46cad48d6f7aa62de2fd..92273b6e9f47a15bbaf6fe7e641721c3bd8887bb 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -1252,7 +1252,7 @@ static int f2fs_release_file(struct inode *inode, struct file *filp)
 {
        /* some remained atomic pages should discarded */
        if (f2fs_is_atomic_file(inode))
-               commit_inmem_pages(inode, true);
+               drop_inmem_pages(inode);
        if (f2fs_is_volatile_file(inode)) {
                set_inode_flag(F2FS_I(inode), FI_DROP_CACHE);
                filemap_fdatawrite(inode->i_mapping);
@@ -1376,7 +1376,7 @@ static int f2fs_ioc_commit_atomic_write(struct file *filp)
 
        if (f2fs_is_atomic_file(inode)) {
                clear_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
-               ret = commit_inmem_pages(inode, false);
+               ret = commit_inmem_pages(inode);
                if (ret) {
                        set_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
                        goto err_out;
@@ -1439,7 +1439,7 @@ static int f2fs_ioc_abort_volatile_write(struct file *filp)
 
        if (f2fs_is_atomic_file(inode)) {
                clear_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
-               commit_inmem_pages(inode, true);
+               drop_inmem_pages(inode);
        }
        if (f2fs_is_volatile_file(inode)) {
                clear_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE);

diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index 60e3b3078b81469b300fca0d4bf44b2117f709bf..d4477073dbb03344ba331c4a75b8fec569261b62 100644 (file)
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -324,7 +324,7 @@ void f2fs_evict_inode(struct inode *inode)
 
        /* some remained atomic pages should discarded */
        if (f2fs_is_atomic_file(inode))
-               commit_inmem_pages(inode, true);
+               drop_inmem_pages(inode);
 
        trace_f2fs_evict_inode(inode);
        truncate_inode_pages_final(&inode->i_data);

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 47fbb72635ef24242e0abdb1571e2442ddca9a85..5ae66baf69895710614e2ea997b4b3052ef64d58 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -191,56 +191,67 @@ void register_inmem_page(struct inode *inode, struct page *page)
        trace_f2fs_register_inmem_page(page, INMEM);
 }
 
-int commit_inmem_pages(struct inode *inode, bool abort)
+static void __revoke_inmem_pages(struct inode *inode,
+                                                       struct list_head *head)
+{
+       struct inmem_pages *cur, *tmp;
+
+       list_for_each_entry_safe(cur, tmp, head, list) {
+               trace_f2fs_commit_inmem_page(cur->page, INMEM_DROP);
+
+               lock_page(cur->page);
+               ClearPageUptodate(cur->page);
+               set_page_private(cur->page, 0);
+               ClearPagePrivate(cur->page);
+               f2fs_put_page(cur->page, 1);
+
+               list_del(&cur->list);
+               kmem_cache_free(inmem_entry_slab, cur);
+               dec_page_count(F2FS_I_SB(inode), F2FS_INMEM_PAGES);
+       }
+}
+
+void drop_inmem_pages(struct inode *inode)
+{
+       struct f2fs_inode_info *fi = F2FS_I(inode);
+
+       mutex_lock(&fi->inmem_lock);
+       __revoke_inmem_pages(inode, &fi->inmem_pages);
+       mutex_unlock(&fi->inmem_lock);
+}
+
+static int __commit_inmem_pages(struct inode *inode)
 {
        struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
        struct f2fs_inode_info *fi = F2FS_I(inode);
        struct inmem_pages *cur, *tmp;
-       bool submit_bio = false;
        struct f2fs_io_info fio = {
                .sbi = sbi,
                .type = DATA,
                .rw = WRITE_SYNC | REQ_PRIO,
                .encrypted_page = NULL,
        };
+       bool submit_bio = false;
        int err = 0;
 
-       /*
-        * The abort is true only when f2fs_evict_inode is called.
-        * Basically, the f2fs_evict_inode doesn't produce any data writes, so
-        * that we don't need to call f2fs_balance_fs.
-        * Otherwise, f2fs_gc in f2fs_balance_fs can wait forever until this
-        * inode becomes free by iget_locked in f2fs_iget.
-        */
-       if (!abort) {
-               f2fs_balance_fs(sbi, true);
-               f2fs_lock_op(sbi);
-       }
-
-       mutex_lock(&fi->inmem_lock);
        list_for_each_entry_safe(cur, tmp, &fi->inmem_pages, list) {
                lock_page(cur->page);
-               if (!abort) {
-                       if (cur->page->mapping == inode->i_mapping) {
-                               set_page_dirty(cur->page);
-                               f2fs_wait_on_page_writeback(cur->page, DATA,
-                                                                       true);
-                               if (clear_page_dirty_for_io(cur->page))
-                                       inode_dec_dirty_pages(inode);
-                               trace_f2fs_commit_inmem_page(cur->page, INMEM);
-                               fio.page = cur->page;
-                               err = do_write_data_page(&fio);
-                               if (err) {
-                                       unlock_page(cur->page);
-                                       break;
-                               }
-                               clear_cold_data(cur->page);
-                               submit_bio = true;
+               if (cur->page->mapping == inode->i_mapping) {
+                       set_page_dirty(cur->page);
+                       f2fs_wait_on_page_writeback(cur->page, DATA, true);
+                       if (clear_page_dirty_for_io(cur->page))
+                               inode_dec_dirty_pages(inode);
+                       trace_f2fs_commit_inmem_page(cur->page, INMEM);
+                       fio.page = cur->page;
+                       err = do_write_data_page(&fio);
+                       if (err) {
+                               unlock_page(cur->page);
+                               break;
                        }
-               } else {
-                       ClearPageUptodate(cur->page);
-                       trace_f2fs_commit_inmem_page(cur->page, INMEM_DROP);
+                       clear_cold_data(cur->page);
+                       submit_bio = true;
                }
+
                set_page_private(cur->page, 0);
                ClearPagePrivate(cur->page);
                f2fs_put_page(cur->page, 1);
@@ -249,14 +260,26 @@ int commit_inmem_pages(struct inode *inode, bool abort)
                kmem_cache_free(inmem_entry_slab, cur);
                dec_page_count(F2FS_I_SB(inode), F2FS_INMEM_PAGES);
        }
+
+       if (submit_bio)
+               f2fs_submit_merged_bio_cond(sbi, inode, NULL, 0, DATA, WRITE);
+       return err;
+}
+
+int commit_inmem_pages(struct inode *inode)
+{
+       struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
+       struct f2fs_inode_info *fi = F2FS_I(inode);
+       int err = 0;
+
+       f2fs_balance_fs(sbi, true);
+       f2fs_lock_op(sbi);
+
+       mutex_lock(&fi->inmem_lock);
+       err = __commit_inmem_pages(inode);
        mutex_unlock(&fi->inmem_lock);
 
-       if (!abort) {
-               f2fs_unlock_op(sbi);
-               if (submit_bio)
-                       f2fs_submit_merged_bio_cond(sbi, inode, NULL, 0,
-                                                               DATA, WRITE);
-       }
+       f2fs_unlock_op(sbi);
        return err;
 }
 

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 9445a34b8d48c184ecf0762b65dc2096896d2885..fa4bbe0eab7a42c5cf07756f474ad71587474fbe 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -494,7 +494,7 @@ static int f2fs_drop_inode(struct inode *inode)
 
                        /* some remained atomic pages should discarded */
                        if (f2fs_is_atomic_file(inode))
-                               commit_inmem_pages(inode, true);
+                               drop_inmem_pages(inode);
 
                        /* should remain fi->extent_tree for writepage */
                        f2fs_destroy_extent_node(inode);