f2fs: fix long latency due to discard during umount
PATCH 1/1 f2fs: fix long latency due to discard during umount
F2FS already has a default timeout of 5 secs for discards that can be issued during umount, but it can take more than the 5 sec timeout if the underlying UFS device queue is already full and there are no more available free tags to be used. In that case, submit_bio() will wait for the already queued discard requests to complete to get a free tag, which can potentially take way more than 5 sec.
Fix this by submitting the discard requests with REQ_NOWAIT flags during umount. This will return -EAGAIN for UFS queue/tag full scenario without waiting in the context of submit_bio(). The FS can then handle these requests by retrying again within the stipulated discard timeout period to avoid long latencies.
--- fs/f2fs/segment.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-)
fs/f2fs/segment.c +13 -1
@@ -1124,10 +1124,13 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi,struct discard_cmd_control *dcc =SM_I (sbi)->dcc_info;struct list_head *wait_list = (dpolicy->type ==DPOLICY_FSTRIM ) ? &(dcc->fstrim_list) : &(dcc->wait_list); -int flag = dpolicy->sync ?REQ_SYNC :0 ; +int flag;block_t lstart, start, len, total_len;int err =0 ; + flag = dpolicy->sync ?REQ_SYNC :0 ; + flag |= dpolicy->type ==DPOLICY_UMOUNT ?REQ_NOWAIT :0 ; +if (dc->state !=D_PREP )return 0 ;
@@ -1203,6 +1206,11 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi, bio->bi_end_io = f2fs_submit_discard_endio; bio->bi_opf |= flag;submit_bio (bio); +if ((flag &REQ_NOWAIT ) && (dc->error == -EAGAIN )) { + dc->state =D_PREP ; + err = dc->error; +break ; + }atomic_inc (&dcc->issued_discard);
@@ -1510,6 +1518,10 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi, }__submit_discard_cmd (sbi, dpolicy, dc, &issued); +if (dc->error == -EAGAIN ) { +congestion_wait (BLK_RW_ASYNC ,HZ /50 ); +__relocate_discard_cmd (dcc, dc); + }if (issued >= dpolicy->max_requests)break ;
Signature · 2 lines
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc. Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, a Linux Foundation Collaborative Project.
Jaegeuk Kim
maintainerQuoted 50 lines · Sahitya Tummala
F2FS already has a default timeout of 5 secs for discards that can be issued during umount, but it can take more than the 5 sec timeout if the underlying UFS device queue is already full and there are no more available free tags to be used. In that case,
submit_bio()will wait for the already queued discard requests to complete to get a free tag, which can potentially take way more than 5 sec.Fix this by submitting the discard requests with
REQ_NOWAITflags during umount. This will return-EAGAINfor UFS queue/tag full scenario without waiting in the context ofsubmit_bio(). The FS can then handle these requests by retrying again within the stipulated discard timeout period to avoid long latencies.Signed-off-by Sahitya Tummala <[email protected]>--- fs/f2fs/segment.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-)fs/f2fs/segment.c +9
-1@@ -1124,10 +1124,13 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi,struct discard_cmd_control *dcc =SM_I (sbi)->dcc_info;struct list_head *wait_list = (dpolicy->type ==DPOLICY_FSTRIM ) ? &(dcc->fstrim_list) : &(dcc->wait_list); -int flag = dpolicy->sync ?REQ_SYNC :0 ; +int flag;block_t lstart, start, len, total_len;int err =0 ; + flag = dpolicy->sync ?REQ_SYNC :0 ; + flag |= dpolicy->type ==DPOLICY_UMOUNT ?REQ_NOWAIT :0 ; +if (dc->state !=D_PREP )return 0 ;@@ -1203,6 +1206,11 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi, bio->bi_end_io = f2fs_submit_discard_endio; bio->bi_opf |= flag;submit_bio (bio); +if ((flag &REQ_NOWAIT ) && (dc->error == -EAGAIN )) { + dc->state =D_PREP ; + err = dc->error; +break ; + }atomic_inc (&dcc->issued_discard);
fs/f2fs/segment.c static int __issue_discard_cmd(struct f2fs_sb_info *sbi, · line 1522
Quoted 5 lines
fs/f2fs/segment.c +2
-0@@ -1510,6 +1518,10 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi, }__submit_discard_cmd (sbi, dpolicy, dc, &issued); +if (dc->error == -EAGAIN ) { +congestion_wait (BLK_RW_ASYNC ,HZ /50 );
--> need to be DEFAULT_IO_TIMEOUT
fs/f2fs/segment.c static int __issue_discard_cmd(struct f2fs_sb_info *sbi, · line 1523
Quoted 1 line
fs/f2fs/segment.c +1
-0+__relocate_discard_cmd (dcc, dc);
It seems we need to submit bio first, and then move dc to wait_list, if there's no error, in __submit_discard_cmd().
Quoted 7 lines
fs/f2fs/segment.c +1
-0+ }if (issued >= dpolicy->max_requests)break ;Signature · 2 lines
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc. Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, a Linux Foundation Collaborative Project.
Quoted 50 lines · Jaegeuk Kim
Quoted 49 lines · Sahitya Tummala
F2FS already has a default timeout of 5 secs for discards that can be issued during umount, but it can take more than the 5 sec timeout if the underlying UFS device queue is already full and there are no more available free tags to be used. In that case,
submit_bio()will wait for the already queued discard requests to complete to get a free tag, which can potentially take way more than 5 sec.Fix this by submitting the discard requests with
REQ_NOWAITflags during umount. This will return-EAGAINfor UFS queue/tag full scenario without waiting in the context ofsubmit_bio(). The FS can then handle these requests by retrying again within the stipulated discard timeout period to avoid long latencies.Signed-off-by Sahitya Tummala <[email protected]>--- fs/f2fs/segment.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-)fs/f2fs/segment.c +9
-1@@ -1124,10 +1124,13 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi,struct discard_cmd_control *dcc =SM_I (sbi)->dcc_info;struct list_head *wait_list = (dpolicy->type ==DPOLICY_FSTRIM ) ? &(dcc->fstrim_list) : &(dcc->wait_list); -int flag = dpolicy->sync ?REQ_SYNC :0 ; +int flag;block_t lstart, start, len, total_len;int err =0 ; + flag = dpolicy->sync ?REQ_SYNC :0 ; + flag |= dpolicy->type ==DPOLICY_UMOUNT ?REQ_NOWAIT :0 ; +if (dc->state !=D_PREP )return 0 ;@@ -1203,6 +1206,11 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi, bio->bi_end_io = f2fs_submit_discard_endio; bio->bi_opf |= flag;submit_bio (bio); +if ((flag &REQ_NOWAIT ) && (dc->error == -EAGAIN )) { + dc->state =D_PREP ; + err = dc->error; +break ; + }atomic_inc (&dcc->issued_discard);
Quoted 8 lines
fs/f2fs/segment.c static int __issue_discard_cmd(struct f2fs_sb_info *sbi, · line 1522
Quoted 6 lines
fs/f2fs/segment.c +2
-0@@ -1510,6 +1518,10 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi, }__submit_discard_cmd (sbi, dpolicy, dc, &issued); +if (dc->error == -EAGAIN ) { +congestion_wait (BLK_RW_ASYNC ,HZ /50 );--> need to be DEFAULT_IO_TIMEOUT
Yes, i will update it.
Quoted 5 lines
fs/f2fs/segment.c static int __issue_discard_cmd(struct f2fs_sb_info *sbi, · line 1523
Quoted 2 lines
fs/f2fs/segment.c +1
-0+__relocate_discard_cmd (dcc, dc);It seems we need to submit bio first, and then move dc to
wait_list, if there's no error, in__submit_discard_cmd().
Yes, that is not changed and it still happens for the failed request that is re-queued here too when it gets submitted again later.
I am requeuing the discard request failed with -EAGAIN error back to dcc->pend_list[] from wait_list. It will call submit_bio() for this request and also move to wait_list when it calls __submit_discard_cmd() again next time. Please let me know if I am missing anything?
Thanks,
Quoted 8 lines
Quoted 8 lines
fs/f2fs/segment.c +1
-0+ }if (issued >= dpolicy->max_requests)break ;Signature · 2 lines
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc. Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, a Linux Foundation Collaborative Project.
Signature · 3 lines
-- Sent by a consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
Jaegeuk Kim
maintainerQuoted 68 lines · Sahitya Tummala
Quoted 50 lines · Jaegeuk Kim
Quoted 49 lines · Sahitya Tummala
F2FS already has a default timeout of 5 secs for discards that can be issued during umount, but it can take more than the 5 sec timeout if the underlying UFS device queue is already full and there are no more available free tags to be used. In that case,
submit_bio()will wait for the already queued discard requests to complete to get a free tag, which can potentially take way more than 5 sec.Fix this by submitting the discard requests with
REQ_NOWAITflags during umount. This will return-EAGAINfor UFS queue/tag full scenario without waiting in the context ofsubmit_bio(). The FS can then handle these requests by retrying again within the stipulated discard timeout period to avoid long latencies.Signed-off-by Sahitya Tummala <[email protected]>--- fs/f2fs/segment.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-)fs/f2fs/segment.c +9
-1@@ -1124,10 +1124,13 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi,struct discard_cmd_control *dcc =SM_I (sbi)->dcc_info;struct list_head *wait_list = (dpolicy->type ==DPOLICY_FSTRIM ) ? &(dcc->fstrim_list) : &(dcc->wait_list); -int flag = dpolicy->sync ?REQ_SYNC :0 ; +int flag;block_t lstart, start, len, total_len;int err =0 ; + flag = dpolicy->sync ?REQ_SYNC :0 ; + flag |= dpolicy->type ==DPOLICY_UMOUNT ?REQ_NOWAIT :0 ; +if (dc->state !=D_PREP )return 0 ;@@ -1203,6 +1206,11 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi, bio->bi_end_io = f2fs_submit_discard_endio; bio->bi_opf |= flag;submit_bio (bio); +if ((flag &REQ_NOWAIT ) && (dc->error == -EAGAIN )) { + dc->state =D_PREP ; + err = dc->error; +break ; + }atomic_inc (&dcc->issued_discard);Quoted 8 lines
fs/f2fs/segment.c static int __issue_discard_cmd(struct f2fs_sb_info *sbi, · line 1522
Quoted 6 lines
fs/f2fs/segment.c +2
-0@@ -1510,6 +1518,10 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi, }__submit_discard_cmd (sbi, dpolicy, dc, &issued); +if (dc->error == -EAGAIN ) { +congestion_wait (BLK_RW_ASYNC ,HZ /50 );--> need to be DEFAULT_IO_TIMEOUTYes, i will update it.
Quoted 5 lines
fs/f2fs/segment.c static int __issue_discard_cmd(struct f2fs_sb_info *sbi, · line 1523
Quoted 2 lines
fs/f2fs/segment.c +1
-0+__relocate_discard_cmd (dcc, dc);It seems we need to submit bio first, and then move dc to
wait_list, if there's no error, in__submit_discard_cmd().
Quoted 7 lines
Yes, that is not changed and it still happens for the failed request that is re-queued here too when it gets submitted again later.
I am requeuing the discard request failed with
-EAGAINerror back to dcc->pend_list[] fromwait_list. It will callsubmit_bio()for this request and also move towait_listwhen it calls__submit_discard_cmd()again next time. Please let me know if I am missing anything?
This patch has no problem, but I'm thinking that __submit_discard_cmd() needs to return with any values by assumption where the waiting list should have submitted commands.
Quoted 16 lines
Thanks,
Quoted 8 lines
Quoted 8 lines
fs/f2fs/segment.c +1
-0+ }if (issued >= dpolicy->max_requests)break ;Signature · 2 lines
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc. Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, a Linux Foundation Collaborative Project.Signature · 3 lines
-- Sent by a consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
Quoted 38 lines · Sahitya Tummala
F2FS already has a default timeout of 5 secs for discards that can be issued during umount, but it can take more than the 5 sec timeout if the underlying UFS device queue is already full and there are no more available free tags to be used. In that case,
submit_bio()will wait for the already queued discard requests to complete to get a free tag, which can potentially take way more than 5 sec.Fix this by submitting the discard requests with
REQ_NOWAITflags during umount. This will return-EAGAINfor UFS queue/tag full scenario without waiting in the context ofsubmit_bio(). The FS can then handle these requests by retrying again within the stipulated discard timeout period to avoid long latencies.Signed-off-by Sahitya Tummala <[email protected]>--- fs/f2fs/segment.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-)fs/f2fs/segment.c +4
-1@@ -1124,10 +1124,13 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi,struct discard_cmd_control *dcc =SM_I (sbi)->dcc_info;struct list_head *wait_list = (dpolicy->type ==DPOLICY_FSTRIM ) ? &(dcc->fstrim_list) : &(dcc->wait_list); -int flag = dpolicy->sync ?REQ_SYNC :0 ; +int flag;block_t lstart, start, len, total_len;int err =0 ; + flag = dpolicy->sync ?REQ_SYNC :0 ; + flag |= dpolicy->type ==DPOLICY_UMOUNT ?REQ_NOWAIT :0 ; +if (dc->state !=D_PREP )return 0 ;
fs/f2fs/segment.c static int __submit_discard_cmd(struct f2fs_sb_info *sbi, · line 1209
Quoted 4 lines
fs/f2fs/segment.c +1
-0@@ -1203,6 +1206,11 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi, bio->bi_end_io = f2fs_submit_discard_endio; bio->bi_opf |= flag;submit_bio (bio); +if ((flag &REQ_NOWAIT ) && (dc->error == -EAGAIN )) {
If we want to update dc->state, we need to cover it with dc->lock.
fs/f2fs/segment.c static int __submit_discard_cmd(struct f2fs_sb_info *sbi, · line 1210
Quoted 1 line
fs/f2fs/segment.c +1
-0+ dc->state =D_PREP ;
BTW, one dc can be referenced by multiple bios, so dc->state could be updated to D_DONE later by f2fs_submit_discard_endio(), however we just relocate it to pending list... which is inconsistent status.
Thanks,
Quoted 18 lines
fs/f2fs/segment.c +7
-0+ err = dc->error; +break ; + }atomic_inc (&dcc->issued_discard);@@ -1510,6 +1518,10 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi, }__submit_discard_cmd (sbi, dpolicy, dc, &issued); +if (dc->error == -EAGAIN ) { +congestion_wait (BLK_RW_ASYNC ,HZ /50 ); +__relocate_discard_cmd (dcc, dc); + }if (issued >= dpolicy->max_requests)break ;
Quoted 38 lines · Chao Yu
Quoted 37 lines · Sahitya Tummala
F2FS already has a default timeout of 5 secs for discards that can be issued during umount, but it can take more than the 5 sec timeout if the underlying UFS device queue is already full and there are no more available free tags to be used. In that case,
submit_bio()will wait for the already queued discard requests to complete to get a free tag, which can potentially take way more than 5 sec.Fix this by submitting the discard requests with
REQ_NOWAITflags during umount. This will return-EAGAINfor UFS queue/tag full scenario without waiting in the context ofsubmit_bio(). The FS can then handle these requests by retrying again within the stipulated discard timeout period to avoid long latencies.Signed-off-by Sahitya Tummala <[email protected]>--- fs/f2fs/segment.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-)fs/f2fs/segment.c +4
-1@@ -1124,10 +1124,13 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi,struct discard_cmd_control *dcc =SM_I (sbi)->dcc_info;struct list_head *wait_list = (dpolicy->type ==DPOLICY_FSTRIM ) ? &(dcc->fstrim_list) : &(dcc->wait_list); -int flag = dpolicy->sync ?REQ_SYNC :0 ; +int flag;block_t lstart, start, len, total_len;int err =0 ; + flag = dpolicy->sync ?REQ_SYNC :0 ; + flag |= dpolicy->type ==DPOLICY_UMOUNT ?REQ_NOWAIT :0 ; +if (dc->state !=D_PREP )return 0 ;
Quoted 7 lines
fs/f2fs/segment.c static int __submit_discard_cmd(struct f2fs_sb_info *sbi, · line 1209
Quoted 5 lines
fs/f2fs/segment.c +1
-0@@ -1203,6 +1206,11 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi, bio->bi_end_io = f2fs_submit_discard_endio; bio->bi_opf |= flag;submit_bio (bio); +if ((flag &REQ_NOWAIT ) && (dc->error == -EAGAIN )) {If we want to update
dc->state, we need to cover it withdc->lock.
Sure, will update it.
Quoted 6 lines
fs/f2fs/segment.c static int __submit_discard_cmd(struct f2fs_sb_info *sbi, · line 1210
Quoted 2 lines
fs/f2fs/segment.c +1
-0+ dc->state =D_PREP ;BTW, one dc can be referenced by multiple bios, so
dc->statecould be updated toD_DONElater byf2fs_submit_discard_endio(), however we just relocate it to pending list... which is inconsistent status.
In that case dc->bio_ref will reflect it and until it becomes 0, the dc->state will not be updated to D_DONE in f2fs_submit_discard_endio()?
Thanks,
Quoted 21 lines
Thanks,
Quoted 18 lines
fs/f2fs/segment.c +7
-0+ err = dc->error; +break ; + }atomic_inc (&dcc->issued_discard);@@ -1510,6 +1518,10 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi, }__submit_discard_cmd (sbi, dpolicy, dc, &issued); +if (dc->error == -EAGAIN ) { +congestion_wait (BLK_RW_ASYNC ,HZ /50 ); +__relocate_discard_cmd (dcc, dc); + }if (issued >= dpolicy->max_requests)break ;
Signature · 3 lines
-- Sent by a consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
Quoted 72 lines · Jaegeuk Kim
Quoted 71 lines · Sahitya Tummala
Quoted 50 lines · Jaegeuk Kim
Quoted 49 lines · Sahitya Tummala
F2FS already has a default timeout of 5 secs for discards that can be issued during umount, but it can take more than the 5 sec timeout if the underlying UFS device queue is already full and there are no more available free tags to be used. In that case,
submit_bio()will wait for the already queued discard requests to complete to get a free tag, which can potentially take way more than 5 sec.Fix this by submitting the discard requests with
REQ_NOWAITflags during umount. This will return-EAGAINfor UFS queue/tag full scenario without waiting in the context ofsubmit_bio(). The FS can then handle these requests by retrying again within the stipulated discard timeout period to avoid long latencies.Signed-off-by Sahitya Tummala <[email protected]>--- fs/f2fs/segment.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-)fs/f2fs/segment.c +9
-1@@ -1124,10 +1124,13 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi,struct discard_cmd_control *dcc =SM_I (sbi)->dcc_info;struct list_head *wait_list = (dpolicy->type ==DPOLICY_FSTRIM ) ? &(dcc->fstrim_list) : &(dcc->wait_list); -int flag = dpolicy->sync ?REQ_SYNC :0 ; +int flag;block_t lstart, start, len, total_len;int err =0 ; + flag = dpolicy->sync ?REQ_SYNC :0 ; + flag |= dpolicy->type ==DPOLICY_UMOUNT ?REQ_NOWAIT :0 ; +if (dc->state !=D_PREP )return 0 ;@@ -1203,6 +1206,11 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi, bio->bi_end_io = f2fs_submit_discard_endio; bio->bi_opf |= flag;submit_bio (bio); +if ((flag &REQ_NOWAIT ) && (dc->error == -EAGAIN )) { + dc->state =D_PREP ; + err = dc->error; +break ; + }atomic_inc (&dcc->issued_discard);Quoted 8 lines
fs/f2fs/segment.c static int __issue_discard_cmd(struct f2fs_sb_info *sbi, · line 1522
Quoted 6 lines
fs/f2fs/segment.c +2
-0@@ -1510,6 +1518,10 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi, }__submit_discard_cmd (sbi, dpolicy, dc, &issued); +if (dc->error == -EAGAIN ) { +congestion_wait (BLK_RW_ASYNC ,HZ /50 );--> need to be DEFAULT_IO_TIMEOUTYes, i will update it.
Quoted 5 lines
fs/f2fs/segment.c static int __issue_discard_cmd(struct f2fs_sb_info *sbi, · line 1523
Quoted 2 lines
fs/f2fs/segment.c +1
-0+__relocate_discard_cmd (dcc, dc);It seems we need to submit bio first, and then move dc to
wait_list, if there's no error, in__submit_discard_cmd().Yes, that is not changed and it still happens for the failed request that is re-queued here too when it gets submitted again later.
Quoted 8 lines
Quoted 4 lines
I am requeuing the discard request failed with
-EAGAINerror back to dcc->pend_list[] fromwait_list. It will callsubmit_bio()for this request and also move towait_listwhen it calls__submit_discard_cmd()again next time. Please let me know if I am missing anything?This patch has no problem, but I'm thinking that
__submit_discard_cmd()needs to return with any values by assumption where the waiting list should have submitted commands.
I think dc->queued will indicated that dc is moved to wait_list. This can be used along with return value to take right action. Can you check if this works?
fs/f2fs/segment.c +5 -3
@@ -1478,7 +1478,7 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,struct list_head *pend_list;struct discard_cmd *dc, *tmp;struct blk_plug plug; -int i, issued =0 ; +int i, err, issued =0 ;bool io_interrupted = false;if (dpolicy->timeout !=0 )
@@ -1517,8 +1517,10 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,break ; } -__submit_discard_cmd (sbi, dpolicy, dc, &issued); -if (dc->error == -EAGAIN ) { + err =__submit_discard_cmd (sbi, dpolicy, dc, &issued); +if (err && err != -EAGAIN ) { +__remove_discard_cmd (sbi, dc); + }else if (err == -EAGAIN && dc->queued) {congestion_wait (BLK_RW_ASYNC ,HZ /50 );__relocate_discard_cmd (dcc, dc); }
thanks,
Quoted 17 lines
Quoted 17 lines
Thanks,
Quoted 8 lines
Quoted 8 lines
fs/f2fs/segment.c +1
-0+ }if (issued >= dpolicy->max_requests)break ;Signature · 2 lines
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc. Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, a Linux Foundation Collaborative Project.Signature · 3 lines
-- Sent by a consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
Signature · 3 lines
-- Sent by a consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
Quoted 50 lines · Sahitya Tummala
Quoted 38 lines · Chao Yu
Quoted 37 lines · Sahitya Tummala
F2FS already has a default timeout of 5 secs for discards that can be issued during umount, but it can take more than the 5 sec timeout if the underlying UFS device queue is already full and there are no more available free tags to be used. In that case,
submit_bio()will wait for the already queued discard requests to complete to get a free tag, which can potentially take way more than 5 sec.Fix this by submitting the discard requests with
REQ_NOWAITflags during umount. This will return-EAGAINfor UFS queue/tag full scenario without waiting in the context ofsubmit_bio(). The FS can then handle these requests by retrying again within the stipulated discard timeout period to avoid long latencies.Signed-off-by Sahitya Tummala <[email protected]>--- fs/f2fs/segment.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-)fs/f2fs/segment.c +4
-1@@ -1124,10 +1124,13 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi,struct discard_cmd_control *dcc =SM_I (sbi)->dcc_info;struct list_head *wait_list = (dpolicy->type ==DPOLICY_FSTRIM ) ? &(dcc->fstrim_list) : &(dcc->wait_list); -int flag = dpolicy->sync ?REQ_SYNC :0 ; +int flag;block_t lstart, start, len, total_len;int err =0 ; + flag = dpolicy->sync ?REQ_SYNC :0 ; + flag |= dpolicy->type ==DPOLICY_UMOUNT ?REQ_NOWAIT :0 ; +if (dc->state !=D_PREP )return 0 ;Quoted 7 lines
fs/f2fs/segment.c static int __submit_discard_cmd(struct f2fs_sb_info *sbi, · line 1209
Quoted 5 lines
fs/f2fs/segment.c +1
-0@@ -1203,6 +1206,11 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi, bio->bi_end_io = f2fs_submit_discard_endio; bio->bi_opf |= flag;submit_bio (bio); +if ((flag &REQ_NOWAIT ) && (dc->error == -EAGAIN )) {If we want to update
dc->state, we need to cover it withdc->lock.Sure, will update it.
Quoted 1 line
Quoted 8 lines
Quoted 5 lines
fs/f2fs/segment.c static int __submit_discard_cmd(struct f2fs_sb_info *sbi, · line 1210
Quoted 1 line
fs/f2fs/segment.c +1
-0+ dc->state =D_PREP ;BTW, one dc can be referenced by multiple bios, so
dc->statecould be updated toD_DONElater byf2fs_submit_discard_endio(), however we just relocate it to pending list... which is inconsistent status.In that case
dc->bio_refwill reflect it and until it becomes 0, thedc->statewill not be updated toD_DONEinf2fs_submit_discard_endio()?
__submit_discard_cmd()
lock()
dc->state = D_SUBMIT;
dc->bio_ref++;
unlock()
...
submit_bio()
f2fs_submit_discard_endio() dc->error = -EAGAIN; lock() dc->bio_ref--;
dc->state = D_PREP;
dc->state = D_DONE; unlock()
So finally, dc's state is D_DONE, and it's in wait list, then will be relocated to pending list.
Quoted 21 lines
Thanks,
Quoted 18 lines
Thanks,
Quoted 15 lines
fs/f2fs/segment.c +7
-0+ err = dc->error; +break ; + }atomic_inc (&dcc->issued_discard);@@ -1510,6 +1518,10 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi, }__submit_discard_cmd (sbi, dpolicy, dc, &issued); +if (dc->error == -EAGAIN ) { +congestion_wait (BLK_RW_ASYNC ,HZ /50 ); +__relocate_discard_cmd (dcc, dc); + }
Quoted 4 lines
Quoted 3 lines
fs/f2fs/segment.c static int __issue_discard_cmd(struct f2fs_sb_info *sbi, · line 1527
Quoted 3 lines
fs/f2fs/segment.c +0
-0if (issued >= dpolicy->max_requests)break ;
_______________________________________________
Linux-f2fs-devel mailing list
[email protected]
https://lists.sourceforge.net/lists/listinfo/linux-f2fs-devel
Quoted 72 lines · Chao Yu
Quoted 50 lines · Sahitya Tummala
Quoted 38 lines · Chao Yu
Quoted 37 lines · Sahitya Tummala
F2FS already has a default timeout of 5 secs for discards that can be issued during umount, but it can take more than the 5 sec timeout if the underlying UFS device queue is already full and there are no more available free tags to be used. In that case,
submit_bio()will wait for the already queued discard requests to complete to get a free tag, which can potentially take way more than 5 sec.Fix this by submitting the discard requests with
REQ_NOWAITflags during umount. This will return-EAGAINfor UFS queue/tag full scenario without waiting in the context ofsubmit_bio(). The FS can then handle these requests by retrying again within the stipulated discard timeout period to avoid long latencies.Signed-off-by Sahitya Tummala <[email protected]>--- fs/f2fs/segment.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-)fs/f2fs/segment.c +4
-1@@ -1124,10 +1124,13 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi,struct discard_cmd_control *dcc =SM_I (sbi)->dcc_info;struct list_head *wait_list = (dpolicy->type ==DPOLICY_FSTRIM ) ? &(dcc->fstrim_list) : &(dcc->wait_list); -int flag = dpolicy->sync ?REQ_SYNC :0 ; +int flag;block_t lstart, start, len, total_len;int err =0 ; + flag = dpolicy->sync ?REQ_SYNC :0 ; + flag |= dpolicy->type ==DPOLICY_UMOUNT ?REQ_NOWAIT :0 ; +if (dc->state !=D_PREP )return 0 ;Quoted 7 lines
fs/f2fs/segment.c static int __submit_discard_cmd(struct f2fs_sb_info *sbi, · line 1209
Quoted 5 lines
fs/f2fs/segment.c +1
-0@@ -1203,6 +1206,11 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi, bio->bi_end_io = f2fs_submit_discard_endio; bio->bi_opf |= flag;submit_bio (bio); +if ((flag &REQ_NOWAIT ) && (dc->error == -EAGAIN )) {If we want to update
dc->state, we need to cover it withdc->lock.Sure, will update it.
Quoted 1 line
Quoted 8 lines
Quoted 5 lines
fs/f2fs/segment.c static int __submit_discard_cmd(struct f2fs_sb_info *sbi, · line 1210
Quoted 1 line
fs/f2fs/segment.c +1
-0+ dc->state =D_PREP ;BTW, one dc can be referenced by multiple bios, so
dc->statecould be updated toD_DONElater byf2fs_submit_discard_endio(), however we just relocate it to pending list... which is inconsistent status.In that case
dc->bio_refwill reflect it and until it becomes 0, thedc->statewill not be updated toD_DONEinf2fs_submit_discard_endio()?
__submit_discard_cmd()
lock()
dc->state=D_SUBMIT;
dc->bio_ref++;
unlock()
...
submit_bio()f2fs_submit_discard_endio() dc->error = -EAGAIN; lock() dc->bio_ref--;
Quoted 7 lines
dc->state=D_PREP;dc->state = D_DONE; unlock()So finally, dc's state is
D_DONE, and it's in wait list, then will be relocated to pending list.
In case of queue full, f2fs_submit_discard_endio() will not be called asynchronously. It will be called in the context of submit_bio() itself. So by the time, submit_bio returns dc->error will be -EAGAIN and dc->state will be D_DONE.
submit_bio()
->blk_mq_make_request
->blk_mq_get_request()
->bio_wouldblock_error() (called due to queue full)
->bio_endio()
Thanks,
Quoted 26 lines
Quoted 26 lines
Thanks,
Quoted 21 lines
Thanks,
Quoted 18 lines
fs/f2fs/segment.c +7
-0+ err = dc->error; +break ; + }atomic_inc (&dcc->issued_discard);@@ -1510,6 +1518,10 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi, }__submit_discard_cmd (sbi, dpolicy, dc, &issued); +if (dc->error == -EAGAIN ) { +congestion_wait (BLK_RW_ASYNC ,HZ /50 ); +__relocate_discard_cmd (dcc, dc); + }if (issued >= dpolicy->max_requests)break ;
Signature · 3 lines
-- Sent by a consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
Jaegeuk Kim
maintainerQuoted 78 lines · Sahitya Tummala
Quoted 77 lines · Jaegeuk Kim
Quoted 75 lines · Sahitya Tummala
Quoted 50 lines · Jaegeuk Kim
Quoted 49 lines · Sahitya Tummala
F2FS already has a default timeout of 5 secs for discards that can be issued during umount, but it can take more than the 5 sec timeout if the underlying UFS device queue is already full and there are no more available free tags to be used. In that case,
submit_bio()will wait for the already queued discard requests to complete to get a free tag, which can potentially take way more than 5 sec.Fix this by submitting the discard requests with
REQ_NOWAITflags during umount. This will return-EAGAINfor UFS queue/tag full scenario without waiting in the context ofsubmit_bio(). The FS can then handle these requests by retrying again within the stipulated discard timeout period to avoid long latencies.Signed-off-by Sahitya Tummala <[email protected]>--- fs/f2fs/segment.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-)fs/f2fs/segment.c +9
-1@@ -1124,10 +1124,13 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi,struct discard_cmd_control *dcc =SM_I (sbi)->dcc_info;struct list_head *wait_list = (dpolicy->type ==DPOLICY_FSTRIM ) ? &(dcc->fstrim_list) : &(dcc->wait_list); -int flag = dpolicy->sync ?REQ_SYNC :0 ; +int flag;block_t lstart, start, len, total_len;int err =0 ; + flag = dpolicy->sync ?REQ_SYNC :0 ; + flag |= dpolicy->type ==DPOLICY_UMOUNT ?REQ_NOWAIT :0 ; +if (dc->state !=D_PREP )return 0 ;@@ -1203,6 +1206,11 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi, bio->bi_end_io = f2fs_submit_discard_endio; bio->bi_opf |= flag;submit_bio (bio); +if ((flag &REQ_NOWAIT ) && (dc->error == -EAGAIN )) { + dc->state =D_PREP ; + err = dc->error; +break ; + }atomic_inc (&dcc->issued_discard);Quoted 8 lines
fs/f2fs/segment.c static int __issue_discard_cmd(struct f2fs_sb_info *sbi, · line 1522
Quoted 6 lines
fs/f2fs/segment.c +2
-0@@ -1510,6 +1518,10 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi, }__submit_discard_cmd (sbi, dpolicy, dc, &issued); +if (dc->error == -EAGAIN ) { +congestion_wait (BLK_RW_ASYNC ,HZ /50 );--> need to be DEFAULT_IO_TIMEOUTYes, i will update it.
Quoted 5 lines
fs/f2fs/segment.c static int __issue_discard_cmd(struct f2fs_sb_info *sbi, · line 1523
Quoted 2 lines
fs/f2fs/segment.c +1
-0+__relocate_discard_cmd (dcc, dc);It seems we need to submit bio first, and then move dc to
wait_list, if there's no error, in__submit_discard_cmd().Yes, that is not changed and it still happens for the failed request that is re-queued here too when it gets submitted again later.
I am requeuing the discard request failed with
-EAGAINerror back to dcc->pend_list[] fromwait_list. It will callsubmit_bio()for this request and also move towait_listwhen it calls__submit_discard_cmd()again next time. Please let me know if I am missing anything?
Quoted 7 lines
Quoted 3 lines
This patch has no problem, but I'm thinking that
__submit_discard_cmd()needs to return with any values by assumption where the waiting list should have submitted commands.I think
dc->queuedwill indicated that dc is moved towait_list. This can be used along with return value to take right action. Can you check if this works?
I mean why can't do this *in* __submit_discard_cmd()? Otherwise, existing and future callers should consider to handle the errors everytime.
Quoted 51 lines
fs/f2fs/segment.c +5
-3@@ -1478,7 +1478,7 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,struct list_head *pend_list;struct discard_cmd *dc, *tmp;struct blk_plug plug; -int i, issued =0 ; +int i, err, issued =0 ;bool io_interrupted = false;if (dpolicy->timeout !=0 )@@ -1517,8 +1517,10 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,break ; } -__submit_discard_cmd (sbi, dpolicy, dc, &issued); -if (dc->error == -EAGAIN ) { + err =__submit_discard_cmd (sbi, dpolicy, dc, &issued); +if (err && err != -EAGAIN ) { +__remove_discard_cmd (sbi, dc); + }else if (err == -EAGAIN && dc->queued) {congestion_wait (BLK_RW_ASYNC ,HZ /50 );__relocate_discard_cmd (dcc, dc); }thanks,
Quoted 17 lines
Quoted 17 lines
Thanks,
Quoted 8 lines
Quoted 8 lines
fs/f2fs/segment.c +1
-0+ }if (issued >= dpolicy->max_requests)break ;Signature · 2 lines
Qualcomm India Private Limited, on behalf of Qualcomm Innovation Center, Inc. Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, a Linux Foundation Collaborative Project.Signature · 3 lines
-- Sent by a consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.Signature · 3 lines
-- Sent by a consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.
Quoted 75 lines · Sahitya Tummala
Quoted 74 lines · Chao Yu
Quoted 50 lines · Sahitya Tummala
Quoted 38 lines · Chao Yu
Quoted 37 lines · Sahitya Tummala
F2FS already has a default timeout of 5 secs for discards that can be issued during umount, but it can take more than the 5 sec timeout if the underlying UFS device queue is already full and there are no more available free tags to be used. In that case,
submit_bio()will wait for the already queued discard requests to complete to get a free tag, which can potentially take way more than 5 sec.Fix this by submitting the discard requests with
REQ_NOWAITflags during umount. This will return-EAGAINfor UFS queue/tag full scenario without waiting in the context ofsubmit_bio(). The FS can then handle these requests by retrying again within the stipulated discard timeout period to avoid long latencies.Signed-off-by Sahitya Tummala <[email protected]>--- fs/f2fs/segment.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-)fs/f2fs/segment.c +4
-1@@ -1124,10 +1124,13 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi,struct discard_cmd_control *dcc =SM_I (sbi)->dcc_info;struct list_head *wait_list = (dpolicy->type ==DPOLICY_FSTRIM ) ? &(dcc->fstrim_list) : &(dcc->wait_list); -int flag = dpolicy->sync ?REQ_SYNC :0 ; +int flag;block_t lstart, start, len, total_len;int err =0 ; + flag = dpolicy->sync ?REQ_SYNC :0 ; + flag |= dpolicy->type ==DPOLICY_UMOUNT ?REQ_NOWAIT :0 ; +if (dc->state !=D_PREP )return 0 ;Quoted 7 lines
fs/f2fs/segment.c static int __submit_discard_cmd(struct f2fs_sb_info *sbi, · line 1209
Quoted 5 lines
fs/f2fs/segment.c +1
-0@@ -1203,6 +1206,11 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi, bio->bi_end_io = f2fs_submit_discard_endio; bio->bi_opf |= flag;submit_bio (bio); +if ((flag &REQ_NOWAIT ) && (dc->error == -EAGAIN )) {If we want to update
dc->state, we need to cover it withdc->lock.Sure, will update it.
Quoted 1 line
Quoted 8 lines
Quoted 5 lines
fs/f2fs/segment.c static int __submit_discard_cmd(struct f2fs_sb_info *sbi, · line 1210
Quoted 1 line
fs/f2fs/segment.c +1
-0+ dc->state =D_PREP ;BTW, one dc can be referenced by multiple bios, so
dc->statecould be updated toD_DONElater byf2fs_submit_discard_endio(), however we just relocate it to pending list... which is inconsistent status.In that case
dc->bio_refwill reflect it and until it becomes 0, thedc->statewill not be updated toD_DONEinf2fs_submit_discard_endio()?
__submit_discard_cmd()
lock()
dc->state=D_SUBMIT;
dc->bio_ref++;
unlock()
...
submit_bio()f2fs_submit_discard_endio() dc->error = -EAGAIN; lock() dc->bio_ref--;
dc->state=D_PREP;
Quoted 7 lines
Quoted 5 lines
dc->state = D_DONE; unlock()So finally, dc's state is
D_DONE, and it's in wait list, then will be relocated to pending list.In case of queue full,
f2fs_submit_discard_endio()will not be called
I guess the case is there are multiple bios related to one dc and partially callback of bio is called asynchronously and the other is called synchronously, so the race condition could happen.
Thanks,
Quoted 38 lines
asynchronously. It will be called in the context of
submit_bio()itself. So by the time,submit_bioreturnsdc->errorwill be-EAGAINanddc->statewill beD_DONE.
submit_bio()
->blk_mq_make_request
->blk_mq_get_request()
->bio_wouldblock_error() (called due to queue full)->bio_endio()Thanks,
Quoted 26 lines
Quoted 26 lines
Thanks,
Quoted 21 lines
Thanks,
Quoted 18 lines
fs/f2fs/segment.c +7
-0+ err = dc->error; +break ; + }atomic_inc (&dcc->issued_discard);@@ -1510,6 +1518,10 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi, }__submit_discard_cmd (sbi, dpolicy, dc, &issued); +if (dc->error == -EAGAIN ) { +congestion_wait (BLK_RW_ASYNC ,HZ /50 ); +__relocate_discard_cmd (dcc, dc); + }if (issued >= dpolicy->max_requests)break ;
Hi Chao,
Quoted 79 lines · Chao Yu
Quoted 78 lines · Sahitya Tummala
Quoted 77 lines · Chao Yu
Quoted 50 lines · Sahitya Tummala
Quoted 38 lines · Chao Yu
Quoted 37 lines · Sahitya Tummala
F2FS already has a default timeout of 5 secs for discards that can be issued during umount, but it can take more than the 5 sec timeout if the underlying UFS device queue is already full and there are no more available free tags to be used. In that case,
submit_bio()will wait for the already queued discard requests to complete to get a free tag, which can potentially take way more than 5 sec.Fix this by submitting the discard requests with
REQ_NOWAITflags during umount. This will return-EAGAINfor UFS queue/tag full scenario without waiting in the context ofsubmit_bio(). The FS can then handle these requests by retrying again within the stipulated discard timeout period to avoid long latencies.Signed-off-by Sahitya Tummala <[email protected]>--- fs/f2fs/segment.c | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-)fs/f2fs/segment.c +4
-1@@ -1124,10 +1124,13 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi,struct discard_cmd_control *dcc =SM_I (sbi)->dcc_info;struct list_head *wait_list = (dpolicy->type ==DPOLICY_FSTRIM ) ? &(dcc->fstrim_list) : &(dcc->wait_list); -int flag = dpolicy->sync ?REQ_SYNC :0 ; +int flag;block_t lstart, start, len, total_len;int err =0 ; + flag = dpolicy->sync ?REQ_SYNC :0 ; + flag |= dpolicy->type ==DPOLICY_UMOUNT ?REQ_NOWAIT :0 ; +if (dc->state !=D_PREP )return 0 ;Quoted 7 lines
fs/f2fs/segment.c static int __submit_discard_cmd(struct f2fs_sb_info *sbi, · line 1209
Quoted 5 lines
fs/f2fs/segment.c +1
-0@@ -1203,6 +1206,11 @@ static int __submit_discard_cmd(struct f2fs_sb_info *sbi, bio->bi_end_io = f2fs_submit_discard_endio; bio->bi_opf |= flag;submit_bio (bio); +if ((flag &REQ_NOWAIT ) && (dc->error == -EAGAIN )) {If we want to update
dc->state, we need to cover it withdc->lock.Sure, will update it.
Quoted 1 line
Quoted 8 lines
Quoted 5 lines
fs/f2fs/segment.c static int __submit_discard_cmd(struct f2fs_sb_info *sbi, · line 1210
Quoted 1 line
fs/f2fs/segment.c +1
-0+ dc->state =D_PREP ;BTW, one dc can be referenced by multiple bios, so
dc->statecould be updated toD_DONElater byf2fs_submit_discard_endio(), however we just relocate it to pending list... which is inconsistent status.In that case
dc->bio_refwill reflect it and until it becomes 0, thedc->statewill not be updated toD_DONEinf2fs_submit_discard_endio()?
__submit_discard_cmd()
lock()
dc->state=D_SUBMIT;
dc->bio_ref++;
unlock()
...
submit_bio()f2fs_submit_discard_endio() dc->error = -EAGAIN; lock() dc->bio_ref--;
dc->state=D_PREP;dc->state = D_DONE; unlock()
Quoted 8 lines
Quoted 4 lines
Quoted 2 lines
So finally, dc's state is
D_DONE, and it's in wait list, then will be relocated to pending list.In case of queue full,
f2fs_submit_discard_endio()will not be calledI guess the case is there are multiple bios related to one dc and partially callback of bio is called asynchronously and the other is called synchronously, so the race condition could happen.
You are right. Let me review that case and try to fix it.
Thanks,
Quoted 41 lines
Thanks,
Quoted 38 lines
asynchronously. It will be called in the context of
submit_bio()itself. So by the time,submit_bioreturnsdc->errorwill be-EAGAINanddc->statewill beD_DONE.
submit_bio()
->blk_mq_make_request
->blk_mq_get_request()
->bio_wouldblock_error() (called due to queue full)->bio_endio()Thanks,
Quoted 26 lines
Quoted 26 lines
Thanks,
Quoted 21 lines
Thanks,
Quoted 18 lines
fs/f2fs/segment.c +7
-0+ err = dc->error; +break ; + }atomic_inc (&dcc->issued_discard);@@ -1510,6 +1518,10 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi, }__submit_discard_cmd (sbi, dpolicy, dc, &issued); +if (dc->error == -EAGAIN ) { +congestion_wait (BLK_RW_ASYNC ,HZ /50 ); +__relocate_discard_cmd (dcc, dc); + }if (issued >= dpolicy->max_requests)break ;
Signature · 3 lines
-- Sent by a consultant of the Qualcomm Innovation Center, Inc. The Qualcomm Innovation Center, Inc. is a member of the Code Aurora Forum.