Skip to contentSkip to conversation

f2fs: use f2fs_submit_page_bio for ra_meta_pages

PATCH In review Jaegeuk Kim 2 participants 8 messages May 10, 2017 – May 11, 2017

Subsystems (3)
lore
Share & tools
lore

Jaegeuk Kim

author maintainer
#0 lore raw

PATCH 1/3 f2fs: use f2fs_submit_page_bio for ra_meta_pages

This patch avoids to use f2fs_submit_merged_bio for read, which was the only read case.

---
 fs/f2fs/checkpoint.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)
fs/f2fs/checkpoint.c +1 -3
index ea9c317b5916..8d92f8249000 100644
@@ -207,12 +207,10 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,
 		}
 
 		fio.page = page;
-		fio.old_blkaddr = fio.new_blkaddr;
-		f2fs_submit_page_mbio(&fio);
+		f2fs_submit_page_bio(&fio);
 		f2fs_put_page(page, 0);
 	}
 out:
-	f2fs_submit_merged_bio(sbi, META, READ);
 	blk_finish_plug(&plug);
 	return blkno - start;
 }
Signature · 1 line
2.11.0
author maintainer
#1 lore raw

PATCH 2/3 f2fs: remove unnecessary read cases in merged IO flow

Merged IO flow doesn't need to care about read IOs.

f2fs_submit_merged_bio -> f2fs_submit_merged_write f2fs_submit_merged_bios -> f2fs_submit_merged_writes f2fs_submit_merged_bio_cond -> f2fs_submit_merged_write_cond

---
 fs/f2fs/checkpoint.c        | 14 ++++++------
 fs/f2fs/data.c              | 55 ++++++++++++++++++++-------------------------
 fs/f2fs/f2fs.h              | 11 +++++----
 fs/f2fs/gc.c                |  6 ++---
 fs/f2fs/node.c              | 11 +++++----
 fs/f2fs/segment.c           | 11 +++++----
 fs/f2fs/super.c             |  2 +-
 include/trace/events/f2fs.h |  2 +-
 8 files changed, 51 insertions(+), 61 deletions(-)
fs/f2fs/checkpoint.c +7 -7
index 8d92f8249000..13828f63a871 100644
@@ -31,7 +31,7 @@ void f2fs_stop_checkpoint(struct f2fs_sb_info *sbi, bool end_io)
 	set_ckpt_flags(sbi, CP_ERROR_FLAG);
 	sbi->sb->s_flags |= MS_RDONLY;
 	if (!end_io)
-		f2fs_flush_merged_bios(sbi);
+		f2fs_flush_merged_writes(sbi);
 }
 
 /*
@@ -247,13 +247,13 @@ static int f2fs_write_meta_page(struct page *page,
 	dec_page_count(sbi, F2FS_DIRTY_META);
 
 	if (wbc->for_reclaim)
-		f2fs_submit_merged_bio_cond(sbi, page->mapping->host,
-						0, page->index, META, WRITE);
+		f2fs_submit_merged_write_cond(sbi, page->mapping->host,
+						0, page->index, META);
 
 	unlock_page(page);
 
 	if (unlikely(f2fs_cp_error(sbi)))
-		f2fs_submit_merged_bio(sbi, META, WRITE);
+		f2fs_submit_merged_write(sbi, META);
 
 	return 0;
 
@@ -356,7 +356,7 @@ long sync_meta_pages(struct f2fs_sb_info *sbi, enum page_type type,
 	}
 stop:
 	if (nwritten)
-		f2fs_submit_merged_bio(sbi, type, WRITE);
+		f2fs_submit_merged_write(sbi, type);
 
 	blk_finish_plug(&plug);
 
@@ -904,7 +904,7 @@ int sync_dirty_inodes(struct f2fs_sb_info *sbi, enum inode_type type)
 		 * We should submit bio, since it exists several
 		 * wribacking dentry pages in the freeing inode.
 		 */
-		f2fs_submit_merged_bio(sbi, DATA, WRITE);
+		f2fs_submit_merged_write(sbi, DATA);
 		cond_resched();
 	}
 	goto retry;
@@ -1293,7 +1293,7 @@ int write_checkpoint(struct f2fs_sb_info *sbi, struct cp_control *cpc)
 
 	trace_f2fs_write_checkpoint(sbi->sb, cpc->reason, "finish block_ops");
 
-	f2fs_flush_merged_bios(sbi);
+	f2fs_flush_merged_writes(sbi);
 
 	/* this is the case of multiple fstrims without any changes */
 	if (cpc->reason & CP_DISCARD) {
fs/f2fs/data.c +24 -31

136 lines not on this page · raw message

fs/f2fs/f2fs.h +5 -6
index e26999a74522..bf837458cb18 100644
@@ -2325,14 +2325,13 @@ void destroy_checkpoint_caches(void);
 /*
  * data.c
  */
-void f2fs_submit_merged_bio(struct f2fs_sb_info *sbi, enum page_type type,
-			int rw);
-void f2fs_submit_merged_bio_cond(struct f2fs_sb_info *sbi,
+void f2fs_submit_merged_write(struct f2fs_sb_info *sbi, enum page_type type);
+void f2fs_submit_merged_write_cond(struct f2fs_sb_info *sbi,
 				struct inode *inode, nid_t ino, pgoff_t idx,
-				enum page_type type, int rw);
-void f2fs_flush_merged_bios(struct f2fs_sb_info *sbi);
+				enum page_type type);
+void f2fs_flush_merged_writes(struct f2fs_sb_info *sbi);
 int f2fs_submit_page_bio(struct f2fs_io_info *fio);
-int f2fs_submit_page_mbio(struct f2fs_io_info *fio);
+int f2fs_submit_page_write(struct f2fs_io_info *fio);
 struct block_device *f2fs_target_device(struct f2fs_sb_info *sbi,
 			block_t blk_addr, struct bio *bio);
 int f2fs_target_device_index(struct f2fs_sb_info *sbi, block_t blkaddr);
fs/f2fs/gc.c +3 -3
index 965fbf5d0a2e..67b87155bc48 100644
@@ -670,7 +670,7 @@ static void move_encrypted_block(struct inode *inode, block_t bidx,
 	fio.op = REQ_OP_WRITE;
 	fio.op_flags = REQ_SYNC;
 	fio.new_blkaddr = newaddr;
-	f2fs_submit_page_mbio(&fio);
+	f2fs_submit_page_write(&fio);
 
 	f2fs_update_data_blkaddr(&dn, newaddr);
 	set_inode_flag(inode, FI_APPEND_WRITE);
@@ -936,8 +936,8 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi,
 	}
 
 	if (gc_type == FG_GC)
-		f2fs_submit_merged_bio(sbi,
-				(type == SUM_TYPE_NODE) ? NODE : DATA, WRITE);
+		f2fs_submit_merged_write(sbi,
+				(type == SUM_TYPE_NODE) ? NODE : DATA);
 
 	blk_finish_plug(&plug);
 
fs/f2fs/node.c +5 -6
index 98351a4a4da3..41bb632ac2e0 100644
@@ -1373,15 +1373,15 @@ static int __write_node_page(struct page *page, bool atomic, bool *submitted,
 	up_read(&sbi->node_write);
 
 	if (wbc->for_reclaim) {
-		f2fs_submit_merged_bio_cond(sbi, page->mapping->host, 0,
-						page->index, NODE, WRITE);
+		f2fs_submit_merged_write_cond(sbi, page->mapping->host, 0,
+						page->index, NODE);
 		submitted = NULL;
 	}
 
 	unlock_page(page);
 
 	if (unlikely(f2fs_cp_error(sbi))) {
-		f2fs_submit_merged_bio(sbi, NODE, WRITE);
+		f2fs_submit_merged_write(sbi, NODE);
 		submitted = NULL;
 	}
 	if (submitted)
@@ -1518,8 +1518,7 @@ int fsync_node_pages(struct f2fs_sb_info *sbi, struct inode *inode,
 	}
 out:
 	if (last_idx != ULONG_MAX)
-		f2fs_submit_merged_bio_cond(sbi, NULL, ino, last_idx,
-							NODE, WRITE);
+		f2fs_submit_merged_write_cond(sbi, NULL, ino, last_idx, NODE);
 	return ret ? -EIO: 0;
 }
 
@@ -1625,7 +1624,7 @@ int sync_node_pages(struct f2fs_sb_info *sbi, struct writeback_control *wbc)
 	}
 out:
 	if (nwritten)
-		f2fs_submit_merged_bio(sbi, NODE, WRITE);
+		f2fs_submit_merged_write(sbi, NODE);
 	return ret;
 }
 
fs/f2fs/segment.c +5 -6
index de31030b5041..38bb675976e2 100644
@@ -328,8 +328,7 @@ static int __commit_inmem_pages(struct inode *inode,
 	}
 
 	if (last_idx != ULONG_MAX)
-		f2fs_submit_merged_bio_cond(sbi, inode, 0, last_idx,
-							DATA, WRITE);
+		f2fs_submit_merged_write_cond(sbi, inode, 0, last_idx, DATA);
 
 	if (!err)
 		__revoke_inmem_pages(inode, revoke_list, false, false);
@@ -2150,7 +2149,7 @@ static void do_write_page(struct f2fs_summary *sum, struct f2fs_io_info *fio)
 					&fio->new_blkaddr, sum, type);
 
 	/* writeout dirty page into bdev */
-	err = f2fs_submit_page_mbio(fio);
+	err = f2fs_submit_page_write(fio);
 	if (err == -EAGAIN) {
 		fio->old_blkaddr = fio->new_blkaddr;
 		goto reallocate;
@@ -2177,7 +2176,7 @@ void write_meta_page(struct f2fs_sb_info *sbi, struct page *page)
 		fio.op_flags &= ~REQ_META;
 
 	set_page_writeback(page);
-	f2fs_submit_page_mbio(&fio);
+	f2fs_submit_page_write(&fio);
 }
 
 void write_node_page(unsigned int nid, struct f2fs_io_info *fio)
@@ -2296,8 +2295,8 @@ void f2fs_wait_on_page_writeback(struct page *page,
 	if (PageWriteback(page)) {
 		struct f2fs_sb_info *sbi = F2FS_P_SB(page);
 
-		f2fs_submit_merged_bio_cond(sbi, page->mapping->host,
-						0, page->index, type, WRITE);
+		f2fs_submit_merged_write_cond(sbi, page->mapping->host,
+						0, page->index, type);
 		if (ordered)
 			wait_on_page_writeback(page);
 		else
fs/f2fs/super.c +1 -1
index 83355ec4a92c..104a571a41c0 100644
@@ -817,7 +817,7 @@ static void f2fs_put_super(struct super_block *sb)
 	mutex_unlock(&sbi->umount_mutex);
 
 	/* our cp_error case, we can wait for any writeback page */
-	f2fs_flush_merged_bios(sbi);
+	f2fs_flush_merged_writes(sbi);
 
 	iput(sbi->node_inode);
 	iput(sbi->meta_inode);
include/trace/events/f2fs.h +1 -1
index 15da88c5c3a4..5805d92893a8 100644
@@ -790,7 +790,7 @@ DEFINE_EVENT_CONDITION(f2fs__submit_page_bio, f2fs_submit_page_bio,
 	TP_CONDITION(page->mapping)
 );
 
-DEFINE_EVENT_CONDITION(f2fs__submit_page_bio, f2fs_submit_page_mbio,
+DEFINE_EVENT_CONDITION(f2fs__submit_page_bio, f2fs_submit_page_write,
 
 	TP_PROTO(struct page *page, struct f2fs_io_info *fio),
 
Signature · 1 line
2.11.0
author maintainer
#2 lore raw

PATCH 3/3 f2fs: use fio instead of multiple parameters

In reply to Jaegeuk Kim

This patch just changes using fio instead of parameters.

---
 fs/f2fs/segment.c | 41 +++++++++++++++++++++--------------------
 1 file changed, 21 insertions(+), 20 deletions(-)
fs/f2fs/segment.c +21 -20
index 38bb675976e2..c9f3a2faee21 100644
@@ -2039,61 +2039,62 @@ static bool __has_curseg_space(struct f2fs_sb_info *sbi, int type)
 	return false;
 }
 
-static int __get_segment_type_2(struct page *page, enum page_type p_type)
+static int __get_segment_type_2(struct f2fs_io_info *fio)
 {
-	if (p_type == DATA)
+	if (fio->type == DATA)
 		return CURSEG_HOT_DATA;
 	else
 		return CURSEG_HOT_NODE;
 }
 
-static int __get_segment_type_4(struct page *page, enum page_type p_type)
+static int __get_segment_type_4(struct f2fs_io_info *fio)
 {
-	if (p_type == DATA) {
-		struct inode *inode = page->mapping->host;
+	if (fio->type == DATA) {
+		struct inode *inode = fio->page->mapping->host;
 
 		if (S_ISDIR(inode->i_mode))
 			return CURSEG_HOT_DATA;
 		else
 			return CURSEG_COLD_DATA;
 	} else {
-		if (IS_DNODE(page) && is_cold_node(page))
+		if (IS_DNODE(fio->page) && is_cold_node(fio->page))
 			return CURSEG_WARM_NODE;
 		else
 			return CURSEG_COLD_NODE;
 	}
 }
 
-static int __get_segment_type_6(struct page *page, enum page_type p_type)
+static int __get_segment_type_6(struct f2fs_io_info *fio)
 {
-	if (p_type == DATA) {
-		struct inode *inode = page->mapping->host;
+	if (fio->type == DATA) {
+		struct inode *inode = fio->page->mapping->host;
 
-		if (is_cold_data(page) || file_is_cold(inode))
+		if (is_cold_data(fio->page) || file_is_cold(inode))
 			return CURSEG_COLD_DATA;
 		if (is_inode_flag_set(inode, FI_HOT_DATA))
 			return CURSEG_HOT_DATA;
 		return CURSEG_WARM_DATA;
 	} else {
-		if (IS_DNODE(page))
-			return is_cold_node(page) ? CURSEG_WARM_NODE :
+		if (IS_DNODE(fio->page))
+			return is_cold_node(fio->page) ? CURSEG_WARM_NODE :
 						CURSEG_HOT_NODE;
 		return CURSEG_COLD_NODE;
 	}
 }
 
-static int __get_segment_type(struct page *page, enum page_type p_type)
+static int __get_segment_type(struct f2fs_io_info *fio)
 {
-	switch (F2FS_P_SB(page)->active_logs) {
+	switch (fio->sbi->active_logs) {
 	case 2:
-		return __get_segment_type_2(page, p_type);
+		return __get_segment_type_2(fio);
 	case 4:
-		return __get_segment_type_4(page, p_type);
+		return __get_segment_type_4(fio);
 	}
+
 	/* NR_CURSEG_TYPE(6) logs by default */
-	f2fs_bug_on(F2FS_P_SB(page),
-		F2FS_P_SB(page)->active_logs != NR_CURSEG_TYPE);
-	return __get_segment_type_6(page, p_type);
+	f2fs_bug_on(fio->sbi, fio->sbi->active_logs != NR_CURSEG_TYPE);
+
+	return __get_segment_type_6(fio);
 }
 
 void allocate_data_block(struct f2fs_sb_info *sbi, struct page *page,
@@ -2139,7 +2140,7 @@ void allocate_data_block(struct f2fs_sb_info *sbi, struct page *page,
 
 static void do_write_page(struct f2fs_summary *sum, struct f2fs_io_info *fio)
 {
-	int type = __get_segment_type(fio->page, fio->type);
+	int type = __get_segment_type(fio);
 	int err;
 
 	if (fio->type == NODE || fio->type == DATA)
Signature · 1 line
2.11.0
#3 lore raw
In reply to Jaegeuk Kim

Hi Jaegeuk,

Quoted 2 lines · Jaegeuk Kim

This patch avoids to use f2fs_submit_merged_bio for read, which was the only read case.

This makes f2fs losing the chance to merge multiple pages into one bio during reading continuous physical blocks, it may cause potential performance regression, how about using a local bio in ra_meta_pages to cache more pages?

Thanks,

Quoted 25 lines
---
 fs/f2fs/checkpoint.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)
fs/f2fs/checkpoint.c +1 -3
index ea9c317b5916..8d92f8249000 100644
@@ -207,12 +207,10 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,
 		}
 
 		fio.page = page;
-		fio.old_blkaddr = fio.new_blkaddr;
-		f2fs_submit_page_mbio(&fio);
+		f2fs_submit_page_bio(&fio);
 		f2fs_put_page(page, 0);
 	}
 out:
-	f2fs_submit_merged_bio(sbi, META, READ);
 	blk_finish_plug(&plug);
 	return blkno - start;
 }
#4 lore raw
Quoted 9 lines · Chao Yu

Hi Jaegeuk,

Quoted 2 lines · Jaegeuk Kim

This patch avoids to use f2fs_submit_merged_bio for read, which was the only read case.

This makes f2fs losing the chance to merge multiple pages into one bio during reading continuous physical blocks, it may cause potential performance regression, how about using a local bio in ra_meta_pages to cache more pages?

BTW, need to remove sbi->read_io as well?

Thanks,

Quoted 32 lines

Thanks,

Quoted 15 lines
---
 fs/f2fs/checkpoint.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)
fs/f2fs/checkpoint.c +0 -0
index ea9c317b5916..8d92f8249000 100644
@@ -207,12 +207,10 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,
 		}
 
 		fio.page = page;

fs/f2fs/checkpoint.c int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages, · line 216

Quoted 10 lines
fs/f2fs/checkpoint.c +1 -3
-		fio.old_blkaddr = fio.new_blkaddr;
-		f2fs_submit_page_mbio(&fio);
+		f2fs_submit_page_bio(&fio);
 		f2fs_put_page(page, 0);
 	}
 out:
-	f2fs_submit_merged_bio(sbi, META, READ);
 	blk_finish_plug(&plug);
 	return blkno - start;
 }

.

author maintainer
#5 lore raw
Quoted 4 lines · Chao Yu
Quoted 3 lines · Chao Yu

Hi Jaegeuk,

On 2017/5/11 7:48, Jaegeuk Kim wrote:

Quoted 8 lines
Quoted 6 lines
Quoted 2 lines

This patch avoids to use f2fs_submit_merged_bio for read, which was the only read case.

This makes f2fs losing the chance to merge multiple pages into one bio during reading continuous physical blocks, it may cause potential performance regression, how about using a local bio in ra_meta_pages to cache more pages?

BTW, need to remove sbi->read_io as well?

Yup.

Quoted 35 lines

Thanks,

Quoted 32 lines

Thanks,

Quoted 15 lines
---
 fs/f2fs/checkpoint.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)
fs/f2fs/checkpoint.c +0 -0
index ea9c317b5916..8d92f8249000 100644
@@ -207,12 +207,10 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,
 		}
 
 		fio.page = page;

fs/f2fs/checkpoint.c int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages, · line 216

Quoted 10 lines
fs/f2fs/checkpoint.c +1 -3
-		fio.old_blkaddr = fio.new_blkaddr;
-		f2fs_submit_page_mbio(&fio);
+		f2fs_submit_page_bio(&fio);
 		f2fs_put_page(page, 0);
 	}
 out:
-	f2fs_submit_merged_bio(sbi, META, READ);
 	blk_finish_plug(&plug);
 	return blkno - start;
 }

.

author maintainer
#6 lore raw
In reply to Chao Yu
Quoted 9 lines · Chao Yu

Hi Jaegeuk,

Quoted 2 lines · Jaegeuk Kim

This patch avoids to use f2fs_submit_merged_bio for read, which was the only read case.

This makes f2fs losing the chance to merge multiple pages into one bio during reading continuous physical blocks, it may cause potential performance regression, how about using a local bio in ra_meta_pages to cache more pages?

This is a readahead flow, which is asynchronous and not a performance critical flow. And, I expect blk_plug is still able to merge them. We're using this in readahead of node blocks as well.

Thanks,

Quoted 28 lines

Thanks,

Quoted 25 lines
---
 fs/f2fs/checkpoint.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)
fs/f2fs/checkpoint.c +1 -3
index ea9c317b5916..8d92f8249000 100644
@@ -207,12 +207,10 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,
 		}
 
 		fio.page = page;
-		fio.old_blkaddr = fio.new_blkaddr;
-		f2fs_submit_page_mbio(&fio);
+		f2fs_submit_page_bio(&fio);
 		f2fs_put_page(page, 0);
 	}
 out:
-	f2fs_submit_merged_bio(sbi, META, READ);
 	blk_finish_plug(&plug);
 	return blkno - start;
 }
#7 lore raw
Quoted 7 lines · Jaegeuk Kim
Quoted 6 lines · Chao Yu

Hi Jaegeuk,

Quoted 2 lines · Jaegeuk Kim

This patch avoids to use f2fs_submit_merged_bio for read, which was the only read case.

Quoted 7 lines
Quoted 3 lines

This makes f2fs losing the chance to merge multiple pages into one bio during reading continuous physical blocks, it may cause potential performance regression, how about using a local bio in ra_meta_pages to cache more pages?

This is a readahead flow, which is asynchronous and not a performance critical flow. And, I expect blk_plug is still able to merge them. We're using this in readahead of node blocks as well.

Confirmed, block plug can do the merge. :)

Thanks,

Quoted 34 lines

Thanks,

Quoted 16 lines

Thanks,

Quoted 13 lines
---
 fs/f2fs/checkpoint.c | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)
fs/f2fs/checkpoint.c +0 -0
index ea9c317b5916..8d92f8249000 100644
@@ -207,12 +207,10 @@ int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages,
 		}
 
Quoted 12 lines

fs/f2fs/checkpoint.c int ra_meta_pages(struct f2fs_sb_info *sbi, block_t start, int nrpages, · line 216

Quoted 12 lines
fs/f2fs/checkpoint.c +1 -3
 		fio.page = page;
-		fio.old_blkaddr = fio.new_blkaddr;
-		f2fs_submit_page_mbio(&fio);
+		f2fs_submit_page_bio(&fio);
 		f2fs_put_page(page, 0);
 	}
 out:
-	f2fs_submit_merged_bio(sbi, META, READ);
 	blk_finish_plug(&plug);
 	return blkno - start;
 }

.