Commit 7bc155fe authored by Jaegeuk Kim's avatar Jaegeuk Kim
Browse files

f2fs: kill volatile write support 



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

Signed-off-by: default avatarJaegeuk Kim <jaegeuk@kernel.org>
parent 3db1de0e

fs/f2fs/checkpoint.c

+1 −3
Original line number Diff line number Diff line
@@ -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);

}

fs/f2fs/data.c

+0 −5
Original line number Diff line number Diff line
@@ -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)) {

fs/f2fs/debug.c

+2 −8
Original line number Diff line number Diff line
@@ -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);

fs/f2fs/f2fs.h

+2 −25
Original line number Diff line number Diff line
@@ -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);

}

fs/f2fs/file.c

+3 −113
Original line number Diff line number Diff line
@@ -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:

	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:

unlock_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: