tree 22f7b2620d0128fdd91e0244ae6fb73b443c6ba3
parent 4081b77c3a86151d2eaeed9d568a34dd0982ed52
author Brian King <brking@linux.vnet.ibm.com> 1226691232 -0600
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1230571457 -0600

[SCSI] ibmvfc: Fix command timeouts due to cached CRQ access

The CRQs used by the ibmvfc driver are read and written by both
the client and the server. Therefore, we need to mark them volatile
so that we do not cache their contents when handling an interrupt.
This fixes a problem which can surface as occasional command timeouts.
No commands were actually timing out, but due to accessing cached data
for the CRQ in the interrupt handler, the interrupt was not processing
all command completions as it should.

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