tree db8928e93f09708714f3bed2dd2a2a244721b6b5
parent 50119dad2a6c2674f35d81e708822b40f65f40cb
author Brian King <brking@linux.vnet.ibm.com> 1225288001 -0500
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1230571453 -0600

[SCSI] ibmvfc: Error handling fixes

Due to an ambiguity in the VIOS VFC interface specification,
abort/cancel handling is not done correctly and can result in double
completion of commands. In order to cancel all outstanding commands to
a device, a cancel must be sent, followed by an abort task set. After
the responses are received for these commands, there may still be
commands outstanding, in the process of getting flushed back, in which
case, we need to wait for them. This patch removes the assumption that
if the abort and the cancel both complete successfully that the device
queue has been flushed and waits for all the responses to come back.

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