More device removal fixes
v9 cover More device removal fixes
Fix a few issues that can be triggered by removing a device:
- Fix a race between starved list processing and device removal.
- Avoid that a SCSI LLD callback can get invoked after scsi_remove_host() finished.
- Speed up device removal by stopping error handling as soon as the SHOST_DEL or SHOST_DEL_RECOVERY state has been reached.
- Save and restore the host_scribble field during error handling.
These patches have been tested on top of kernel v3.8-rc7 and are also available here: http://github.com/bvanassche/linux/tree/device-removal-fixes.
Changes compared to v8:
- Addressed the feedback from Joe Lawrence - dropped the patch that makes scsi_remove_host() wait until the last sdev user is gone.
- Eliminated Scsi_Host.tmf_in_progress since it duplicates state information available in Scsi_Host.eh_active.
- Added a patch to avoid reenabling I/O after the transport layer became offline.
Changes compared to v7:
- Addressed the review comments posted by Hannes Reinecke and Rolf Eike Beer.
- Modified patch "Make scsi_remove_host() wait until error handling finished" such that it is also safe for SCSI timeout values below the maximum LLD response time by modifying scsi_send_eh_cmnd() such that it does not invoke any LLD code after scsi_remove_host() started.
- Added a patch to save and restore the host_scribble field.
- Refined / clarified several patch descriptions.
- Rebased and retested on top of kernel v3.8-rc6.
Changes compared to v6:
- Dropped the first six patches since Jens queued these for 3.8.
- Added patch to avoid that __scsi_remove_device() is invoked twice.
- Restore error recovery in the SHOST_CANCEL state.
Changes compared to v5:
- Avoid that block layer work can be scheduled on a dead queue.
- Do not invoke any SCSI LLD callback after scsi_remove_host() finished.
- Stop error handling as soon as scsi_remove_host() started.
- Remove the unused function bsg_goose_queue().
- Avoid that scsi_device_set_state() triggers a race condition.
Changes compared to v4:
- Moved queue_flag_set(QUEUE_FLAG_DEAD, q) from blk_drain_queue() into blk_cleanup_queue().
- Declared the new __blk_run_queue_uncond() function inline. Checked in the generated assembler code that this function is really inlined in __blk_run_queue().
- Elaborated several patch descriptions.
- Added sparse annotations to scsi_request_fn().
- Split several patches.
Changes compared to v3:
- Fixed a race condition by setting QUEUE_FLAG_DEAD earlier.
- Added a patch for fixing a race between starved list processing and device removal to this series.
Changes compared to v2:
- Split second patch into two patches.
- Refined patch descriptions.
Changes compared to v1:
- Included a patch to rename QUEUE_FLAG_DEAD.
- Refined the descriptions of the __blk_run_queue_uncond() and blk_cleanup_queue() functions.
--
To unsubscribe from this list: send the line "unsubscribe linux-scsi" in the body of a message to [email protected]
More majordomo info at http://vger.kernel.org/majordomo-info.html
PATCH v9 1/9 Fix race between starved list processing and device removal
scsi_run_queue() examines all SCSI devices that are present on the starved list. Since scsi_run_queue() unlocks the SCSI host lock before running a queue a SCSI device can get removed after it has been removed from the starved list and before its queue is run. Protect against that race condition by increasing the sdev refcount before running the sdev queue. Also, remove a SCSI device from the starved list before __scsi_remove_device() decreases the sdev refcount such that the get_device() call added in scsi_run_queue() is guaranteed to succeed.
Reference: http://lkml.org/lkml/2012/8/2/96
--- drivers/scsi/scsi_lib.c | 16 +++++++++++----- drivers/scsi/scsi_sysfs.c | 14 +++++++++++++- 2 files changed, 24 insertions(+), 6 deletions(-)
drivers/scsi/scsi_lib.c +11 -5
@@ -452,11 +452,17 @@ static void scsi_run_queue(struct request_queue *q)continue ; } -spin_unlock (shost->host_lock); -spin_lock (sdev->request_queue->queue_lock); -__blk_run_queue (sdev->request_queue); -spin_unlock (sdev->request_queue->queue_lock); -spin_lock (shost->host_lock); +/* +* Obtain a reference before unlocking the host_lock such that +* the sdev can't disappear before blk_run_queue() is invoked. +*/ +get_device (&sdev->sdev_gendev); +spin_unlock_irqrestore (shost->host_lock, flags); + +blk_run_queue (sdev->request_queue); +put_device (&sdev->sdev_gendev); + +spin_lock_irqsave (shost->host_lock, flags); }/* put any unprocessed entries back */ list_splice (&starved_list, &shost->starved_list);
drivers/scsi/scsi_sysfs.c +13 -1
@@ -345,7 +345,6 @@ static void scsi_device_dev_release_usercontext(struct work_struct *work) starget->reap_ref++;list_del (&sdev->siblings);list_del (&sdev->same_target_siblings); -list_del (&sdev->starved_entry);spin_unlock_irqrestore (sdev->host->host_lock, flags);cancel_work_sync (&sdev->event_work);
@@ -953,6 +952,8 @@ int scsi_sysfs_add_sdev(struct scsi_device *sdev)void __scsi_remove_device (struct scsi_device *sdev) {struct device *dev = &sdev->sdev_gendev; +struct Scsi_Host *shost = sdev->host; +unsigned long flags;if (sdev->is_visible) {if (scsi_device_set_state (sdev,SDEV_CANCEL ) !=0 )
@@ -974,6 +975,17 @@ void __scsi_remove_device(struct scsi_device *sdev)blk_cleanup_queue (sdev->request_queue);cancel_work_sync (&sdev->requeue_work); +/* +* Remove a SCSI device from the starved list after blk_cleanup_queue() +* finished such that scsi_request_fn() can't add it back to that list. +* Also remove an sdev from the starved list before invoking +* put_device() such that get_device() is guaranteed to succeed for an +* sdev present on the starved list. +*/ +spin_lock_irqsave (shost->host_lock, flags); +list_del (&sdev->starved_entry); +spin_unlock_irqrestore (shost->host_lock, flags); +if (sdev->host->hostt->slave_destroy) sdev->host->hostt->slave_destroy (sdev);transport_destroy_device (dev);
Signature · 1 line
1.7.10.4
PATCH v9 2/9 Remove get_device() / put_device() pair from scsi_request_fn()
In reply to Bart Van AsscheNow that all scsi_request_fn() callers hold a reference on the SCSI device that function is invoked for and since blk_cleanup_queue() waits until scsi_request_fn() has finished it is safe to remove the get_device() / put_device() pair from scsi_request_fn().
--- drivers/scsi/scsi_lib.c | 14 +++----------- 1 file changed, 3 insertions(+), 11 deletions(-)
drivers/scsi/scsi_lib.c +3 -11
@@ -1529,16 +1529,14 @@ static void scsi_softirq_done(struct request *rq)* Lock status: IO request lock assumed to be held when called. */ static void scsi_request_fn (struct request_queue *q) + __releases(q->queue_lock) + __acquires(q->queue_lock) {struct scsi_device *sdev = q->queuedata;struct Scsi_Host *shost;struct scsi_cmnd *cmd;struct request *req; -if (!get_device (&sdev->sdev_gendev)) -/* We must be tearing the block queue down already */ -return ; -/* * To start with, we keep looping until the queue is empty, or until * the host is no longer able to accept any more requests.
@@ -1627,7 +1625,7 @@ static void scsi_request_fn(struct request_queue *q) goto out_delay; } - goto out; +return ; not_ready:spin_unlock_irq (shost->host_lock);
@@ -1646,12 +1644,6 @@ static void scsi_request_fn(struct request_queue *q) out_delay:if (sdev->device_busy ==0 )blk_delay_queue (q,SCSI_QUEUE_DELAY ); -out: -/* must be careful here...if we trigger the ->remove() function -* we cannot be holding the q lock */ -spin_unlock_irq (q->queue_lock); -put_device (&sdev->sdev_gendev); -spin_lock_irq (q->queue_lock); }u64 scsi_calculate_bounce_limit (struct Scsi_Host *shost)
Signature · 1 line
1.7.10.4
PATCH v9 3/9 Avoid calling __scsi_remove_device() twice
In reply to Bart Van AsscheSCSI devices are added to the shost->__devices list from inside scsi_alloc_sdev(). If something goes wrong during LUN scanning, e.g. a transport layer failure occurs, then __scsi_remove_device() can get invoked by the LUN scanning code for a SCSI device in state SDEV_CREATED_BLOCK or SDEV_BLOCKED. If this happens this happens before a SCSI device is added to sysfs (is_visible == 0). Make sure that if this happens these devices are transitioned into state SDEV_DEL. This avoids that __scsi_remove_device() gets invoked a second time by scsi_forget_host().
--- drivers/scsi/scsi_lib.c | 2 ++ drivers/scsi/scsi_sysfs.c | 5 ++--- 2 files changed, 4 insertions(+), 3 deletions(-)
drivers/scsi/scsi_lib.c +2 -0
@@ -2171,6 +2171,8 @@ scsi_device_set_state(struct scsi_device *sdev, enum scsi_device_state state)case SDEV_OFFLINE :case SDEV_TRANSPORT_OFFLINE :case SDEV_CANCEL : +case SDEV_BLOCK : +case SDEV_CREATED_BLOCK :break ;default : goto illegal;
drivers/scsi/scsi_sysfs.c +2 -3
@@ -956,8 +956,7 @@ void __scsi_remove_device(struct scsi_device *sdev)unsigned long flags;if (sdev->is_visible) { -if (scsi_device_set_state (sdev,SDEV_CANCEL ) !=0 ) -return ; +WARN_ON_ONCE (scsi_device_set_state (sdev,SDEV_CANCEL ) !=0 );bsg_unregister_queue (sdev->request_queue);device_unregister (&sdev->sdev_dev);
@@ -971,7 +970,7 @@ void __scsi_remove_device(struct scsi_device *sdev)* scsi_run_queue() invocations have finished before tearing down the * device. */ -scsi_device_set_state (sdev,SDEV_DEL ); +WARN_ON_ONCE (scsi_device_set_state (sdev,SDEV_DEL ) !=0 );blk_cleanup_queue (sdev->request_queue);cancel_work_sync (&sdev->requeue_work);
Signature · 1 line
1.7.10.4
PATCH v9 4/9 Disallow changing the device state via sysfs into "deleted"
In reply to Bart Van AsscheChanging the state of a SCSI device via sysfs into "cancel" or "deleted" prevents removal of these devices by scsi_remove_host(). Hence do not allow this. Also, introduce the symbolic name INVALID_SDEV_STATE, representing a value different from any valid SCSI device state. Update scsi_device_set_state() such that gcc does not issue a warning about an enumeration value not being handled inside a switch statement.
--- drivers/scsi/scsi_lib.c | 2 ++ drivers/scsi/scsi_sysfs.c | 5 +++-- include/scsi/scsi_device.h | 6 +++++- 3 files changed, 10 insertions(+), 3 deletions(-)
drivers/scsi/scsi_lib.c +2 -0
@@ -2179,6 +2179,8 @@ scsi_device_set_state(struct scsi_device *sdev, enum scsi_device_state state) }break ; +case INVALID_SDEV_STATE : + goto illegal; } sdev->sdev_state = state;return 0 ;
drivers/scsi/scsi_sysfs.c +3 -2
@@ -594,7 +594,7 @@ store_state_field(struct device *dev, struct device_attribute *attr, {int i;struct scsi_device *sdev =to_scsi_device (dev); -enum scsi_device_state state =0 ; +enum scsi_device_state state =INVALID_SDEV_STATE ;for (i =0 ; i <ARRAY_SIZE (sdev_states); i++) {const int len =strlen (sdev_states[i].name);
@@ -604,7 +604,8 @@ store_state_field(struct device *dev, struct device_attribute *attr,break ; } } -if (!state) +if (state ==INVALID_SDEV_STATE || state ==SDEV_CANCEL || + state ==SDEV_DEL )return -EINVAL ;if (scsi_device_set_state (sdev, state))
include/scsi/scsi_device.h +5 -1
@@ -29,7 +29,11 @@ struct scsi_mode_data {* scsi_lib:scsi_device_set_state(). */ enum scsi_device_state { -SDEV_CREATED =1 ,/* device created but not added to sysfs +INVALID_SDEV_STATE ,/* Not a valid SCSI device state but a +* symbolic name that can be used wherever +* a value is needed that is different from +* any valid SCSI device state. */ +SDEV_CREATED ,/* device created but not added to sysfs * Only internal commands allowed (for inq) */ SDEV_RUNNING ,/* device properly configured * All commands allowed */
Signature · 1 line
1.7.10.4
PATCH v9 5/9 Avoid saving/restoring interrupt state inside scsi_remove_host()
In reply to Bart Van AsscheSince it is not allowed to invoke scsi_remove_host() with interrupts disabled, avoid saving and restoring the interrupt state inside scsi_remove_host(). This patch does not change the functionality of the function scsi_remove_host().
--- drivers/scsi/hosts.c | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-)
drivers/scsi/hosts.c +5 -7
@@ -156,27 +156,25 @@ EXPORT_SYMBOL(scsi_host_set_state);**/ void scsi_remove_host (struct Scsi_Host *shost) { -unsigned long flags; -mutex_lock (&shost->scan_mutex); -spin_lock_irqsave (shost->host_lock, flags); +spin_lock_irq (shost->host_lock);if (scsi_host_set_state (shost,SHOST_CANCEL ))if (scsi_host_set_state (shost,SHOST_CANCEL_RECOVERY )) { -spin_unlock_irqrestore (shost->host_lock, flags); +spin_unlock_irq (shost->host_lock);mutex_unlock (&shost->scan_mutex);return ; } -spin_unlock_irqrestore (shost->host_lock, flags); +spin_unlock_irq (shost->host_lock);scsi_autopm_get_host (shost);scsi_forget_host (shost);mutex_unlock (&shost->scan_mutex);scsi_proc_host_rm (shost); -spin_lock_irqsave (shost->host_lock, flags); +spin_lock_irq (shost->host_lock);if (scsi_host_set_state (shost,SHOST_DEL ))BUG_ON (scsi_host_set_state (shost,SHOST_DEL_RECOVERY )); -spin_unlock_irqrestore (shost->host_lock, flags); +spin_unlock_irq (shost->host_lock);transport_unregister_device (&shost->shost_gendev);device_unregister (&shost->shost_dev);
Signature · 1 line
1.7.10.4
PATCH v9 6/9 Make scsi_remove_host() wait until error handling finished
In reply to Bart Van AsscheA SCSI LLD may start cleaning up host resources as soon as scsi_remove_host() returns. These host resources may be needed by the LLD in an implementation of one of the eh_* functions. So if one of the eh_* functions is in progress when scsi_remove_host() is invoked, wait until the eh_* function has finished. Also, do not invoke any of the eh_* functions after scsi_remove_host() has started. Remove Scsi_Host.tmf_in_progress because it is now superfluous.
--- drivers/scsi/hosts.c | 6 ++++ drivers/scsi/scsi_error.c | 86 ++++++++++++++++++++++++++++++++++++++------- include/scsi/scsi_host.h | 6 ++-- 3 files changed, 81 insertions(+), 17 deletions(-)
drivers/scsi/hosts.c +6 -0
@@ -176,6 +176,12 @@ void scsi_remove_host(struct Scsi_Host *shost)BUG_ON (scsi_host_set_state (shost,SHOST_DEL_RECOVERY ));spin_unlock_irq (shost->host_lock); +/* +* Wait until the error handler has finished invoking LLD callbacks +* before allowing the LLD to proceed. +*/ +wait_event (shost->host_wait, shost->eh_active ==0 ); +transport_unregister_device (&shost->shost_gendev);device_unregister (&shost->shost_dev);device_del (&shost->shost_gendev);
drivers/scsi/scsi_error.c +73 -13
184 lines not on this page · raw message
include/scsi/scsi_host.h +2 -4
@@ -576,6 +576,7 @@ struct Scsi_Host {struct task_struct * ehandler;/* Error recovery thread. */ struct completion * eh_action;/* Wait for specific actions on the host. */ +int eh_active;wait_queue_head_t host_wait;struct scsi_host_template *hostt;struct scsi_transport_template *transportt;
@@ -663,9 +664,6 @@ struct Scsi_Host {*/ unsigned ordered_tag:1; -/* Task mgmt function in progress */ - unsigned tmf_in_progress:1; -/* Asynchronous scan in progress */ unsigned async_scan:1;
@@ -769,7 +767,7 @@ static inline int scsi_host_in_recovery(struct Scsi_Host *shost)return shost->shost_state ==SHOST_RECOVERY || shost->shost_state ==SHOST_CANCEL_RECOVERY || shost->shost_state ==SHOST_DEL_RECOVERY || - shost->tmf_in_progress; + shost->eh_active; }extern int scsi_queue_work (struct Scsi_Host *,struct work_struct *);
Signature · 1 line
1.7.10.4
PATCH v9 7/9 Avoid that scsi_device_set_state() triggers a race
In reply to Bart Van AsscheMake concurrent invocations of scsi_device_set_state() safe.
--- drivers/scsi/scsi_error.c | 4 ++++ drivers/scsi/scsi_lib.c | 43 ++++++++++++++++++++++++++++++++++--------- drivers/scsi/scsi_scan.c | 15 ++++++++------- drivers/scsi/scsi_sysfs.c | 18 ++++++++++++++---- 4 files changed, 60 insertions(+), 20 deletions(-)
drivers/scsi/scsi_error.c +4 -0
@@ -1431,7 +1431,11 @@ static void scsi_eh_offline_sdevs(struct list_head *work_q,list_for_each_entry_safe (scmd, next, work_q, eh_entry) {sdev_printk (KERN_INFO , scmd->device,"Device offlined - " "not ready after error recovery\n" ); + +spin_lock_irq (scmd->device->host->host_lock);scsi_device_set_state (scmd->device,SDEV_OFFLINE ); +spin_unlock_irq (scmd->device->host->host_lock); +if (scmd->eh_eflags &SCSI_EH_CANCEL_CMD ) {/* * FIXME: Handle lost cmds.
drivers/scsi/scsi_lib.c +34 -9
98 lines not on this page · raw message
drivers/scsi/scsi_scan.c +8 -7
@@ -898,18 +898,19 @@ static int scsi_add_lun(struct scsi_device *sdev, unsigned char *inq_result,if (*bflags &BLIST_USE_10_BYTE_MS ) sdev->use_10_for_ms =1 ; +spin_lock_irq (sdev->host->host_lock);/* set the device running here so that slave configure * may do I/O */ ret =scsi_device_set_state (sdev,SDEV_RUNNING ); -if (ret) { +if (ret) ret =scsi_device_set_state (sdev,SDEV_BLOCK ); +spin_unlock_irq (sdev->host->host_lock); -if (ret) { -sdev_printk (KERN_ERR , sdev, -"in wrong state %s to complete scan\n" , -scsi_device_state_name (sdev->sdev_state)); -return SCSI_SCAN_NO_RESPONSE ; - } +if (ret) { +sdev_printk (KERN_ERR , sdev, +"in wrong state %s to complete scan\n" , +scsi_device_state_name (sdev->sdev_state)); +return SCSI_SCAN_NO_RESPONSE ; }if (*bflags &BLIST_MS_192_BYTES_FOR_3F )
drivers/scsi/scsi_sysfs.c +14 -4
@@ -592,7 +592,7 @@ static ssize_t store_state_field(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { - int i; + int i, ret;struct scsi_device *sdev =to_scsi_device (dev);enum scsi_device_state state =INVALID_SDEV_STATE ;
@@ -608,9 +608,11 @@ store_state_field(struct device *dev, struct device_attribute *attr, state == SDEV_DEL)return -EINVAL ; -if (scsi_device_set_state (sdev, state)) -return -EINVAL ; -return count; +spin_lock_irq (sdev->host->host_lock); + ret =scsi_device_set_state (sdev, state); +spin_unlock_irq (sdev->host->host_lock); + +return ret <0 ? ret : count; } static ssize_t
@@ -870,7 +872,10 @@ int scsi_sysfs_add_sdev(struct scsi_device *sdev)struct request_queue *rq = sdev->request_queue;struct scsi_target *starget = sdev->sdev_target; +spin_lock_irq (sdev->host->host_lock); error =scsi_device_set_state (sdev,SDEV_RUNNING ); +spin_unlock_irq (sdev->host->host_lock); +if (error)return error;
@@ -957,7 +962,9 @@ void __scsi_remove_device(struct scsi_device *sdev)unsigned long flags;if (sdev->is_visible) { +spin_lock_irqsave (shost->host_lock, flags);WARN_ON_ONCE (scsi_device_set_state (sdev,SDEV_CANCEL ) !=0 ); +spin_unlock_irqrestore (shost->host_lock, flags);bsg_unregister_queue (sdev->request_queue);device_unregister (&sdev->sdev_dev);
@@ -971,7 +978,10 @@ void __scsi_remove_device(struct scsi_device *sdev)* scsi_run_queue() invocations have finished before tearing down the * device. */ +spin_lock_irqsave (shost->host_lock, flags);WARN_ON_ONCE (scsi_device_set_state (sdev,SDEV_DEL ) !=0 ); +spin_unlock_irqrestore (shost->host_lock, flags); +blk_cleanup_queue (sdev->request_queue);cancel_work_sync (&sdev->requeue_work);
Signature · 1 line
1.7.10.4
PATCH v9 8/9 Save and restore host_scribble during error handling
In reply to Bart Van AsscheA SCSI LLD may overwrite host_scribble in its queuecommand() implementation. Several drivers need that field to process requests and aborts correctly. Hence this field must be saved by scsi_eh_prep_cmnd() and must be restored by scsi_eh_restore_cmnd().
--- drivers/scsi/scsi_error.c | 2 ++ include/scsi/scsi_eh.h | 1 + 2 files changed, 3 insertions(+)
drivers/scsi/scsi_error.c +2 -0
@@ -770,6 +770,7 @@ void scsi_eh_prep_cmnd(struct scsi_cmnd *scmd, struct scsi_eh_save *ses, ses->result = scmd->result; ses->underflow = scmd->underflow; ses->prot_op = scmd->prot_op; + ses->host_scribble = scmd->host_scribble; scmd->prot_op =SCSI_PROT_NORMAL ; scmd->cmnd = ses->eh_cmnd;
@@ -831,6 +832,7 @@ void scsi_eh_restore_cmnd(struct scsi_cmnd* scmd, struct scsi_eh_save *ses) scmd->result = ses->result; scmd->underflow = ses->underflow; scmd->prot_op = ses->prot_op; + scmd->host_scribble = ses->host_scribble; }EXPORT_SYMBOL (scsi_eh_restore_cmnd);
include/scsi/scsi_eh.h +1 -0
@@ -83,6 +83,7 @@ struct scsi_eh_save {/* new command support */ unsigned char eh_cmnd[BLK_MAX_CDB ];struct scatterlist sense_sgl; +unsigned char *host_scribble; }; extern void scsi_eh_prep_cmnd(struct scsi_cmnd *scmd,
Signature · 1 line
1.7.10.4
PATCH v9 9/9 Avoid reenabling I/O after the transport became offline
In reply to Bart Van AsscheDisallow the SDEV_TRANSPORT_OFFLINE to SDEV_CANCEL transition such that no I/O is sent to devices for which the transport is offline. Notes:
- Functions like sd_shutdown() use scsi_execute_req() and hence set the REQ_PREEMPT flag. Such requests are passed to the LLD queuecommand callback in the SDEV_CANCEL state.
- This patch does not affect Fibre Channel LLD drivers since these drivers invoke fc_remote_port_chkready() before submitting a SCSI request to the HBA. That prevents a timeout to occur in state SDEV_CANCEL if the transport is offline.
--- drivers/scsi/scsi_lib.c | 1 - drivers/scsi/scsi_sysfs.c | 3 ++- 2 files changed, 2 insertions(+), 2 deletions(-)
drivers/scsi/scsi_lib.c +0 -1
@@ -2158,7 +2158,6 @@ scsi_device_set_state(struct scsi_device *sdev, enum scsi_device_state state)case SDEV_RUNNING :case SDEV_QUIESCE :case SDEV_OFFLINE : -case SDEV_TRANSPORT_OFFLINE :case SDEV_BLOCK :break ;default :
drivers/scsi/scsi_sysfs.c +2 -1
@@ -963,7 +963,8 @@ void __scsi_remove_device(struct scsi_device *sdev)if (sdev->is_visible) {spin_lock_irqsave (shost->host_lock, flags); -WARN_ON_ONCE (scsi_device_set_state (sdev,SDEV_CANCEL ) !=0 ); +WARN_ON_ONCE (scsi_device_set_state (sdev,SDEV_CANCEL ) !=0 + && sdev->sdev_state !=SDEV_TRANSPORT_OFFLINE );spin_unlock_irqrestore (shost->host_lock, flags);bsg_unregister_queue (sdev->request_queue);
Signature · 1 line
1.7.10.4
Re: [PATCH v9 9/9] Avoid reenabling I/O after the transport became offline
Quoted 11 lines · Bart Van Assche
Disallow the
SDEV_TRANSPORT_OFFLINEtoSDEV_CANCELtransition such that no I/O is sent to devices for which the transport is offline. Notes:
- Functions likesd_shutdown()usescsi_execute_req()and hence set theREQ_PREEMPTflag. Such requests are passed to the LLD queuecommand callback in theSDEV_CANCELstate.
- This patch does not affect Fibre Channel LLD drivers since these drivers invokefc_remote_port_chkready()before submitting a SCSI request to the HBA. That prevents a timeout to occur in stateSDEV_CANCELif the transport is offline.
Thanks for fixing this. Looks right to me.