Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ed1311e5 authored by Jaegeuk Kim's avatar Jaegeuk Kim
Browse files

f2fs: add an ioctl to disable GC for specific file 



This patch gives a flag to disable GC on given file, which would be useful, when
user wants to keep its block map. It also conducts in-place-update for dontmove
file.

Reviewed-by: default avatarChao Yu <yuchao0@huawei.com>
Signed-off-by: default avatarJaegeuk Kim <jaegeuk@kernel.org>
parent b08974ab

fs/f2fs/data.c

+2 −0
Original line number Diff line number Diff line
@@ -1479,6 +1479,8 @@ static inline bool need_inplace_update(struct f2fs_io_info *fio) 
{

	struct inode *inode = fio->page->mapping->host;



	if (f2fs_is_pinned_file(inode))

		return true;

	if (S_ISDIR(inode->i_mode) || f2fs_is_atomic_file(inode))

		return false;

	if (is_cold_data(fio->page))

fs/f2fs/f2fs.h

+28 −1
Original line number Diff line number Diff line
@@ -356,6 +356,8 @@ static inline bool __has_cursum_space(struct f2fs_journal *journal, 
#define F2FS_IOC_GARBAGE_COLLECT_RANGE	_IOW(F2FS_IOCTL_MAGIC, 11,	\

						struct f2fs_gc_range)

#define F2FS_IOC_GET_FEATURES		_IOR(F2FS_IOCTL_MAGIC, 12, __u32)

#define F2FS_IOC_SET_PIN_FILE		_IOW(F2FS_IOCTL_MAGIC, 13, __u32)

#define F2FS_IOC_GET_PIN_FILE		_IOR(F2FS_IOCTL_MAGIC, 14, __u32)



#define F2FS_IOC_SET_ENCRYPTION_POLICY	FS_IOC_SET_ENCRYPTION_POLICY

#define F2FS_IOC_GET_ENCRYPTION_POLICY	FS_IOC_GET_ENCRYPTION_POLICY
@@ -593,7 +595,10 @@ struct f2fs_inode_info { 
	unsigned long i_flags;		/* keep an inode flags for ioctl */

	unsigned char i_advise;		/* use to give file attribute hints */

	unsigned char i_dir_level;	/* use for dentry level for large dir */

	unsigned int i_current_depth;	/* use only in directory structure */

	union {

		unsigned int i_current_depth;	/* only for directory depth */

		unsigned short i_gc_failures;	/* only for regular file */

	};

	unsigned int i_pino;		/* parent inode number */

	umode_t i_acl_mode;		/* keep file acl mode temporarily */
@@ -1142,6 +1147,9 @@ struct f2fs_sb_info { 
	/* threshold for converting bg victims for fg */

	u64 fggc_threshold;



	/* threshold for gc trials on pinned files */

	u64 gc_pin_file_threshold;



	/* maximum # of trials to find a victim segment for SSR and GC */

	unsigned int max_victim_search;
@@ -2141,6 +2149,7 @@ enum { 
	FI_HOT_DATA,		/* indicate file is hot */

	FI_EXTRA_ATTR,		/* indicate file has extra attribute */

	FI_PROJ_INHERIT,	/* indicate file inherits projectid */

	FI_PIN_FILE,		/* indicate file should not be gced */

};



static inline void __mark_inode_dirty_flag(struct inode *inode,
@@ -2155,6 +2164,7 @@ static inline void __mark_inode_dirty_flag(struct inode *inode, 
			return;

	case FI_DATA_EXIST:

	case FI_INLINE_DOTS:

	case FI_PIN_FILE:

		f2fs_mark_inode_dirty_sync(inode, true);

	}

}
@@ -2235,6 +2245,13 @@ static inline void f2fs_i_depth_write(struct inode *inode, unsigned int depth) 
	f2fs_mark_inode_dirty_sync(inode, true);

}



static inline void f2fs_i_gc_failures_write(struct inode *inode,

					unsigned int count)

{

	F2FS_I(inode)->i_gc_failures = count;

	f2fs_mark_inode_dirty_sync(inode, true);

}



static inline void f2fs_i_xnid_write(struct inode *inode, nid_t xnid)

{

	F2FS_I(inode)->i_xattr_nid = xnid;
@@ -2263,6 +2280,8 @@ static inline void get_inline_info(struct inode *inode, struct f2fs_inode *ri) 
		set_bit(FI_INLINE_DOTS, &fi->flags);

	if (ri->i_inline & F2FS_EXTRA_ATTR)

		set_bit(FI_EXTRA_ATTR, &fi->flags);

	if (ri->i_inline & F2FS_PIN_FILE)

		set_bit(FI_PIN_FILE, &fi->flags);

}



static inline void set_raw_inline(struct inode *inode, struct f2fs_inode *ri)
@@ -2281,6 +2300,8 @@ static inline void set_raw_inline(struct inode *inode, struct f2fs_inode *ri) 
		ri->i_inline |= F2FS_INLINE_DOTS;

	if (is_inode_flag_set(inode, FI_EXTRA_ATTR))

		ri->i_inline |= F2FS_EXTRA_ATTR;

	if (is_inode_flag_set(inode, FI_PIN_FILE))

		ri->i_inline |= F2FS_PIN_FILE;

}



static inline int f2fs_has_extra_attr(struct inode *inode)
@@ -2326,6 +2347,11 @@ static inline int f2fs_has_inline_dots(struct inode *inode) 
	return is_inode_flag_set(inode, FI_INLINE_DOTS);

}



static inline bool f2fs_is_pinned_file(struct inode *inode)

{

	return is_inode_flag_set(inode, FI_PIN_FILE);

}



static inline bool f2fs_is_atomic_file(struct inode *inode)

{

	return is_inode_flag_set(inode, FI_ATOMIC_FILE);
@@ -2540,6 +2566,7 @@ int truncate_hole(struct inode *inode, pgoff_t pg_start, pgoff_t pg_end); 
void truncate_data_blocks_range(struct dnode_of_data *dn, int count);

long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg);

long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg);

int f2fs_pin_file_control(struct inode *inode, bool inc);



/*

 * inode.c

fs/f2fs/file.c

+83 −0
Original line number Diff line number Diff line
@@ -2671,6 +2671,83 @@ static int f2fs_ioc_fssetxattr(struct file *filp, unsigned long arg) 
	return 0;

}



int f2fs_pin_file_control(struct inode *inode, bool inc)

{

	struct f2fs_inode_info *fi = F2FS_I(inode);

	struct f2fs_sb_info *sbi = F2FS_I_SB(inode);



	/* Use i_gc_failures for normal file as a risk signal. */

	if (inc)

		f2fs_i_gc_failures_write(inode, fi->i_gc_failures + 1);



	if (fi->i_gc_failures > sbi->gc_pin_file_threshold) {

		f2fs_msg(sbi->sb, KERN_WARNING,

			"%s: Enable GC = ino %lx after %x GC trials\n",

			__func__, inode->i_ino, fi->i_gc_failures);

		clear_inode_flag(inode, FI_PIN_FILE);

		return -EAGAIN;

	}

	return 0;

}



static int f2fs_ioc_set_pin_file(struct file *filp, unsigned long arg)

{

	struct inode *inode = file_inode(filp);

	__u32 pin;

	int ret = 0;



	if (!inode_owner_or_capable(inode))

		return -EACCES;



	if (get_user(pin, (__u32 __user *)arg))

		return -EFAULT;



	if (!S_ISREG(inode->i_mode))

		return -EINVAL;



	if (f2fs_readonly(F2FS_I_SB(inode)->sb))

		return -EROFS;



	ret = mnt_want_write_file(filp);

	if (ret)

		return ret;



	inode_lock(inode);



	if (!pin) {

		clear_inode_flag(inode, FI_PIN_FILE);

		F2FS_I(inode)->i_gc_failures = 1;

		goto done;

	}



	if (f2fs_pin_file_control(inode, false)) {

		ret = -EAGAIN;

		goto out;

	}

	ret = f2fs_convert_inline_inode(inode);

	if (ret)

		goto out;



	set_inode_flag(inode, FI_PIN_FILE);

	ret = F2FS_I(inode)->i_gc_failures;

done:

	f2fs_update_time(F2FS_I_SB(inode), REQ_TIME);

out:

	inode_unlock(inode);

	mnt_drop_write_file(filp);

	return ret;

}



static int f2fs_ioc_get_pin_file(struct file *filp, unsigned long arg)

{

	struct inode *inode = file_inode(filp);

	__u32 pin = 0;



	if (is_inode_flag_set(inode, FI_PIN_FILE))

		pin = F2FS_I(inode)->i_gc_failures;

	return put_user(pin, (u32 __user *)arg);

}



long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)

{

	if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp)))))
@@ -2721,6 +2798,10 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg) 
		return f2fs_ioc_fsgetxattr(filp, arg);

	case F2FS_IOC_FSSETXATTR:

		return f2fs_ioc_fssetxattr(filp, arg);

	case F2FS_IOC_GET_PIN_FILE:

		return f2fs_ioc_get_pin_file(filp, arg);

	case F2FS_IOC_SET_PIN_FILE:

		return f2fs_ioc_set_pin_file(filp, arg);

	default:

		return -ENOTTY;

	}
@@ -2796,6 +2877,8 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg) 
	case F2FS_IOC_GET_FEATURES:

	case F2FS_IOC_FSGETXATTR:

	case F2FS_IOC_FSSETXATTR:

	case F2FS_IOC_GET_PIN_FILE:

	case F2FS_IOC_SET_PIN_FILE:

		break;

	default:

		return -ENOIOCTLCMD;

fs/f2fs/gc.c

+11 −0
Original line number Diff line number Diff line
@@ -624,6 +624,11 @@ static void move_data_block(struct inode *inode, block_t bidx, 
	if (f2fs_is_atomic_file(inode))

		goto out;



	if (f2fs_is_pinned_file(inode)) {

		f2fs_pin_file_control(inode, true);

		goto out;

	}



	set_new_dnode(&dn, inode, NULL, NULL, 0);

	err = get_dnode_of_data(&dn, bidx, LOOKUP_NODE);

	if (err)
@@ -720,6 +725,11 @@ static void move_data_page(struct inode *inode, block_t bidx, int gc_type, 


	if (f2fs_is_atomic_file(inode))

		goto out;

	if (f2fs_is_pinned_file(inode)) {

		if (gc_type == FG_GC)

			f2fs_pin_file_control(inode, true);

		goto out;

	}



	if (gc_type == BG_GC) {

		if (PageWriteback(page))
@@ -1091,6 +1101,7 @@ void build_gc_manager(struct f2fs_sb_info *sbi) 


	sbi->fggc_threshold = div64_u64((main_count - ovp_count) *

				BLKS_PER_SEC(sbi), (main_count - resv_count));

	sbi->gc_pin_file_threshold = DEF_GC_FAILED_PINNED_FILES;



	/* give warm/cold data area from slower device */

	if (sbi->s_ndevs && sbi->segs_per_sec == 1)

fs/f2fs/gc.h

+2 −0
Original line number Diff line number Diff line
@@ -20,6 +20,8 @@ 
#define LIMIT_INVALID_BLOCK	40 /* percentage over total user space */

#define LIMIT_FREE_BLOCK	40 /* percentage over invalid + free space */



#define DEF_GC_FAILED_PINNED_FILES	2048



/* Search max. number of dirty segments to select a victim segment */

#define DEF_MAX_VICTIM_SEARCH 4096 /* covers 8GB */