tree c5bb008170708e1d63e09e813e30257c5fcac7ce
parent ad8dcffaf9bc1d7eb86dabf591e95f4ffb86cf1b
author Brian King <brking@linux.vnet.ibm.com> 1225288005 -0500
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1230571453 -0600

[SCSI] ibmvfc: Fix target initialization failure retry handling

If the ibmvfc driver is in discovery attempting to log into a target
and it encounters an error, the command may get retried one or more
times, depending on the error received. If the retries are
unsuccessful such that the discovery thread gives up on discovery to
that target, the target ends up in a state where, if SCSI core had
previously known about the device, the host will get unblocked but the
host will not be logged into the target, causing any commands sent to
the target to fail. This patch fixes this so that if this occurs, the
target is deleted such that the normal dev_loss processing can occur
instead.

Signed-off-by: Brian King <brking@linux.vnet.ibm.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
