1 files changed, 57 insertions, 23 deletions

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 9b79056d705d..aa7fe79b62b2 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -191,8 +191,7 @@ void f2fs_register_inmem_page(struct inode *inode, struct page *page)
 
         f2fs_trace_pid(page);
 
-        set_page_private(page, (unsigned long)ATOMIC_WRITTEN_PAGE);
-        SetPagePrivate(page);
+        f2fs_set_page_private(page, (unsigned long)ATOMIC_WRITTEN_PAGE);
 
         new = f2fs_kmem_cache_alloc(inmem_entry_slab, GFP_NOFS);
 
@@ -215,7 +214,8 @@ void f2fs_register_inmem_page(struct inode *inode, struct page *page)
 }
 
 static int __revoke_inmem_pages(struct inode *inode,
-                                struct list_head *head, bool drop, bool recover)
+                                struct list_head *head, bool drop, bool recover,
+                                bool trylock)
 {
         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
         struct inmem_pages *cur, *tmp;
@@ -227,7 +227,16 @@ static int __revoke_inmem_pages(struct inode *inode,
                 if (drop)
                         trace_f2fs_commit_inmem_page(page, INMEM_DROP);
 
-                lock_page(page);
+                if (trylock) {
+                        /*
+                         * to avoid deadlock in between page lock and
+                         * inmem_lock.
+                         */
+                        if (!trylock_page(page))
+                                continue;
+                } else {
+                        lock_page(page);
+                }
 
                 f2fs_wait_on_page_writeback(page, DATA, true, true);
 
@@ -270,8 +279,7 @@ next:
                         ClearPageUptodate(page);
                         clear_cold_data(page);
                 }
-                set_page_private(page, 0);
-                ClearPagePrivate(page);
+                f2fs_clear_page_private(page);
                 f2fs_put_page(page, 1);
 
                 list_del(&cur->list);
@@ -318,13 +326,19 @@ void f2fs_drop_inmem_pages(struct inode *inode)
         struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
         struct f2fs_inode_info *fi = F2FS_I(inode);
 
-        mutex_lock(&fi->inmem_lock);
-        __revoke_inmem_pages(inode, &fi->inmem_pages, true, false);
-        spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
-        if (!list_empty(&fi->inmem_ilist))
-                list_del_init(&fi->inmem_ilist);
-        spin_unlock(&sbi->inode_lock[ATOMIC_FILE]);
-        mutex_unlock(&fi->inmem_lock);
+        while (!list_empty(&fi->inmem_pages)) {
+                mutex_lock(&fi->inmem_lock);
+                __revoke_inmem_pages(inode, &fi->inmem_pages,
+                                                true, false, true);
+
+                if (list_empty(&fi->inmem_pages)) {
+                        spin_lock(&sbi->inode_lock[ATOMIC_FILE]);
+                        if (!list_empty(&fi->inmem_ilist))
+                                list_del_init(&fi->inmem_ilist);
+                        spin_unlock(&sbi->inode_lock[ATOMIC_FILE]);
+                }
+                mutex_unlock(&fi->inmem_lock);
+        }
 
         clear_inode_flag(inode, FI_ATOMIC_FILE);
         fi->i_gc_failures[GC_FAILURE_ATOMIC] = 0;
@@ -354,8 +368,7 @@ void f2fs_drop_inmem_page(struct inode *inode, struct page *page)
         kmem_cache_free(inmem_entry_slab, cur);
 
         ClearPageUptodate(page);
-        set_page_private(page, 0);
-        ClearPagePrivate(page);
+        f2fs_clear_page_private(page);
         f2fs_put_page(page, 0);
 
         trace_f2fs_commit_inmem_page(page, INMEM_INVALIDATE);
@@ -429,12 +442,15 @@ retry:
                  * recovery or rewrite & commit last transaction. For other
                  * error number, revoking was done by filesystem itself.
                  */
-                err = __revoke_inmem_pages(inode, &revoke_list, false, true);
+                err = __revoke_inmem_pages(inode, &revoke_list,
+                                                false, true, false);
 
                 /* drop all uncommitted pages */
-                __revoke_inmem_pages(inode, &fi->inmem_pages, true, false);
+                __revoke_inmem_pages(inode, &fi->inmem_pages,
+                                                true, false, false);
         } else {
-                __revoke_inmem_pages(inode, &revoke_list, false, false);
+                __revoke_inmem_pages(inode, &revoke_list,
+                                                false, false, false);
         }
 
         return err;
@@ -542,9 +558,13 @@ void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi)
 static int __submit_flush_wait(struct f2fs_sb_info *sbi,
                                 struct block_device *bdev)
 {
-        struct bio *bio = f2fs_bio_alloc(sbi, 0, true);
+        struct bio *bio;
         int ret;
 
+        bio = f2fs_bio_alloc(sbi, 0, false);
+        if (!bio)
+                return -ENOMEM;
+
         bio->bi_opf = REQ_OP_WRITE | REQ_SYNC | REQ_PREFLUSH;
         bio_set_dev(bio, bdev);
         ret = submit_bio_wait(bio);
@@ -868,6 +888,9 @@ int f2fs_disable_cp_again(struct f2fs_sb_info *sbi)
 
         if (holes[DATA] > ovp || holes[NODE] > ovp)
                 return -EAGAIN;
+        if (is_sbi_flag_set(sbi, SBI_CP_DISABLED_QUICK) &&
+                dirty_segments(sbi) > overprovision_segments(sbi))
+                return -EAGAIN;
         return 0;
 }
 
@@ -1037,6 +1060,7 @@ static void __init_discard_policy(struct f2fs_sb_info *sbi,
 
         dpolicy->max_requests = DEF_MAX_DISCARD_REQUEST;
         dpolicy->io_aware_gran = MAX_PLIST_NUM;
+        dpolicy->timeout = 0;
 
         if (discard_type == DPOLICY_BG) {
                 dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
@@ -1059,6 +1083,8 @@ static void __init_discard_policy(struct f2fs_sb_info *sbi,
         } else if (discard_type == DPOLICY_UMOUNT) {
                 dpolicy->max_requests = UINT_MAX;
                 dpolicy->io_aware = false;
+                /* we need to issue all to keep CP_TRIMMED_FLAG */
+                dpolicy->granularity = 1;
         }
 }
 
@@ -1424,7 +1450,14 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
         int i, issued = 0;
         bool io_interrupted = false;
 
+        if (dpolicy->timeout != 0)
+                f2fs_update_time(sbi, dpolicy->timeout);
+
         for (i = MAX_PLIST_NUM - 1; i >= 0; i--) {
+                if (dpolicy->timeout != 0 &&
+                                f2fs_time_over(sbi, dpolicy->timeout))
+                        break;
+
                 if (i + 1 < dpolicy->granularity)
                         break;
 
@@ -1611,7 +1644,7 @@ void f2fs_stop_discard_thread(struct f2fs_sb_info *sbi)
 }
 
 /* This comes from f2fs_put_super */
-bool f2fs_wait_discard_bios(struct f2fs_sb_info *sbi)
+bool f2fs_issue_discard_timeout(struct f2fs_sb_info *sbi)
 {
         struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
         struct discard_policy dpolicy;
@@ -1619,6 +1652,7 @@ bool f2fs_wait_discard_bios(struct f2fs_sb_info *sbi)
 
         __init_discard_policy(sbi, &dpolicy, DPOLICY_UMOUNT,
                                         dcc->discard_granularity);
+        dpolicy.timeout = UMOUNT_DISCARD_TIMEOUT;
         __issue_discard_cmd(sbi, &dpolicy);
         dropped = __drop_discard_cmd(sbi);
 
@@ -3164,10 +3198,10 @@ int f2fs_inplace_write_data(struct f2fs_io_info *fio)
         stat_inc_inplace_blocks(fio->sbi);
 
         err = f2fs_submit_page_bio(fio);
-        if (!err)
+        if (!err) {
                 update_device_state(fio);
-
-        f2fs_update_iostat(fio->sbi, fio->io_type, F2FS_BLKSIZE);
+                f2fs_update_iostat(fio->sbi, fio->io_type, F2FS_BLKSIZE);
+        }
 
         return err;
 }