| Message ID | 20160608172444.60371-3-jaegeuk@kernel.org (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
Hi Jaegeuk, On 2016/6/9 1:24, Jaegeuk Kim wrote: > In f2fs, we don't need to keep block plugging for NODE and DATA writes, since > we already merged bios as much as possible. IMO, we can not remove block plug, this is because there are still many conditions which stops us merging r/w IOs into one bio as we expect, theoretically, block plug can hold bios as much as possible, then submitting them into queue in batch, it will reduce racing of grabbing queue->lock during bio submitting, if we drop them, when syncing nodes or flushing datas, we will suffer more lock racing. Or there are something I am missing, do you suffer any performance issue on block plug? Thanks, > > Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org> > --- > fs/f2fs/checkpoint.c | 4 ---- > fs/f2fs/data.c | 17 ++++++++++------- > fs/f2fs/gc.c | 5 ----- > fs/f2fs/segment.c | 7 +------ > 4 files changed, 11 insertions(+), 22 deletions(-) > > diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c > index 5ddd15c..4179c7b 100644 > --- a/fs/f2fs/checkpoint.c > +++ b/fs/f2fs/checkpoint.c > @@ -897,11 +897,8 @@ static int block_operations(struct f2fs_sb_info *sbi) > .nr_to_write = LONG_MAX, > .for_reclaim = 0, > }; > - struct blk_plug plug; > int err = 0; > > - blk_start_plug(&plug); > - > retry_flush_dents: > f2fs_lock_all(sbi); > /* write all the dirty dentry pages */ > @@ -938,7 +935,6 @@ retry_flush_nodes: > goto retry_flush_nodes; > } > out: > - blk_finish_plug(&plug); > return err; > } > > diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c > index 30dc448..5f655d0 100644 > --- a/fs/f2fs/data.c > +++ b/fs/f2fs/data.c > @@ -98,10 +98,13 @@ static struct bio *__bio_alloc(struct f2fs_sb_info *sbi, block_t blk_addr, > } > > static inline void __submit_bio(struct f2fs_sb_info *sbi, int rw, > - struct bio *bio) > + struct bio *bio, enum page_type type) > { > - if (!is_read_io(rw)) > + if (!is_read_io(rw)) { > atomic_inc(&sbi->nr_wb_bios); > + if (current->plug && (type == DATA || type == NODE)) > + blk_finish_plug(current->plug); > + } > submit_bio(rw, bio); > } > > @@ -117,7 +120,7 @@ static void __submit_merged_bio(struct f2fs_bio_info *io) > else > trace_f2fs_submit_write_bio(io->sbi->sb, fio, io->bio); > > - __submit_bio(io->sbi, fio->rw, io->bio); > + __submit_bio(io->sbi, fio->rw, io->bio, fio->type); > io->bio = NULL; > } > > @@ -235,7 +238,7 @@ int f2fs_submit_page_bio(struct f2fs_io_info *fio) > return -EFAULT; > } > > - __submit_bio(fio->sbi, fio->rw, bio); > + __submit_bio(fio->sbi, fio->rw, bio, fio->type); > return 0; > } > > @@ -1040,7 +1043,7 @@ got_it: > */ > if (bio && (last_block_in_bio != block_nr - 1)) { > submit_and_realloc: > - __submit_bio(F2FS_I_SB(inode), READ, bio); > + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); > bio = NULL; > } > if (bio == NULL) { > @@ -1083,7 +1086,7 @@ set_error_page: > goto next_page; > confused: > if (bio) { > - __submit_bio(F2FS_I_SB(inode), READ, bio); > + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); > bio = NULL; > } > unlock_page(page); > @@ -1093,7 +1096,7 @@ next_page: > } > BUG_ON(pages && !list_empty(pages)); > if (bio) > - __submit_bio(F2FS_I_SB(inode), READ, bio); > + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); > return 0; > } > > diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c > index 4a03076..67fd285 100644 > --- a/fs/f2fs/gc.c > +++ b/fs/f2fs/gc.c > @@ -777,7 +777,6 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi, > { > struct page *sum_page; > struct f2fs_summary_block *sum; > - struct blk_plug plug; > unsigned int segno = start_segno; > unsigned int end_segno = start_segno + sbi->segs_per_sec; > int seg_freed = 0; > @@ -795,8 +794,6 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi, > unlock_page(sum_page); > } > > - blk_start_plug(&plug); > - > for (segno = start_segno; segno < end_segno; segno++) { > /* find segment summary of victim */ > sum_page = find_get_page(META_MAPPING(sbi), > @@ -830,8 +827,6 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi, > f2fs_submit_merged_bio(sbi, > (type == SUM_TYPE_NODE) ? NODE : DATA, WRITE); > > - blk_finish_plug(&plug); > - > if (gc_type == FG_GC) { > while (start_segno < end_segno) > if (get_valid_blocks(sbi, start_segno++, 1) == 0) > diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c > index 7b58bfb..eff046a 100644 > --- a/fs/f2fs/segment.c > +++ b/fs/f2fs/segment.c > @@ -379,13 +379,8 @@ void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi) > excess_prefree_segs(sbi) || > excess_dirty_nats(sbi) || > (is_idle(sbi) && f2fs_time_over(sbi, CP_TIME))) { > - if (test_opt(sbi, DATA_FLUSH)) { > - struct blk_plug plug; > - > - blk_start_plug(&plug); > + if (test_opt(sbi, DATA_FLUSH)) > sync_dirty_inodes(sbi, FILE_INODE); > - blk_finish_plug(&plug); > - } > f2fs_sync_fs(sbi->sb, true); > stat_inc_bg_cp_count(sbi->stat_info); > } > -- To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On Sat, Jul 09, 2016 at 10:28:49AM +0800, Chao Yu wrote: > Hi Jaegeuk, > > On 2016/6/9 1:24, Jaegeuk Kim wrote: > > In f2fs, we don't need to keep block plugging for NODE and DATA writes, since > > we already merged bios as much as possible. > > IMO, we can not remove block plug, this is because there are still many > conditions which stops us merging r/w IOs into one bio as we expect, > theoretically, block plug can hold bios as much as possible, then submitting > them into queue in batch, it will reduce racing of grabbing queue->lock during > bio submitting, if we drop them, when syncing nodes or flushing datas, we will > suffer more lock racing. > > Or there are something I am missing, do you suffer any performance issue on > block plug? In the latest patch, I've turned off plugging forcefully, only if the underlying device is SMR drive. And, still I removed other block plugging, since I couldn't see any performance regression. Even in some workloads, I could have seen some inverted IOs due to race condition between plugged and unplugged IOs. Thanks, > > Thanks, > > > > > Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org> > > --- > > fs/f2fs/checkpoint.c | 4 ---- > > fs/f2fs/data.c | 17 ++++++++++------- > > fs/f2fs/gc.c | 5 ----- > > fs/f2fs/segment.c | 7 +------ > > 4 files changed, 11 insertions(+), 22 deletions(-) > > > > diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c > > index 5ddd15c..4179c7b 100644 > > --- a/fs/f2fs/checkpoint.c > > +++ b/fs/f2fs/checkpoint.c > > @@ -897,11 +897,8 @@ static int block_operations(struct f2fs_sb_info *sbi) > > .nr_to_write = LONG_MAX, > > .for_reclaim = 0, > > }; > > - struct blk_plug plug; > > int err = 0; > > > > - blk_start_plug(&plug); > > - > > retry_flush_dents: > > f2fs_lock_all(sbi); > > /* write all the dirty dentry pages */ > > @@ -938,7 +935,6 @@ retry_flush_nodes: > > goto retry_flush_nodes; > > } > > out: > > - blk_finish_plug(&plug); > > return err; > > } > > > > diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c > > index 30dc448..5f655d0 100644 > > --- a/fs/f2fs/data.c > > +++ b/fs/f2fs/data.c > > @@ -98,10 +98,13 @@ static struct bio *__bio_alloc(struct f2fs_sb_info *sbi, block_t blk_addr, > > } > > > > static inline void __submit_bio(struct f2fs_sb_info *sbi, int rw, > > - struct bio *bio) > > + struct bio *bio, enum page_type type) > > { > > - if (!is_read_io(rw)) > > + if (!is_read_io(rw)) { > > atomic_inc(&sbi->nr_wb_bios); > > + if (current->plug && (type == DATA || type == NODE)) > > + blk_finish_plug(current->plug); > > + } > > submit_bio(rw, bio); > > } > > > > @@ -117,7 +120,7 @@ static void __submit_merged_bio(struct f2fs_bio_info *io) > > else > > trace_f2fs_submit_write_bio(io->sbi->sb, fio, io->bio); > > > > - __submit_bio(io->sbi, fio->rw, io->bio); > > + __submit_bio(io->sbi, fio->rw, io->bio, fio->type); > > io->bio = NULL; > > } > > > > @@ -235,7 +238,7 @@ int f2fs_submit_page_bio(struct f2fs_io_info *fio) > > return -EFAULT; > > } > > > > - __submit_bio(fio->sbi, fio->rw, bio); > > + __submit_bio(fio->sbi, fio->rw, bio, fio->type); > > return 0; > > } > > > > @@ -1040,7 +1043,7 @@ got_it: > > */ > > if (bio && (last_block_in_bio != block_nr - 1)) { > > submit_and_realloc: > > - __submit_bio(F2FS_I_SB(inode), READ, bio); > > + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); > > bio = NULL; > > } > > if (bio == NULL) { > > @@ -1083,7 +1086,7 @@ set_error_page: > > goto next_page; > > confused: > > if (bio) { > > - __submit_bio(F2FS_I_SB(inode), READ, bio); > > + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); > > bio = NULL; > > } > > unlock_page(page); > > @@ -1093,7 +1096,7 @@ next_page: > > } > > BUG_ON(pages && !list_empty(pages)); > > if (bio) > > - __submit_bio(F2FS_I_SB(inode), READ, bio); > > + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); > > return 0; > > } > > > > diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c > > index 4a03076..67fd285 100644 > > --- a/fs/f2fs/gc.c > > +++ b/fs/f2fs/gc.c > > @@ -777,7 +777,6 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi, > > { > > struct page *sum_page; > > struct f2fs_summary_block *sum; > > - struct blk_plug plug; > > unsigned int segno = start_segno; > > unsigned int end_segno = start_segno + sbi->segs_per_sec; > > int seg_freed = 0; > > @@ -795,8 +794,6 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi, > > unlock_page(sum_page); > > } > > > > - blk_start_plug(&plug); > > - > > for (segno = start_segno; segno < end_segno; segno++) { > > /* find segment summary of victim */ > > sum_page = find_get_page(META_MAPPING(sbi), > > @@ -830,8 +827,6 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi, > > f2fs_submit_merged_bio(sbi, > > (type == SUM_TYPE_NODE) ? NODE : DATA, WRITE); > > > > - blk_finish_plug(&plug); > > - > > if (gc_type == FG_GC) { > > while (start_segno < end_segno) > > if (get_valid_blocks(sbi, start_segno++, 1) == 0) > > diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c > > index 7b58bfb..eff046a 100644 > > --- a/fs/f2fs/segment.c > > +++ b/fs/f2fs/segment.c > > @@ -379,13 +379,8 @@ void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi) > > excess_prefree_segs(sbi) || > > excess_dirty_nats(sbi) || > > (is_idle(sbi) && f2fs_time_over(sbi, CP_TIME))) { > > - if (test_opt(sbi, DATA_FLUSH)) { > > - struct blk_plug plug; > > - > > - blk_start_plug(&plug); > > + if (test_opt(sbi, DATA_FLUSH)) > > sync_dirty_inodes(sbi, FILE_INODE); > > - blk_finish_plug(&plug); > > - } > > f2fs_sync_fs(sbi->sb, true); > > stat_inc_bg_cp_count(sbi->stat_info); > > } > > -- To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
On 2016/7/10 0:32, Jaegeuk Kim wrote: > On Sat, Jul 09, 2016 at 10:28:49AM +0800, Chao Yu wrote: >> Hi Jaegeuk, >> >> On 2016/6/9 1:24, Jaegeuk Kim wrote: >>> In f2fs, we don't need to keep block plugging for NODE and DATA writes, since >>> we already merged bios as much as possible. >> >> IMO, we can not remove block plug, this is because there are still many >> conditions which stops us merging r/w IOs into one bio as we expect, >> theoretically, block plug can hold bios as much as possible, then submitting >> them into queue in batch, it will reduce racing of grabbing queue->lock during >> bio submitting, if we drop them, when syncing nodes or flushing datas, we will >> suffer more lock racing. >> >> Or there are something I am missing, do you suffer any performance issue on >> block plug? > > In the latest patch, I've turned off plugging forcefully, only if the underlying > device is SMR drive. Got it. > And, still I removed other block plugging, since I couldn't see any performance > regression. I suspect that in low-end machine with single-queue which is used in block layer, we will suffer regression. > Even in some workloads, I could have seen some inverted IOs due to > race condition between plugged and unplugged IOs. For data path, what about enabling block plug for IPU/SSR ? Thanks, > > Thanks, > >> >> Thanks, >> >>> >>> Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org> >>> --- >>> fs/f2fs/checkpoint.c | 4 ---- >>> fs/f2fs/data.c | 17 ++++++++++------- >>> fs/f2fs/gc.c | 5 ----- >>> fs/f2fs/segment.c | 7 +------ >>> 4 files changed, 11 insertions(+), 22 deletions(-) >>> >>> diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c >>> index 5ddd15c..4179c7b 100644 >>> --- a/fs/f2fs/checkpoint.c >>> +++ b/fs/f2fs/checkpoint.c >>> @@ -897,11 +897,8 @@ static int block_operations(struct f2fs_sb_info *sbi) >>> .nr_to_write = LONG_MAX, >>> .for_reclaim = 0, >>> }; >>> - struct blk_plug plug; >>> int err = 0; >>> >>> - blk_start_plug(&plug); >>> - >>> retry_flush_dents: >>> f2fs_lock_all(sbi); >>> /* write all the dirty dentry pages */ >>> @@ -938,7 +935,6 @@ retry_flush_nodes: >>> goto retry_flush_nodes; >>> } >>> out: >>> - blk_finish_plug(&plug); >>> return err; >>> } >>> >>> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c >>> index 30dc448..5f655d0 100644 >>> --- a/fs/f2fs/data.c >>> +++ b/fs/f2fs/data.c >>> @@ -98,10 +98,13 @@ static struct bio *__bio_alloc(struct f2fs_sb_info *sbi, block_t blk_addr, >>> } >>> >>> static inline void __submit_bio(struct f2fs_sb_info *sbi, int rw, >>> - struct bio *bio) >>> + struct bio *bio, enum page_type type) >>> { >>> - if (!is_read_io(rw)) >>> + if (!is_read_io(rw)) { >>> atomic_inc(&sbi->nr_wb_bios); >>> + if (current->plug && (type == DATA || type == NODE)) >>> + blk_finish_plug(current->plug); >>> + } >>> submit_bio(rw, bio); >>> } >>> >>> @@ -117,7 +120,7 @@ static void __submit_merged_bio(struct f2fs_bio_info *io) >>> else >>> trace_f2fs_submit_write_bio(io->sbi->sb, fio, io->bio); >>> >>> - __submit_bio(io->sbi, fio->rw, io->bio); >>> + __submit_bio(io->sbi, fio->rw, io->bio, fio->type); >>> io->bio = NULL; >>> } >>> >>> @@ -235,7 +238,7 @@ int f2fs_submit_page_bio(struct f2fs_io_info *fio) >>> return -EFAULT; >>> } >>> >>> - __submit_bio(fio->sbi, fio->rw, bio); >>> + __submit_bio(fio->sbi, fio->rw, bio, fio->type); >>> return 0; >>> } >>> >>> @@ -1040,7 +1043,7 @@ got_it: >>> */ >>> if (bio && (last_block_in_bio != block_nr - 1)) { >>> submit_and_realloc: >>> - __submit_bio(F2FS_I_SB(inode), READ, bio); >>> + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); >>> bio = NULL; >>> } >>> if (bio == NULL) { >>> @@ -1083,7 +1086,7 @@ set_error_page: >>> goto next_page; >>> confused: >>> if (bio) { >>> - __submit_bio(F2FS_I_SB(inode), READ, bio); >>> + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); >>> bio = NULL; >>> } >>> unlock_page(page); >>> @@ -1093,7 +1096,7 @@ next_page: >>> } >>> BUG_ON(pages && !list_empty(pages)); >>> if (bio) >>> - __submit_bio(F2FS_I_SB(inode), READ, bio); >>> + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); >>> return 0; >>> } >>> >>> diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c >>> index 4a03076..67fd285 100644 >>> --- a/fs/f2fs/gc.c >>> +++ b/fs/f2fs/gc.c >>> @@ -777,7 +777,6 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi, >>> { >>> struct page *sum_page; >>> struct f2fs_summary_block *sum; >>> - struct blk_plug plug; >>> unsigned int segno = start_segno; >>> unsigned int end_segno = start_segno + sbi->segs_per_sec; >>> int seg_freed = 0; >>> @@ -795,8 +794,6 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi, >>> unlock_page(sum_page); >>> } >>> >>> - blk_start_plug(&plug); >>> - >>> for (segno = start_segno; segno < end_segno; segno++) { >>> /* find segment summary of victim */ >>> sum_page = find_get_page(META_MAPPING(sbi), >>> @@ -830,8 +827,6 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi, >>> f2fs_submit_merged_bio(sbi, >>> (type == SUM_TYPE_NODE) ? NODE : DATA, WRITE); >>> >>> - blk_finish_plug(&plug); >>> - >>> if (gc_type == FG_GC) { >>> while (start_segno < end_segno) >>> if (get_valid_blocks(sbi, start_segno++, 1) == 0) >>> diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c >>> index 7b58bfb..eff046a 100644 >>> --- a/fs/f2fs/segment.c >>> +++ b/fs/f2fs/segment.c >>> @@ -379,13 +379,8 @@ void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi) >>> excess_prefree_segs(sbi) || >>> excess_dirty_nats(sbi) || >>> (is_idle(sbi) && f2fs_time_over(sbi, CP_TIME))) { >>> - if (test_opt(sbi, DATA_FLUSH)) { >>> - struct blk_plug plug; >>> - >>> - blk_start_plug(&plug); >>> + if (test_opt(sbi, DATA_FLUSH)) >>> sync_dirty_inodes(sbi, FILE_INODE); >>> - blk_finish_plug(&plug); >>> - } >>> f2fs_sync_fs(sbi->sb, true); >>> stat_inc_bg_cp_count(sbi->stat_info); >>> } >>> > > . > -- To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Hi Chao, On Tue, Jul 12, 2016 at 09:38:11AM +0800, Chao Yu wrote: > On 2016/7/10 0:32, Jaegeuk Kim wrote: > > On Sat, Jul 09, 2016 at 10:28:49AM +0800, Chao Yu wrote: > >> Hi Jaegeuk, > >> > >> On 2016/6/9 1:24, Jaegeuk Kim wrote: > >>> In f2fs, we don't need to keep block plugging for NODE and DATA writes, since > >>> we already merged bios as much as possible. > >> > >> IMO, we can not remove block plug, this is because there are still many > >> conditions which stops us merging r/w IOs into one bio as we expect, > >> theoretically, block plug can hold bios as much as possible, then submitting > >> them into queue in batch, it will reduce racing of grabbing queue->lock during > >> bio submitting, if we drop them, when syncing nodes or flushing datas, we will > >> suffer more lock racing. > >> > >> Or there are something I am missing, do you suffer any performance issue on > >> block plug? > > > > In the latest patch, I've turned off plugging forcefully, only if the underlying > > device is SMR drive. > > Got it. > > > And, still I removed other block plugging, since I couldn't see any performance > > regression. > > I suspect that in low-end machine with single-queue which is used in block > layer, we will suffer regression. > > > Even in some workloads, I could have seen some inverted IOs due to > > race condition between plugged and unplugged IOs. > > For data path, what about enabling block plug for IPU/SSR ? Not sure. IPU and SSR will produce small (likely random) writes. What I'm seeing here is that we already try to merge bios as much as possible. Thus, I'm in doubt why we need to wait for merging them by block layer. If possible, could you check this in android? Thanks, > >>> > >>> Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org> > >>> --- > >>> fs/f2fs/checkpoint.c | 4 ---- > >>> fs/f2fs/data.c | 17 ++++++++++------- > >>> fs/f2fs/gc.c | 5 ----- > >>> fs/f2fs/segment.c | 7 +------ > >>> 4 files changed, 11 insertions(+), 22 deletions(-) > >>> > >>> diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c > >>> index 5ddd15c..4179c7b 100644 > >>> --- a/fs/f2fs/checkpoint.c > >>> +++ b/fs/f2fs/checkpoint.c > >>> @@ -897,11 +897,8 @@ static int block_operations(struct f2fs_sb_info *sbi) > >>> .nr_to_write = LONG_MAX, > >>> .for_reclaim = 0, > >>> }; > >>> - struct blk_plug plug; > >>> int err = 0; > >>> > >>> - blk_start_plug(&plug); > >>> - > >>> retry_flush_dents: > >>> f2fs_lock_all(sbi); > >>> /* write all the dirty dentry pages */ > >>> @@ -938,7 +935,6 @@ retry_flush_nodes: > >>> goto retry_flush_nodes; > >>> } > >>> out: > >>> - blk_finish_plug(&plug); > >>> return err; > >>> } > >>> > >>> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c > >>> index 30dc448..5f655d0 100644 > >>> --- a/fs/f2fs/data.c > >>> +++ b/fs/f2fs/data.c > >>> @@ -98,10 +98,13 @@ static struct bio *__bio_alloc(struct f2fs_sb_info *sbi, block_t blk_addr, > >>> } > >>> > >>> static inline void __submit_bio(struct f2fs_sb_info *sbi, int rw, > >>> - struct bio *bio) > >>> + struct bio *bio, enum page_type type) > >>> { > >>> - if (!is_read_io(rw)) > >>> + if (!is_read_io(rw)) { > >>> atomic_inc(&sbi->nr_wb_bios); > >>> + if (current->plug && (type == DATA || type == NODE)) > >>> + blk_finish_plug(current->plug); > >>> + } > >>> submit_bio(rw, bio); > >>> } > >>> > >>> @@ -117,7 +120,7 @@ static void __submit_merged_bio(struct f2fs_bio_info *io) > >>> else > >>> trace_f2fs_submit_write_bio(io->sbi->sb, fio, io->bio); > >>> > >>> - __submit_bio(io->sbi, fio->rw, io->bio); > >>> + __submit_bio(io->sbi, fio->rw, io->bio, fio->type); > >>> io->bio = NULL; > >>> } > >>> > >>> @@ -235,7 +238,7 @@ int f2fs_submit_page_bio(struct f2fs_io_info *fio) > >>> return -EFAULT; > >>> } > >>> > >>> - __submit_bio(fio->sbi, fio->rw, bio); > >>> + __submit_bio(fio->sbi, fio->rw, bio, fio->type); > >>> return 0; > >>> } > >>> > >>> @@ -1040,7 +1043,7 @@ got_it: > >>> */ > >>> if (bio && (last_block_in_bio != block_nr - 1)) { > >>> submit_and_realloc: > >>> - __submit_bio(F2FS_I_SB(inode), READ, bio); > >>> + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); > >>> bio = NULL; > >>> } > >>> if (bio == NULL) { > >>> @@ -1083,7 +1086,7 @@ set_error_page: > >>> goto next_page; > >>> confused: > >>> if (bio) { > >>> - __submit_bio(F2FS_I_SB(inode), READ, bio); > >>> + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); > >>> bio = NULL; > >>> } > >>> unlock_page(page); > >>> @@ -1093,7 +1096,7 @@ next_page: > >>> } > >>> BUG_ON(pages && !list_empty(pages)); > >>> if (bio) > >>> - __submit_bio(F2FS_I_SB(inode), READ, bio); > >>> + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); > >>> return 0; > >>> } > >>> > >>> diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c > >>> index 4a03076..67fd285 100644 > >>> --- a/fs/f2fs/gc.c > >>> +++ b/fs/f2fs/gc.c > >>> @@ -777,7 +777,6 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi, > >>> { > >>> struct page *sum_page; > >>> struct f2fs_summary_block *sum; > >>> - struct blk_plug plug; > >>> unsigned int segno = start_segno; > >>> unsigned int end_segno = start_segno + sbi->segs_per_sec; > >>> int seg_freed = 0; > >>> @@ -795,8 +794,6 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi, > >>> unlock_page(sum_page); > >>> } > >>> > >>> - blk_start_plug(&plug); > >>> - > >>> for (segno = start_segno; segno < end_segno; segno++) { > >>> /* find segment summary of victim */ > >>> sum_page = find_get_page(META_MAPPING(sbi), > >>> @@ -830,8 +827,6 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi, > >>> f2fs_submit_merged_bio(sbi, > >>> (type == SUM_TYPE_NODE) ? NODE : DATA, WRITE); > >>> > >>> - blk_finish_plug(&plug); > >>> - > >>> if (gc_type == FG_GC) { > >>> while (start_segno < end_segno) > >>> if (get_valid_blocks(sbi, start_segno++, 1) == 0) > >>> diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c > >>> index 7b58bfb..eff046a 100644 > >>> --- a/fs/f2fs/segment.c > >>> +++ b/fs/f2fs/segment.c > >>> @@ -379,13 +379,8 @@ void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi) > >>> excess_prefree_segs(sbi) || > >>> excess_dirty_nats(sbi) || > >>> (is_idle(sbi) && f2fs_time_over(sbi, CP_TIME))) { > >>> - if (test_opt(sbi, DATA_FLUSH)) { > >>> - struct blk_plug plug; > >>> - > >>> - blk_start_plug(&plug); > >>> + if (test_opt(sbi, DATA_FLUSH)) > >>> sync_dirty_inodes(sbi, FILE_INODE); > >>> - blk_finish_plug(&plug); > >>> - } > >>> f2fs_sync_fs(sbi->sb, true); > >>> stat_inc_bg_cp_count(sbi->stat_info); > >>> } > >>> > > > > . > > -- To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
SGksIEtpbSwNCg0KCVlvdSBhcmUgcmlnaHQuIElmIGZpbGUgc3lzdGVtIGNhbiBtZXJnZSBiaW9z IGFzIG11Y2ggYXMgcG9zc2libGUuIEl0J3MgdmVyeSBoZWxwZnVsIHRvIGJsb2NrIGxheWVyLiBC dXQgcGx1Z2dpbmcgbWVjaGFuaXNtIGhhcyBhIHByZWNvZ25pdGlvbiBvZiBJTyBzdHJlYW0gZXhj ZXB0IG1lcmdpbmcgYmlvcy4gRm9yIGV4YW1wbGUsIHdlIGNhbiBvdXQgdGhlIGxvdy1wb3dlciBt b2RlIGluIGFkdmFuY2Ugd2hlbiB5b3Ugc3RhcnQgYSBwbHVnIGFuZCB3ZSBjYW4gaW4gdGhlIGxv dy1wb3dlciBtb2RlIG9ubHkgd2hlbiB5b3UgZW5kIGEgcGx1ZyB0byBhdm9pZCBpbi1vdXQgbG93 LXBvd2VyIG1vZGUgZnJlcXVlbnRseS4gU28gSSB3YW50IHRvIGtub3cgaWYgdGhlcmUgaXMgYW55 IHNpZGUgZWZmZWN0IGluIEYyRlMgdG8gcmVzZXJ2ZSB0aGUgcGx1ZyBtZWNoYW5pc20gPw0KDQot LS0tLU9yaWdpbmFsIE1lc3NhZ2UtLS0tLQ0KRnJvbTogSmFlZ2V1ayBLaW0gW21haWx0bzpqYWVn ZXVrQGtlcm5lbC5vcmddIA0KU2VudDogMjAxNsTqN9TCMTPI1SAxOjA4DQpUbzogWXVjaGFvIChU KSA8eXVjaGFvMEBodWF3ZWkuY29tPg0KQ2M6IGxpbnV4LWtlcm5lbEB2Z2VyLmtlcm5lbC5vcmc7 IGxpbnV4LWZzZGV2ZWxAdmdlci5rZXJuZWwub3JnOyBsaW51eC1mMmZzLWRldmVsQGxpc3RzLnNv dXJjZWZvcmdlLm5ldDsgQ0hFTiBDSFVOIFlFTiAoSUFOKSA8Y2hlbi5jaHVuLnllbkBodWF3ZWku Y29tPjsgaGViaWFvIChHKSA8aGViaWFvNkBodWF3ZWkuY29tPg0KU3ViamVjdDogUmU6IFtmMmZz LWRldl0gW1BBVENIIDMvN10gZjJmczogZHJvcCBhbnkgYmxvY2sgcGx1Z2dpbmcNCg0KSGkgQ2hh bywNCg0KT24gVHVlLCBKdWwgMTIsIDIwMTYgYXQgMDk6Mzg6MTFBTSArMDgwMCwgQ2hhbyBZdSB3 cm90ZToNCj4gT24gMjAxNi83LzEwIDA6MzIsIEphZWdldWsgS2ltIHdyb3RlOg0KPiA+IE9uIFNh dCwgSnVsIDA5LCAyMDE2IGF0IDEwOjI4OjQ5QU0gKzA4MDAsIENoYW8gWXUgd3JvdGU6DQo+ID4+ IEhpIEphZWdldWssDQo+ID4+DQo+ID4+IE9uIDIwMTYvNi85IDE6MjQsIEphZWdldWsgS2ltIHdy b3RlOg0KPiA+Pj4gSW4gZjJmcywgd2UgZG9uJ3QgbmVlZCB0byBrZWVwIGJsb2NrIHBsdWdnaW5n IGZvciBOT0RFIGFuZCBEQVRBIA0KPiA+Pj4gd3JpdGVzLCBzaW5jZSB3ZSBhbHJlYWR5IG1lcmdl ZCBiaW9zIGFzIG11Y2ggYXMgcG9zc2libGUuDQo+ID4+DQo+ID4+IElNTywgd2UgY2FuIG5vdCBy ZW1vdmUgYmxvY2sgcGx1ZywgdGhpcyBpcyBiZWNhdXNlIHRoZXJlIGFyZSBzdGlsbCANCj4gPj4g bWFueSBjb25kaXRpb25zIHdoaWNoIHN0b3BzIHVzIG1lcmdpbmcgci93IElPcyBpbnRvIG9uZSBi aW8gYXMgd2UgDQo+ID4+IGV4cGVjdCwgdGhlb3JldGljYWxseSwgYmxvY2sgcGx1ZyBjYW4gaG9s ZCBiaW9zIGFzIG11Y2ggYXMgDQo+ID4+IHBvc3NpYmxlLCB0aGVuIHN1Ym1pdHRpbmcgdGhlbSBp bnRvIHF1ZXVlIGluIGJhdGNoLCBpdCB3aWxsIHJlZHVjZSANCj4gPj4gcmFjaW5nIG9mIGdyYWJi aW5nIHF1ZXVlLT5sb2NrIGR1cmluZyBiaW8gc3VibWl0dGluZywgaWYgd2UgZHJvcCANCj4gPj4g dGhlbSwgd2hlbiBzeW5jaW5nIG5vZGVzIG9yIGZsdXNoaW5nIGRhdGFzLCB3ZSB3aWxsIHN1ZmZl ciBtb3JlIGxvY2sgcmFjaW5nLg0KPiA+Pg0KPiA+PiBPciB0aGVyZSBhcmUgc29tZXRoaW5nIEkg YW0gbWlzc2luZywgZG8geW91IHN1ZmZlciBhbnkgcGVyZm9ybWFuY2UgDQo+ID4+IGlzc3VlIG9u IGJsb2NrIHBsdWc/DQo+ID4gDQo+ID4gSW4gdGhlIGxhdGVzdCBwYXRjaCwgSSd2ZSB0dXJuZWQg b2ZmIHBsdWdnaW5nIGZvcmNlZnVsbHksIG9ubHkgaWYgDQo+ID4gdGhlIHVuZGVybHlpbmcgZGV2 aWNlIGlzIFNNUiBkcml2ZS4NCj4gDQo+IEdvdCBpdC4NCj4gDQo+ID4gQW5kLCBzdGlsbCBJIHJl bW92ZWQgb3RoZXIgYmxvY2sgcGx1Z2dpbmcsIHNpbmNlIEkgY291bGRuJ3Qgc2VlIGFueSANCj4g PiBwZXJmb3JtYW5jZSByZWdyZXNzaW9uLg0KPiANCj4gSSBzdXNwZWN0IHRoYXQgaW4gbG93LWVu ZCBtYWNoaW5lIHdpdGggc2luZ2xlLXF1ZXVlIHdoaWNoIGlzIHVzZWQgaW4gDQo+IGJsb2NrIGxh eWVyLCB3ZSB3aWxsIHN1ZmZlciByZWdyZXNzaW9uLg0KPiANCj4gPiBFdmVuIGluIHNvbWUgd29y a2xvYWRzLCBJIGNvdWxkIGhhdmUgc2VlbiBzb21lIGludmVydGVkIElPcyBkdWUgdG8gDQo+ID4g cmFjZSBjb25kaXRpb24gYmV0d2VlbiBwbHVnZ2VkIGFuZCB1bnBsdWdnZWQgSU9zLg0KPiANCj4g Rm9yIGRhdGEgcGF0aCwgd2hhdCBhYm91dCBlbmFibGluZyBibG9jayBwbHVnIGZvciBJUFUvU1NS ID8NCg0KTm90IHN1cmUuIElQVSBhbmQgU1NSIHdpbGwgcHJvZHVjZSBzbWFsbCAobGlrZWx5IHJh bmRvbSkgd3JpdGVzLg0KV2hhdCBJJ20gc2VlaW5nIGhlcmUgaXMgdGhhdCB3ZSBhbHJlYWR5IHRy eSB0byBtZXJnZSBiaW9zIGFzIG11Y2ggYXMgcG9zc2libGUuDQpUaHVzLCBJJ20gaW4gZG91YnQg d2h5IHdlIG5lZWQgdG8gd2FpdCBmb3IgbWVyZ2luZyB0aGVtIGJ5IGJsb2NrIGxheWVyLg0KSWYg cG9zc2libGUsIGNvdWxkIHlvdSBjaGVjayB0aGlzIGluIGFuZHJvaWQ/DQoNClRoYW5rcywNCg0K PiA+Pj4NCj4gPj4+IFNpZ25lZC1vZmYtYnk6IEphZWdldWsgS2ltIDxqYWVnZXVrQGtlcm5lbC5v cmc+DQo+ID4+PiAtLS0NCj4gPj4+ICBmcy9mMmZzL2NoZWNrcG9pbnQuYyB8ICA0IC0tLS0NCj4g Pj4+ICBmcy9mMmZzL2RhdGEuYyAgICAgICB8IDE3ICsrKysrKysrKystLS0tLS0tDQo+ID4+PiAg ZnMvZjJmcy9nYy5jICAgICAgICAgfCAgNSAtLS0tLQ0KPiA+Pj4gIGZzL2YyZnMvc2VnbWVudC5j ICAgIHwgIDcgKy0tLS0tLQ0KPiA+Pj4gIDQgZmlsZXMgY2hhbmdlZCwgMTEgaW5zZXJ0aW9ucygr KSwgMjIgZGVsZXRpb25zKC0pDQo+ID4+Pg0KPiA+Pj4gZGlmZiAtLWdpdCBhL2ZzL2YyZnMvY2hl Y2twb2ludC5jIGIvZnMvZjJmcy9jaGVja3BvaW50LmMgaW5kZXggDQo+ID4+PiA1ZGRkMTVjLi40 MTc5YzdiIDEwMDY0NA0KPiA+Pj4gLS0tIGEvZnMvZjJmcy9jaGVja3BvaW50LmMNCj4gPj4+ICsr KyBiL2ZzL2YyZnMvY2hlY2twb2ludC5jDQo+ID4+PiBAQCAtODk3LDExICs4OTcsOCBAQCBzdGF0 aWMgaW50IGJsb2NrX29wZXJhdGlvbnMoc3RydWN0IGYyZnNfc2JfaW5mbyAqc2JpKQ0KPiA+Pj4g IAkJLm5yX3RvX3dyaXRlID0gTE9OR19NQVgsDQo+ID4+PiAgCQkuZm9yX3JlY2xhaW0gPSAwLA0K PiA+Pj4gIAl9Ow0KPiA+Pj4gLQlzdHJ1Y3QgYmxrX3BsdWcgcGx1ZzsNCj4gPj4+ICAJaW50IGVy ciA9IDA7DQo+ID4+PiAgDQo+ID4+PiAtCWJsa19zdGFydF9wbHVnKCZwbHVnKTsNCj4gPj4+IC0N Cj4gPj4+ICByZXRyeV9mbHVzaF9kZW50czoNCj4gPj4+ICAJZjJmc19sb2NrX2FsbChzYmkpOw0K PiA+Pj4gIAkvKiB3cml0ZSBhbGwgdGhlIGRpcnR5IGRlbnRyeSBwYWdlcyAqLyBAQCAtOTM4LDcg KzkzNSw2IEBAIA0KPiA+Pj4gcmV0cnlfZmx1c2hfbm9kZXM6DQo+ID4+PiAgCQlnb3RvIHJldHJ5 X2ZsdXNoX25vZGVzOw0KPiA+Pj4gIAl9DQo+ID4+PiAgb3V0Og0KPiA+Pj4gLQlibGtfZmluaXNo X3BsdWcoJnBsdWcpOw0KPiA+Pj4gIAlyZXR1cm4gZXJyOw0KPiA+Pj4gIH0NCj4gPj4+ICANCj4g Pj4+IGRpZmYgLS1naXQgYS9mcy9mMmZzL2RhdGEuYyBiL2ZzL2YyZnMvZGF0YS5jIGluZGV4IA0K PiA+Pj4gMzBkYzQ0OC4uNWY2NTVkMCAxMDA2NDQNCj4gPj4+IC0tLSBhL2ZzL2YyZnMvZGF0YS5j DQo+ID4+PiArKysgYi9mcy9mMmZzL2RhdGEuYw0KPiA+Pj4gQEAgLTk4LDEwICs5OCwxMyBAQCBz dGF0aWMgc3RydWN0IGJpbyAqX19iaW9fYWxsb2Moc3RydWN0IA0KPiA+Pj4gZjJmc19zYl9pbmZv ICpzYmksIGJsb2NrX3QgYmxrX2FkZHIsICB9DQo+ID4+PiAgDQo+ID4+PiAgc3RhdGljIGlubGlu ZSB2b2lkIF9fc3VibWl0X2JpbyhzdHJ1Y3QgZjJmc19zYl9pbmZvICpzYmksIGludCBydywNCj4g Pj4+IC0JCQkJCQlzdHJ1Y3QgYmlvICpiaW8pDQo+ID4+PiArCQkJc3RydWN0IGJpbyAqYmlvLCBl bnVtIHBhZ2VfdHlwZSB0eXBlKQ0KPiA+Pj4gIHsNCj4gPj4+IC0JaWYgKCFpc19yZWFkX2lvKHJ3 KSkNCj4gPj4+ICsJaWYgKCFpc19yZWFkX2lvKHJ3KSkgew0KPiA+Pj4gIAkJYXRvbWljX2luYygm c2JpLT5ucl93Yl9iaW9zKTsNCj4gPj4+ICsJCWlmIChjdXJyZW50LT5wbHVnICYmICh0eXBlID09 IERBVEEgfHwgdHlwZSA9PSBOT0RFKSkNCj4gPj4+ICsJCQlibGtfZmluaXNoX3BsdWcoY3VycmVu dC0+cGx1Zyk7DQo+ID4+PiArCX0NCj4gPj4+ICAJc3VibWl0X2JpbyhydywgYmlvKTsNCj4gPj4+ ICB9DQo+ID4+PiAgDQo+ID4+PiBAQCAtMTE3LDcgKzEyMCw3IEBAIHN0YXRpYyB2b2lkIF9fc3Vi bWl0X21lcmdlZF9iaW8oc3RydWN0IGYyZnNfYmlvX2luZm8gKmlvKQ0KPiA+Pj4gIAllbHNlDQo+ ID4+PiAgCQl0cmFjZV9mMmZzX3N1Ym1pdF93cml0ZV9iaW8oaW8tPnNiaS0+c2IsIGZpbywgaW8t PmJpbyk7DQo+ID4+PiAgDQo+ID4+PiAtCV9fc3VibWl0X2Jpbyhpby0+c2JpLCBmaW8tPnJ3LCBp by0+YmlvKTsNCj4gPj4+ICsJX19zdWJtaXRfYmlvKGlvLT5zYmksIGZpby0+cncsIGlvLT5iaW8s IGZpby0+dHlwZSk7DQo+ID4+PiAgCWlvLT5iaW8gPSBOVUxMOw0KPiA+Pj4gIH0NCj4gPj4+ICAN Cj4gPj4+IEBAIC0yMzUsNyArMjM4LDcgQEAgaW50IGYyZnNfc3VibWl0X3BhZ2VfYmlvKHN0cnVj dCBmMmZzX2lvX2luZm8gKmZpbykNCj4gPj4+ICAJCXJldHVybiAtRUZBVUxUOw0KPiA+Pj4gIAl9 DQo+ID4+PiAgDQo+ID4+PiAtCV9fc3VibWl0X2JpbyhmaW8tPnNiaSwgZmlvLT5ydywgYmlvKTsN Cj4gPj4+ICsJX19zdWJtaXRfYmlvKGZpby0+c2JpLCBmaW8tPnJ3LCBiaW8sIGZpby0+dHlwZSk7 DQo+ID4+PiAgCXJldHVybiAwOw0KPiA+Pj4gIH0NCj4gPj4+ICANCj4gPj4+IEBAIC0xMDQwLDcg KzEwNDMsNyBAQCBnb3RfaXQ6DQo+ID4+PiAgCQkgKi8NCj4gPj4+ICAJCWlmIChiaW8gJiYgKGxh c3RfYmxvY2tfaW5fYmlvICE9IGJsb2NrX25yIC0gMSkpIHsNCj4gPj4+ICBzdWJtaXRfYW5kX3Jl YWxsb2M6DQo+ID4+PiAtCQkJX19zdWJtaXRfYmlvKEYyRlNfSV9TQihpbm9kZSksIFJFQUQsIGJp byk7DQo+ID4+PiArCQkJX19zdWJtaXRfYmlvKEYyRlNfSV9TQihpbm9kZSksIFJFQUQsIGJpbywg REFUQSk7DQo+ID4+PiAgCQkJYmlvID0gTlVMTDsNCj4gPj4+ICAJCX0NCj4gPj4+ICAJCWlmIChi aW8gPT0gTlVMTCkgew0KPiA+Pj4gQEAgLTEwODMsNyArMTA4Niw3IEBAIHNldF9lcnJvcl9wYWdl Og0KPiA+Pj4gIAkJZ290byBuZXh0X3BhZ2U7DQo+ID4+PiAgY29uZnVzZWQ6DQo+ID4+PiAgCQlp ZiAoYmlvKSB7DQo+ID4+PiAtCQkJX19zdWJtaXRfYmlvKEYyRlNfSV9TQihpbm9kZSksIFJFQUQs IGJpbyk7DQo+ID4+PiArCQkJX19zdWJtaXRfYmlvKEYyRlNfSV9TQihpbm9kZSksIFJFQUQsIGJp bywgREFUQSk7DQo+ID4+PiAgCQkJYmlvID0gTlVMTDsNCj4gPj4+ICAJCX0NCj4gPj4+ICAJCXVu bG9ja19wYWdlKHBhZ2UpOw0KPiA+Pj4gQEAgLTEwOTMsNyArMTA5Niw3IEBAIG5leHRfcGFnZToN Cj4gPj4+ICAJfQ0KPiA+Pj4gIAlCVUdfT04ocGFnZXMgJiYgIWxpc3RfZW1wdHkocGFnZXMpKTsN Cj4gPj4+ICAJaWYgKGJpbykNCj4gPj4+IC0JCV9fc3VibWl0X2JpbyhGMkZTX0lfU0IoaW5vZGUp LCBSRUFELCBiaW8pOw0KPiA+Pj4gKwkJX19zdWJtaXRfYmlvKEYyRlNfSV9TQihpbm9kZSksIFJF QUQsIGJpbywgREFUQSk7DQo+ID4+PiAgCXJldHVybiAwOw0KPiA+Pj4gIH0NCj4gPj4+ICANCj4g Pj4+IGRpZmYgLS1naXQgYS9mcy9mMmZzL2djLmMgYi9mcy9mMmZzL2djLmMgaW5kZXggNGEwMzA3 Ni4uNjdmZDI4NSANCj4gPj4+IDEwMDY0NA0KPiA+Pj4gLS0tIGEvZnMvZjJmcy9nYy5jDQo+ID4+ PiArKysgYi9mcy9mMmZzL2djLmMNCj4gPj4+IEBAIC03NzcsNyArNzc3LDYgQEAgc3RhdGljIGlu dCBkb19nYXJiYWdlX2NvbGxlY3Qoc3RydWN0IA0KPiA+Pj4gZjJmc19zYl9pbmZvICpzYmksICB7 DQo+ID4+PiAgCXN0cnVjdCBwYWdlICpzdW1fcGFnZTsNCj4gPj4+ICAJc3RydWN0IGYyZnNfc3Vt bWFyeV9ibG9jayAqc3VtOw0KPiA+Pj4gLQlzdHJ1Y3QgYmxrX3BsdWcgcGx1ZzsNCj4gPj4+ICAJ dW5zaWduZWQgaW50IHNlZ25vID0gc3RhcnRfc2Vnbm87DQo+ID4+PiAgCXVuc2lnbmVkIGludCBl bmRfc2Vnbm8gPSBzdGFydF9zZWdubyArIHNiaS0+c2Vnc19wZXJfc2VjOw0KPiA+Pj4gIAlpbnQg c2VnX2ZyZWVkID0gMDsNCj4gPj4+IEBAIC03OTUsOCArNzk0LDYgQEAgc3RhdGljIGludCBkb19n YXJiYWdlX2NvbGxlY3Qoc3RydWN0IGYyZnNfc2JfaW5mbyAqc2JpLA0KPiA+Pj4gIAkJdW5sb2Nr X3BhZ2Uoc3VtX3BhZ2UpOw0KPiA+Pj4gIAl9DQo+ID4+PiAgDQo+ID4+PiAtCWJsa19zdGFydF9w bHVnKCZwbHVnKTsNCj4gPj4+IC0NCj4gPj4+ICAJZm9yIChzZWdubyA9IHN0YXJ0X3NlZ25vOyBz ZWdubyA8IGVuZF9zZWdubzsgc2Vnbm8rKykgew0KPiA+Pj4gIAkJLyogZmluZCBzZWdtZW50IHN1 bW1hcnkgb2YgdmljdGltICovDQo+ID4+PiAgCQlzdW1fcGFnZSA9IGZpbmRfZ2V0X3BhZ2UoTUVU QV9NQVBQSU5HKHNiaSksIEBAIC04MzAsOCArODI3LDYgQEAgDQo+ID4+PiBzdGF0aWMgaW50IGRv X2dhcmJhZ2VfY29sbGVjdChzdHJ1Y3QgZjJmc19zYl9pbmZvICpzYmksDQo+ID4+PiAgCQlmMmZz X3N1Ym1pdF9tZXJnZWRfYmlvKHNiaSwNCj4gPj4+ICAJCQkJKHR5cGUgPT0gU1VNX1RZUEVfTk9E RSkgPyBOT0RFIDogREFUQSwgV1JJVEUpOw0KPiA+Pj4gIA0KPiA+Pj4gLQlibGtfZmluaXNoX3Bs dWcoJnBsdWcpOw0KPiA+Pj4gLQ0KPiA+Pj4gIAlpZiAoZ2NfdHlwZSA9PSBGR19HQykgew0KPiA+ Pj4gIAkJd2hpbGUgKHN0YXJ0X3NlZ25vIDwgZW5kX3NlZ25vKQ0KPiA+Pj4gIAkJCWlmIChnZXRf dmFsaWRfYmxvY2tzKHNiaSwgc3RhcnRfc2Vnbm8rKywgMSkgPT0gMCkgZGlmZiAtLWdpdCANCj4g Pj4+IGEvZnMvZjJmcy9zZWdtZW50LmMgYi9mcy9mMmZzL3NlZ21lbnQuYyBpbmRleCA3YjU4YmZi Li5lZmYwNDZhIA0KPiA+Pj4gMTAwNjQ0DQo+ID4+PiAtLS0gYS9mcy9mMmZzL3NlZ21lbnQuYw0K PiA+Pj4gKysrIGIvZnMvZjJmcy9zZWdtZW50LmMNCj4gPj4+IEBAIC0zNzksMTMgKzM3OSw4IEBA IHZvaWQgZjJmc19iYWxhbmNlX2ZzX2JnKHN0cnVjdCBmMmZzX3NiX2luZm8gKnNiaSkNCj4gPj4+ ICAJCQlleGNlc3NfcHJlZnJlZV9zZWdzKHNiaSkgfHwNCj4gPj4+ICAJCQlleGNlc3NfZGlydHlf bmF0cyhzYmkpIHx8DQo+ID4+PiAgCQkJKGlzX2lkbGUoc2JpKSAmJiBmMmZzX3RpbWVfb3Zlcihz YmksIENQX1RJTUUpKSkgew0KPiA+Pj4gLQkJaWYgKHRlc3Rfb3B0KHNiaSwgREFUQV9GTFVTSCkp IHsNCj4gPj4+IC0JCQlzdHJ1Y3QgYmxrX3BsdWcgcGx1ZzsNCj4gPj4+IC0NCj4gPj4+IC0JCQli bGtfc3RhcnRfcGx1ZygmcGx1Zyk7DQo+ID4+PiArCQlpZiAodGVzdF9vcHQoc2JpLCBEQVRBX0ZM VVNIKSkNCj4gPj4+ICAJCQlzeW5jX2RpcnR5X2lub2RlcyhzYmksIEZJTEVfSU5PREUpOw0KPiA+ Pj4gLQkJCWJsa19maW5pc2hfcGx1ZygmcGx1Zyk7DQo+ID4+PiAtCQl9DQo+ID4+PiAgCQlmMmZz X3N5bmNfZnMoc2JpLT5zYiwgdHJ1ZSk7DQo+ID4+PiAgCQlzdGF0X2luY19iZ19jcF9jb3VudChz YmktPnN0YXRfaW5mbyk7DQo+ID4+PiAgCX0NCj4gPj4+DQo+ID4gDQo+ID4gLg0KPiA+IA0K -- To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Hi hebiao, On Wed, Jul 13, 2016 at 01:21:15AM +0000, hebiao (G) wrote: > Hi, Kim, > > You are right. If file system can merge bios as much as possible. It's very helpful to block layer. But plugging mechanism has a precognition of IO stream except merging bios. For example, we can out the low-power mode in advance when you start a plug and we can in the low-power mode only when you end a plug to avoid in-out low-power mode frequently. So I want to know if there is any side effect in F2FS to reserve the plug mechanism ? Oh, does android kernel act like that? Nevertheless, I'll take a look at any performance regression if I add plugs in all the IO submission again. Thanks, > > -----Original Message----- > From: Jaegeuk Kim [mailto:jaegeuk@kernel.org] > Sent: 2016年7月13日 1:08 > To: Yuchao (T) <yuchao0@huawei.com> > Cc: linux-kernel@vger.kernel.org; linux-fsdevel@vger.kernel.org; linux-f2fs-devel@lists.sourceforge.net; CHEN CHUN YEN (IAN) <chen.chun.yen@huawei.com>; hebiao (G) <hebiao6@huawei.com> > Subject: Re: [f2fs-dev] [PATCH 3/7] f2fs: drop any block plugging > > Hi Chao, > > On Tue, Jul 12, 2016 at 09:38:11AM +0800, Chao Yu wrote: > > On 2016/7/10 0:32, Jaegeuk Kim wrote: > > > On Sat, Jul 09, 2016 at 10:28:49AM +0800, Chao Yu wrote: > > >> Hi Jaegeuk, > > >> > > >> On 2016/6/9 1:24, Jaegeuk Kim wrote: > > >>> In f2fs, we don't need to keep block plugging for NODE and DATA > > >>> writes, since we already merged bios as much as possible. > > >> > > >> IMO, we can not remove block plug, this is because there are still > > >> many conditions which stops us merging r/w IOs into one bio as we > > >> expect, theoretically, block plug can hold bios as much as > > >> possible, then submitting them into queue in batch, it will reduce > > >> racing of grabbing queue->lock during bio submitting, if we drop > > >> them, when syncing nodes or flushing datas, we will suffer more lock racing. > > >> > > >> Or there are something I am missing, do you suffer any performance > > >> issue on block plug? > > > > > > In the latest patch, I've turned off plugging forcefully, only if > > > the underlying device is SMR drive. > > > > Got it. > > > > > And, still I removed other block plugging, since I couldn't see any > > > performance regression. > > > > I suspect that in low-end machine with single-queue which is used in > > block layer, we will suffer regression. > > > > > Even in some workloads, I could have seen some inverted IOs due to > > > race condition between plugged and unplugged IOs. > > > > For data path, what about enabling block plug for IPU/SSR ? > > Not sure. IPU and SSR will produce small (likely random) writes. > What I'm seeing here is that we already try to merge bios as much as possible. > Thus, I'm in doubt why we need to wait for merging them by block layer. > If possible, could you check this in android? > > Thanks, > > > >>> > > >>> Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org> > > >>> --- > > >>> fs/f2fs/checkpoint.c | 4 ---- > > >>> fs/f2fs/data.c | 17 ++++++++++------- > > >>> fs/f2fs/gc.c | 5 ----- > > >>> fs/f2fs/segment.c | 7 +------ > > >>> 4 files changed, 11 insertions(+), 22 deletions(-) > > >>> > > >>> diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c index > > >>> 5ddd15c..4179c7b 100644 > > >>> --- a/fs/f2fs/checkpoint.c > > >>> +++ b/fs/f2fs/checkpoint.c > > >>> @@ -897,11 +897,8 @@ static int block_operations(struct f2fs_sb_info *sbi) > > >>> .nr_to_write = LONG_MAX, > > >>> .for_reclaim = 0, > > >>> }; > > >>> - struct blk_plug plug; > > >>> int err = 0; > > >>> > > >>> - blk_start_plug(&plug); > > >>> - > > >>> retry_flush_dents: > > >>> f2fs_lock_all(sbi); > > >>> /* write all the dirty dentry pages */ @@ -938,7 +935,6 @@ > > >>> retry_flush_nodes: > > >>> goto retry_flush_nodes; > > >>> } > > >>> out: > > >>> - blk_finish_plug(&plug); > > >>> return err; > > >>> } > > >>> > > >>> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c index > > >>> 30dc448..5f655d0 100644 > > >>> --- a/fs/f2fs/data.c > > >>> +++ b/fs/f2fs/data.c > > >>> @@ -98,10 +98,13 @@ static struct bio *__bio_alloc(struct > > >>> f2fs_sb_info *sbi, block_t blk_addr, } > > >>> > > >>> static inline void __submit_bio(struct f2fs_sb_info *sbi, int rw, > > >>> - struct bio *bio) > > >>> + struct bio *bio, enum page_type type) > > >>> { > > >>> - if (!is_read_io(rw)) > > >>> + if (!is_read_io(rw)) { > > >>> atomic_inc(&sbi->nr_wb_bios); > > >>> + if (current->plug && (type == DATA || type == NODE)) > > >>> + blk_finish_plug(current->plug); > > >>> + } > > >>> submit_bio(rw, bio); > > >>> } > > >>> > > >>> @@ -117,7 +120,7 @@ static void __submit_merged_bio(struct f2fs_bio_info *io) > > >>> else > > >>> trace_f2fs_submit_write_bio(io->sbi->sb, fio, io->bio); > > >>> > > >>> - __submit_bio(io->sbi, fio->rw, io->bio); > > >>> + __submit_bio(io->sbi, fio->rw, io->bio, fio->type); > > >>> io->bio = NULL; > > >>> } > > >>> > > >>> @@ -235,7 +238,7 @@ int f2fs_submit_page_bio(struct f2fs_io_info *fio) > > >>> return -EFAULT; > > >>> } > > >>> > > >>> - __submit_bio(fio->sbi, fio->rw, bio); > > >>> + __submit_bio(fio->sbi, fio->rw, bio, fio->type); > > >>> return 0; > > >>> } > > >>> > > >>> @@ -1040,7 +1043,7 @@ got_it: > > >>> */ > > >>> if (bio && (last_block_in_bio != block_nr - 1)) { > > >>> submit_and_realloc: > > >>> - __submit_bio(F2FS_I_SB(inode), READ, bio); > > >>> + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); > > >>> bio = NULL; > > >>> } > > >>> if (bio == NULL) { > > >>> @@ -1083,7 +1086,7 @@ set_error_page: > > >>> goto next_page; > > >>> confused: > > >>> if (bio) { > > >>> - __submit_bio(F2FS_I_SB(inode), READ, bio); > > >>> + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); > > >>> bio = NULL; > > >>> } > > >>> unlock_page(page); > > >>> @@ -1093,7 +1096,7 @@ next_page: > > >>> } > > >>> BUG_ON(pages && !list_empty(pages)); > > >>> if (bio) > > >>> - __submit_bio(F2FS_I_SB(inode), READ, bio); > > >>> + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); > > >>> return 0; > > >>> } > > >>> > > >>> diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c index 4a03076..67fd285 > > >>> 100644 > > >>> --- a/fs/f2fs/gc.c > > >>> +++ b/fs/f2fs/gc.c > > >>> @@ -777,7 +777,6 @@ static int do_garbage_collect(struct > > >>> f2fs_sb_info *sbi, { > > >>> struct page *sum_page; > > >>> struct f2fs_summary_block *sum; > > >>> - struct blk_plug plug; > > >>> unsigned int segno = start_segno; > > >>> unsigned int end_segno = start_segno + sbi->segs_per_sec; > > >>> int seg_freed = 0; > > >>> @@ -795,8 +794,6 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi, > > >>> unlock_page(sum_page); > > >>> } > > >>> > > >>> - blk_start_plug(&plug); > > >>> - > > >>> for (segno = start_segno; segno < end_segno; segno++) { > > >>> /* find segment summary of victim */ > > >>> sum_page = find_get_page(META_MAPPING(sbi), @@ -830,8 +827,6 @@ > > >>> static int do_garbage_collect(struct f2fs_sb_info *sbi, > > >>> f2fs_submit_merged_bio(sbi, > > >>> (type == SUM_TYPE_NODE) ? NODE : DATA, WRITE); > > >>> > > >>> - blk_finish_plug(&plug); > > >>> - > > >>> if (gc_type == FG_GC) { > > >>> while (start_segno < end_segno) > > >>> if (get_valid_blocks(sbi, start_segno++, 1) == 0) diff --git > > >>> a/fs/f2fs/segment.c b/fs/f2fs/segment.c index 7b58bfb..eff046a > > >>> 100644 > > >>> --- a/fs/f2fs/segment.c > > >>> +++ b/fs/f2fs/segment.c > > >>> @@ -379,13 +379,8 @@ void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi) > > >>> excess_prefree_segs(sbi) || > > >>> excess_dirty_nats(sbi) || > > >>> (is_idle(sbi) && f2fs_time_over(sbi, CP_TIME))) { > > >>> - if (test_opt(sbi, DATA_FLUSH)) { > > >>> - struct blk_plug plug; > > >>> - > > >>> - blk_start_plug(&plug); > > >>> + if (test_opt(sbi, DATA_FLUSH)) > > >>> sync_dirty_inodes(sbi, FILE_INODE); > > >>> - blk_finish_plug(&plug); > > >>> - } > > >>> f2fs_sync_fs(sbi->sb, true); > > >>> stat_inc_bg_cp_count(sbi->stat_info); > > >>> } > > >>> > > > > > > . > > > -- To unsubscribe from this list: send the line "unsubscribe linux-fsdevel" in the body of a message to majordomo@vger.kernel.org More majordomo info at http://vger.kernel.org/majordomo-info.html
Thanks Kim, it'll be very meaningful in block layer :-) -----Original Message----- From: Jaegeuk Kim [mailto:jaegeuk@kernel.org] Sent: 2016年7月14日 10:40 To: hebiao (G) <hebiao6@huawei.com> Cc: Yuchao (T) <yuchao0@huawei.com>; linux-kernel@vger.kernel.org; linux-fsdevel@vger.kernel.org; linux-f2fs-devel@lists.sourceforge.net; CHEN CHUN YEN (IAN) <chen.chun.yen@huawei.com>; Kongfei <kongfei@hisilicon.com> Subject: Re: [f2fs-dev] [PATCH 3/7] f2fs: drop any block plugging Hi hebiao, On Wed, Jul 13, 2016 at 01:21:15AM +0000, hebiao (G) wrote: > Hi, Kim, > > You are right. If file system can merge bios as much as possible. It's very helpful to block layer. But plugging mechanism has a precognition of IO stream except merging bios. For example, we can out the low-power mode in advance when you start a plug and we can in the low-power mode only when you end a plug to avoid in-out low-power mode frequently. So I want to know if there is any side effect in F2FS to reserve the plug mechanism ? Oh, does android kernel act like that? Nevertheless, I'll take a look at any performance regression if I add plugs in all the IO submission again. Thanks, > > -----Original Message----- > From: Jaegeuk Kim [mailto:jaegeuk@kernel.org] > Sent: 2016年7月13日 1:08 > To: Yuchao (T) <yuchao0@huawei.com> > Cc: linux-kernel@vger.kernel.org; linux-fsdevel@vger.kernel.org; > linux-f2fs-devel@lists.sourceforge.net; CHEN CHUN YEN (IAN) > <chen.chun.yen@huawei.com>; hebiao (G) <hebiao6@huawei.com> > Subject: Re: [f2fs-dev] [PATCH 3/7] f2fs: drop any block plugging > > Hi Chao, > > On Tue, Jul 12, 2016 at 09:38:11AM +0800, Chao Yu wrote: > > On 2016/7/10 0:32, Jaegeuk Kim wrote: > > > On Sat, Jul 09, 2016 at 10:28:49AM +0800, Chao Yu wrote: > > >> Hi Jaegeuk, > > >> > > >> On 2016/6/9 1:24, Jaegeuk Kim wrote: > > >>> In f2fs, we don't need to keep block plugging for NODE and DATA > > >>> writes, since we already merged bios as much as possible. > > >> > > >> IMO, we can not remove block plug, this is because there are > > >> still many conditions which stops us merging r/w IOs into one bio > > >> as we expect, theoretically, block plug can hold bios as much as > > >> possible, then submitting them into queue in batch, it will > > >> reduce racing of grabbing queue->lock during bio submitting, if > > >> we drop them, when syncing nodes or flushing datas, we will suffer more lock racing. > > >> > > >> Or there are something I am missing, do you suffer any > > >> performance issue on block plug? > > > > > > In the latest patch, I've turned off plugging forcefully, only if > > > the underlying device is SMR drive. > > > > Got it. > > > > > And, still I removed other block plugging, since I couldn't see > > > any performance regression. > > > > I suspect that in low-end machine with single-queue which is used in > > block layer, we will suffer regression. > > > > > Even in some workloads, I could have seen some inverted IOs due to > > > race condition between plugged and unplugged IOs. > > > > For data path, what about enabling block plug for IPU/SSR ? > > Not sure. IPU and SSR will produce small (likely random) writes. > What I'm seeing here is that we already try to merge bios as much as possible. > Thus, I'm in doubt why we need to wait for merging them by block layer. > If possible, could you check this in android? > > Thanks, > > > >>> > > >>> Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org> > > >>> --- > > >>> fs/f2fs/checkpoint.c | 4 ---- > > >>> fs/f2fs/data.c | 17 ++++++++++------- > > >>> fs/f2fs/gc.c | 5 ----- > > >>> fs/f2fs/segment.c | 7 +------ > > >>> 4 files changed, 11 insertions(+), 22 deletions(-) > > >>> > > >>> diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c index > > >>> 5ddd15c..4179c7b 100644 > > >>> --- a/fs/f2fs/checkpoint.c > > >>> +++ b/fs/f2fs/checkpoint.c > > >>> @@ -897,11 +897,8 @@ static int block_operations(struct f2fs_sb_info *sbi) > > >>> .nr_to_write = LONG_MAX, > > >>> .for_reclaim = 0, > > >>> }; > > >>> - struct blk_plug plug; > > >>> int err = 0; > > >>> > > >>> - blk_start_plug(&plug); > > >>> - > > >>> retry_flush_dents: > > >>> f2fs_lock_all(sbi); > > >>> /* write all the dirty dentry pages */ @@ -938,7 +935,6 @@ > > >>> retry_flush_nodes: > > >>> goto retry_flush_nodes; > > >>> } > > >>> out: > > >>> - blk_finish_plug(&plug); > > >>> return err; > > >>> } > > >>> > > >>> diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c index > > >>> 30dc448..5f655d0 100644 > > >>> --- a/fs/f2fs/data.c > > >>> +++ b/fs/f2fs/data.c > > >>> @@ -98,10 +98,13 @@ static struct bio *__bio_alloc(struct > > >>> f2fs_sb_info *sbi, block_t blk_addr, } > > >>> > > >>> static inline void __submit_bio(struct f2fs_sb_info *sbi, int rw, > > >>> - struct bio *bio) > > >>> + struct bio *bio, enum page_type type) > > >>> { > > >>> - if (!is_read_io(rw)) > > >>> + if (!is_read_io(rw)) { > > >>> atomic_inc(&sbi->nr_wb_bios); > > >>> + if (current->plug && (type == DATA || type == NODE)) > > >>> + blk_finish_plug(current->plug); > > >>> + } > > >>> submit_bio(rw, bio); > > >>> } > > >>> > > >>> @@ -117,7 +120,7 @@ static void __submit_merged_bio(struct f2fs_bio_info *io) > > >>> else > > >>> trace_f2fs_submit_write_bio(io->sbi->sb, fio, io->bio); > > >>> > > >>> - __submit_bio(io->sbi, fio->rw, io->bio); > > >>> + __submit_bio(io->sbi, fio->rw, io->bio, fio->type); > > >>> io->bio = NULL; > > >>> } > > >>> > > >>> @@ -235,7 +238,7 @@ int f2fs_submit_page_bio(struct f2fs_io_info *fio) > > >>> return -EFAULT; > > >>> } > > >>> > > >>> - __submit_bio(fio->sbi, fio->rw, bio); > > >>> + __submit_bio(fio->sbi, fio->rw, bio, fio->type); > > >>> return 0; > > >>> } > > >>> > > >>> @@ -1040,7 +1043,7 @@ got_it: > > >>> */ > > >>> if (bio && (last_block_in_bio != block_nr - 1)) { > > >>> submit_and_realloc: > > >>> - __submit_bio(F2FS_I_SB(inode), READ, bio); > > >>> + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); > > >>> bio = NULL; > > >>> } > > >>> if (bio == NULL) { > > >>> @@ -1083,7 +1086,7 @@ set_error_page: > > >>> goto next_page; > > >>> confused: > > >>> if (bio) { > > >>> - __submit_bio(F2FS_I_SB(inode), READ, bio); > > >>> + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); > > >>> bio = NULL; > > >>> } > > >>> unlock_page(page); > > >>> @@ -1093,7 +1096,7 @@ next_page: > > >>> } > > >>> BUG_ON(pages && !list_empty(pages)); > > >>> if (bio) > > >>> - __submit_bio(F2FS_I_SB(inode), READ, bio); > > >>> + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); > > >>> return 0; > > >>> } > > >>> > > >>> diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c index 4a03076..67fd285 > > >>> 100644 > > >>> --- a/fs/f2fs/gc.c > > >>> +++ b/fs/f2fs/gc.c > > >>> @@ -777,7 +777,6 @@ static int do_garbage_collect(struct > > >>> f2fs_sb_info *sbi, { > > >>> struct page *sum_page; > > >>> struct f2fs_summary_block *sum; > > >>> - struct blk_plug plug; > > >>> unsigned int segno = start_segno; > > >>> unsigned int end_segno = start_segno + sbi->segs_per_sec; > > >>> int seg_freed = 0; > > >>> @@ -795,8 +794,6 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi, > > >>> unlock_page(sum_page); > > >>> } > > >>> > > >>> - blk_start_plug(&plug); > > >>> - > > >>> for (segno = start_segno; segno < end_segno; segno++) { > > >>> /* find segment summary of victim */ > > >>> sum_page = find_get_page(META_MAPPING(sbi), @@ -830,8 +827,6 > > >>> @@ static int do_garbage_collect(struct f2fs_sb_info *sbi, > > >>> f2fs_submit_merged_bio(sbi, > > >>> (type == SUM_TYPE_NODE) ? NODE : DATA, WRITE); > > >>> > > >>> - blk_finish_plug(&plug); > > >>> - > > >>> if (gc_type == FG_GC) { > > >>> while (start_segno < end_segno) > > >>> if (get_valid_blocks(sbi, start_segno++, 1) == 0) diff --git > > >>> a/fs/f2fs/segment.c b/fs/f2fs/segment.c index 7b58bfb..eff046a > > >>> 100644 > > >>> --- a/fs/f2fs/segment.c > > >>> +++ b/fs/f2fs/segment.c > > >>> @@ -379,13 +379,8 @@ void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi) > > >>> excess_prefree_segs(sbi) || > > >>> excess_dirty_nats(sbi) || > > >>> (is_idle(sbi) && f2fs_time_over(sbi, CP_TIME))) { > > >>> - if (test_opt(sbi, DATA_FLUSH)) { > > >>> - struct blk_plug plug; > > >>> - > > >>> - blk_start_plug(&plug); > > >>> + if (test_opt(sbi, DATA_FLUSH)) > > >>> sync_dirty_inodes(sbi, FILE_INODE); > > >>> - blk_finish_plug(&plug); > > >>> - } > > >>> f2fs_sync_fs(sbi->sb, true); > > >>> stat_inc_bg_cp_count(sbi->stat_info); > > >>> } > > >>> > > > > > > . > > >
diff --git a/fs/f2fs/checkpoint.c b/fs/f2fs/checkpoint.c index 5ddd15c..4179c7b 100644 --- a/fs/f2fs/checkpoint.c +++ b/fs/f2fs/checkpoint.c @@ -897,11 +897,8 @@ static int block_operations(struct f2fs_sb_info *sbi) .nr_to_write = LONG_MAX, .for_reclaim = 0, }; - struct blk_plug plug; int err = 0; - blk_start_plug(&plug); - retry_flush_dents: f2fs_lock_all(sbi); /* write all the dirty dentry pages */ @@ -938,7 +935,6 @@ retry_flush_nodes: goto retry_flush_nodes; } out: - blk_finish_plug(&plug); return err; } diff --git a/fs/f2fs/data.c b/fs/f2fs/data.c index 30dc448..5f655d0 100644 --- a/fs/f2fs/data.c +++ b/fs/f2fs/data.c @@ -98,10 +98,13 @@ static struct bio *__bio_alloc(struct f2fs_sb_info *sbi, block_t blk_addr, } static inline void __submit_bio(struct f2fs_sb_info *sbi, int rw, - struct bio *bio) + struct bio *bio, enum page_type type) { - if (!is_read_io(rw)) + if (!is_read_io(rw)) { atomic_inc(&sbi->nr_wb_bios); + if (current->plug && (type == DATA || type == NODE)) + blk_finish_plug(current->plug); + } submit_bio(rw, bio); } @@ -117,7 +120,7 @@ static void __submit_merged_bio(struct f2fs_bio_info *io) else trace_f2fs_submit_write_bio(io->sbi->sb, fio, io->bio); - __submit_bio(io->sbi, fio->rw, io->bio); + __submit_bio(io->sbi, fio->rw, io->bio, fio->type); io->bio = NULL; } @@ -235,7 +238,7 @@ int f2fs_submit_page_bio(struct f2fs_io_info *fio) return -EFAULT; } - __submit_bio(fio->sbi, fio->rw, bio); + __submit_bio(fio->sbi, fio->rw, bio, fio->type); return 0; } @@ -1040,7 +1043,7 @@ got_it: */ if (bio && (last_block_in_bio != block_nr - 1)) { submit_and_realloc: - __submit_bio(F2FS_I_SB(inode), READ, bio); + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); bio = NULL; } if (bio == NULL) { @@ -1083,7 +1086,7 @@ set_error_page: goto next_page; confused: if (bio) { - __submit_bio(F2FS_I_SB(inode), READ, bio); + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); bio = NULL; } unlock_page(page); @@ -1093,7 +1096,7 @@ next_page: } BUG_ON(pages && !list_empty(pages)); if (bio) - __submit_bio(F2FS_I_SB(inode), READ, bio); + __submit_bio(F2FS_I_SB(inode), READ, bio, DATA); return 0; } diff --git a/fs/f2fs/gc.c b/fs/f2fs/gc.c index 4a03076..67fd285 100644 --- a/fs/f2fs/gc.c +++ b/fs/f2fs/gc.c @@ -777,7 +777,6 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi, { struct page *sum_page; struct f2fs_summary_block *sum; - struct blk_plug plug; unsigned int segno = start_segno; unsigned int end_segno = start_segno + sbi->segs_per_sec; int seg_freed = 0; @@ -795,8 +794,6 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi, unlock_page(sum_page); } - blk_start_plug(&plug); - for (segno = start_segno; segno < end_segno; segno++) { /* find segment summary of victim */ sum_page = find_get_page(META_MAPPING(sbi), @@ -830,8 +827,6 @@ static int do_garbage_collect(struct f2fs_sb_info *sbi, f2fs_submit_merged_bio(sbi, (type == SUM_TYPE_NODE) ? NODE : DATA, WRITE); - blk_finish_plug(&plug); - if (gc_type == FG_GC) { while (start_segno < end_segno) if (get_valid_blocks(sbi, start_segno++, 1) == 0) diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c index 7b58bfb..eff046a 100644 --- a/fs/f2fs/segment.c +++ b/fs/f2fs/segment.c @@ -379,13 +379,8 @@ void f2fs_balance_fs_bg(struct f2fs_sb_info *sbi) excess_prefree_segs(sbi) || excess_dirty_nats(sbi) || (is_idle(sbi) && f2fs_time_over(sbi, CP_TIME))) { - if (test_opt(sbi, DATA_FLUSH)) { - struct blk_plug plug; - - blk_start_plug(&plug); + if (test_opt(sbi, DATA_FLUSH)) sync_dirty_inodes(sbi, FILE_INODE); - blk_finish_plug(&plug); - } f2fs_sync_fs(sbi->sb, true); stat_inc_bg_cp_count(sbi->stat_info); }
In f2fs, we don't need to keep block plugging for NODE and DATA writes, since we already merged bios as much as possible. Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org> --- fs/f2fs/checkpoint.c | 4 ---- fs/f2fs/data.c | 17 ++++++++++------- fs/f2fs/gc.c | 5 ----- fs/f2fs/segment.c | 7 +------ 4 files changed, 11 insertions(+), 22 deletions(-)