tree 852495622d2f422c127b88ec30a5391d7f8cb955
parent 206c5f60a3d902bc4b56dab2de3e88de5eb06108
author Christoph Hellwig <hch@lst.de> 1415039800 +0100
committer Christoph Hellwig <hch@lst.de> 1415629398 +0100

scsi: only re-lock door after EH on devices that were reset

Setups that use the blk-mq I/O path can lock up if a host with a single
device that has its door locked enters EH.  Make sure to only send the
command to re-lock the door to devices that actually were reset and thus
might have lost their state.  Otherwise the EH code might be get blocked
on blk_get_request as all requests for non-reset devices might be in use.

Cc: stable@vger.kernel.org
Signed-off-by: Christoph Hellwig <hch@lst.de>
Reported-by: Meelis Roos <meelis.roos@ut.ee>
Tested-by: Meelis Roos <meelis.roos@ut.ee>
Reviewed-by: Martin K. Petersen <martin.petersen@oracle.com>
