tree 93a373ec24d3a290533bbcce1e7d038a6fb81179
parent 048feec5548c0582ee96148c61b87cccbcb5f9be
author James Bottomley <James.Bottomley@HansenPartnership.com> 1221870710 +0000
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1222198141 -0700

[SCSI] Fix hang with split requests

Sometimes, particularly for USB devices with the last sector bug,
requests get completed in chunks.  There's a bug in this in that if
one of the chunks gets an error, we complete that chunk with an error
but never move on to the remaining ones, leading to the request
hanging (because it's not fully completed).

Fix this by completing all remaining chunks if an error is encountered.

Cc: Alan Stern <stern@rowland.harvard.edu>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
