tree 04b35f05814a74b3b1e5e71abd722ee164b3ca9c
parent ddb3e0c111fed0a8bf74884dc918274acec2b618
author Christof Schmitt <christof.schmitt@de.ibm.com> 1247490369 +0200
committer James Bottomley <James.Bottomley@HansenPartnership.com> 1248961797 -0500

[SCSI] zfcp: Fix erp escalation procedure

If an action fails, retry it until the erp count exceeds the
threshold. If there is something fundamentally wrong, the FSF layer
will trigger a more appropriate action depending on the FSF status
codes.

The followup for successful actions is a different followup than
retrying failed actions, so split the code two functions to make this
clear.

Reviewed-by: Swen Schillig <swen@vnet.ibm.com>
Signed-off-by: Christof Schmitt <christof.schmitt@de.ibm.com>
Signed-off-by: James Bottomley <James.Bottomley@HansenPartnership.com>
