tree a7339c6e87cabfcd5fa27b0a47611cae93588074
parent 4f0e359c939e4c217aea3a294b7356d60c351e35
author Mike Christie <michaelc@cs.wisc.edu> 1362544824 -0600
committer James Bottomley <JBottomley@Parallels.com> 1365566121 -0700

[SCSI] scsi_dh_alua: fix stpg sense handling

For the stpg_endio path we are not evaluating the sense. The bug
is that

1. The error value is set to -EIO when there is sense, so we hit the first
error check and always return SCSI_DH_IO.

2. h->senselen is set to zero in submit_stpg. It is not later set to
req->sense_len like in the synchrounous exection paths, so we must
check the req->sense_len field.

Signed-off-by: Mike Christie <michaelc@cs.wisc.edu>
Signed-off-by: James Bottomley <JBottomley@Parallels.com>
