f2fs: detect idle time depending on user behavior

This patch adds last time that user requested filesystem operations.
This information is used to detect whether system is idle or not later.

Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>

diff --git a/Documentation/ABI/testing/sysfs-fs-f2fs b/Documentation/ABI/testing/sysfs-fs-f2fs
index 0345f2d1c7278ffebb1406c2b6ecf10fb7f430ff..e5200f354abfe933d3fbe69f919da2dcc0e585a6 100644 (file)
--- a/Documentation/ABI/testing/sysfs-fs-f2fs
+++ b/Documentation/ABI/testing/sysfs-fs-f2fs
@@ -87,6 +87,12 @@ Contact:     "Jaegeuk Kim" <jaegeuk@kernel.org>
 Description:
                 Controls the checkpoint timing.
 
+What:          /sys/fs/f2fs/<disk>/idle_interval
+Date:          January 2016
+Contact:       "Jaegeuk Kim" <jaegeuk@kernel.org>
+Description:
+                Controls the idle timing.
+
 What:          /sys/fs/f2fs/<disk>/ra_nid_pages
 Date:          October 2015
 Contact:       "Chao Yu" <chao2.yu@samsung.com>

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index a3bce12b0cce535b11878d0a628e458d115a2a15..ac9e7c6aac74df601ddf3043c7ce364ad0cf2294 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -1596,6 +1596,7 @@ static int f2fs_write_end(struct file *file,
        }
 
        f2fs_put_page(page, 1);
+       f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
        return copied;
 }
 

diff --git a/fs/f2fs/dir.c b/fs/f2fs/dir.c
index 29bb8dd76a46e7a589e9a2c3f0d22a9867373863..faa7495e2d7e62effef70b681c52ba2c75ca36d9 100644 (file)
--- a/fs/f2fs/dir.c
+++ b/fs/f2fs/dir.c
@@ -636,6 +636,7 @@ fail:
        f2fs_put_page(dentry_page, 1);
 out:
        f2fs_fname_free_filename(&fname);
+       f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);
        return err;
 }
 
@@ -657,6 +658,7 @@ int f2fs_do_tmpfile(struct inode *inode, struct inode *dir)
        clear_inode_flag(F2FS_I(inode), FI_NEW_INODE);
 fail:
        up_write(&F2FS_I(inode)->i_sem);
+       f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
        return err;
 }
 
@@ -701,6 +703,8 @@ void f2fs_delete_entry(struct f2fs_dir_entry *dentry, struct page *page,
        int slots = GET_DENTRY_SLOTS(le16_to_cpu(dentry->name_len));
        int i;
 
+       f2fs_update_time(F2FS_I_SB(dir), REQ_TIME);
+
        if (f2fs_has_inline_dentry(dir))
                return f2fs_delete_inline_entry(dentry, page, dir, inode);
 

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 5bbb6a407e79f53fc9ad0ceed9d87dbb4b4b5fae..4331b9fe6f27fb892bbad5501a65be607a31fc62 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -21,6 +21,7 @@
 #include <linux/sched.h>
 #include <linux/vmalloc.h>
 #include <linux/bio.h>
+#include <linux/blkdev.h>
 
 #ifdef CONFIG_F2FS_CHECK_FS
 #define f2fs_bug_on(sbi, condition)    BUG_ON(condition)
@@ -126,6 +127,7 @@ enum {
 #define BATCHED_TRIM_BLOCKS(sbi)       \
                (BATCHED_TRIM_SEGMENTS(sbi) << (sbi)->log_blocks_per_seg)
 #define DEF_CP_INTERVAL                        60      /* 60 secs */
+#define DEF_IDLE_INTERVAL              120     /* 2 mins */
 
 struct cp_control {
        int reason;
@@ -723,6 +725,7 @@ enum {
 
 enum {
        CP_TIME,
+       REQ_TIME,
        MAX_TIME,
 };
 
@@ -856,6 +859,18 @@ static inline bool f2fs_time_over(struct f2fs_sb_info *sbi, int type)
        return time_after(jiffies, sbi->last_time[type] + interval);
 }
 
+static inline bool is_idle(struct f2fs_sb_info *sbi)
+{
+       struct block_device *bdev = sbi->sb->s_bdev;
+       struct request_queue *q = bdev_get_queue(bdev);
+       struct request_list *rl = &q->root_rl;
+
+       if (rl->count[BLK_RW_SYNC] || rl->count[BLK_RW_ASYNC])
+               return 0;
+
+       return f2fs_time_over(sbi, REQ_TIME);
+}
+
 /*
  * Inline functions
  */

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index ff06827aa3695662655756edf37f393306b075eb..3d43857e989232add7e37c3703b48579e4d853ec 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -96,6 +96,7 @@ mapped:
        clear_cold_data(page);
 out:
        sb_end_pagefault(inode->i_sb);
+       f2fs_update_time(sbi, REQ_TIME);
        return block_page_mkwrite_return(err);
 }
 
@@ -280,6 +281,7 @@ flush_out:
        remove_ino_entry(sbi, ino, UPDATE_INO);
        clear_inode_flag(fi, FI_UPDATE_WRITE);
        ret = f2fs_issue_flush(sbi);
+       f2fs_update_time(sbi, REQ_TIME);
 out:
        trace_f2fs_sync_file_exit(inode, need_cp, datasync, ret);
        f2fs_trace_ios(NULL, 1);
@@ -485,6 +487,7 @@ int truncate_data_blocks_range(struct dnode_of_data *dn, int count)
        }
        dn->ofs_in_node = ofs;
 
+       f2fs_update_time(sbi, REQ_TIME);
        trace_f2fs_truncate_data_blocks_range(dn->inode, dn->nid,
                                         dn->ofs_in_node, nr_free);
        return nr_free;
@@ -1236,6 +1239,7 @@ static long f2fs_fallocate(struct file *file, int mode,
        if (!ret) {
                inode->i_mtime = inode->i_ctime = CURRENT_TIME;
                mark_inode_dirty(inode);
+               f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
        }
 
 out:
@@ -1351,6 +1355,8 @@ static int f2fs_ioc_start_atomic_write(struct file *filp)
                return ret;
 
        set_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
+       f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
+
        return 0;
 }
 
@@ -1398,6 +1404,7 @@ static int f2fs_ioc_start_volatile_write(struct file *filp)
                return ret;
 
        set_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE);
+       f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
        return 0;
 }
 
@@ -1439,6 +1446,7 @@ static int f2fs_ioc_abort_volatile_write(struct file *filp)
        }
 
        mnt_drop_write_file(filp);
+       f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
        return ret;
 }
 
@@ -1478,6 +1486,7 @@ static int f2fs_ioc_shutdown(struct file *filp, unsigned long arg)
        default:
                return -EINVAL;
        }
+       f2fs_update_time(sbi, REQ_TIME);
        return 0;
 }
 
@@ -1508,6 +1517,7 @@ static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg)
        if (copy_to_user((struct fstrim_range __user *)arg, &range,
                                sizeof(range)))
                return -EFAULT;
+       f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
        return 0;
 }
 
@@ -1531,6 +1541,7 @@ static int f2fs_ioc_set_encryption_policy(struct file *filp, unsigned long arg)
                                sizeof(policy)))
                return -EFAULT;
 
+       f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
        return f2fs_process_policy(&policy, inode);
 #else
        return -EOPNOTSUPP;
@@ -1807,6 +1818,7 @@ static int f2fs_ioc_defragment(struct file *filp, unsigned long arg)
        }
 
        err = f2fs_defragment_range(sbi, filp, &range);
+       f2fs_update_time(sbi, REQ_TIME);
        if (err < 0)
                goto out;
 

diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c
index c09be339569cfdb7249099a83f0702673f0ed5ce..f610c2a9bdde9561d3be71ab4d674376db8ec401 100644 (file)
--- a/fs/f2fs/gc.c
+++ b/fs/f2fs/gc.c
@@ -16,7 +16,6 @@
 #include <linux/kthread.h>
 #include <linux/delay.h>
 #include <linux/freezer.h>
-#include <linux/blkdev.h>
 
 #include "f2fs.h"
 #include "node.h"

diff --git a/fs/f2fs/gc.h b/fs/f2fs/gc.h
index b4a65be9f7d3fc03a9b1836873f392fea1cfd646..a993967dcdb979160ec5bced54fa7df565bf1e65 100644 (file)
--- a/fs/f2fs/gc.h
+++ b/fs/f2fs/gc.h
@@ -100,11 +100,3 @@ static inline bool has_enough_invalid_blocks(struct f2fs_sb_info *sbi)
                return true;
        return false;
 }
-
-static inline int is_idle(struct f2fs_sb_info *sbi)
-{
-       struct block_device *bdev = sbi->sb->s_bdev;
-       struct request_queue *q = bdev_get_queue(bdev);
-       struct request_list *rl = &q->root_rl;
-       return !(rl->count[BLK_RW_SYNC]) && !(rl->count[BLK_RW_ASYNC]);
-}

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index fed23d5a7b34395be82a22a503cd8f82beac4d0a..d8ad1abfa4fdb84c1ea4950aab119bc26c7cd348 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -293,7 +293,7 @@ void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi)
        if (!available_free_memory(sbi, NAT_ENTRIES) ||
                        excess_prefree_segs(sbi) ||
                        !available_free_memory(sbi, INO_ENTRIES) ||
-                       f2fs_time_over(sbi, CP_TIME)) {
+                       (is_idle(sbi) && f2fs_time_over(sbi, CP_TIME))) {
                if (test_opt(sbi, DATA_FLUSH))
                        sync_dirty_inodes(sbi, FILE_INODE);
                f2fs_sync_fs(sbi->sb, true);

diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index 787047f59c007b60c477f17c6beb1958a62ba21a..3bf990b80026229590dcb7b3fd8647a31927d4d0 100644 (file)
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -219,6 +219,7 @@ F2FS_RW_ATTR(NM_INFO, f2fs_nm_info, ra_nid_pages, ra_nid_pages);
 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, max_victim_search, max_victim_search);
 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, dir_level, dir_level);
 F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, cp_interval, interval_time[CP_TIME]);
+F2FS_RW_ATTR(F2FS_SBI, f2fs_sb_info, idle_interval, interval_time[REQ_TIME]);
 
 #define ATTR_LIST(name) (&f2fs_attr_##name.attr)
 static struct attribute *f2fs_attrs[] = {
@@ -237,6 +238,7 @@ static struct attribute *f2fs_attrs[] = {
        ATTR_LIST(ram_thresh),
        ATTR_LIST(ra_nid_pages),
        ATTR_LIST(cp_interval),
+       ATTR_LIST(idle_interval),
        NULL,
 };
 
@@ -1123,6 +1125,7 @@ static void init_sb_info(struct f2fs_sb_info *sbi)
 
        sbi->dir_level = DEF_DIR_LEVEL;
        sbi->interval_time[CP_TIME] = DEF_CP_INTERVAL;
+       sbi->interval_time[REQ_TIME] = DEF_IDLE_INTERVAL;
        clear_sbi_flag(sbi, SBI_NEED_FSCK);
 
        INIT_LIST_HEAD(&sbi->s_list);
@@ -1468,6 +1471,7 @@ try_onemore:
        }
 
        f2fs_update_time(sbi, CP_TIME);
+       f2fs_update_time(sbi, REQ_TIME);
        return 0;
 
 free_kobj:

diff --git a/fs/f2fs/xattr.c b/fs/f2fs/xattr.c
index 822a8af89c122dbe402ef3d67c781aeceef12e51..0108f487cc8e4da925f6eb88c9e6e608dd18c98a 100644 (file)
--- a/fs/f2fs/xattr.c
+++ b/fs/f2fs/xattr.c
@@ -618,5 +618,6 @@ int f2fs_setxattr(struct inode *inode, int index, const char *name,
        up_write(&F2FS_I(inode)->i_sem);
        f2fs_unlock_op(sbi);
 
+       f2fs_update_time(sbi, REQ_TIME);
        return err;
 }