f2fs: change atomic and volatile write policies

This patch adds two new ioctls to release inmemory pages grabbed by atomic
writes.
 o f2fs_ioc_abort_volatile_write
  - If transaction was failed, all the grabbed pages and data should be written.
 o f2fs_ioc_release_volatile_write
  - This is to enhance the performance of PERSIST mode in sqlite.

In order to avoid huge memory consumption which causes OOM, this patch changes
volatile writes to use normal dirty pages, instead blocked flushing to the disk
as long as system does not suffer from memory pressure.

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

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 7ec697b37f19316e0476869ec79b491e6370b3f6..32264e3d524fafd365f0144aa4228846f343081c 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -814,6 +814,11 @@ static int f2fs_write_data_page(struct page *page,
 write:
        if (unlikely(sbi->por_doing))
                goto redirty_out;
+       if (f2fs_is_drop_cache(inode))
+               goto out;
+       if (f2fs_is_volatile_file(inode) && !wbc->for_reclaim &&
+                       available_free_memory(sbi, BASE_CHECK))
+               goto redirty_out;
 
        /* Dentry blocks are controlled by checkpoint */
        if (S_ISDIR(inode->i_mode)) {
@@ -1109,7 +1114,7 @@ static void f2fs_invalidate_data_page(struct page *page, unsigned int offset,
        if (offset % PAGE_CACHE_SIZE || length != PAGE_CACHE_SIZE)
                return;
 
-       if (f2fs_is_atomic_file(inode) || f2fs_is_volatile_file(inode))
+       if (f2fs_is_atomic_file(inode))
                invalidate_inmem_page(inode, page);
 
        if (PageDirty(page))
@@ -1132,7 +1137,7 @@ static int f2fs_set_data_page_dirty(struct page *page)
 
        SetPageUptodate(page);
 
-       if (f2fs_is_atomic_file(inode) || f2fs_is_volatile_file(inode)) {
+       if (f2fs_is_atomic_file(inode)) {
                register_inmem_page(inode, page);
                return 1;
        }

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index ec58bb2373fc862b0db949b8e66dd304fa0ba6fb..8c9bf3d6cb7d24faae9f2e85ffe4594a0d291f64 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -201,6 +201,8 @@ static inline bool __has_cursum_space(struct f2fs_summary_block *sum, int size,
 #define F2FS_IOC_START_ATOMIC_WRITE    _IO(F2FS_IOCTL_MAGIC, 1)
 #define F2FS_IOC_COMMIT_ATOMIC_WRITE   _IO(F2FS_IOCTL_MAGIC, 2)
 #define F2FS_IOC_START_VOLATILE_WRITE  _IO(F2FS_IOCTL_MAGIC, 3)
+#define F2FS_IOC_RELEASE_VOLATILE_WRITE        _IO(F2FS_IOCTL_MAGIC, 4)
+#define F2FS_IOC_ABORT_VOLATILE_WRITE  _IO(F2FS_IOCTL_MAGIC, 5)
 
 #if defined(__KERNEL__) && defined(CONFIG_COMPAT)
 /*
@@ -1113,6 +1115,7 @@ enum {
        FI_NEED_IPU,            /* used for ipu per file */
        FI_ATOMIC_FILE,         /* indicate atomic file */
        FI_VOLATILE_FILE,       /* indicate volatile file */
+       FI_DROP_CACHE,          /* drop dirty page cache */
        FI_DATA_EXIST,          /* indicate data exists */
 };
 
@@ -1220,6 +1223,11 @@ static inline bool f2fs_is_volatile_file(struct inode *inode)
        return is_inode_flag_set(F2FS_I(inode), FI_VOLATILE_FILE);
 }
 
+static inline bool f2fs_is_drop_cache(struct inode *inode)
+{
+       return is_inode_flag_set(F2FS_I(inode), FI_DROP_CACHE);
+}
+
 static inline void *inline_data_addr(struct page *page)
 {
        struct f2fs_inode *ri = F2FS_INODE(page);

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 3c27e0ecb3bcf1d57a1b349b0e00b30ce99cd43f..5139f90e92c1c5404409b433fd8c38d534400787 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -836,6 +836,19 @@ static long f2fs_fallocate(struct file *file, int mode,
        return ret;
 }
 
+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);
+       if (f2fs_is_volatile_file(inode)) {
+               set_inode_flag(F2FS_I(inode), FI_DROP_CACHE);
+               filemap_fdatawrite(inode->i_mapping);
+               clear_inode_flag(F2FS_I(inode), FI_DROP_CACHE);
+       }
+       return 0;
+}
+
 #define F2FS_REG_FLMASK                (~(FS_DIRSYNC_FL | FS_TOPDIR_FL))
 #define F2FS_OTHER_FLMASK      (FS_NODUMP_FL | FS_NOATIME_FL)
 
@@ -909,26 +922,20 @@ out:
 static int f2fs_ioc_start_atomic_write(struct file *filp)
 {
        struct inode *inode = file_inode(filp);
-       struct f2fs_sb_info *sbi = F2FS_I_SB(inode);
 
        if (!inode_owner_or_capable(inode))
                return -EACCES;
 
-       f2fs_balance_fs(sbi);
+       f2fs_balance_fs(F2FS_I_SB(inode));
+
+       if (f2fs_is_atomic_file(inode))
+               return 0;
 
        set_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
 
        return f2fs_convert_inline_inode(inode);
 }
 
-static int f2fs_release_file(struct inode *inode, struct file *filp)
-{
-       /* some remained atomic pages should discarded */
-       if (f2fs_is_atomic_file(inode) || f2fs_is_volatile_file(inode))
-               commit_inmem_pages(inode, true);
-       return 0;
-}
-
 static int f2fs_ioc_commit_atomic_write(struct file *filp)
 {
        struct inode *inode = file_inode(filp);
@@ -949,6 +956,7 @@ static int f2fs_ioc_commit_atomic_write(struct file *filp)
 
        ret = f2fs_sync_file(filp, 0, LONG_MAX, 0);
        mnt_drop_write_file(filp);
+       clear_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
        return ret;
 }
 
@@ -959,11 +967,56 @@ static int f2fs_ioc_start_volatile_write(struct file *filp)
        if (!inode_owner_or_capable(inode))
                return -EACCES;
 
+       if (f2fs_is_volatile_file(inode))
+               return 0;
+
        set_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE);
 
        return f2fs_convert_inline_inode(inode);
 }
 
+static int f2fs_ioc_release_volatile_write(struct file *filp)
+{
+       struct inode *inode = file_inode(filp);
+
+       if (!inode_owner_or_capable(inode))
+               return -EACCES;
+
+       if (!f2fs_is_volatile_file(inode))
+               return 0;
+
+       punch_hole(inode, 0, F2FS_BLKSIZE);
+       return 0;
+}
+
+static int f2fs_ioc_abort_volatile_write(struct file *filp)
+{
+       struct inode *inode = file_inode(filp);
+       int ret;
+
+       if (!inode_owner_or_capable(inode))
+               return -EACCES;
+
+       ret = mnt_want_write_file(filp);
+       if (ret)
+               return ret;
+
+       f2fs_balance_fs(F2FS_I_SB(inode));
+
+       if (f2fs_is_atomic_file(inode)) {
+               commit_inmem_pages(inode, false);
+               clear_inode_flag(F2FS_I(inode), FI_ATOMIC_FILE);
+       }
+
+       if (f2fs_is_volatile_file(inode)) {
+               clear_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE);
+               filemap_fdatawrite(inode->i_mapping);
+               set_inode_flag(F2FS_I(inode), FI_VOLATILE_FILE);
+       }
+       mnt_drop_write_file(filp);
+       return ret;
+}
+
 static int f2fs_ioc_fitrim(struct file *filp, unsigned long arg)
 {
        struct inode *inode = file_inode(filp);
@@ -1007,6 +1060,10 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
                return f2fs_ioc_commit_atomic_write(filp);
        case F2FS_IOC_START_VOLATILE_WRITE:
                return f2fs_ioc_start_volatile_write(filp);
+       case F2FS_IOC_RELEASE_VOLATILE_WRITE:
+               return f2fs_ioc_release_volatile_write(filp);
+       case F2FS_IOC_ABORT_VOLATILE_WRITE:
+               return f2fs_ioc_abort_volatile_write(filp);
        case FITRIM:
                return f2fs_ioc_fitrim(filp, arg);
        default:

diff --git a/fs/f2fs/inode.c b/fs/f2fs/inode.c
index 196cc7843aaff5f7073e1f5d7d7934a61eea8d67..3a8958d1684f3952268053b5e4b87b303d33cec2 100644 (file)
--- a/fs/f2fs/inode.c
+++ b/fs/f2fs/inode.c
@@ -304,7 +304,7 @@ void f2fs_evict_inode(struct inode *inode)
        nid_t xnid = F2FS_I(inode)->i_xattr_nid;
 
        /* some remained atomic pages should discarded */
-       if (f2fs_is_atomic_file(inode) || f2fs_is_volatile_file(inode))
+       if (f2fs_is_atomic_file(inode))
                commit_inmem_pages(inode, true);
 
        trace_f2fs_evict_inode(inode);

diff --git a/fs/f2fs/node.c b/fs/f2fs/node.c
index d6f073edd8616eca1d03b95ac42a6cf6dfe99f4e..cabecee88377fefed9dc3ffa3302121d123a9375 100644 (file)
--- a/fs/f2fs/node.c
+++ b/fs/f2fs/node.c
@@ -61,6 +61,9 @@ bool available_free_memory(struct f2fs_sb_info *sbi, int type)
                        mem_size += (sbi->im[i].ino_num *
                                sizeof(struct ino_entry)) >> PAGE_CACHE_SHIFT;
                res = mem_size < ((avail_ram * nm_i->ram_thresh / 100) >> 1);
+       } else {
+               if (sbi->sb->s_bdi->dirty_exceeded)
+                       return false;
        }
        return res;
 }

diff --git a/fs/f2fs/node.h b/fs/f2fs/node.h
index d10b6448a671fc961a5c8fc121dee4a02d0cd37a..036b887176ff0d016cf4b60923373d093d3628cb 100644 (file)
--- a/fs/f2fs/node.h
+++ b/fs/f2fs/node.h
@@ -108,6 +108,7 @@ enum mem_type {
        NAT_ENTRIES,    /* indicates the cached nat entry */
        DIRTY_DENTS,    /* indicates dirty dentry pages */
        INO_ENTRIES,    /* indicates inode entries */
+       BASE_CHECK,     /* check kernel status */
 };
 
 struct nat_entry_set {

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 3ce86c533604a6be9aa033b27f09f299fdc2bdc2..de9c0700c88e80a9baf64703792113dd2f50b2c9 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -230,7 +230,7 @@ void commit_inmem_pages(struct inode *inode, bool abort)
        bool submit_bio = false;
        struct f2fs_io_info fio = {
                .type = DATA,
-               .rw = WRITE_SYNC,
+               .rw = WRITE_SYNC | REQ_PRIO,
        };
 
        /*