tree 0899a1087c0c4cde4d44cdcd651a6a36e6dbee96
parent 26871c97d52e50dc574bd01967926650643b142a
author Swen Schillig <swen@vnet.ibm.com> 1227719259 +0100
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1228148270 -0600

[SCSI] zfcp: eliminate race between validation and locking

The check of having a valid pointer was performed before the
processing was secured by the lock. Between those two steps the
pointer can turn invalid.  During further processing another value is
used (referenced by the pointer described above) as a function pointer
which is never verified to be valid either, resulting under some
circumstances in an invalid function call.  This patch is fixing both
issues.

Signed-off-by: Swen Schillig <swen@vnet.ibm.com>
Signed-off-by: Christof Schmitt <christof.schmitt@de.ibm.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
