scsi: ufs: Let devices remain runtime suspended during system suspend
v3 cover scsi: ufs: Let devices remain runtime suspended during system suspend
Hi
UFS devices can remain runtime suspended at system suspend time, if the conditions are right. Add support for that, first fixing the impediments.
Changes in V3:
scsi: ufs: Fix error handler clear ua deadlock
Correct commit message.
Amend stable tags to add dependent cherry picks
Changes in V2:
scsi: ufs: Let devices remain runtime suspended during system suspend
The ufs-hisi driver uses different RPM and SPM, but it is made explicit by a new parameter to suspend prepare.
Adrian Hunter (3):
scsi: ufs: Fix error handler clear ua deadlock
scsi: ufs: Fix runtime PM dependencies getting broken
scsi: ufs: Let devices remain runtime suspended during system suspend
drivers/scsi/scsi_pm.c | 16 ++++++--- drivers/scsi/ufs/ufs-hisi.c | 8 ++++- drivers/scsi/ufs/ufshcd.c | 87 +++++++++++++++++++++++++++++++-------------- drivers/scsi/ufs/ufshcd.h | 12 ++++++- include/scsi/scsi_device.h | 1 + 5 files changed, 90 insertions(+), 34 deletions(-)
Regards
Adrian
PATCH v3 1/3 scsi: ufs: Fix error handler clear ua deadlock
There is no guarantee to be able to enter the queue if requests are blocked. That is because freezing the queue will block entry to the queue, but freezing also waits for outstanding requests which can make no progress while the queue is blocked.
That situation can happen when the error handler issues requests to clear unit attention condition. Requests can be blocked if the ufshcd_state is UFSHCD_STATE_EH_SCHEDULED_FATAL, which can happen as a result either of error handler activity, or theoretically a request that is issued after the error handler unblocks the queue but before clearing unit attention condition.
The deadlock is very unlikely, so the error handler can be expected to clear ua at some point anyway, so the simple solution is not to wait to enter the queue.
Additionally, note that the RPMB queue might be not be entered because it is runtime suspended, but in that case ua will be cleared at RPMB runtime resume.
---
Changes in V3:
Correct commit message.
Amend stable tags to add dependent cherry picks
drivers/scsi/ufs/ufshcd.c | 33 +++++++++++++++++++-------------- 1 file changed, 19 insertions(+), 14 deletions(-)
drivers/scsi/ufs/ufshcd.c +19 -14
@@ -224,7 +224,7 @@ static int ufshcd_reset_and_restore(struct ufs_hba *hba);static int ufshcd_eh_host_reset_handler (struct scsi_cmnd *cmd);static int ufshcd_clear_tm_cmd (struct ufs_hba *hba,int tag);static void ufshcd_hba_exit (struct ufs_hba *hba); -static int ufshcd_clear_ua_wluns (struct ufs_hba *hba); +static int ufshcd_clear_ua_wluns (struct ufs_hba *hba,bool nowait);static int ufshcd_probe_hba (struct ufs_hba *hba,bool async);static int ufshcd_setup_clocks (struct ufs_hba *hba,bool on);static int ufshcd_uic_hibern8_enter (struct ufs_hba *hba);
@@ -4110,7 +4110,7 @@ int ufshcd_link_recovery(struct ufs_hba *hba)dev_err (hba->dev,"%s: link recovery failed, err %d" , __func__, ret); else -ufshcd_clear_ua_wluns (hba ); +ufshcd_clear_ua_wluns (hba ,false );return ret; }
@@ -5974,7 +5974,7 @@ static void ufshcd_err_handling_unprepare(struct ufs_hba *hba)ufshcd_release (hba);if (ufshcd_is_clkscaling_supported (hba))ufshcd_clk_scaling_suspend (hba, false); -ufshcd_clear_ua_wluns (hba); +ufshcd_clear_ua_wluns (hba, true);ufshcd_rpm_put (hba); }
@@ -7907,7 +7907,7 @@ static int ufshcd_add_lus(struct ufs_hba *hba)if (ret) goto out; -ufshcd_clear_ua_wluns (hba); +ufshcd_clear_ua_wluns (hba, false);/* Initialize devfreq after UFS device is detected */ if (ufshcd_is_clkscaling_supported (hba)) {
@@ -7943,7 +7943,8 @@ static void ufshcd_request_sense_done(struct request *rq, blk_status_t error) }static int -ufshcd_request_sense_async (struct ufs_hba *hba,struct scsi_device *sdev) +ufshcd_request_sense_async (struct ufs_hba *hba,struct scsi_device *sdev, +bool nowait) {/* * Some UFS devices clear unit attention condition only if the sense
@@ -7951,6 +7952,7 @@ ufshcd_request_sense_async(struct ufs_hba *hba, struct scsi_device *sdev)*/ static const u8 cmd[6 ] = {REQUEST_SENSE ,0 ,0 ,0 ,UFS_SENSE_SIZE ,0 };struct scsi_request *rq; +blk_mq_req_flags_t flags;struct request *req;char *buffer;int ret;
@@ -7959,8 +7961,8 @@ ufshcd_request_sense_async(struct ufs_hba *hba, struct scsi_device *sdev)if (!buffer)return -ENOMEM ; - req =blk_get_request (sdev->request_queue,REQ_OP_DRV_IN , -/*flags=*/ BLK_MQ_REQ_PM ); + flags =BLK_MQ_REQ_PM | (nowait ?BLK_MQ_REQ_NOWAIT :0 ); + req =blk_get_request (sdev->request_queue,REQ_OP_DRV_IN , flags);if (IS_ERR (req)) { ret =PTR_ERR (req); goto out_free;
@@ -7990,7 +7992,7 @@ ufshcd_request_sense_async(struct ufs_hba *hba, struct scsi_device *sdev)return ret; } -static int ufshcd_clear_ua_wlun (struct ufs_hba *hba,u8 wlun) +static int ufshcd_clear_ua_wlun (struct ufs_hba *hba,u8 wlun,bool nowait) {struct scsi_device *sdp;unsigned long flags;
@@ -8016,7 +8018,10 @@ static int ufshcd_clear_ua_wlun(struct ufs_hba *hba, u8 wlun)if (ret) goto out_err; - ret =ufshcd_request_sense_async (hba, sdp); + ret =ufshcd_request_sense_async (hba, sdp, nowait); +if (nowait && ret && wlun ==UFS_UPIU_RPMB_WLUN && +pm_runtime_suspended (&sdp->sdev_gendev)) + ret =0 ;/* RPMB runtime resume will clear UAC */ scsi_device_put (sdp); out_err:if (ret)
@@ -8025,16 +8030,16 @@ static int ufshcd_clear_ua_wlun(struct ufs_hba *hba, u8 wlun)return ret; } -static int ufshcd_clear_ua_wluns (struct ufs_hba *hba) +static int ufshcd_clear_ua_wluns (struct ufs_hba *hba,bool nowait) {int ret =0 ;if (!hba->wlun_dev_clr_ua) goto out; - ret =ufshcd_clear_ua_wlun (hba,UFS_UPIU_UFS_DEVICE_WLUN ); + ret =ufshcd_clear_ua_wlun (hba,UFS_UPIU_UFS_DEVICE_WLUN , nowait);if (!ret) - ret =ufshcd_clear_ua_wlun (hba,UFS_UPIU_RPMB_WLUN ); + ret =ufshcd_clear_ua_wlun (hba,UFS_UPIU_RPMB_WLUN , nowait);if (!ret) hba->wlun_dev_clr_ua = false; out:
@@ -8656,7 +8661,7 @@ static int ufshcd_set_dev_pwr_mode(struct ufs_hba *hba,*/ hba->host->eh_noresume =1 ;if (hba->wlun_dev_clr_ua) -ufshcd_clear_ua_wlun (hba,UFS_UPIU_UFS_DEVICE_WLUN ); +ufshcd_clear_ua_wlun (hba,UFS_UPIU_UFS_DEVICE_WLUN , false); cmd[4 ] = pwr_mode <<4 ;
@@ -9825,7 +9830,7 @@ static inline int ufshcd_clear_rpmb_uac(struct ufs_hba *hba)if (!hba->wlun_rpmb_clr_ua)return 0 ; - ret =ufshcd_clear_ua_wlun (hba,UFS_UPIU_RPMB_WLUN ); + ret =ufshcd_clear_ua_wlun (hba,UFS_UPIU_RPMB_WLUN , false);if (!ret) hba->wlun_rpmb_clr_ua =0 ;return ret;
Signature · 1 line
2.17.1
PATCH v3 2/3 scsi: ufs: Fix runtime PM dependencies getting broken
In reply to Adrian HunterUFS SCSI devices make use of device links to establish PM dependencies. However, SCSI PM will force devices' runtime PM state to be active during system resume. That can break runtime PM dependencies for UFS devices. Fix by adding a flag 'preserve_rpm' to let UFS SCSI devices opt-out of the unwanted behaviour.
--- drivers/scsi/scsi_pm.c | 16 +++++++++++----- drivers/scsi/ufs/ufshcd.c | 1 + include/scsi/scsi_device.h | 1 + 3 files changed, 13 insertions(+), 5 deletions(-)
drivers/scsi/scsi_pm.c +11 -5
@@ -73,13 +73,22 @@ static int scsi_dev_type_resume(struct device *dev, int (*cb)(struct device *, const struct dev_pm_ops *)) {const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm :NULL ; +struct scsi_device *sdev =NULL ; +bool preserve_rpm = false;int err =0 ; +if (scsi_is_sdev_device (dev)) { + sdev =to_scsi_device (dev); + preserve_rpm = sdev->preserve_rpm; +if (preserve_rpm &&pm_runtime_suspended (dev)) +return 0 ; + } + err =cb (dev, pm);scsi_device_resume (to_scsi_device (dev));dev_dbg (dev,"scsi resume: %d\n" , err); -if (err ==0 ) { +if (err ==0 && !preserve_rpm) {pm_runtime_disable (dev); err =pm_runtime_set_active (dev);pm_runtime_enable (dev);
@@ -91,11 +100,8 @@ static int scsi_dev_type_resume(struct device *dev,* * The resume hook will correct runtime PM status of the disk. */ -if (!err &&scsi_is_sdev_device (dev)) { -struct scsi_device *sdev =to_scsi_device (dev); - +if (!err && sdev)blk_set_runtime_active (sdev->request_queue); - } }return err;
drivers/scsi/ufs/ufshcd.c +1 -0
@@ -5016,6 +5016,7 @@ static int ufshcd_slave_configure(struct scsi_device *sdev)pm_runtime_get_noresume (&sdev->sdev_gendev); else if (ufshcd_is_rpm_autosuspend_allowed(hba)) sdev->rpm_autosuspend = 1; + sdev->preserve_rpm =1 ;ufshcd_crypto_setup_rq_keyslot_manager (hba, q);
include/scsi/scsi_device.h +1 -0
@@ -197,6 +197,7 @@ struct scsi_device { unsigned no_read_disc_info:1; /* Avoid READ_DISC_INFO cmds */ unsigned no_read_capacity_16:1; /* Avoid READ_CAPACITY_16 cmds */ unsigned try_rc_10_first:1; /* Try READ_CAPACACITY_10 first */ + unsigned preserve_rpm:1; /* Preserve runtime PM */ unsigned security_supported:1; /* Supports Security Protocols */ unsigned is_visible:1; /* is the device visible in sysfs */ unsigned wce_default_on:1; /* Cache is ON by default */
Signature · 1 line
2.17.1
PATCH v3 3/3 scsi: ufs: Let devices remain runtime suspended during system suspend
In reply to Adrian HunterIf the UFS Device WLUN is runtime suspended and is in the same power mode, link state and b_rpm_dev_flush_capable (BKOP or WB buffer flush etc) state, then it can remain runtime suspended instead of being runtime resumed and then system suspended.
The following patches have cleared the way for that to happen:
scsi: ufs: Fix runtime PM dependencies getting broken
scsi: ufs: Fix error handler clear ua deadlock
So amend the logic accordingly.
Note, the ufs-hisi driver uses different RPM and SPM, but it is made explicit by a new parameter to suspend prepare.
---
Changes in V3:
None.
Changes in V2:
The ufs-hisi driver uses different RPM and SPM, but it is made explicit by a new parameter to suspend prepare.
drivers/scsi/ufs/ufs-hisi.c | 8 +++++- drivers/scsi/ufs/ufshcd.c | 53 ++++++++++++++++++++++++++++--------- drivers/scsi/ufs/ufshcd.h | 12 ++++++++- 3 files changed, 58 insertions(+), 15 deletions(-)
drivers/scsi/ufs/ufs-hisi.c +7 -1
@@ -396,6 +396,12 @@ static int ufs_hisi_pwr_change_notify(struct ufs_hba *hba,return ret; } +static int ufs_hisi_suspend_prepare (struct device *dev) +{ +/* RPM and SPM are different. Refer ufs_hisi_suspend() */ +return __ufshcd_suspend_prepare (dev, false); +} +static int ufs_hisi_suspend (struct ufs_hba *hba,enum ufs_pm_op pm_op) {struct ufs_hisi_host *host =ufshcd_get_variant (hba);
@@ -574,7 +580,7 @@ static int ufs_hisi_remove(struct platform_device *pdev)static const struct dev_pm_ops ufs_hisi_pm_ops = { SET_SYSTEM_SLEEP_PM_OPS(ufshcd_system_suspend, ufshcd_system_resume)SET_RUNTIME_PM_OPS (ufshcd_runtime_suspend, ufshcd_runtime_resume,NULL ) - .prepare = ufshcd_suspend_prepare, + .prepare = ufs_hisi_suspend_prepare, .complete = ufshcd_resume_complete, };
drivers/scsi/ufs/ufshcd.c +40 -13
73 lines not on this page · raw message
drivers/scsi/ufs/ufshcd.h +11 -1
@@ -915,7 +915,6 @@ struct ufs_hba {#endif u32 luns_avail;bool complete_put; -bool rpmb_complete_put; };/* Returns true if clocks can be gated. Otherwise false */
@@ -1175,6 +1174,7 @@ int ufshcd_exec_raw_upiu_cmd(struct ufs_hba *hba,int ufshcd_wb_toggle (struct ufs_hba *hba,bool enable);int ufshcd_suspend_prepare (struct device *dev); +int __ufshcd_suspend_prepare (struct device *dev,bool rpm_ok_for_spm);void ufshcd_resume_complete (struct device *dev);/* Wrapper functions for safely calling variant operations */
@@ -1383,6 +1383,16 @@ static inline int ufshcd_rpm_put_sync(struct ufs_hba *hba)return pm_runtime_put_sync (&hba->sdev_ufs_device->sdev_gendev); } +static inline void ufshcd_rpm_get_noresume (struct ufs_hba *hba) +{ +pm_runtime_get_noresume (&hba->sdev_ufs_device->sdev_gendev); +} + +static inline int ufshcd_rpm_resume (struct ufs_hba *hba) +{ +return pm_runtime_resume (&hba->sdev_ufs_device->sdev_gendev); +} +static inline int ufshcd_rpm_put (struct ufs_hba *hba) {return pm_runtime_put (&hba->sdev_ufs_device->sdev_gendev);
Signature · 1 line
2.17.1
Re: [PATCH V3 1/3] scsi: ufs: Fix error handler clear ua deadlock
In reply to Adrian HunterQuoted 12 lines · Adrian Hunter
There is no guarantee to be able to enter the queue if requests are blocked. That is because freezing the queue will block entry to the queue, but freezing also waits for outstanding requests which can make no progress while the queue is blocked.
That situation can happen when the error handler issues requests to clear unit attention condition. Requests can be blocked if the
ufshcd_stateisUFSHCD_STATE_EH_SCHEDULED_FATAL, which can happen as a result either of error handler activity, or theoretically a request that is issued after the error handler unblocks the queue but before clearing unit attention condition.
Quoted 3 lines
The deadlock is very unlikely, so the error handler can be expected to clear ua at some point anyway, so the simple solution is not to wait to enter the queue.
Do you agree that the interaction between ufshcd_scsi_block_requests() and blk_mq_freeze_queue() can only lead to a deadlock if blk_queue_enter() is called without using the BLK_MQ_REQ_NOWAIT flag and if unblocking SCSI request processing can only happen by the same thread?
Do you agree that no ufshcd_clear_ua_wluns() caller blocks SCSI request processing and hence that it is not necessary to add a "nowait" argument to ufshcd_clear_ua_wluns()?
Thanks,
Bart.
Re: [PATCH V3 1/3] scsi: ufs: Fix error handler clear ua deadlock
Quoted 13 lines · Bart Van Assche
Quoted 12 lines · Adrian Hunter
There is no guarantee to be able to enter the queue if requests are blocked. That is because freezing the queue will block entry to the queue, but freezing also waits for outstanding requests which can make no progress while the queue is blocked.
That situation can happen when the error handler issues requests to clear unit attention condition. Requests can be blocked if the
ufshcd_stateisUFSHCD_STATE_EH_SCHEDULED_FATAL, which can happen as a result either of error handler activity, or theoretically a request that is issued after the error handler unblocks the queue but before clearing unit attention condition.
Quoted 8 lines
Quoted 3 lines
The deadlock is very unlikely, so the error handler can be expected to clear ua at some point anyway, so the simple solution is not to wait to enter the queue.
Do you agree that the interaction between
ufshcd_scsi_block_requests()andblk_mq_freeze_queue()can only lead to a deadlock ifblk_queue_enter()is called without using theBLK_MQ_REQ_NOWAITflag and if unblocking SCSI request processing can only happen by the same thread?
Sure
Quoted 3 lines
Do you agree that no
ufshcd_clear_ua_wluns()caller blocks SCSI request processing and hence that it is not necessary to add a "nowait" argument toufshcd_clear_ua_wluns()?
No. Requests cannot make progress when ufshcd_state is UFSHCD_STATE_EH_SCHEDULED_FATAL, and only the error handler can change that, so if the error handler is waiting to enter the queue and blk_mq_freeze_queue() is waiting for outstanding requests, they will deadlock.
Re: [PATCH V3 1/3] scsi: ufs: Fix error handler clear ua deadlock
Quoted 4 lines · Adrian Hunter
No. Requests cannot make progress when
ufshcd_stateisUFSHCD_STATE_EH_SCHEDULED_FATAL, and only the error handler can change that, so if the error handler is waiting to enter the queue andblk_mq_freeze_queue()is waiting for outstanding requests, they will deadlock.
How about adding the above text as a comment above ufshcd_clear_ua_wluns() such that this information becomes available to those who have not followed this conversation?
Thanks,
Bart.
Re: [PATCH V3 1/3] scsi: ufs: Fix error handler clear ua deadlock
Quoted 9 lines · Bart Van Assche
Quoted 4 lines · Adrian Hunter
No. Requests cannot make progress when
ufshcd_stateisUFSHCD_STATE_EH_SCHEDULED_FATAL, and only the error handler can change that, so if the error handler is waiting to enter the queue andblk_mq_freeze_queue()is waiting for outstanding requests, they will deadlock.How about adding the above text as a comment above
ufshcd_clear_ua_wluns()such that this information becomes available to those who have not followed this conversation?
After having given patch 1/3 some further thought: an unfortunate effect of this patch is that unit attention clearing is skipped for the states UFSHCD_STATE_EH_SCHEDULED_FATAL and UFSHCD_STATE_RESET. How about replacing patch 1/3 with the untested patch below since that patch does not have the disadvantage of sometimes skipping clearing UA?
Thanks,
Bart.
[PATCH] scsi: ufs: Fix a recently introduced deadlock
Completing pending commands with DID_IMM_RETRY triggers the following code paths:
scsi_complete()
-> scsi_queue_insert()
-> __scsi_queue_insert()
-> scsi_device_unbusy()
-> scsi_dec_host_busy()
-> scsi_eh_wakeup()
-> blk_mq_requeue_request() scsi_queue_rq()
-> scsi_host_queue_ready()
-> scsi_host_in_recovery()
--- drivers/scsi/ufs/ufshcd.c | 8 ++++++++ 1 file changed, 8 insertions(+)
drivers/scsi/ufs/ufshcd.c +8 -0
@@ -2707,6 +2707,14 @@ static int ufshcd_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd) } fallthrough;case UFSHCD_STATE_RESET : +/* +* The SCSI error handler only starts after all pending commands +* have failed or timed out. Complete commands with +* DID_IMM_RETRY to allow the error handler to start +* if it has been scheduled. +*/ +set_host_byte (cmd,DID_IMM_RETRY ); + cmd->scsi_done (cmd); err =SCSI_MLQUEUE_HOST_BUSY ; goto out;case UFSHCD_STATE_ERROR :
Re: [PATCH V3 1/3] scsi: ufs: Fix error handler clear ua deadlock
Quoted 7 lines · Bart Van Assche
Quoted 6 lines · Bart Van Assche
Quoted 4 lines · Adrian Hunter
No. Requests cannot make progress when
ufshcd_stateisUFSHCD_STATE_EH_SCHEDULED_FATAL, and only the error handler can change that, so if the error handler is waiting to enter the queue andblk_mq_freeze_queue()is waiting for outstanding requests, they will deadlock.
Quoted 7 lines
Quoted 3 lines
How about adding the above text as a comment above
ufshcd_clear_ua_wluns()such that this information becomes available to those who have not followed this conversation?After having given patch 1/3 some further thought: an unfortunate effect of this patch is that unit attention clearing is skipped for the states
UFSHCD_STATE_EH_SCHEDULED_FATALandUFSHCD_STATE_RESET.
Only if the error handler is racing with blk_mq_freeze_queue(), but it is not ideal.
Quoted 2 lines
How about replacing patch 1/3 with the untested patch below since that patch does not have the disadvantage of sometimes skipping clearing UA?
I presume you mean without reverting "scsi: ufs: Synchronize SCSI and UFS error handling" but in that case the deadlock happens because:
error handler is waiting on blk_queue_enter()blk_queue_enter() is waiting on blk_mq_freeze_queue()blk_mq_freeze_queue() is waiting on outstanding requests
outstanding requests are blocked by the SCSI error handler shost_state == SHOST_RECOVERY set by scsi_schedule_eh()
Quoted 36 lines
Thanks,
Bart.
[PATCH] scsi: ufs: Fix a recently introduced deadlock
Completing pending commands with
DID_IMM_RETRYtriggers the following code paths:
scsi_complete()
->scsi_queue_insert()
->__scsi_queue_insert()
->scsi_device_unbusy()
->scsi_dec_host_busy()
->scsi_eh_wakeup()
->blk_mq_requeue_request()
scsi_queue_rq()
->scsi_host_queue_ready()
->scsi_host_in_recovery()Fixes a113eaaf8637 ("scsi: ufs: Synchronize SCSI and UFS error handling")Signed-off-by Bart Van Assche <[email protected]>---
drivers/scsi/ufs/ufshcd.c | 8 ++++++++1 file changed, 8 insertions(+)drivers/scsi/ufs/ufshcd.c +0
-0@@ -2707,6 +2707,14 @@ static int ufshcd_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd) } fallthrough;case
UFSHCD_STATE_RESET:
Quoted 8 lines
+ /*
+ * The SCSI error handler only starts after all pending commands + * have failed or timed out. Complete commands with + *DID_IMM_RETRYto allow the error handler to start + * if it has been scheduled.
+ */
+set_host_byte(cmd, DID_IMM_RETRY);
+cmd->scsi_done(cmd);
Setting non-zero return value, in this case "err = SCSI_MLQUEUE_HOST_BUSY" will anyway cause scsi_dec_host_busy(), so does this make any difference?
Quoted 3 lines
err =
SCSI_MLQUEUE_HOST_BUSY;
goto out;
caseUFSHCD_STATE_ERROR:
Re: [PATCH V3 1/3] scsi: ufs: Fix error handler clear ua deadlock
Quoted 10 lines · Adrian Hunter
Quoted 9 lines · Bart Van Assche
drivers/scsi/ufs/ufshcd.c +3
-0@@ -2707,6 +2707,14 @@ static int ufshcd_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd) } fallthrough; case UFSHCD_STATE_RESET: + /* +* The SCSI error handler only starts after all pending commands +* have failed or timed out. Complete commands with
Quoted 8 lines
drivers/scsi/ufs/ufshcd.c static int ufshcd_queuecommand(struct Scsi_Host *host, struct scsi_cmnd *cmd) · line 2717
Quoted 5 lines
drivers/scsi/ufs/ufshcd.c +5
-0+* DID_IMM_RETRY to allow the error handler to start +* if it has been scheduled. +*/ + set_host_byte(cmd, DID_IMM_RETRY); + cmd->scsi_done(cmd);Setting non-zero return value, in this case "err =
SCSI_MLQUEUE_HOST_BUSY" will anyway causescsi_dec_host_busy(), so does this make any difference?
The return value should be changed into 0 since returning SCSI_MLQUEUE_HOST_BUSY is only allowed if cmd->scsi_done(cmd) has not yet been called.
I expect that setting the host byte to DID_IMM_RETRY and calling scsi_done will make a difference, otherwise I wouldn't have suggested this. As explained in my previous email doing that triggers the SCSI command completion and resubmission paths. Resubmission only happens if the SCSI error handler has not yet been scheduled. The SCSI error handler is scheduled after for all pending commands scsi_done() has been called or a timeout occurred. In other words, setting the host byte to DID_IMM_RETRY and calling scsi_done() makes it possible for the error handler to be scheduled, something that won't happen if ufshcd_queuecommand() systematically returns SCSI_MLQUEUE_HOST_BUSY. In the latter case the block layer timer is reset over and over again. See also the blk_mq_start_request() in scsi_queue_rq(). One could wonder whether this is really what the SCSI core should do if a SCSI LLD keeps returning the SCSI_MLQUEUE_HOST_BUSY status code ...
Bart.
Re: [PATCH V3 1/3] scsi: ufs: Fix error handler clear ua deadlock
Quoted 20 lines · Bart Van Assche
Quoted 14 lines · Adrian Hunter
Quoted 9 lines · Bart Van Assche
---
a/drivers/scsi/ufs/ufshcd.c+++b/drivers/scsi/ufs/ufshcd.c(quoted diff) +0
-0@@ -2707,6 +2707,14 @@ static int ufshcd_queuecommand(struct
Scsi_Host*host, structscsi_cmnd*cmd) } fallthrough; caseUFSHCD_STATE_RESET: + /* + * The SCSI error
handler only starts after all pending commands + * have
failed or timed out. Complete commands with + *DID_IMM_RETRYto allow the error handler to start + * if
it has been scheduled. + */ + set_host_byte(cmd,DID_IMM_RETRY); +cmd->scsi_done(cmd);Setting non-zero return value, in this case "err =
SCSI_MLQUEUE_HOST_BUSY" will anyway causescsi_dec_host_busy(), so does this make any difference?The return value should be changed into 0 since returning
SCSI_MLQUEUE_HOST_BUSYis only allowed ifcmd->scsi_done(cmd)has not yet been called.
Quoted 9 lines
I expect that setting the host byte to
DID_IMM_RETRYand callingscsi_donewill make a difference, otherwise I wouldn't have suggested
this. As explained in my previous email doing that triggers the SCSI> command completion and resubmission paths. Resubmission only happens if the SCSI error handler has not yet been scheduled. The SCSI error
handler is scheduled after for all pending commandsscsi_done()has
been called or a timeout occurred. In other words, setting the host
byte toDID_IMM_RETRYand callingscsi_done()makes it possible for
the error handler to be scheduled, something that won't happen ifufshcd_queuecommand()systematically returnsSCSI_MLQUEUE_HOST_BUSY.
Not getting it, sorry. :-(
The error handler sets UFSHCD_STATE_RESET and never leaves the state as UFSHCD_STATE_RESET, so that case does not need to start the error handler because it is already running.
The error handler is always scheduled after setting UFSHCD_STATE_EH_SCHEDULED_FATAL.
scsi_dec_host_busy() is called for any non-zero return value like SCSI_MLQUEUE_HOST_BUSY:
i.e.
reason = scsi_dispatch_cmd(cmd);
if (reason) {
scsi_set_blocked(cmd, reason);
ret = BLK_STS_RESOURCE;
goto out_dec_host_busy;
}
return BLK_STS_OK;out_dec_host_busy:
scsi_dec_host_busy(shost, cmd);
And that will wake the error handler:
static void scsi_dec_host_busy(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
{
unsigned long flags;
rcu_read_lock();
__clear_bit(SCMD_STATE_INFLIGHT, &cmd->state);
if (unlikely(scsi_host_in_recovery(shost))) {
spin_lock_irqsave(shost->host_lock, flags);
if (shost->host_failed || shost->host_eh_scheduled)
scsi_eh_wakeup(shost);
spin_unlock_irqrestore(shost->host_lock, flags);
}
rcu_read_unlock();
}Note that scsi_host_queue_ready() won't let any requests through when scsi_host_in_recovery(), so the potential problem is with requests that have already been successfully submitted to the UFS driver but have not completed. The change you suggest does not help with that.
That seems like another problem with the patch "scsi: ufs: Synchronize SCSI and UFS error handling".
Quoted 6 lines
In the latter case the block layer timer is reset over and over again. See also the
blk_mq_start_request()inscsi_queue_rq(). One could wonder whether this is really what the SCSI core should do if a SCSI LLD keeps returning theSCSI_MLQUEUE_HOST_BUSYstatus code ...Bart.
Re: [PATCH V3 1/3] scsi: ufs: Fix error handler clear ua deadlock
Quoted 19 lines · Adrian Hunter
scsi_dec_host_busy()is called for any non-zero return value likeSCSI_MLQUEUE_HOST_BUSY:i.e.
reason = scsi_dispatch_cmd(cmd); if (reason) { scsi_set_blocked(cmd, reason); ret = BLK_STS_RESOURCE; goto out_dec_host_busy; } return BLK_STS_OK;
out_dec_host_busy:scsi_dec_host_busy(shost, cmd);And that will wake the error handler:
static void
scsi_dec_host_busy(struct Scsi_Host *shost, struct scsi_cmnd *cmd)
Quoted 13 lines
{
unsigned long flags;
rcu_read_lock();
__clear_bit(SCMD_STATE_INFLIGHT, &cmd->state);
if (unlikely(scsi_host_in_recovery(shost))) {
spin_lock_irqsave(shost->host_lock, flags);
if (shost->host_failed || shost->host_eh_scheduled)
scsi_eh_wakeup(shost);
spin_unlock_irqrestore(shost->host_lock, flags);
}
rcu_read_unlock();
}Returning SCSI_MLQUEUE_HOST_BUSY is not sufficient to wake up the SCSI error handler because of the following test in scsi_error_handler():
shost->host_failed != scsi_host_busy(shost)
As I mentioned in a previous email, all pending commands must have failed or timed out before the error handler is woken up. Returning SCSI_MLQUEUE_HOST_BUSY from ufshcd_queuecommand() does not fail a command and prevents it from timing out. Hence my suggestion to change "return SCSI_MLQUEUE_HOST_BUSY" into set_host_byte(cmd, DID_IMM_RETRY) followed by cmd->scsi_done(cmd). A possible alternative is to move the blk_mq_start_request() call in the SCSI core such that the block layer request timer is not reset if a SCSI LLD returns SCSI_MLQUEUE_HOST_BUSY.
Bart.
Re: [PATCH V3 1/3] scsi: ufs: Fix error handler clear ua deadlock
Quoted 34 lines · Bart Van Assche
Quoted 22 lines · Adrian Hunter
scsi_dec_host_busy()is called for any non-zero return value likeSCSI_MLQUEUE_HOST_BUSY:i.e.
reason =scsi_dispatch_cmd(cmd);
if (reason) {
scsi_set_blocked(cmd, reason);
ret =BLK_STS_RESOURCE;
gotoout_dec_host_busy;
}return
BLK_STS_OK;
out_dec_host_busy:
scsi_dec_host_busy(shost, cmd);And that will wake the error handler:
static void
scsi_dec_host_busy(struct Scsi_Host *shost, struct scsi_cmnd *cmd){
unsigned long flags;Quoted 10 lines
rcu_read_lock();
__clear_bit(SCMD_STATE_INFLIGHT, &cmd->state); if (unlikely(scsi_host_in_recovery(shost))) {spin_lock_irqsave(shost->host_lock, flags); if (shost->host_failed||shost->host_eh_scheduled)scsi_eh_wakeup(shost);spin_unlock_irqrestore(shost->host_lock, flags); }
rcu_read_unlock();
}
Quoted 4 lines
Returning
SCSI_MLQUEUE_HOST_BUSYis not sufficient to wake up the SCSI error handler because of the following test inscsi_error_handler():shost->host_failed !=
scsi_host_busy(shost)
SCSI_MLQUEUE_HOST_BUSY causes scsi_host_busy() to decrement by calling scsi_dec_host_busy() as described above, so the request is not being counted in that condition anymore.
Quoted 11 lines
As I mentioned in a previous email, all pending commands must have failed or timed out before the error handler is woken up. Returning
SCSI_MLQUEUE_HOST_BUSYfromufshcd_queuecommand()does not fail a command and prevents it from timing out. Hence my suggestion to change "returnSCSI_MLQUEUE_HOST_BUSY" intoset_host_byte(cmd, DID_IMM_RETRY)followed bycmd->scsi_done(cmd). A possible alternative is to move theblk_mq_start_request()call in the SCSI core such that the block layer request timer is not reset if a SCSI LLD returnsSCSI_MLQUEUE_HOST_BUSY.Bart.
Re: [PATCH V3 1/3] scsi: ufs: Fix error handler clear ua deadlock
Quoted 3 lines · Adrian Hunter
SCSI_MLQUEUE_HOST_BUSYcausesscsi_host_busy()to decrement by callingscsi_dec_host_busy()as described above, so the request is not being counted in that condition anymore.
Let's take a step back. My understanding is that the deadlock is caused by the combination of:
* SCSI command processing being blocked because of the state UFSHCD_STATE_EH_SCHEDULED_FATAL.
* The sdev_ufs_device and/or sdev_rpmb request queues are frozen (blk_mq_freeze_queue() has started).
* A REQUEST SENSE command being scheduled from inside the error handler (ufshcd_clear_ua_wlun()).
Is this a theoretical concern or something that has been observed on a test setup?
If this has been observed on a test setup, was the error handler scheduled (ufshcd_err_handler())?
I don't see how SCSI command processing could get stuck indefinitely since it is guaranteed that the UFS error handler will get scheduled and also that the UFS error handler will change ufshcd_state from UFSHCD_STATE_EH_SCHEDULED_FATAL into another state?
What am I missing?
Thanks,
Bart.
Re: [PATCH V3 1/3] scsi: ufs: Fix error handler clear ua deadlock
Quoted 9 lines · Bart Van Assche
Quoted 3 lines · Adrian Hunter
SCSI_MLQUEUE_HOST_BUSYcausesscsi_host_busy()to decrement by callingscsi_dec_host_busy()as described above, so the request is not being counted in that condition anymore.Let's take a step back. My understanding is that the deadlock is caused by the combination of:
* SCSI command processing being blocked because of the stateUFSHCD_STATE_EH_SCHEDULED_FATAL.
That assumes "scsi: ufs: Synchronize SCSI and UFS error handling" is reverted. With "scsi: ufs: Synchronize SCSI and UFS error handling" all requests are blocked because scsi_host_in_recovery().
Quoted 2 lines
* The
sdev_ufs_deviceand/orsdev_rpmbrequest queues are frozen (blk_mq_freeze_queue()has started).
Yes
Quoted 2 lines
* A REQUEST SENSE command being scheduled from inside the error handler (
ufshcd_clear_ua_wlun()).
Not exactly. It is not possible to enter the queue after freezing starts so blk_queue_enter() is stuck waiting on any existing requests to exit the queue, but existing requests are blocked as described above.
Quoted 3 lines
Is this a theoretical concern or something that has been observed on a test setup?
It is observed on Samsung Galaxy Book S when suspending.
Quoted 3 lines
If this has been observed on a test setup, was the error handler scheduled (
ufshcd_err_handler())?
Yes.
Quoted 5 lines
I don't see how SCSI command processing could get stuck indefinitely since it is guaranteed that the UFS error handler will get scheduled and also that the UFS error handler will change
ufshcd_statefromUFSHCD_STATE_EH_SCHEDULED_FATALinto another state?
The error handler is stuck waiting on the freeze, which is stuck waiting on requests which are stuck waiting on the error handler.
Quoted 2 lines
What am I missing?
You have not responded to the issues raised by "scsi: ufs: Synchronize SCSI and UFS error handling"
Re: [PATCH V3 1/3] scsi: ufs: Fix error handler clear ua deadlock
Quoted 4 lines · Adrian Hunter
On 13/09/21 11:11 pm, Bart Van Assche wrote: >> What am I missing?
You have not responded to the issues raised by "scsi: ufs: Synchronize SCSI and UFS error handling"
Because one of the follow-up messages to that patch was so cryptic that I did not comprehend it. Anyway, based on the patch at the start of this email thread I assume that the deadlock is caused by calling blk_get_request() without the BLK_MQ_REQ_NOWAIT flag from inside a SCSI error handler. How about fixing this by removing the code that submits a REQUEST SENSE command and calling scsi_report_bus_reset() or scsi_report_device_reset() instead? ufshcd_reset_and_restore() already uses that approach to make sure that the unit attention condition triggered by a reset is not reported to the SCSI command submitter. I think only if needs_restore == true and needs_reset == false that ufshcd_err_handler() can trigger a UA condition without calling scsi_report_bus_reset().
The following code from scsi_error.c makes sure that the UA after a reset does not reach the upper-level driver:
case NOT_READY:
case UNIT_ATTENTION:
/*
* if we are expecting a cc/ua because of a bus reset that we
* performed, treat this just as a retry. otherwise this is
* information that we should pass up to the upper-level driver
* so that we can deal with it there.
*/
if (scmd->device->expecting_cc_ua) {
/*
* Because some device does not queue unit
* attentions correctly, we carefully check
* additional sense code and qualifier so as
* not to squash media change unit attention.
*/
if (sshdr.asc != 0x28 || sshdr.ascq != 0x00) {
scmd->device->expecting_cc_ua = 0;
return NEEDS_RETRY;
}
}Bart.
Re: [PATCH V3 1/3] scsi: ufs: Fix error handler clear ua deadlock
Quoted 42 lines · Bart Van Assche
Quoted 4 lines · Adrian Hunter
On 13/09/21 11:11 pm, Bart Van Assche wrote: >> What am I missing?
You have not responded to the issues raised by "scsi: ufs: Synchronize SCSI and UFS error handling"
Because one of the follow-up messages to that patch was so cryptic that I did not comprehend it. Anyway, based on the patch at the start of this email thread I assume that the deadlock is caused by calling
blk_get_request()without theBLK_MQ_REQ_NOWAITflag from inside a SCSI error handler. How about fixing this by removing the code that submits a REQUEST SENSE command and callingscsi_report_bus_reset()orscsi_report_device_reset()instead?ufshcd_reset_and_restore()already uses that approach to make sure that the unit attention condition triggered by a reset is not reported to the SCSI command submitter. I think only ifneeds_restore== true andneeds_reset== false thatufshcd_err_handler()can trigger a UA condition without callingscsi_report_bus_reset().The following code from
scsi_error.cmakes sure that the UA after a reset does not reach the upper-level driver:case
NOT_READY:
caseUNIT_ATTENTION:
/*
* if we are expecting a cc/ua because of a bus reset that we
* performed, treat this just as a retry. otherwise this is
* information that we should pass up to the upper-level driver
* so that we can deal with it there.
*/
if (scmd->device->expecting_cc_ua) {
/*
* Because some device does not queue unit
* attentions correctly, we carefully check
* additional sense code and qualifier so as
* not to squash media change unit attention.
*/
if (sshdr.asc !=0x28|| sshdr.ascq !=0x00) {scmd->device->expecting_cc_ua= 0;
returnNEEDS_RETRY;
}
}
Quoted 1 line
Bart.
Thanks for the idea. Unfortunately it does not work for pass-through requests, refer scsi_noretry_cmd(). sdev_ufs_device and sdev_rpmb are used with pass-through requests.
Re: [PATCH V3 1/3] scsi: ufs: Fix error handler clear ua deadlock
Quoted 3 lines · Adrian Hunter
Thanks for the idea. Unfortunately it does not work for pass-through requests, refer
scsi_noretry_cmd().sdev_ufs_deviceandsdev_rpmbare used with pass-through requests.
How about allocating and submitting the REQUEST SENSE command from the context of a workqueue, or in other words, switching back to scsi_execute()? Although that approach doesn't guarantee that the unit attention condition is cleared before the first SCSI command is received from outside the UFS driver, I don't see any other solution since my understanding is that the deadlock between blk_mq_freeze_queue() and blk_get_request() from inside ufshcd_err_handler() can also happen without "ufs: Synchronize SCSI and UFS error handling".
The only code I know of that relies on the UFS driver clearing unit attentions is this code:
https://android.googlesource.com/platform/system/core/+/master/trusty/storage/proxy/rpmb.c
The code that submits a REQUEST SENSE was added in the UFS driver as the result of a request from the team that maintains the Trusty code. Earlier today I have been promised that unit attention handling support will be added in Trusty but I do not when this will be realized.
Bart.
Re: [PATCH V3 1/3] scsi: ufs: Fix error handler clear ua deadlock
Quoted 5 lines · Bart Van Assche
Quoted 3 lines · Adrian Hunter
Thanks for the idea. Unfortunately it does not work for pass-through requests, refer scsi_noretry_cmd().
sdev_ufs_deviceandsdev_rpmbare used with pass-through requests.
Quoted 7 lines
How about allocating and submitting the REQUEST SENSE command from the context of a workqueue, or in other words, switching back to
scsi_execute()? Although that approach doesn't guarantee that the unit attention condition is cleared before the first SCSI command is received from outside the UFS driver, I don't see any other solution since my understanding is that the deadlock betweenblk_mq_freeze_queue()andblk_get_request()from insideufshcd_err_handler()can also happen without "ufs: Synchronize SCSI and UFS error handling".
The issue can also be fixed by sending REQUEST SENSE directly avoiding the SCSI queues. Please see V4.
Quoted 12 lines
The only code I know of that relies on the UFS driver clearing unit attentions is this code:
https://android.googlesource.com/platform/system/core/+/master/trusty/storage/proxy/rpmb.c
The code that submits a REQUEST SENSE was added in the UFS driver as the result of a request from the team that maintains the Trusty code. Earlier today I have been promised that unit attention handling support will be added in Trusty but I do not when this will be realized.Bart.