f2fs: avoid readahead race condition
Jaegeuk Kim
maintainerPATCH 1/1 f2fs: avoid readahead race condition
If two readahead threads having same offset enter in readpages, every read IOs are split and issued to the disk which giving lower bandwidth.
This patch tries to avoid redundant readahead calls.
--- fs/f2fs/data.c | 15 +++++++++++++++ fs/f2fs/f2fs.h | 1 + fs/f2fs/super.c | 2 ++ 3 files changed, 18 insertions(+)
fs/f2fs/data.c +15 -0
@@ -2292,6 +2292,7 @@ static int f2fs_mpage_readpages(struct inode *inode,unsigned nr_pages = rac ?readahead_count (rac) :1 ;unsigned max_nr_pages = nr_pages;int ret =0 ; +bool drop_ra = false; map.m_pblk =0 ; map.m_lblk =0 ;
@@ -2302,6 +2303,17 @@ static int f2fs_mpage_readpages(struct inode *inode, map.m_seg_type =NO_CHECK_TYPE ; map.m_may_create = false; +/* +* Two readahead threads for same address range can cause race condition +* which fragments sequential read IOs. So let's avoid each other. +*/ +if (rac &&readahead_count (rac)) { +if (F2FS_I (inode)->ra_offset ==readahead_index (rac)) + drop_ra = true; +else +F2FS_I (inode)->ra_offset =readahead_index (rac); + } +for (; nr_pages; nr_pages--) {if (rac) { page =readahead_page (rac);
@@ -2368,6 +2380,9 @@ static int f2fs_mpage_readpages(struct inode *inode, }if (bio)__submit_bio (F2FS_I_SB (inode), bio,DATA ); + +if (rac &&readahead_count (rac) && !drop_ra) +F2FS_I (inode)->ra_offset =-1 ;return ret; }
fs/f2fs/f2fs.h +1 -0
@@ -809,6 +809,7 @@ struct f2fs_inode_info {struct list_head inmem_pages;/* inmemory pages managed by f2fs */ struct task_struct *inmem_task;/* store inmemory task */ struct mutex inmem_lock;/* lock for inmemory pages */ +pgoff_t ra_offset;/* ongoing readahead offset */ struct extent_tree *extent_tree;/* cached extent_tree entry */ /* avoid racing between foreground op and gc */
fs/f2fs/super.c +2 -0
@@ -1015,6 +1015,8 @@ static struct inode *f2fs_alloc_inode(struct super_block *sb)/* Will be used by directory only */ fi->i_dir_level =F2FS_SB (sb)->dir_level; + fi->ra_offset =-1 ; +return &fi->vfs_inode; }
Signature · 1 line
2.27.0.111.gc72c7da667-goog
Quoted 25 lines · Jaegeuk Kim
If two readahead threads having same offset enter in readpages, every read IOs are split and issued to the disk which giving lower bandwidth.
This patch tries to avoid redundant readahead calls.
Signed-off-by Jaegeuk Kim <[email protected]>--- fs/f2fs/data.c | 15 +++++++++++++++ fs/f2fs/f2fs.h | 1 + fs/f2fs/super.c | 2 ++ 3 files changed, 18 insertions(+)fs/f2fs/data.c +1
-0@@ -2292,6 +2292,7 @@ static int f2fs_mpage_readpages(struct inode *inode,unsigned nr_pages = rac ?readahead_count (rac) :1 ;unsigned max_nr_pages = nr_pages;int ret =0 ; +bool drop_ra = false; map.m_pblk =0 ; map.m_lblk =0 ;
fs/f2fs/data.c static int f2fs_mpage_readpages(struct inode *inode, · line 2312
Quoted 10 lines
fs/f2fs/data.c +7
-0@@ -2302,6 +2303,17 @@ static int f2fs_mpage_readpages(struct inode *inode, map.m_seg_type =NO_CHECK_TYPE ; map.m_may_create = false; +/* +* Two readahead threads for same address range can cause race condition +* which fragments sequential read IOs. So let's avoid each other. +*/ +if (rac &&readahead_count (rac)) { +if (F2FS_I (inode)->ra_offset ==readahead_index (rac)) + drop_ra = true;
I guess you missed to return at somewhere when drop_ra is true?
thanks,
Quoted 43 lines
fs/f2fs/data.c +7
-0+else +F2FS_I (inode)->ra_offset =readahead_index (rac); + } +for (; nr_pages; nr_pages--) {if (rac) { page =readahead_page (rac);@@ -2368,6 +2380,9 @@ static int f2fs_mpage_readpages(struct inode *inode, }if (bio)__submit_bio (F2FS_I_SB (inode), bio,DATA ); + +if (rac &&readahead_count (rac) && !drop_ra) +F2FS_I (inode)->ra_offset =-1 ;return ret; }fs/f2fs/f2fs.h +1
-0@@ -809,6 +809,7 @@ struct f2fs_inode_info {struct list_head inmem_pages;/* inmemory pages managed by f2fs */ struct task_struct *inmem_task;/* store inmemory task */ struct mutex inmem_lock;/* lock for inmemory pages */ +pgoff_t ra_offset;/* ongoing readahead offset */ struct extent_tree *extent_tree;/* cached extent_tree entry */ /* avoid racing between foreground op and gc */ fs/f2fs/super.c +2
-0@@ -1015,6 +1015,8 @@ static struct inode *f2fs_alloc_inode(struct super_block *sb)/* Will be used by directory only */ fi->i_dir_level =F2FS_SB (sb)->dir_level; + fi->ra_offset =-1 ; +return &fi->vfs_inode; }
Jaegeuk Kim
maintainerIf two readahead threads having same offset enter in readpages, every read IOs are split and issued to the disk which giving lower bandwidth.
This patch tries to avoid redundant readahead calls.
---
v2:
- add missing code to bypass read
fs/f2fs/data.c | 18 +++++++++++++++++- fs/f2fs/f2fs.h | 1 + fs/f2fs/super.c | 2 ++ 3 files changed, 20 insertions(+), 1 deletion(-)
fs/f2fs/data.c +17 -1
@@ -2403,6 +2403,7 @@ int f2fs_mpage_readpages(struct address_space *mapping,#endif unsigned max_nr_pages = nr_pages;int ret =0 ; +bool drop_ra = false; map.m_pblk =0 ; map.m_lblk =0 ;
@@ -2413,13 +2414,25 @@ int f2fs_mpage_readpages(struct address_space *mapping, map.m_seg_type =NO_CHECK_TYPE ; map.m_may_create = false; +/* +* Two readahead threads for same address range can cause race condition +* which fragments sequential read IOs. So let's avoid each other. +*/ +if (pages && is_readahead) { + page = list_last_entry(pages, struct page, lru); +if (F2FS_I (inode)->ra_offset ==page_index (page)) + drop_ra = true; +else +F2FS_I (inode)->ra_offset =page_index (page); + } +for (; nr_pages; nr_pages--) {if (pages) { page = list_last_entry(pages, struct page, lru);prefetchw (&page->flags);list_del (&page->lru); -if (add_to_page_cache_lru (page, mapping, +if (drop_ra ||add_to_page_cache_lru (page, mapping,page_index (page),readahead_gfp_mask (mapping))) goto next_page;
@@ -2484,6 +2497,9 @@ int f2fs_mpage_readpages(struct address_space *mapping,BUG_ON (pages && !list_empty (pages));if (bio)__f2fs_submit_read_bio (F2FS_I_SB (inode), bio,DATA ); + +if (pages && is_readahead && !drop_ra) +F2FS_I (inode)->ra_offset =-1 ;return pages ?0 : ret; }
fs/f2fs/f2fs.h +1 -0
@@ -806,6 +806,7 @@ struct f2fs_inode_info {struct list_head inmem_pages;/* inmemory pages managed by f2fs */ struct task_struct *inmem_task;/* store inmemory task */ struct mutex inmem_lock;/* lock for inmemory pages */ +pgoff_t ra_offset;/* ongoing readahead offset */ struct extent_tree *extent_tree;/* cached extent_tree entry */ /* avoid racing between foreground op and gc */
fs/f2fs/super.c +2 -0
@@ -1011,6 +1011,8 @@ static struct inode *f2fs_alloc_inode(struct super_block *sb)/* Will be used by directory only */ fi->i_dir_level =F2FS_SB (sb)->dir_level; + fi->ra_offset =-1 ; +return &fi->vfs_inode; }
Signature · 8 lines
2.27.0.111.gc72c7da667-goog _______________________________________________ Linux-f2fs-devel mailing list [email protected] https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Quoted 32 lines · Jaegeuk Kim
If two readahead threads having same offset enter in readpages, every read IOs are split and issued to the disk which giving lower bandwidth.
This patch tries to avoid redundant readahead calls.
Signed-off-by Jaegeuk Kim <[email protected]>---
v2:
- add missing code to bypass readfs/f2fs/data.c | 18 +++++++++++++++++- fs/f2fs/f2fs.h | 1 + fs/f2fs/super.c | 2 ++ 3 files changed, 20 insertions(+), 1 deletion(-)fs/f2fs/data.c +2
-0@@ -2403,6 +2403,7 @@ int f2fs_mpage_readpages(struct address_space *mapping,#endif unsigned max_nr_pages = nr_pages;int ret =0 ; +bool drop_ra = false; map.m_pblk =0 ; map.m_lblk =0 ;@@ -2413,13 +2414,25 @@ int f2fs_mpage_readpages(struct address_space *mapping, map.m_seg_type =NO_CHECK_TYPE ; map.m_may_create = false; +/*
fs/f2fs/data.c int f2fs_mpage_readpages(struct address_space *mapping, · line 2427
Quoted 10 lines
fs/f2fs/data.c +10
-0+* Two readahead threads for same address range can cause race condition +* which fragments sequential read IOs. So let's avoid each other. +*/ +if (pages && is_readahead) { + page = list_last_entry(pages, struct page, lru); +if (F2FS_I (inode)->ra_offset ==page_index (page)) + drop_ra = true; +else +F2FS_I (inode)->ra_offset =page_index (page); + }
This is a data race because ra_offset can be read/written by different threads concurrently.
It either needs locking, or READ_ONCE() and WRITE_ONCE() if races are okay.
- Eric
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Jaegeuk Kim
maintainerQuoted 47 lines · Eric Biggers
Quoted 32 lines · Jaegeuk Kim
If two readahead threads having same offset enter in readpages, every read IOs are split and issued to the disk which giving lower bandwidth.
This patch tries to avoid redundant readahead calls.
Signed-off-by Jaegeuk Kim <[email protected]>---
v2:
- add missing code to bypass readfs/f2fs/data.c | 18 +++++++++++++++++- fs/f2fs/f2fs.h | 1 + fs/f2fs/super.c | 2 ++ 3 files changed, 20 insertions(+), 1 deletion(-)fs/f2fs/data.c +2
-0@@ -2403,6 +2403,7 @@ int f2fs_mpage_readpages(struct address_space *mapping,#endif unsigned max_nr_pages = nr_pages;int ret =0 ; +bool drop_ra = false; map.m_pblk =0 ; map.m_lblk =0 ;@@ -2413,13 +2414,25 @@ int f2fs_mpage_readpages(struct address_space *mapping, map.m_seg_type =NO_CHECK_TYPE ; map.m_may_create = false; +/* fs/f2fs/data.c int f2fs_mpage_readpages(struct address_space *mapping, · line 2427
Quoted 10 lines
fs/f2fs/data.c +10
-0+* Two readahead threads for same address range can cause race condition +* which fragments sequential read IOs. So let's avoid each other. +*/ +if (pages && is_readahead) { + page = list_last_entry(pages, struct page, lru); +if (F2FS_I (inode)->ra_offset ==page_index (page)) + drop_ra = true; +else +F2FS_I (inode)->ra_offset =page_index (page); + }This is a data race because
ra_offsetcan be read/written by different threads concurrently.
Quoted 1 line
It either needs locking, or
READ_ONCE()andWRITE_ONCE()if races are okay.
I just wanted to keep zero overhead, since it doesn't matter either cases of skipping readahead or not.
Quoted 2 lines
- Eric
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Quoted 48 lines · Jaegeuk Kim
Quoted 47 lines · Eric Biggers
Quoted 32 lines · Jaegeuk Kim
If two readahead threads having same offset enter in readpages, every read IOs are split and issued to the disk which giving lower bandwidth.
This patch tries to avoid redundant readahead calls.
Signed-off-by Jaegeuk Kim <[email protected]>---
v2:
- add missing code to bypass readfs/f2fs/data.c | 18 +++++++++++++++++- fs/f2fs/f2fs.h | 1 + fs/f2fs/super.c | 2 ++ 3 files changed, 20 insertions(+), 1 deletion(-)fs/f2fs/data.c +2
-0@@ -2403,6 +2403,7 @@ int f2fs_mpage_readpages(struct address_space *mapping,#endif unsigned max_nr_pages = nr_pages;int ret =0 ; +bool drop_ra = false; map.m_pblk =0 ; map.m_lblk =0 ;@@ -2413,13 +2414,25 @@ int f2fs_mpage_readpages(struct address_space *mapping, map.m_seg_type =NO_CHECK_TYPE ; map.m_may_create = false; +/* fs/f2fs/data.c int f2fs_mpage_readpages(struct address_space *mapping, · line 2427
Quoted 10 lines
fs/f2fs/data.c +10
-0+* Two readahead threads for same address range can cause race condition +* which fragments sequential read IOs. So let's avoid each other. +*/ +if (pages && is_readahead) { + page = list_last_entry(pages, struct page, lru); +if (F2FS_I (inode)->ra_offset ==page_index (page)) + drop_ra = true; +else +F2FS_I (inode)->ra_offset =page_index (page); + }This is a data race because
ra_offsetcan be read/written by different threads concurrently.
Quoted 5 lines
Quoted 1 line
It either needs locking, or
READ_ONCE()andWRITE_ONCE()if races are okay.I just wanted to keep zero overhead, since it doesn't matter either cases of skipping readahead or not.
Okay, then it should use READ_ONCE() and WRITE_ONCE().
- Eric
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Jaegeuk Kim
maintainerIf two readahead threads having same offset enter in readpages, every read IOs are split and issued to the disk which giving lower bandwidth.
This patch tries to avoid redundant readahead calls.
---
v3:
- use READ|WRITE_ONCE
v2:
- add missing code to bypass read
fs/f2fs/data.c | 18 ++++++++++++++++++ fs/f2fs/f2fs.h | 1 + fs/f2fs/super.c | 2 ++ 3 files changed, 21 insertions(+)
fs/f2fs/data.c +18 -0
@@ -2296,6 +2296,7 @@ static int f2fs_mpage_readpages(struct inode *inode,unsigned nr_pages = rac ?readahead_count (rac) :1 ;unsigned max_nr_pages = nr_pages;int ret =0 ; +bool drop_ra = false; map.m_pblk =0 ; map.m_lblk =0 ;
@@ -2306,10 +2307,24 @@ static int f2fs_mpage_readpages(struct inode *inode, map.m_seg_type =NO_CHECK_TYPE ; map.m_may_create = false; +/* +* Two readahead threads for same address range can cause race condition +* which fragments sequential read IOs. So let's avoid each other. +*/ +if (rac &&readahead_count (rac)) { +if (READ_ONCE (F2FS_I (inode)->ra_offset) ==readahead_index (rac)) + drop_ra = true; +else +WRITE_ONCE (F2FS_I (inode)->ra_offset, +readahead_index (rac)); + } +for (; nr_pages; nr_pages--) {if (rac) { page =readahead_page (rac);prefetchw (&page->flags); +if (drop_ra) + goto next_page; }#ifdef CONFIG_F2FS_FS_COMPRESSION
@@ -2372,6 +2387,9 @@ static int f2fs_mpage_readpages(struct inode *inode, }if (bio)__submit_bio (F2FS_I_SB (inode), bio,DATA ); + +if (rac &&readahead_count (rac) && !drop_ra) +WRITE_ONCE (F2FS_I (inode)->ra_offset,-1 );return ret; }
fs/f2fs/f2fs.h +1 -0
@@ -809,6 +809,7 @@ struct f2fs_inode_info {struct list_head inmem_pages;/* inmemory pages managed by f2fs */ struct task_struct *inmem_task;/* store inmemory task */ struct mutex inmem_lock;/* lock for inmemory pages */ +pgoff_t ra_offset;/* ongoing readahead offset */ struct extent_tree *extent_tree;/* cached extent_tree entry */ /* avoid racing between foreground op and gc */
fs/f2fs/super.c +2 -0
@@ -1015,6 +1015,8 @@ static struct inode *f2fs_alloc_inode(struct super_block *sb)/* Will be used by directory only */ fi->i_dir_level =F2FS_SB (sb)->dir_level; + fi->ra_offset =-1 ; +return &fi->vfs_inode; }
Signature · 1 line
2.27.0.212.ge8ba1cc988-goog
Quoted 41 lines · Jaegeuk Kim
If two readahead threads having same offset enter in readpages, every read IOs are split and issued to the disk which giving lower bandwidth.
This patch tries to avoid redundant readahead calls.
Signed-off-by Jaegeuk Kim <[email protected]>---
v3:
- use READ|WRITE_ONCE
v2:
- add missing code to bypass readfs/f2fs/data.c | 18 ++++++++++++++++++ fs/f2fs/f2fs.h | 1 + fs/f2fs/super.c | 2 ++ 3 files changed, 21 insertions(+)fs/f2fs/data.c +9
-0@@ -2296,6 +2296,7 @@ static int f2fs_mpage_readpages(struct inode *inode,unsigned nr_pages = rac ?readahead_count (rac) :1 ;unsigned max_nr_pages = nr_pages;int ret =0 ; +bool drop_ra = false; map.m_pblk =0 ; map.m_lblk =0 ;@@ -2306,10 +2307,24 @@ static int f2fs_mpage_readpages(struct inode *inode, map.m_seg_type =NO_CHECK_TYPE ; map.m_may_create = false; +/* +* Two readahead threads for same address range can cause race condition +* which fragments sequential read IOs. So let's avoid each other. +*/ +if (rac &&readahead_count (rac)) { +if (READ_ONCE (F2FS_I (inode)->ra_offset) ==readahead_index (rac)) + drop_ra = true; +else
fs/f2fs/data.c static int f2fs_mpage_readpages(struct inode *inode, · line 2327
Quoted 10 lines
fs/f2fs/data.c +6
-0+WRITE_ONCE (F2FS_I (inode)->ra_offset, +readahead_index (rac)); + } +for (; nr_pages; nr_pages--) {if (rac) { page =readahead_page (rac);prefetchw (&page->flags); +if (drop_ra) + goto next_page;
When CONFIG_F2FS_FS_COMPRESSION is not set (i.e. x86_64 defconfig + CONFIG_F2FS_FS=y):
$ make -skj"$(nproc)" O=out distclean defconfig fs/f2fs/data.o
../fs/f2fs/data.c: In function ‘f2fs_mpage_readpages’:
../fs/f2fs/data.c:2327:5: error: label ‘next_page’ used but not defined
2327 | goto next_page;
| ^~~~
...Cheers,
Nathan
Jaegeuk Kim
maintainerQuoted 56 lines · Nathan Chancellor
Quoted 41 lines · Jaegeuk Kim
If two readahead threads having same offset enter in readpages, every read IOs are split and issued to the disk which giving lower bandwidth.
This patch tries to avoid redundant readahead calls.
Signed-off-by Jaegeuk Kim <[email protected]>---
v3:
- use READ|WRITE_ONCE
v2:
- add missing code to bypass readfs/f2fs/data.c | 18 ++++++++++++++++++ fs/f2fs/f2fs.h | 1 + fs/f2fs/super.c | 2 ++ 3 files changed, 21 insertions(+)fs/f2fs/data.c +9
-0@@ -2296,6 +2296,7 @@ static int f2fs_mpage_readpages(struct inode *inode,unsigned nr_pages = rac ?readahead_count (rac) :1 ;unsigned max_nr_pages = nr_pages;int ret =0 ; +bool drop_ra = false; map.m_pblk =0 ; map.m_lblk =0 ;@@ -2306,10 +2307,24 @@ static int f2fs_mpage_readpages(struct inode *inode, map.m_seg_type =NO_CHECK_TYPE ; map.m_may_create = false; +/* +* Two readahead threads for same address range can cause race condition +* which fragments sequential read IOs. So let's avoid each other. +*/ +if (rac &&readahead_count (rac)) { +if (READ_ONCE (F2FS_I (inode)->ra_offset) ==readahead_index (rac)) + drop_ra = true; +else fs/f2fs/data.c static int f2fs_mpage_readpages(struct inode *inode, · line 2327
Quoted 10 lines
fs/f2fs/data.c +6
-0+WRITE_ONCE (F2FS_I (inode)->ra_offset, +readahead_index (rac)); + } +for (; nr_pages; nr_pages--) {if (rac) { page =readahead_page (rac);prefetchw (&page->flags); +if (drop_ra) + goto next_page;When
CONFIG_F2FS_FS_COMPRESSIONis not set (i.e.x86_64defconfig +CONFIG_F2FS_FS=y):
Quoted 6 lines
$ make -skj"$(nproc)" O=out distclean defconfig fs/f2fs/data.o
../fs/f2fs/data.c: In function ‘f2fs_mpage_readpages’:
../fs/f2fs/data.c:2327:5: error: label ‘next_page’ used but not defined
2327 | goto next_page;
| ^~~~
...Thanks. I pushed the fix for -next.
https://lore.kernel.org/linux-f2fs-devel/[email protected]/T/#t
Thanks,
Quoted 9 lines
Cheers,
Nathan_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Chao Yu
Reviewed-byQuoted 64 lines · Jaegeuk Kim
Quoted 56 lines · Nathan Chancellor
Quoted 41 lines · Jaegeuk Kim
If two readahead threads having same offset enter in readpages, every read IOs are split and issued to the disk which giving lower bandwidth.
This patch tries to avoid redundant readahead calls.
Signed-off-by Jaegeuk Kim <[email protected]>---
v3:
- use READ|WRITE_ONCE
v2:
- add missing code to bypass readfs/f2fs/data.c | 18 ++++++++++++++++++ fs/f2fs/f2fs.h | 1 + fs/f2fs/super.c | 2 ++ 3 files changed, 21 insertions(+)fs/f2fs/data.c +9
-0@@ -2296,6 +2296,7 @@ static int f2fs_mpage_readpages(struct inode *inode,unsigned nr_pages = rac ?readahead_count (rac) :1 ;unsigned max_nr_pages = nr_pages;int ret =0 ; +bool drop_ra = false; map.m_pblk =0 ; map.m_lblk =0 ;@@ -2306,10 +2307,24 @@ static int f2fs_mpage_readpages(struct inode *inode, map.m_seg_type =NO_CHECK_TYPE ; map.m_may_create = false; +/* +* Two readahead threads for same address range can cause race condition +* which fragments sequential read IOs. So let's avoid each other. +*/ +if (rac &&readahead_count (rac)) { +if (READ_ONCE (F2FS_I (inode)->ra_offset) ==readahead_index (rac)) + drop_ra = true; +else fs/f2fs/data.c static int f2fs_mpage_readpages(struct inode *inode, · line 2327
Quoted 10 lines
fs/f2fs/data.c +6
-0+WRITE_ONCE (F2FS_I (inode)->ra_offset, +readahead_index (rac)); + } +for (; nr_pages; nr_pages--) {if (rac) { page =readahead_page (rac);prefetchw (&page->flags); +if (drop_ra) + goto next_page;When
CONFIG_F2FS_FS_COMPRESSIONis not set (i.e.x86_64defconfig +CONFIG_F2FS_FS=y):Quoted 6 lines
$ make -skj"$(nproc)" O=out distclean defconfig fs/f2fs/data.o ../fs/f2fs/data.c: In function ‘f2fs_mpage_readpages’: ../fs/f2fs/data.c:2327:5: error: label ‘next_page’ used but not defined 2327 | goto next_page; | ^~~~ ...
Quoted 2 lines
Thanks. I pushed the fix for -next.
https://lore.kernel.org/linux-f2fs-devel/[email protected]/T/#t
Thanks,
Quoted 19 lines
Thanks,
Quoted 9 lines
Cheers,
Nathan_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Quoted 65 lines · Chao Yu
Quoted 64 lines · Jaegeuk Kim
Quoted 62 lines · Nathan Chancellor
Quoted 41 lines · Jaegeuk Kim
If two readahead threads having same offset enter in readpages, every read IOs are split and issued to the disk which giving lower bandwidth.
This patch tries to avoid redundant readahead calls.
Signed-off-by Jaegeuk Kim <[email protected]>---
v3:
- use READ|WRITE_ONCE
v2:
- add missing code to bypass readfs/f2fs/data.c | 18 ++++++++++++++++++ fs/f2fs/f2fs.h | 1 + fs/f2fs/super.c | 2 ++ 3 files changed, 21 insertions(+)fs/f2fs/data.c +9
-0@@ -2296,6 +2296,7 @@ static int f2fs_mpage_readpages(struct inode *inode,unsigned nr_pages = rac ?readahead_count (rac) :1 ;unsigned max_nr_pages = nr_pages;int ret =0 ; +bool drop_ra = false; map.m_pblk =0 ; map.m_lblk =0 ;@@ -2306,10 +2307,24 @@ static int f2fs_mpage_readpages(struct inode *inode, map.m_seg_type =NO_CHECK_TYPE ; map.m_may_create = false; +/* +* Two readahead threads for same address range can cause race condition +* which fragments sequential read IOs. So let's avoid each other. +*/ +if (rac &&readahead_count (rac)) { +if (READ_ONCE (F2FS_I (inode)->ra_offset) ==readahead_index (rac)) + drop_ra = true; +else fs/f2fs/data.c static int f2fs_mpage_readpages(struct inode *inode, · line 2327
Quoted 10 lines
fs/f2fs/data.c +6
-0+WRITE_ONCE (F2FS_I (inode)->ra_offset, +readahead_index (rac)); + } +for (; nr_pages; nr_pages--) {if (rac) { page =readahead_page (rac);prefetchw (&page->flags); +if (drop_ra) + goto next_page;When
CONFIG_F2FS_FS_COMPRESSIONis not set (i.e.x86_64defconfig +CONFIG_F2FS_FS=y):$ make -skj"$(nproc)" O=out distclean defconfig fs/f2fs/data.o ../fs/f2fs/data.c: In function ‘f2fs_mpage_readpages’: ../fs/f2fs/data.c:2327:5: error: label ‘next_page’ used but not defined 2327 | goto next_page; | ^~~~ ...
Quoted 2 lines
Quoted 2 lines
Thanks. I pushed the fix for -next.
https://lore.kernel.org/linux-f2fs-devel/[email protected]/T/#t
It will hang the kernel because we missed to unlock those cached pages, I changed to 'goto set_error_page', the issue was gone.
Thanks,
Quoted 31 lines
Reviewed-by Chao Yu <[email protected]>Thanks,
Quoted 14 lines
Thanks,
Quoted 9 lines
Cheers,
Nathan_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-develQuoted 5 lines
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Jaegeuk Kim
maintainerQuoted 66 lines · Chao Yu
Quoted 65 lines · Chao Yu
Quoted 64 lines · Jaegeuk Kim
Quoted 62 lines · Nathan Chancellor
Quoted 41 lines · Jaegeuk Kim
If two readahead threads having same offset enter in readpages, every read IOs are split and issued to the disk which giving lower bandwidth.
This patch tries to avoid redundant readahead calls.
Signed-off-by Jaegeuk Kim <[email protected]>---
v3:
- use READ|WRITE_ONCE
v2:
- add missing code to bypass readfs/f2fs/data.c | 18 ++++++++++++++++++ fs/f2fs/f2fs.h | 1 + fs/f2fs/super.c | 2 ++ 3 files changed, 21 insertions(+)fs/f2fs/data.c +9
-0@@ -2296,6 +2296,7 @@ static int f2fs_mpage_readpages(struct inode *inode,unsigned nr_pages = rac ?readahead_count (rac) :1 ;unsigned max_nr_pages = nr_pages;int ret =0 ; +bool drop_ra = false; map.m_pblk =0 ; map.m_lblk =0 ;@@ -2306,10 +2307,24 @@ static int f2fs_mpage_readpages(struct inode *inode, map.m_seg_type =NO_CHECK_TYPE ; map.m_may_create = false; +/* +* Two readahead threads for same address range can cause race condition +* which fragments sequential read IOs. So let's avoid each other. +*/ +if (rac &&readahead_count (rac)) { +if (READ_ONCE (F2FS_I (inode)->ra_offset) ==readahead_index (rac)) + drop_ra = true; +else fs/f2fs/data.c static int f2fs_mpage_readpages(struct inode *inode, · line 2327
Quoted 10 lines
fs/f2fs/data.c +6
-0+WRITE_ONCE (F2FS_I (inode)->ra_offset, +readahead_index (rac)); + } +for (; nr_pages; nr_pages--) {if (rac) { page =readahead_page (rac);prefetchw (&page->flags); +if (drop_ra) + goto next_page;When
CONFIG_F2FS_FS_COMPRESSIONis not set (i.e.x86_64defconfig +CONFIG_F2FS_FS=y):$ make -skj"$(nproc)" O=out distclean defconfig fs/f2fs/data.o ../fs/f2fs/data.c: In function ‘f2fs_mpage_readpages’: ../fs/f2fs/data.c:2327:5: error: label ‘next_page’ used but not defined 2327 | goto next_page; | ^~~~ ...
Quoted 5 lines
Quoted 2 lines
Quoted 2 lines
Thanks. I pushed the fix for -next.
https://lore.kernel.org/linux-f2fs-devel/[email protected]/T/#tIt will hang the kernel because we missed to unlock those cached pages, I changed to 'goto
set_error_page', the issue was gone.
How about v4?
Quoted 34 lines
Thanks,
Quoted 31 lines
Reviewed-by Chao Yu <[email protected]>Thanks,
Quoted 14 lines
Thanks,
Quoted 9 lines
Cheers,
Nathan_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-develQuoted 5 lines
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Quoted 1 line · Jaegeuk Kim
How about v4?
It looks good to me.
Thanks,
From 3634864095bd1aafbb60ff49dac7d13ce157b658 Mon Sep 17 00:00:00 2001
From: Jaegeuk Kim <[email protected]>
Date: Mon, 22 Jun 2020 23:01:05 -0700
Subject: [PATCH] f2fs: avoid readahead race condition
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
If two readahead threads having same offset enter in readpages, every read IOs are split and issued to the disk which giving lower bandwidth.
This patch tries to avoid redundant readahead calls.
Fixes one build error reported by Randy.
Fix build error when F2FS_FS_COMPRESSION is not set/enabled. This label is needed in either case.
../fs/f2fs/data.c: In function ‘f2fs_mpage_readpages’:../fs/f2fs/data.c:2327:5: error: label ‘next_page’ used but not defined
goto next_page;
---
v4:
- fix missing unlock_page
v3:
- use READ|WRITE_ONCE
v2:
- add missing code to bypass read
fs/f2fs/data.c | 20 ++++++++++++++++++++ fs/f2fs/f2fs.h | 1 + fs/f2fs/super.c | 2 ++ 3 files changed, 23 insertions(+)
fs/f2fs/data.c +20 -0
@@ -2296,6 +2296,7 @@ static int f2fs_mpage_readpages(struct inode *inode,unsigned nr_pages = rac ?readahead_count (rac) :1 ;unsigned max_nr_pages = nr_pages;int ret =0 ; +bool drop_ra = false; map.m_pblk =0 ; map.m_lblk =0 ;
@@ -2306,10 +2307,26 @@ static int f2fs_mpage_readpages(struct inode *inode, map.m_seg_type =NO_CHECK_TYPE ; map.m_may_create = false; +/* +* Two readahead threads for same address range can cause race condition +* which fragments sequential read IOs. So let's avoid each other. +*/ +if (rac &&readahead_count (rac)) { +if (READ_ONCE (F2FS_I (inode)->ra_offset) ==readahead_index (rac)) + drop_ra = true; +else +WRITE_ONCE (F2FS_I (inode)->ra_offset, +readahead_index (rac)); + } +for (; nr_pages; nr_pages--) {if (rac) { page =readahead_page (rac);prefetchw (&page->flags); +if (drop_ra) { +f2fs_put_page (page,1 ); +continue ; + } }#ifdef CONFIG_F2FS_FS_COMPRESSION
@@ -2372,6 +2389,9 @@ static int f2fs_mpage_readpages(struct inode *inode, }if (bio)__submit_bio (F2FS_I_SB (inode), bio,DATA ); + +if (rac &&readahead_count (rac) && !drop_ra) +WRITE_ONCE (F2FS_I (inode)->ra_offset,-1 );return ret; }
fs/f2fs/f2fs.h +1 -0
@@ -809,6 +809,7 @@ struct f2fs_inode_info {struct list_head inmem_pages;/* inmemory pages managed by f2fs */ struct task_struct *inmem_task;/* store inmemory task */ struct mutex inmem_lock;/* lock for inmemory pages */ +pgoff_t ra_offset;/* ongoing readahead offset */ struct extent_tree *extent_tree;/* cached extent_tree entry */ /* avoid racing between foreground op and gc */
fs/f2fs/super.c +2 -0
@@ -1015,6 +1015,8 @@ static struct inode *f2fs_alloc_inode(struct super_block *sb)/* Will be used by directory only */ fi->i_dir_level =F2FS_SB (sb)->dir_level; + fi->ra_offset =-1 ; +return &fi->vfs_inode; }
Signature · 1 line
2.27.0.212.ge8ba1cc988-goog