tree 020c415dbade29e0c0fd3e39ec5b97d730d29f15
parent 5aa22af3d089123df954693d1f911323307d41f7
author Salyzyn, Mark <Mark_Salyzyn@adaptec.com> 1201189210 -0800
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1201274722 -0600

[SCSI] aacraid: fib context lock for management ioctls

Alan noticed the lack of locking surrounding the driver's dealings
with the fib context managed by the trio of ioctls that are used by
the RAID management applications to retrieve Adapter Initiated FIBs. I
merely expanded the fib lock to include the fib context. There have
been no field reports of any issues generally because the applications
are relatively static and do not come and go often enough to stress
this area. I bloated this patch a little with some space junk.

Signed-off-by: Mark Salyzyn <aacraid@adaptec.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
