[PATCH 1/4] f2fs: support F2FS_IOC_PRECACHE_EXTENTS

[PATCH 1/4] f2fs: support F2FS_IOC_PRECACHE_EXTENTS

[Chao Yu]

This patch introduces a new ioctl F2FS_IOC_PRECACHE_EXTENTS to precache
extent info, in order to gain better performance during data/meta
accessing.

Signed-off-by: Chao Yu <yuchao0@huawei.com>
---
 fs/f2fs/data.c | 27 +++++++++++++++++++++++++++
 fs/f2fs/f2fs.h |  2 ++
 fs/f2fs/file.c | 35 +++++++++++++++++++++++++++++++++++
 3 files changed, 64 insertions(+)

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index 429764118604..f38e660bc889 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -920,6 +920,7 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
 	blkcnt_t prealloc;
 	struct extent_info ei = {0,0,0};
 	block_t blkaddr;
+	unsigned int start_pgofs;
 
 	if (!maxblocks)
 		return 0;
@@ -935,6 +936,8 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
 		map->m_pblk = ei.blk + pgofs - ei.fofs;
 		map->m_len = min((pgoff_t)maxblocks, ei.fofs + ei.len - pgofs);
 		map->m_flags = F2FS_MAP_MAPPED;
+		if (map->m_next_pgofs)
+			*map->m_next_pgofs = pgofs + map->m_len;
 		goto out;
 	}
 
@@ -957,6 +960,7 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
 		goto unlock_out;
 	}
 
+	start_pgofs = pgofs;
 	prealloc = 0;
 	last_ofs_in_node = ofs_in_node = dn.ofs_in_node;
 	end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
@@ -990,6 +994,8 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
 				map->m_pblk = 0;
 				goto sync_out;
 			}
+			if (flag == F2FS_GET_BLOCK_PRECACHE)
+				goto sync_out;
 			if (flag == F2FS_GET_BLOCK_FIEMAP &&
 						blkaddr == NULL_ADDR) {
 				if (map->m_next_pgofs)
@@ -1048,6 +1054,16 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
 	else if (dn.ofs_in_node < end_offset)
 		goto next_block;
 
+	if (flag == F2FS_GET_BLOCK_PRECACHE) {
+		if (map->m_flags & F2FS_MAP_MAPPED) {
+			unsigned int ofs = start_pgofs - map->m_lblk;
+
+			f2fs_update_extent_cache_range(&dn,
+				start_pgofs, map->m_pblk + ofs,
+				map->m_len - ofs);
+		}
+	}
+
 	f2fs_put_dnode(&dn);
 
 	if (create) {
@@ -1057,6 +1073,17 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
 	goto next_dnode;
 
 sync_out:
+	if (flag == F2FS_GET_BLOCK_PRECACHE) {
+		if (map->m_flags & F2FS_MAP_MAPPED) {
+			unsigned int ofs = start_pgofs - map->m_lblk;
+
+			f2fs_update_extent_cache_range(&dn,
+				start_pgofs, map->m_pblk + ofs,
+				map->m_len - ofs);
+		}
+		if (map->m_next_pgofs)
+			*map->m_next_pgofs = pgofs + 1;
+	}
 	f2fs_put_dnode(&dn);
 unlock_out:
 	if (create) {
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 2f097139b8f7..14177cebc3e7 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -353,6 +353,7 @@ static inline bool __has_cursum_space(struct f2fs_journal *journal,
 						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_PRECACHE_EXTENTS	_IO(F2FS_IOCTL_MAGIC, 14)
 
 #define F2FS_IOC_SET_ENCRYPTION_POLICY	FS_IOC_SET_ENCRYPTION_POLICY
 #define F2FS_IOC_GET_ENCRYPTION_POLICY	FS_IOC_GET_ENCRYPTION_POLICY
@@ -558,6 +559,7 @@ enum {
 	F2FS_GET_BLOCK_BMAP,
 	F2FS_GET_BLOCK_PRE_DIO,
 	F2FS_GET_BLOCK_PRE_AIO,
+	F2FS_GET_BLOCK_PRECACHE,
 };
 
 /*
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index e4078b32856c..14e75871acf3 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -2734,6 +2734,38 @@ static int f2fs_ioc_set_pin_file(struct file *filp, unsigned long arg)
 	return ret;
 }
 
+static int f2fs_ioc_precache_extents(struct file *filp, unsigned long arg)
+{
+	struct inode *inode = file_inode(filp);
+	struct f2fs_inode_info *fi = F2FS_I(inode);
+	struct f2fs_map_blocks map;
+	pgoff_t next_pgofs;
+	loff_t end;
+	int err;
+
+	if (is_inode_flag_set(inode, FI_NO_EXTENT))
+		return -EOPNOTSUPP;
+
+	map.m_lblk = 0;
+	map.m_next_pgofs = &next_pgofs;
+	map.m_seg_type = NO_CHECK_TYPE;
+	end = F2FS_I_SB(inode)->max_file_blocks;
+
+	while (map.m_lblk < end) {
+		map.m_len = end - map.m_lblk;
+
+		down_write(&fi->dio_rwsem[WRITE]);
+		err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_PRECACHE);
+		up_write(&fi->dio_rwsem[WRITE]);
+		if (err)
+			return err;
+
+		map.m_lblk = next_pgofs;
+	}
+
+	return 0;
+}
+
 long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 {
 	if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp)))))
@@ -2786,6 +2818,8 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 		return f2fs_ioc_fssetxattr(filp, arg);
 	case F2FS_IOC_SET_PIN_FILE:
 		return f2fs_ioc_set_pin_file(filp, arg);
+	case F2FS_IOC_PRECACHE_EXTENTS:
+		return f2fs_ioc_precache_extents(filp, arg);
 	default:
 		return -ENOTTY;
 	}
@@ -2862,6 +2896,7 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 	case F2FS_IOC_FSGETXATTR:
 	case F2FS_IOC_FSSETXATTR:
 	case F2FS_IOC_SET_PIN_FILE:
+	case F2FS_IOC_PRECACHE_EXTENTS:
 		break;
 	default:
 		return -ENOIOCTLCMD;
-- 
2.15.0.55.gc2ece9dc4de6

[PATCH 2/4] f2fs: support FIEMAP_FLAG_CACHE

[Chao Yu]

This patch factors out f2fs_precache_extents from
f2fs_ioc_precache_extents, with the new function we can support
FIEMAP_FLAG_CACHE in ->fiemap.

Signed-off-by: Chao Yu <yuchao0@huawei.com>
---
 fs/f2fs/data.c | 12 +++++++++---
 fs/f2fs/f2fs.h |  1 +
 fs/f2fs/file.c | 10 +++++++---
 3 files changed, 17 insertions(+), 6 deletions(-)

diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
index f38e660bc889..33ae1bd14a8e 100644
--- a/fs/f2fs/data.c
+++ b/fs/f2fs/data.c
@@ -1228,11 +1228,17 @@ int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
 	u32 flags = 0;
 	int ret = 0;
 
+	inode_lock(inode);
+
+	if (fieinfo->fi_flags & FIEMAP_FLAG_CACHE) {
+		ret = f2fs_precache_extents(inode);
+		if (ret)
+			goto out;
+	}
+
 	ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC | FIEMAP_FLAG_XATTR);
 	if (ret)
-		return ret;
-
-	inode_lock(inode);
+		goto out;
 
 	if (fieinfo->fi_flags & FIEMAP_FLAG_XATTR) {
 		ret = f2fs_xattr_fiemap(inode, fieinfo);
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 14177cebc3e7..3c3a055c3d4a 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -2543,6 +2543,7 @@ int f2fs_getattr(const struct path *path, struct kstat *stat,
 int f2fs_setattr(struct dentry *dentry, struct iattr *attr);
 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);
+int f2fs_precache_extents(struct inode *inode);
 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);
diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
index 14e75871acf3..6e30016f26ad 100644
--- a/fs/f2fs/file.c
+++ b/fs/f2fs/file.c
@@ -2734,9 +2734,8 @@ static int f2fs_ioc_set_pin_file(struct file *filp, unsigned long arg)
 	return ret;
 }
 
-static int f2fs_ioc_precache_extents(struct file *filp, unsigned long arg)
+int f2fs_precache_extents(struct inode *inode)
 {
-	struct inode *inode = file_inode(filp);
 	struct f2fs_inode_info *fi = F2FS_I(inode);
 	struct f2fs_map_blocks map;
 	pgoff_t next_pgofs;
@@ -2763,7 +2762,12 @@ static int f2fs_ioc_precache_extents(struct file *filp, unsigned long arg)
 		map.m_lblk = next_pgofs;
 	}
 
-	return 0;
+	return err;
+}
+
+static int f2fs_ioc_precache_extents(struct file *filp, unsigned long arg)
+{
+	return f2fs_precache_extents(file_inode(filp));
 }
 
 long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
-- 
2.15.0.55.gc2ece9dc4de6

Re: [PATCH 2/4] f2fs: support FIEMAP_FLAG_CACHE

[Jaegeuk Kim]

On 01/08, Chao Yu wrote:
> This patch factors out f2fs_precache_extents from
> f2fs_ioc_precache_extents, with the new function we can support
> FIEMAP_FLAG_CACHE in ->fiemap.
> 
> Signed-off-by: Chao Yu <yuchao0@huawei.com>
> ---
>  fs/f2fs/data.c | 12 +++++++++---
>  fs/f2fs/f2fs.h |  1 +
>  fs/f2fs/file.c | 10 +++++++---
>  3 files changed, 17 insertions(+), 6 deletions(-)
> 
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index f38e660bc889..33ae1bd14a8e 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -1228,11 +1228,17 @@ int f2fs_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
>  	u32 flags = 0;
>  	int ret = 0;
>  
> +	inode_lock(inode);
> +
> +	if (fieinfo->fi_flags & FIEMAP_FLAG_CACHE) {
> +		ret = f2fs_precache_extents(inode);
> +		if (ret)
> +			goto out;
> +	}

I think we have to integrate this patch into the previous one which defines
this new behavior.

Thanks,

> +
>  	ret = fiemap_check_flags(fieinfo, FIEMAP_FLAG_SYNC | FIEMAP_FLAG_XATTR);
>  	if (ret)
> -		return ret;
> -
> -	inode_lock(inode);
> +		goto out;
>  
>  	if (fieinfo->fi_flags & FIEMAP_FLAG_XATTR) {
>  		ret = f2fs_xattr_fiemap(inode, fieinfo);
> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
> index 14177cebc3e7..3c3a055c3d4a 100644
> --- a/fs/f2fs/f2fs.h
> +++ b/fs/f2fs/f2fs.h
> @@ -2543,6 +2543,7 @@ int f2fs_getattr(const struct path *path, struct kstat *stat,
>  int f2fs_setattr(struct dentry *dentry, struct iattr *attr);
>  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);
> +int f2fs_precache_extents(struct inode *inode);
>  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);
> diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
> index 14e75871acf3..6e30016f26ad 100644
> --- a/fs/f2fs/file.c
> +++ b/fs/f2fs/file.c
> @@ -2734,9 +2734,8 @@ static int f2fs_ioc_set_pin_file(struct file *filp, unsigned long arg)
>  	return ret;
>  }
>  
> -static int f2fs_ioc_precache_extents(struct file *filp, unsigned long arg)
> +int f2fs_precache_extents(struct inode *inode)
>  {
> -	struct inode *inode = file_inode(filp);
>  	struct f2fs_inode_info *fi = F2FS_I(inode);
>  	struct f2fs_map_blocks map;
>  	pgoff_t next_pgofs;
> @@ -2763,7 +2762,12 @@ static int f2fs_ioc_precache_extents(struct file *filp, unsigned long arg)
>  		map.m_lblk = next_pgofs;
>  	}
>  
> -	return 0;
> +	return err;
> +}
> +
> +static int f2fs_ioc_precache_extents(struct file *filp, unsigned long arg)
> +{
> +	return f2fs_precache_extents(file_inode(filp));
>  }
>  
>  long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
> -- 
> 2.15.0.55.gc2ece9dc4de6

[PATCH 3/4] f2fs: avoid high cpu usage in discard thread

[Chao Yu]

We take very long time to finish generic/476, this is because we will
check consistence of all discard entries in global rb tree while
traversing all different granularity pending lists, even when the list
is empty, in order to avoid that unneeded overhead, we have to skip
the check when coming up an empty list.

generic/476 time consumption:
					cost
Before patch & w/o consistence check	57s
Before patch & w/ consistence check	1426s
After patch				78s

Signed-off-by: Chao Yu <yuchao0@huawei.com>
---
 fs/f2fs/segment.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index f2842a8a1341..4a40ef1326a9 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -1204,6 +1204,8 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 		pend_list = &dcc->pend_list[i];
 
 		mutex_lock(&dcc->cmd_lock);
+		if (list_empty(pend_list))
+			goto next;
 		f2fs_bug_on(sbi, !__check_rb_tree_consistence(sbi, &dcc->root));
 		blk_start_plug(&plug);
 		list_for_each_entry_safe(dc, tmp, pend_list, list) {
@@ -1222,6 +1224,7 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
 				break;
 		}
 		blk_finish_plug(&plug);
+next:
 		mutex_unlock(&dcc->cmd_lock);
 
 		if (iter >= dpolicy->max_requests)
-- 
2.15.0.55.gc2ece9dc4de6

[PATCH 4/4] f2fs: remove unused pend_list_tag

[Chao Yu]

In commit 78997b569f56 ("f2fs: split discard policy"), we have get rid
of using pend_list_tag field in struct discard_cmd_control, but forgot
to remove it, now do it.

Signed-off-by: Chao Yu <yuchao0@huawei.com>
---
 fs/f2fs/f2fs.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 3c3a055c3d4a..b13ee958a539 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -269,7 +269,6 @@ struct discard_cmd_control {
 	struct task_struct *f2fs_issue_discard;	/* discard thread */
 	struct list_head entry_list;		/* 4KB discard entry list */
 	struct list_head pend_list[MAX_PLIST_NUM];/* store pending entries */
-	unsigned char pend_list_tag[MAX_PLIST_NUM];/* tag for pending entries */
 	struct list_head wait_list;		/* store on-flushing entries */
 	struct list_head fstrim_list;		/* in-flight discard from fstrim */
 	wait_queue_head_t discard_wait_queue;	/* waiting queue for wake-up */
-- 
2.15.0.55.gc2ece9dc4de6

Re: [PATCH 1/4] f2fs: support F2FS_IOC_PRECACHE_EXTENTS

[Jaegeuk Kim]

On 01/08, Chao Yu wrote:
> This patch introduces a new ioctl F2FS_IOC_PRECACHE_EXTENTS to precache
> extent info, in order to gain better performance during data/meta
> accessing.
> 
> Signed-off-by: Chao Yu <yuchao0@huawei.com>
> ---
>  fs/f2fs/data.c | 27 +++++++++++++++++++++++++++
>  fs/f2fs/f2fs.h |  2 ++
>  fs/f2fs/file.c | 35 +++++++++++++++++++++++++++++++++++
>  3 files changed, 64 insertions(+)
> 
> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> index 429764118604..f38e660bc889 100644
> --- a/fs/f2fs/data.c
> +++ b/fs/f2fs/data.c
> @@ -920,6 +920,7 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
>  	blkcnt_t prealloc;
>  	struct extent_info ei = {0,0,0};
>  	block_t blkaddr;
> +	unsigned int start_pgofs;
>  
>  	if (!maxblocks)
>  		return 0;
> @@ -935,6 +936,8 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
>  		map->m_pblk = ei.blk + pgofs - ei.fofs;
>  		map->m_len = min((pgoff_t)maxblocks, ei.fofs + ei.len - pgofs);
>  		map->m_flags = F2FS_MAP_MAPPED;
> +		if (map->m_next_pgofs)
> +			*map->m_next_pgofs = pgofs + map->m_len;
>  		goto out;
>  	}
>  
> @@ -957,6 +960,7 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
>  		goto unlock_out;
>  	}
>  
> +	start_pgofs = pgofs;
>  	prealloc = 0;
>  	last_ofs_in_node = ofs_in_node = dn.ofs_in_node;
>  	end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
> @@ -990,6 +994,8 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
>  				map->m_pblk = 0;
>  				goto sync_out;
>  			}
> +			if (flag == F2FS_GET_BLOCK_PRECACHE)
> +				goto sync_out;
>  			if (flag == F2FS_GET_BLOCK_FIEMAP &&
>  						blkaddr == NULL_ADDR) {
>  				if (map->m_next_pgofs)
> @@ -1048,6 +1054,16 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
>  	else if (dn.ofs_in_node < end_offset)
>  		goto next_block;
>  
> +	if (flag == F2FS_GET_BLOCK_PRECACHE) {
> +		if (map->m_flags & F2FS_MAP_MAPPED) {
> +			unsigned int ofs = start_pgofs - map->m_lblk;
> +
> +			f2fs_update_extent_cache_range(&dn,
> +				start_pgofs, map->m_pblk + ofs,
> +				map->m_len - ofs);
> +		}
> +	}
> +
>  	f2fs_put_dnode(&dn);
>  
>  	if (create) {
> @@ -1057,6 +1073,17 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
>  	goto next_dnode;
>  
>  sync_out:
> +	if (flag == F2FS_GET_BLOCK_PRECACHE) {
> +		if (map->m_flags & F2FS_MAP_MAPPED) {
> +			unsigned int ofs = start_pgofs - map->m_lblk;
> +
> +			f2fs_update_extent_cache_range(&dn,
> +				start_pgofs, map->m_pblk + ofs,
> +				map->m_len - ofs);
> +		}
> +		if (map->m_next_pgofs)
> +			*map->m_next_pgofs = pgofs + 1;
> +	}
>  	f2fs_put_dnode(&dn);
>  unlock_out:
>  	if (create) {
> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
> index 2f097139b8f7..14177cebc3e7 100644
> --- a/fs/f2fs/f2fs.h
> +++ b/fs/f2fs/f2fs.h
> @@ -353,6 +353,7 @@ static inline bool __has_cursum_space(struct f2fs_journal *journal,
>  						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_PRECACHE_EXTENTS	_IO(F2FS_IOCTL_MAGIC, 14)
>  
>  #define F2FS_IOC_SET_ENCRYPTION_POLICY	FS_IOC_SET_ENCRYPTION_POLICY
>  #define F2FS_IOC_GET_ENCRYPTION_POLICY	FS_IOC_GET_ENCRYPTION_POLICY
> @@ -558,6 +559,7 @@ enum {
>  	F2FS_GET_BLOCK_BMAP,
>  	F2FS_GET_BLOCK_PRE_DIO,
>  	F2FS_GET_BLOCK_PRE_AIO,
> +	F2FS_GET_BLOCK_PRECACHE,
>  };
>  
>  /*
> diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
> index e4078b32856c..14e75871acf3 100644
> --- a/fs/f2fs/file.c
> +++ b/fs/f2fs/file.c
> @@ -2734,6 +2734,38 @@ static int f2fs_ioc_set_pin_file(struct file *filp, unsigned long arg)
>  	return ret;
>  }
>  
> +static int f2fs_ioc_precache_extents(struct file *filp, unsigned long arg)
> +{
> +	struct inode *inode = file_inode(filp);
> +	struct f2fs_inode_info *fi = F2FS_I(inode);
> +	struct f2fs_map_blocks map;
> +	pgoff_t next_pgofs;
> +	loff_t end;
> +	int err;
> +
> +	if (is_inode_flag_set(inode, FI_NO_EXTENT))
> +		return -EOPNOTSUPP;
> +
> +	map.m_lblk = 0;
> +	map.m_next_pgofs = &next_pgofs;
> +	map.m_seg_type = NO_CHECK_TYPE;
> +	end = F2FS_I_SB(inode)->max_file_blocks;
> +
> +	while (map.m_lblk < end) {
> +		map.m_len = end - map.m_lblk;
> +
> +		down_write(&fi->dio_rwsem[WRITE]);
> +		err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_PRECACHE);
> +		up_write(&fi->dio_rwsem[WRITE]);
> +		if (err)
> +			return err;
> +
> +		map.m_lblk = next_pgofs;
> +	}
> +
> +	return 0;
> +}
> +
>  long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
>  {
>  	if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp)))))
> @@ -2786,6 +2818,8 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
>  		return f2fs_ioc_fssetxattr(filp, arg);
>  	case F2FS_IOC_SET_PIN_FILE:
>  		return f2fs_ioc_set_pin_file(filp, arg);
> +	case F2FS_IOC_PRECACHE_EXTENTS:

It looks like F2FS_IOC_CACHE_EXTENTS, and would be better to have an offset
range to look up. BTW, if this is to prepare coming data reads, how about doing
this through fadvise(POSIX_FADV_WILLNEED) instead of additional ioctl?
It seems we can cache extents if the page is marked as PageReadahead().

Thanks,

> +		return f2fs_ioc_precache_extents(filp, arg);
>  	default:
>  		return -ENOTTY;
>  	}
> @@ -2862,6 +2896,7 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
>  	case F2FS_IOC_FSGETXATTR:
>  	case F2FS_IOC_FSSETXATTR:
>  	case F2FS_IOC_SET_PIN_FILE:
> +	case F2FS_IOC_PRECACHE_EXTENTS:
>  		break;
>  	default:
>  		return -ENOIOCTLCMD;
> -- 
> 2.15.0.55.gc2ece9dc4de6

Re: [PATCH 1/4] f2fs: support F2FS_IOC_PRECACHE_EXTENTS

[Jaegeuk Kim]

On 01/09, Jaegeuk Kim wrote:
> On 01/08, Chao Yu wrote:
> > This patch introduces a new ioctl F2FS_IOC_PRECACHE_EXTENTS to precache
> > extent info, in order to gain better performance during data/meta
> > accessing.
> > 
> > Signed-off-by: Chao Yu <yuchao0@huawei.com>
> > ---
> >  fs/f2fs/data.c | 27 +++++++++++++++++++++++++++
> >  fs/f2fs/f2fs.h |  2 ++
> >  fs/f2fs/file.c | 35 +++++++++++++++++++++++++++++++++++
> >  3 files changed, 64 insertions(+)
> > 
> > diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
> > index 429764118604..f38e660bc889 100644
> > --- a/fs/f2fs/data.c
> > +++ b/fs/f2fs/data.c
> > @@ -920,6 +920,7 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
> >  	blkcnt_t prealloc;
> >  	struct extent_info ei = {0,0,0};
> >  	block_t blkaddr;
> > +	unsigned int start_pgofs;
> >  
> >  	if (!maxblocks)
> >  		return 0;
> > @@ -935,6 +936,8 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
> >  		map->m_pblk = ei.blk + pgofs - ei.fofs;
> >  		map->m_len = min((pgoff_t)maxblocks, ei.fofs + ei.len - pgofs);
> >  		map->m_flags = F2FS_MAP_MAPPED;
> > +		if (map->m_next_pgofs)
> > +			*map->m_next_pgofs = pgofs + map->m_len;
> >  		goto out;
> >  	}
> >  
> > @@ -957,6 +960,7 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
> >  		goto unlock_out;
> >  	}
> >  
> > +	start_pgofs = pgofs;
> >  	prealloc = 0;
> >  	last_ofs_in_node = ofs_in_node = dn.ofs_in_node;
> >  	end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
> > @@ -990,6 +994,8 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
> >  				map->m_pblk = 0;
> >  				goto sync_out;
> >  			}
> > +			if (flag == F2FS_GET_BLOCK_PRECACHE)
> > +				goto sync_out;
> >  			if (flag == F2FS_GET_BLOCK_FIEMAP &&
> >  						blkaddr == NULL_ADDR) {
> >  				if (map->m_next_pgofs)
> > @@ -1048,6 +1054,16 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
> >  	else if (dn.ofs_in_node < end_offset)
> >  		goto next_block;
> >  
> > +	if (flag == F2FS_GET_BLOCK_PRECACHE) {
> > +		if (map->m_flags & F2FS_MAP_MAPPED) {
> > +			unsigned int ofs = start_pgofs - map->m_lblk;
> > +
> > +			f2fs_update_extent_cache_range(&dn,
> > +				start_pgofs, map->m_pblk + ofs,
> > +				map->m_len - ofs);
> > +		}
> > +	}
> > +
> >  	f2fs_put_dnode(&dn);
> >  
> >  	if (create) {
> > @@ -1057,6 +1073,17 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
> >  	goto next_dnode;
> >  
> >  sync_out:
> > +	if (flag == F2FS_GET_BLOCK_PRECACHE) {
> > +		if (map->m_flags & F2FS_MAP_MAPPED) {
> > +			unsigned int ofs = start_pgofs - map->m_lblk;
> > +
> > +			f2fs_update_extent_cache_range(&dn,
> > +				start_pgofs, map->m_pblk + ofs,
> > +				map->m_len - ofs);
> > +		}
> > +		if (map->m_next_pgofs)
> > +			*map->m_next_pgofs = pgofs + 1;
> > +	}
> >  	f2fs_put_dnode(&dn);
> >  unlock_out:
> >  	if (create) {
> > diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
> > index 2f097139b8f7..14177cebc3e7 100644
> > --- a/fs/f2fs/f2fs.h
> > +++ b/fs/f2fs/f2fs.h
> > @@ -353,6 +353,7 @@ static inline bool __has_cursum_space(struct f2fs_journal *journal,
> >  						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_PRECACHE_EXTENTS	_IO(F2FS_IOCTL_MAGIC, 14)
> >  
> >  #define F2FS_IOC_SET_ENCRYPTION_POLICY	FS_IOC_SET_ENCRYPTION_POLICY
> >  #define F2FS_IOC_GET_ENCRYPTION_POLICY	FS_IOC_GET_ENCRYPTION_POLICY
> > @@ -558,6 +559,7 @@ enum {
> >  	F2FS_GET_BLOCK_BMAP,
> >  	F2FS_GET_BLOCK_PRE_DIO,
> >  	F2FS_GET_BLOCK_PRE_AIO,
> > +	F2FS_GET_BLOCK_PRECACHE,
> >  };
> >  
> >  /*
> > diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
> > index e4078b32856c..14e75871acf3 100644
> > --- a/fs/f2fs/file.c
> > +++ b/fs/f2fs/file.c
> > @@ -2734,6 +2734,38 @@ static int f2fs_ioc_set_pin_file(struct file *filp, unsigned long arg)
> >  	return ret;
> >  }
> >  
> > +static int f2fs_ioc_precache_extents(struct file *filp, unsigned long arg)
> > +{
> > +	struct inode *inode = file_inode(filp);
> > +	struct f2fs_inode_info *fi = F2FS_I(inode);
> > +	struct f2fs_map_blocks map;
> > +	pgoff_t next_pgofs;
> > +	loff_t end;
> > +	int err;
> > +
> > +	if (is_inode_flag_set(inode, FI_NO_EXTENT))
> > +		return -EOPNOTSUPP;
> > +
> > +	map.m_lblk = 0;
> > +	map.m_next_pgofs = &next_pgofs;
> > +	map.m_seg_type = NO_CHECK_TYPE;
> > +	end = F2FS_I_SB(inode)->max_file_blocks;
> > +
> > +	while (map.m_lblk < end) {
> > +		map.m_len = end - map.m_lblk;
> > +
> > +		down_write(&fi->dio_rwsem[WRITE]);
> > +		err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_PRECACHE);
> > +		up_write(&fi->dio_rwsem[WRITE]);
> > +		if (err)
> > +			return err;
> > +
> > +		map.m_lblk = next_pgofs;
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> >  long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
> >  {
> >  	if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp)))))
> > @@ -2786,6 +2818,8 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
> >  		return f2fs_ioc_fssetxattr(filp, arg);
> >  	case F2FS_IOC_SET_PIN_FILE:
> >  		return f2fs_ioc_set_pin_file(filp, arg);
> > +	case F2FS_IOC_PRECACHE_EXTENTS:
> 
> It looks like F2FS_IOC_CACHE_EXTENTS, and would be better to have an offset
> range to look up. BTW, if this is to prepare coming data reads, how about doing
> this through fadvise(POSIX_FADV_WILLNEED) instead of additional ioctl?
> It seems we can cache extents if the page is marked as PageReadahead().

Oh, I just got noticed that this just follows ext4 implementation. Please
write an integrated patch which introduces this with fiemap and adds description
regarding to ext4.

Thanks,

> 
> Thanks,
> 
> > +		return f2fs_ioc_precache_extents(filp, arg);
> >  	default:
> >  		return -ENOTTY;
> >  	}
> > @@ -2862,6 +2896,7 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
> >  	case F2FS_IOC_FSGETXATTR:
> >  	case F2FS_IOC_FSSETXATTR:
> >  	case F2FS_IOC_SET_PIN_FILE:
> > +	case F2FS_IOC_PRECACHE_EXTENTS:
> >  		break;
> >  	default:
> >  		return -ENOIOCTLCMD;
> > -- 
> > 2.15.0.55.gc2ece9dc4de6

Re: [PATCH 1/4] f2fs: support F2FS_IOC_PRECACHE_EXTENTS

[Chao Yu]

On 2018/1/10 4:43, Jaegeuk Kim wrote:
> On 01/09, Jaegeuk Kim wrote:
>> On 01/08, Chao Yu wrote:
>>> This patch introduces a new ioctl F2FS_IOC_PRECACHE_EXTENTS to precache
>>> extent info, in order to gain better performance during data/meta
>>> accessing.
>>>
>>> Signed-off-by: Chao Yu <yuchao0@huawei.com>
>>> ---
>>>  fs/f2fs/data.c | 27 +++++++++++++++++++++++++++
>>>  fs/f2fs/f2fs.h |  2 ++
>>>  fs/f2fs/file.c | 35 +++++++++++++++++++++++++++++++++++
>>>  3 files changed, 64 insertions(+)
>>>
>>> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c
>>> index 429764118604..f38e660bc889 100644
>>> --- a/fs/f2fs/data.c
>>> +++ b/fs/f2fs/data.c
>>> @@ -920,6 +920,7 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
>>>  	blkcnt_t prealloc;
>>>  	struct extent_info ei = {0,0,0};
>>>  	block_t blkaddr;
>>> +	unsigned int start_pgofs;
>>>  
>>>  	if (!maxblocks)
>>>  		return 0;
>>> @@ -935,6 +936,8 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
>>>  		map->m_pblk = ei.blk + pgofs - ei.fofs;
>>>  		map->m_len = min((pgoff_t)maxblocks, ei.fofs + ei.len - pgofs);
>>>  		map->m_flags = F2FS_MAP_MAPPED;
>>> +		if (map->m_next_pgofs)
>>> +			*map->m_next_pgofs = pgofs + map->m_len;
>>>  		goto out;
>>>  	}
>>>  
>>> @@ -957,6 +960,7 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
>>>  		goto unlock_out;
>>>  	}
>>>  
>>> +	start_pgofs = pgofs;
>>>  	prealloc = 0;
>>>  	last_ofs_in_node = ofs_in_node = dn.ofs_in_node;
>>>  	end_offset = ADDRS_PER_PAGE(dn.node_page, inode);
>>> @@ -990,6 +994,8 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
>>>  				map->m_pblk = 0;
>>>  				goto sync_out;
>>>  			}
>>> +			if (flag == F2FS_GET_BLOCK_PRECACHE)
>>> +				goto sync_out;
>>>  			if (flag == F2FS_GET_BLOCK_FIEMAP &&
>>>  						blkaddr == NULL_ADDR) {
>>>  				if (map->m_next_pgofs)
>>> @@ -1048,6 +1054,16 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
>>>  	else if (dn.ofs_in_node < end_offset)
>>>  		goto next_block;
>>>  
>>> +	if (flag == F2FS_GET_BLOCK_PRECACHE) {
>>> +		if (map->m_flags & F2FS_MAP_MAPPED) {
>>> +			unsigned int ofs = start_pgofs - map->m_lblk;
>>> +
>>> +			f2fs_update_extent_cache_range(&dn,
>>> +				start_pgofs, map->m_pblk + ofs,
>>> +				map->m_len - ofs);
>>> +		}
>>> +	}
>>> +
>>>  	f2fs_put_dnode(&dn);
>>>  
>>>  	if (create) {
>>> @@ -1057,6 +1073,17 @@ int f2fs_map_blocks(struct inode *inode, struct f2fs_map_blocks *map,
>>>  	goto next_dnode;
>>>  
>>>  sync_out:
>>> +	if (flag == F2FS_GET_BLOCK_PRECACHE) {
>>> +		if (map->m_flags & F2FS_MAP_MAPPED) {
>>> +			unsigned int ofs = start_pgofs - map->m_lblk;
>>> +
>>> +			f2fs_update_extent_cache_range(&dn,
>>> +				start_pgofs, map->m_pblk + ofs,
>>> +				map->m_len - ofs);
>>> +		}
>>> +		if (map->m_next_pgofs)
>>> +			*map->m_next_pgofs = pgofs + 1;
>>> +	}
>>>  	f2fs_put_dnode(&dn);
>>>  unlock_out:
>>>  	if (create) {
>>> diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
>>> index 2f097139b8f7..14177cebc3e7 100644
>>> --- a/fs/f2fs/f2fs.h
>>> +++ b/fs/f2fs/f2fs.h
>>> @@ -353,6 +353,7 @@ static inline bool __has_cursum_space(struct f2fs_journal *journal,
>>>  						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_PRECACHE_EXTENTS	_IO(F2FS_IOCTL_MAGIC, 14)
>>>  
>>>  #define F2FS_IOC_SET_ENCRYPTION_POLICY	FS_IOC_SET_ENCRYPTION_POLICY
>>>  #define F2FS_IOC_GET_ENCRYPTION_POLICY	FS_IOC_GET_ENCRYPTION_POLICY
>>> @@ -558,6 +559,7 @@ enum {
>>>  	F2FS_GET_BLOCK_BMAP,
>>>  	F2FS_GET_BLOCK_PRE_DIO,
>>>  	F2FS_GET_BLOCK_PRE_AIO,
>>> +	F2FS_GET_BLOCK_PRECACHE,
>>>  };
>>>  
>>>  /*
>>> diff --git a/fs/f2fs/file.c b/fs/f2fs/file.c
>>> index e4078b32856c..14e75871acf3 100644
>>> --- a/fs/f2fs/file.c
>>> +++ b/fs/f2fs/file.c
>>> @@ -2734,6 +2734,38 @@ static int f2fs_ioc_set_pin_file(struct file *filp, unsigned long arg)
>>>  	return ret;
>>>  }
>>>  
>>> +static int f2fs_ioc_precache_extents(struct file *filp, unsigned long arg)
>>> +{
>>> +	struct inode *inode = file_inode(filp);
>>> +	struct f2fs_inode_info *fi = F2FS_I(inode);
>>> +	struct f2fs_map_blocks map;
>>> +	pgoff_t next_pgofs;
>>> +	loff_t end;
>>> +	int err;
>>> +
>>> +	if (is_inode_flag_set(inode, FI_NO_EXTENT))
>>> +		return -EOPNOTSUPP;
>>> +
>>> +	map.m_lblk = 0;
>>> +	map.m_next_pgofs = &next_pgofs;
>>> +	map.m_seg_type = NO_CHECK_TYPE;
>>> +	end = F2FS_I_SB(inode)->max_file_blocks;
>>> +
>>> +	while (map.m_lblk < end) {
>>> +		map.m_len = end - map.m_lblk;
>>> +
>>> +		down_write(&fi->dio_rwsem[WRITE]);
>>> +		err = f2fs_map_blocks(inode, &map, 0, F2FS_GET_BLOCK_PRECACHE);
>>> +		up_write(&fi->dio_rwsem[WRITE]);
>>> +		if (err)
>>> +			return err;
>>> +
>>> +		map.m_lblk = next_pgofs;
>>> +	}
>>> +
>>> +	return 0;
>>> +}
>>> +
>>>  long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
>>>  {
>>>  	if (unlikely(f2fs_cp_error(F2FS_I_SB(file_inode(filp)))))
>>> @@ -2786,6 +2818,8 @@ long f2fs_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
>>>  		return f2fs_ioc_fssetxattr(filp, arg);
>>>  	case F2FS_IOC_SET_PIN_FILE:
>>>  		return f2fs_ioc_set_pin_file(filp, arg);
>>> +	case F2FS_IOC_PRECACHE_EXTENTS:
>>
>> It looks like F2FS_IOC_CACHE_EXTENTS, and would be better to have an offset
>> range to look up. BTW, if this is to prepare coming data reads, how about doing
>> this through fadvise(POSIX_FADV_WILLNEED) instead of additional ioctl?
>> It seems we can cache extents if the page is marked as PageReadahead().
> 
> Oh, I just got noticed that this just follows ext4 implementation. Please
> write an integrated patch which introduces this with fiemap and adds description
> regarding to ext4.

Done, please help to check it. ;)

Thanks,

> 
> Thanks,
> 
>>
>> Thanks,
>>
>>> +		return f2fs_ioc_precache_extents(filp, arg);
>>>  	default:
>>>  		return -ENOTTY;
>>>  	}
>>> @@ -2862,6 +2896,7 @@ long f2fs_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
>>>  	case F2FS_IOC_FSGETXATTR:
>>>  	case F2FS_IOC_FSSETXATTR:
>>>  	case F2FS_IOC_SET_PIN_FILE:
>>> +	case F2FS_IOC_PRECACHE_EXTENTS:
>>>  		break;
>>>  	default:
>>>  		return -ENOIOCTLCMD;
>>> -- 
>>> 2.15.0.55.gc2ece9dc4de6
> 
> .
>