On 2023/9/5 0:40, Jaegeuk Kim wrote:
On 09/04, Chao Yu wrote:
On 2023/8/31 15:10, Chunhai Guo wrote:
The commit 344150999b7f ("f2fs: fix to avoid potential deadlock") only
requires unplugging current->plug. Using blk_finish_plug() is unnecessary
as it sets current->plug as NULL and prevents
在 2023/8/30 22:05, Chao Yu 写道:
On 2023/8/30 11:52, Chunhai Guo wrote:
The commit 344150999b7f ("f2fs: fix to avoid potential deadlock") only
requires unplugging current->plug. Using blk_finish_plug() is unnecessary
as it sets current->plug as NULL and prevents wb_writeback() from using
plug in s
The commit 344150999b7f ("f2fs: fix to avoid potential deadlock") only
requires unplugging current->plug. Using blk_finish_plug() is unnecessary
as it sets current->plug as NULL and prevents wb_writeback() from using
plug in subsequent loops. Instead, use blk_flush_plug() as a replacement.
Signed-
The commit 344150999b7f ("f2fs: fix to avoid potential deadlock") only
requires unplugging current->plug. Using blk_finish_plug() is unnecessary
as it sets current->plug as NULL and prevents wb_writeback() from using
plug in subsequent loops. Instead, use blk_flush_plug() as a replacement.
Signed-
Now f2fs support four block allocation modes: lfs, adaptive,
fragment:segment, fragment:block. Only lfs mode is allowed with zoned block
device feature.
Signed-off-by: Chunhai Guo
---
fs/f2fs/super.c | 10 +-
1 file changed, 5 insertions(+), 5 deletions(-)
diff --git a/fs/f2fs/super.c b
Hi Chao,
I have sent the second patch with your suggestion. Please have a check.
Thanks.
On 2023/8/2 22:52, Chao Yu wrote:
On 2023/6/20 22:10, Chunhai Guo wrote:
Now f2fs support four block allocation modes: lfs, adaptive,
fragment:segment, fragment:block. Only lfs mode is allowed with zoned
Hi Chao & Jaegeuk,
Could you please help to review this patch?
Thanks.
On 2023/6/20 22:10, 郭纯海 wrote:
Now f2fs support four block allocation modes: lfs, adaptive,
fragment:segment, fragment:block. Only lfs mode is allowed with zoned block
device feature.
Signed-off-by: Chunhai Guo
---
fs/f
Please ignore this patch. Sorry that I make a mistake. 720037f939fa
("f2fs: don't overwrite node block by SSR") has fixed this issue aleady.
On 2023/6/26 22:02, 郭纯海 wrote:
The fsync node chain can break when a node block is used, freed and reused
in the chain. To avoid this, all blocks in the c
The fsync node chain can break when a node block is used, freed and reused
in the chain. To avoid this, all blocks in the chain should be recorded and
not reused before the next checkpoint. However, this approach may require
too many resources. Instead, this patch records all related segments in a
find_fsync_inode() detect the looped node chain by comparing the loop
counter with free blocks. While it may take tens of seconds to quit when
the free blocks are large enough. We can use Floyd's cycle detection
algorithm to make the detection more efficient, and fix the issue by
filling a NULL add
Hi Jaegeuk & Chao,
OK. I will post a final version including the modification.
Thanks.
On 2023/6/24 2:50, Jaegeuk Kim wrote:
On 06/23, Chao Yu wrote:
On 2023/5/24 10:42, Chunhai Guo wrote:
+ if (!c.fix_on) {
err = -1;
break;
Hi Chao,
Sorry for replying late, I have send patch "fsck.f2fs: refactor looped
node chain detetected logic for cleanup" as you suggested.
Thanks.
On 2023/6/17 10:20, Chao Yu wrote:
On 2023/6/14 17:27, Chunhai Guo wrote:
Hi Jaegeuk,
Could you please help to confirm if this patch has been m
Refactor looped node chain detected logic for cleanup as kernel does.
Suggested-by: Chao Yu
Signed-off-by: Chunhai Guo
---
fsck/mount.c | 115 ---
1 file changed, 55 insertions(+), 60 deletions(-)
diff --git a/fsck/mount.c b/fsck/mount.c
index e5
Now f2fs support four block allocation modes: lfs, adaptive,
fragment:segment, fragment:block. Only lfs mode is allowed with zoned block
device feature.
Signed-off-by: Chunhai Guo
---
fs/f2fs/super.c | 12 +++-
1 file changed, 7 insertions(+), 5 deletions(-)
diff --git a/fs/f2fs/super.c
Got it. Thanks.
On 2023/6/15 0:15, Jaegeuk Kim wrote:
On 06/14, Chunhai Guo wrote:
Hi Jaegeuk,
Could you please help to confirm if this patch has been merged? I cannot see
the patch in the dev-test or dev branch.
Thanks. Somehow it was dropped. I start to test again.
Thanks.
On 2023/5/24
Hi Jaegeuk,
Could you please help to confirm if this patch has been merged? I cannot
see the patch in the dev-test or dev branch.
Thanks.
On 2023/5/24 10:42, 郭纯海 wrote:
find_fsync_inode() detect the looped node chain by comparing the loop
counter with free blocks. While it may take tens of s
find_fsync_dnodes() detect the looped node chain by comparing the loop
counter with free blocks. While it may take tens of seconds to quit when
the free blocks are large enough. We can use Floyd's cycle detection
algorithm to make the detection more efficient.
Signed-off-by: Chunhai Guo
---
v2 ->
find_fsync_dnodes() detect the looped node chain by comparing the loop
counter with free blocks. While it may take tens of seconds to quit when
the free blocks are large enough. We can use Floyd's cycle detection
algorithm to make the detection more efficient.
Signed-off-by: Chunhai Guo
---
v1 ->
find_fsync_dnodes() detect the looped node chain by comparing the loop
counter with free blocks. While it may take tens of seconds to quit when
the free blocks are large enough. We can use Floyd's cycle detection
algorithm to make the detection more efficient, and fix the issue by
filling a NULL ad
find_fsync_inode() detect the looped node chain by comparing the loop
counter with free blocks. While it may take tens of seconds to quit when
the free blocks are large enough. We can use Floyd's cycle detection
algorithm to make the detection more efficient, and fix the issue by
filling a NULL add
find_fsync_inode() detect the looped node chain by comparing the loop
counter with free blocks. While it may take tens of seconds to quit when
the free blocks are large enough. We can use Floyd's cycle detection
algorithm to make the detection more efficient, and fix the issue by
filling a NULL add
find_fsync_inode() detect the looped node chain by comparing the loop
counter with free blocks. While it may take tens of seconds to quit when
the free blocks are large enough. We can use Floyd's cycle detection
algorithm to make the detection more efficient, and fix the issue by
filling a NULL add
find_fsync_inode() detect the looped node chain by comparing the loop
counter with free blocks. While it may take tens of seconds to quit when
the free blocks are large enough. We can use Floyd's cycle detection
algorithm to make the detection more efficient, and fix the issue by
filling a NULL add
find_fsync_inode() detect the looped node chain by comparing the loop
counter with free blocks. While it may take tens of seconds to quit when
the free blocks are large enough. We can use Floyd's cycle detection
algorithm to make the detection more efficient, and fix the issue by
filling a NULL add
find_fsync_inode() detect the looped node chain by comparing the loop
counter with free blocks. While it may take tens of seconds to quit when
the free blocks are large enough. We can use Floyd's cycle detection
algorithm to make the detection more efficient, and fix the issue in the
last node of t
find_fsync_inode() detect the looped node chain by comparing the loop
counter with free blocks. While it may take tens of seconds to quit when
the free blocks are large enough. We can use Floyd's cycle detection
algorithm to make the detection more efficient, and fix the issue by
filling a NULL add
Now we detect the looped node chain by comparing the loop counter with
free blocks. While it may take tens of seconds to quit when the free
blocks are large enough. We can use Floyd's cycle detection algorithm to
make it more efficient.
Below is the log we encounter on a 256GB UFS storage and it t
27 matches
Mail list logo
