tree 47ba1a14b3c3843efc4b39eff17424da391c73b5
parent 9ab3610f9c24e7f303f1b0e6bb88a5f804ab847e
author Brian King <brking@linux.vnet.ibm.com> 1237581879 -0500
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1238768563 -0500

[SCSI] ibmvfc: Improve ADISC timeout handling

The ibmvfc driver currently breaks the CRQ and essentially
resets the entire virtual FC adapter, killing all outstanding
ops to all attached targets, if an ADISC times out during target
discover/rediscovery. This patch adds some code to cancel the
ADISC if it times out, which prevents a single ADISC timeout from
affecting the other devices attached to the fabric.

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