f2fs: kill volatile write support

There's no user, since all can use atomic writes simply.
Let's kill it.

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

diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c
index beceac9885c3e60b9684f1bc5442f8999db36f90..63ab8c9d674e6d5fe679141b3a8a79cfa47aeb3e 100644 (file)
--- a/fs/f2fs/checkpoint.c
+++ b/fs/f2fs/checkpoint.c
@@ -1004,9 +1004,7 @@ static void __add_dirty_inode(struct inode *inode, enum inode_type type)
                return;
 
        set_inode_flag(inode, flag);
-       if (!f2fs_is_volatile_file(inode))
-               list_add_tail(&F2FS_I(inode)->dirty_list,
-                                               &sbi->inode_list[type]);
+       list_add_tail(&F2FS_I(inode)->dirty_list, &sbi->inode_list[type]);
        stat_inc_dirty_inode(sbi, type);
 }
 

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 8763a4690aaf6eb62021f9bd449694827167965f..54a7a8ad994d114e784a4b4903f408f0761779ef 100644 (file)
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -2741,11 +2741,6 @@ int f2fs_write_single_data_page(struct page *page, int *submitted,
 write:
        if (f2fs_is_drop_cache(inode))
                goto out;
-       /* we should not write 0'th page having journal header */
-       if (f2fs_is_volatile_file(inode) && (!page->index ||
-                       (!wbc->for_reclaim &&
-                       f2fs_available_free_memory(sbi, BASE_CHECK))))
-               goto redirty_out;
 
        /* Dentry/quota blocks are controlled by checkpoint */
        if (S_ISDIR(inode->i_mode) || IS_NOQUOTA(inode)) {

diff --git a/fs/f2fs/debug.c b/fs/f2fs/debug.c
index 65f0bcf498bb386f98e68b22d22c355993d261df..c92625ef16d0bf000949910d80389364514094b3 100644 (file)
--- a/fs/f2fs/debug.c
+++ b/fs/f2fs/debug.c
@@ -92,9 +92,7 @@ static void update_general_status(struct f2fs_sb_info *sbi)
        si->nquota_files = sbi->nquota_files;
        si->ndirty_all = sbi->ndirty_inode[DIRTY_META];
        si->aw_cnt = sbi->atomic_files;
-       si->vw_cnt = atomic_read(&sbi->vw_cnt);
        si->max_aw_cnt = atomic_read(&sbi->max_aw_cnt);
-       si->max_vw_cnt = atomic_read(&sbi->max_vw_cnt);
        si->nr_dio_read = get_pages(sbi, F2FS_DIO_READ);
        si->nr_dio_write = get_pages(sbi, F2FS_DIO_WRITE);
        si->nr_wb_cp_data = get_pages(sbi, F2FS_WB_CP_DATA);
@@ -511,10 +509,8 @@ static int stat_show(struct seq_file *s, void *v)
                           si->flush_list_empty,
                           si->nr_discarding, si->nr_discarded,
                           si->nr_discard_cmd, si->undiscard_blks);
-               seq_printf(s, "  - atomic IO: %4d (Max. %4d), "
-                       "volatile IO: %4d (Max. %4d)\n",
-                          si->aw_cnt, si->max_aw_cnt,
-                          si->vw_cnt, si->max_vw_cnt);
+               seq_printf(s, "  - atomic IO: %4d (Max. %4d)\n",
+                          si->aw_cnt, si->max_aw_cnt);
                seq_printf(s, "  - compress: %4d, hit:%8d\n", si->compress_pages, si->compress_page_hit);
                seq_printf(s, "  - nodes: %4d in %4d\n",
                           si->ndirty_node, si->node_pages);
@@ -615,9 +611,7 @@ int f2fs_build_stats(struct f2fs_sb_info *sbi)
        for (i = META_CP; i < META_MAX; i++)
                atomic_set(&sbi->meta_count[i], 0);
 
-       atomic_set(&sbi->vw_cnt, 0);
        atomic_set(&sbi->max_aw_cnt, 0);
-       atomic_set(&sbi->max_vw_cnt, 0);
 
        raw_spin_lock_irqsave(&f2fs_stat_lock, flags);
        list_add_tail(&si->stat_list, &f2fs_stat_list);

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 68d299b5482064e52390335b167cd8eb4931e84c..0699d7460d5dfe3313c011d9321300b08920a55e 100644 (file)
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -737,7 +737,6 @@ enum {
        FI_UPDATE_WRITE,        /* inode has in-place-update data */
        FI_NEED_IPU,            /* used for ipu per file */
        FI_ATOMIC_FILE,         /* indicate atomic file */
-       FI_VOLATILE_FILE,       /* indicate volatile file */
        FI_FIRST_BLOCK_WRITTEN, /* indicate #0 data block was written */
        FI_DROP_CACHE,          /* drop dirty page cache */
        FI_DATA_EXIST,          /* indicate data exists */
@@ -1738,9 +1737,7 @@ struct f2fs_sb_info {
        atomic_t inline_dir;                    /* # of inline_dentry inodes */
        atomic_t compr_inode;                   /* # of compressed inodes */
        atomic64_t compr_blocks;                /* # of compressed blocks */
-       atomic_t vw_cnt;                        /* # of volatile writes */
        atomic_t max_aw_cnt;                    /* max # of atomic writes */
-       atomic_t max_vw_cnt;                    /* max # of volatile writes */
        unsigned int io_skip_bggc;              /* skip background gc for in-flight IO */
        unsigned int other_skip_bggc;           /* skip background gc for other reasons */
        unsigned int ndirty_inode[NR_INODE_TYPE];       /* # of dirty inodes */
@@ -3191,11 +3188,6 @@ static inline bool f2fs_is_atomic_file(struct inode *inode)
        return is_inode_flag_set(inode, FI_ATOMIC_FILE);
 }
 
-static inline bool f2fs_is_volatile_file(struct inode *inode)
-{
-       return is_inode_flag_set(inode, FI_VOLATILE_FILE);
-}
-
 static inline bool f2fs_is_first_block_written(struct inode *inode)
 {
        return is_inode_flag_set(inode, FI_FIRST_BLOCK_WRITTEN);
@@ -3815,7 +3807,7 @@ struct f2fs_stat_info {
        int inline_xattr, inline_inode, inline_dir, append, update, orphans;
        int compr_inode;
        unsigned long long compr_blocks;
-       int aw_cnt, max_aw_cnt, vw_cnt, max_vw_cnt;
+       int aw_cnt, max_aw_cnt;
        unsigned int valid_count, valid_node_count, valid_inode_count, discard_blks;
        unsigned int bimodal, avg_vblocks;
        int util_free, util_valid, util_invalid;
@@ -3926,17 +3918,6 @@ static inline struct f2fs_stat_info *F2FS_STAT(struct f2fs_sb_info *sbi)
                if (cur > max)                                          \
                        atomic_set(&F2FS_I_SB(inode)->max_aw_cnt, cur); \
        } while (0)
-#define stat_inc_volatile_write(inode)                                 \
-               (atomic_inc(&F2FS_I_SB(inode)->vw_cnt))
-#define stat_dec_volatile_write(inode)                                 \
-               (atomic_dec(&F2FS_I_SB(inode)->vw_cnt))
-#define stat_update_max_volatile_write(inode)                          \
-       do {                                                            \
-               int cur = atomic_read(&F2FS_I_SB(inode)->vw_cnt);       \
-               int max = atomic_read(&F2FS_I_SB(inode)->max_vw_cnt);   \
-               if (cur > max)                                          \
-                       atomic_set(&F2FS_I_SB(inode)->max_vw_cnt, cur); \
-       } while (0)
 #define stat_inc_seg_count(sbi, type, gc_type)                         \
        do {                                                            \
                struct f2fs_stat_info *si = F2FS_STAT(sbi);             \
@@ -3998,9 +3979,6 @@ void f2fs_update_sit_info(struct f2fs_sb_info *sbi);
 #define stat_add_compr_blocks(inode, blocks)           do { } while (0)
 #define stat_sub_compr_blocks(inode, blocks)           do { } while (0)
 #define stat_update_max_atomic_write(inode)            do { } while (0)
-#define stat_inc_volatile_write(inode)                 do { } while (0)
-#define stat_dec_volatile_write(inode)                 do { } while (0)
-#define stat_update_max_volatile_write(inode)          do { } while (0)
 #define stat_inc_meta_count(sbi, blkaddr)              do { } while (0)
 #define stat_inc_seg_type(sbi, curseg)                 do { } while (0)
 #define stat_inc_block_count(sbi, curseg)              do { } while (0)
@@ -4403,8 +4381,7 @@ static inline bool f2fs_lfs_mode(struct f2fs_sb_info *sbi)
 static inline bool f2fs_may_compress(struct inode *inode)
 {
        if (IS_SWAPFILE(inode) || f2fs_is_pinned_file(inode) ||
-                               f2fs_is_atomic_file(inode) ||
-                               f2fs_is_volatile_file(inode))
+                               f2fs_is_atomic_file(inode))
                return false;
        return S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode);
 }

diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 7e5ec0c48b2a9f757c927d21c7dd28fa3290d2a9..6da8a663de7b7fcdbfcaafc9beec431fb37a5960 100644 (file)
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -1815,13 +1815,6 @@ static int f2fs_release_file(struct inode *inode, struct file *filp)
 
        if (f2fs_is_atomic_file(inode))
                f2fs_abort_atomic_write(inode, true);
-       if (f2fs_is_volatile_file(inode)) {
-               set_inode_flag(inode, FI_DROP_CACHE);
-               filemap_fdatawrite(inode->i_mapping);
-               clear_inode_flag(inode, FI_DROP_CACHE);
-               clear_inode_flag(inode, FI_VOLATILE_FILE);
-               stat_dec_volatile_write(inode);
-       }
        return 0;
 }
 
@@ -2096,15 +2089,10 @@ static int f2fs_ioc_commit_atomic_write(struct file *filp)
 
        inode_lock(inode);
 
-       if (f2fs_is_volatile_file(inode)) {
-               ret = -EINVAL;
-               goto err_out;
-       }
-
        if (f2fs_is_atomic_file(inode)) {
                ret = f2fs_commit_atomic_write(inode);
                if (ret)
-                       goto err_out;
+                       goto unlock_out;
 
                ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
                if (!ret)
@@ -2112,108 +2100,12 @@ static int f2fs_ioc_commit_atomic_write(struct file *filp)
        } else {
                ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 1, false);
        }
-err_out:
+unlock_out:
        inode_unlock(inode);
        mnt_drop_write_file(filp);
        return ret;
 }
 
-static int f2fs_ioc_start_volatile_write(struct file *filp)
-{
-       struct inode *inode = file_inode(filp);
-       struct user_namespace *mnt_userns = file_mnt_user_ns(filp);
-       int ret;
-
-       if (!inode_owner_or_capable(mnt_userns, inode))
-               return -EACCES;
-
-       if (!S_ISREG(inode->i_mode))
-               return -EINVAL;
-
-       ret = mnt_want_write_file(filp);
-       if (ret)
-               return ret;
-
-       inode_lock(inode);
-
-       if (f2fs_is_volatile_file(inode))
-               goto out;
-
-       ret = f2fs_convert_inline_inode(inode);
-       if (ret)
-               goto out;
-
-       stat_inc_volatile_write(inode);
-       stat_update_max_volatile_write(inode);
-
-       set_inode_flag(inode, FI_VOLATILE_FILE);
-       f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
-out:
-       inode_unlock(inode);
-       mnt_drop_write_file(filp);
-       return ret;
-}
-
-static int f2fs_ioc_release_volatile_write(struct file *filp)
-{
-       struct inode *inode = file_inode(filp);
-       struct user_namespace *mnt_userns = file_mnt_user_ns(filp);
-       int ret;
-
-       if (!inode_owner_or_capable(mnt_userns, inode))
-               return -EACCES;
-
-       ret = mnt_want_write_file(filp);
-       if (ret)
-               return ret;
-
-       inode_lock(inode);
-
-       if (!f2fs_is_volatile_file(inode))
-               goto out;
-
-       if (!f2fs_is_first_block_written(inode)) {
-               ret = truncate_partial_data_page(inode, 0, true);
-               goto out;
-       }
-
-       ret = punch_hole(inode, 0, F2FS_BLKSIZE);
-out:
-       inode_unlock(inode);
-       mnt_drop_write_file(filp);
-       return ret;
-}
-
-static int f2fs_ioc_abort_volatile_write(struct file *filp)
-{
-       struct inode *inode = file_inode(filp);
-       struct user_namespace *mnt_userns = file_mnt_user_ns(filp);
-       int ret;
-
-       if (!inode_owner_or_capable(mnt_userns, inode))
-               return -EACCES;
-
-       ret = mnt_want_write_file(filp);
-       if (ret)
-               return ret;
-
-       inode_lock(inode);
-
-       if (f2fs_is_atomic_file(inode))
-               f2fs_abort_atomic_write(inode, true);
-       if (f2fs_is_volatile_file(inode)) {
-               clear_inode_flag(inode, FI_VOLATILE_FILE);
-               stat_dec_volatile_write(inode);
-               ret = f2fs_do_sync_file(filp, 0, LLONG_MAX, 0, true);
-       }
-
-       inode_unlock(inode);
-
-       mnt_drop_write_file(filp);
-       f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);
-       return ret;
-}
-
 static int f2fs_ioc_shutdown(struct file *filp, unsigned long arg)
 {
        struct inode *inode = file_inode(filp);
@@ -4151,11 +4043,9 @@ static long __f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
        case F2FS_IOC_COMMIT_ATOMIC_WRITE:
                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);
+               return -EOPNOTSUPP;
        case F2FS_IOC_SHUTDOWN:
                return f2fs_ioc_shutdown(filp, arg);
        case FITRIM:

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index c0d7118fe171dc33c89c1f96fc5c76bbea36a1eb..47934995e2ca6288af0b40fc89a905a3999c5520 100644 (file)
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -3166,8 +3166,7 @@ static int __get_segment_type_6(struct f2fs_io_info *fio)
                        return CURSEG_COLD_DATA;
                if (file_is_hot(inode) ||
                                is_inode_flag_set(inode, FI_HOT_DATA) ||
-                               f2fs_is_atomic_file(inode) ||
-                               f2fs_is_volatile_file(inode))
+                               f2fs_is_atomic_file(inode))
                        return CURSEG_HOT_DATA;
                return f2fs_rw_hint_to_seg_type(inode->i_write_hint);
        } else {

diff --git a/fs/f2fs/verity.c b/fs/f2fs/verity.c
index 3d793202cc9fef30ffa4778ab5ebb9f27c52c35e..5ac7e756a1bb39cb1598b304024826829edd9528 100644 (file)
--- a/fs/f2fs/verity.c
+++ b/fs/f2fs/verity.c
@@ -128,7 +128,7 @@ static int f2fs_begin_enable_verity(struct file *filp)
        if (f2fs_verity_in_progress(inode))
                return -EBUSY;
 
-       if (f2fs_is_atomic_file(inode) || f2fs_is_volatile_file(inode))
+       if (f2fs_is_atomic_file(inode))
                return -EOPNOTSUPP;
 
        /*