tree 60bcebbe128c331fe9c49ed70ec18f8516ec2939
parent c1ec1f1bf9cb1ba80e79a74d48bcfb5da246d6f6
author Andrew Vasquez <andrew.vasquez@qlogic.com> 1209075685 -0700
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1209316798 -0500

[SCSI] qla2xxx: Correct SRB usage-after-completion/free issues.

The driver is incorrectly assuming that the 'sp' reference held
in qla2[x00|4xx]_abort_command() is valid after the mailbox
command is issued to abort the exchange.  It is *not*, as the
command may be completed during interrupt context before control
is returned to the mailbox caller.

Signed-off-by: Andrew Vasquez <andrew.vasquez@qlogic.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
