tree 7a3750f92393a6567ba80a9a04705687d871fe19
parent d1fde4ad3c22137f8e589e625c21bf2ea7f6ba62
author Benoît Canet <benoit.canet@irqsave.net> 1402493050 +0200
committer Kevin Wolf <kwolf@redhat.com> 1403871497 +0200

quorum: Add the rewrite-corrupted parameter to quorum

On read operations when this parameter is set and some replicas are corrupted
while quorum can be reached quorum will proceed to rewrite the correct version
of the data to fix the corrupted replicas.

This will shine with SSD where the FTL will remap the same block at another
place on rewrite.

Signed-off-by: Benoit Canet <benoit@irqsave.net>
Reviewed-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
