tree 380e7fdb6f689196a648c7c8bc3cf41c5cd58fcc
parent 59d3270326fcba29226c28df27cb43fefd8c58d0
author Martin K. Petersen <martin.petersen@oracle.com> 1231056499 -0500
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1236880675 -0500

[SCSI] scsi_debug: DIF/DIX support

This patch adds support for DIX and DIF in scsi_debug.  A separate
buffer is allocated for the protection information.

 - The dix parameter indicates whether the controller supports DIX
   (protection information DMA)

 - The dif parameter indicates whether the simulated storage device
   supports DIF

 - The guard parameter switches between T10 CRC(0) and IP checksum(1)

 - The ato parameter indicates whether the application tag is owned by
   the disk(0) or the OS(1)

 - DIF and DIX errors can be triggered using the scsi_debug_opts mask

Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
Acked-by: Douglas Gilbert <dgilbert@interlog.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
