tree 59aa713000faab4aa075a52ee2c2be4bc4d3239c
parent 4034cc68157bfa0b6622efe368488d3d3e20f4e6
author James Bottomley <James.Bottomley@HansenPartnership.com> 1235080134 +0000
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1235269778 -0600

[SCSI] fix ABORTED_COMMAND looping forever problem

Instead of terminating after five retries, commands terminated by
ABORTED_COMMAND sense are retrying forever.  The problem was
introduced by:

commit b60af5b0adf0da24c673598c8d3fb4d4189a15ce
Author: Alan Stern <stern@rowland.harvard.edu>
Date:   Mon Nov 3 15:56:47 2008 -0500

    [SCSI] simplify scsi_io_completion()

Which introduced an error whereby ABORTED_COMMAND now gets erroneously
retried in scsi_io_completion.  Fix this by returning the behaviour
back to the default no retry.

Reported-by: Sitsofe Wheeler <sitsofe@yahoo.com>
Tested-by: Sitsofe Wheeler <sitsofe@yahoo.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
