tree dff13a13fdfac127542803b7713ea7ebf1196e0f
parent 73208dfd7ab19f379d73e8a0fbf30f92c203e5e8
author James Smart <james.smart@emulex.com> 1228516199 -0600
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1230571473 -0600

[SCSI] fc transport: pre-emptively terminate i/o upon dev_loss_tmo timeout

Pre-emptively terminate i/o on the rport if dev_loss_tmo has fired.
The desire is to terminate everything, so that the i/o is cleaned up
prior to the sdev's being unblocked, thus any outstanding timeouts/aborts
are avoided.

Also, we do this early enough such that the rport's port_id field is
still valid. FCOE libFC code needs this info to find the i/o's to
terminate.

Signed-off-by: James Smart <james.smart@emulex.com>
[michaelc@cs.wisc.edu: remove extra scsi_target_unblock call]
Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
