From: Eric Biggers <[email protected]>

Move the code that handles mismatches of data block hashes into its own
function so that it doesn't clutter up verity_verify_io().

Signed-off-by: Eric Biggers <[email protected]>
---
 drivers/md/dm-verity-target.c | 64 ++++++++++++++++++++---------------
 1 file changed, 36 insertions(+), 28 deletions(-)

diff --git a/drivers/md/dm-verity-target.c b/drivers/md/dm-verity-target.c
index 88d2a49dca43..796d85526696 100644
--- a/drivers/md/dm-verity-target.c
+++ b/drivers/md/dm-verity-target.c
@@ -540,10 +540,42 @@ static noinline int verity_recheck(struct dm_verity *v, 
struct dm_verity_io *io,
        mempool_free(page, &v->recheck_pool);
 
        return r;
 }
 
+static int verity_handle_data_hash_mismatch(struct dm_verity *v,
+                                           struct dm_verity_io *io,
+                                           struct bio *bio, sector_t blkno,
+                                           struct bvec_iter *start)
+{
+       if (static_branch_unlikely(&use_bh_wq_enabled) && io->in_bh) {
+               /*
+                * Error handling code (FEC included) cannot be run in the
+                * BH workqueue, so fallback to a standard workqueue.
+                */
+               return -EAGAIN;
+       }
+       if (verity_recheck(v, io, *start, blkno) == 0) {
+               if (v->validated_blocks)
+                       set_bit(blkno, v->validated_blocks);
+               return 0;
+       }
+#if defined(CONFIG_DM_VERITY_FEC)
+       if (verity_fec_decode(v, io, DM_VERITY_BLOCK_TYPE_DATA, blkno,
+                             NULL, start) == 0)
+               return 0;
+#endif
+       if (bio->bi_status)
+               return -EIO; /* Error correction failed; Just return error */
+
+       if (verity_handle_err(v, DM_VERITY_BLOCK_TYPE_DATA, blkno)) {
+               dm_audit_log_bio(DM_MSG_PREFIX, "verify-data", bio, blkno, 0);
+               return -EIO;
+       }
+       return 0;
+}
+
 static int verity_bv_zero(struct dm_verity *v, struct dm_verity_io *io,
                          u8 *data, size_t len)
 {
        memset(data, 0, len);
        return 0;
@@ -632,39 +664,15 @@ static int verity_verify_io(struct dm_verity_io *io)
                if (likely(memcmp(verity_io_real_digest(v, io),
                                  verity_io_want_digest(v, io), v->digest_size) 
== 0)) {
                        if (v->validated_blocks)
                                set_bit(cur_block, v->validated_blocks);
                        continue;
-               } else if (static_branch_unlikely(&use_bh_wq_enabled) && 
io->in_bh) {
-                       /*
-                        * Error handling code (FEC included) cannot be run in a
-                        * tasklet since it may sleep, so fallback to 
work-queue.
-                        */
-                       return -EAGAIN;
-               } else if (verity_recheck(v, io, start, cur_block) == 0) {
-                       if (v->validated_blocks)
-                               set_bit(cur_block, v->validated_blocks);
-                       continue;
-#if defined(CONFIG_DM_VERITY_FEC)
-               } else if (verity_fec_decode(v, io, DM_VERITY_BLOCK_TYPE_DATA,
-                                            cur_block, NULL, &start) == 0) {
-                       continue;
-#endif
-               } else {
-                       if (bio->bi_status) {
-                               /*
-                                * Error correction failed; Just return error
-                                */
-                               return -EIO;
-                       }
-                       if (verity_handle_err(v, DM_VERITY_BLOCK_TYPE_DATA,
-                                             cur_block)) {
-                               dm_audit_log_bio(DM_MSG_PREFIX, "verify-data",
-                                                bio, cur_block, 0);
-                               return -EIO;
-                       }
                }
+               r = verity_handle_data_hash_mismatch(v, io, bio, cur_block,
+                                                    &start);
+               if (unlikely(r))
+                       return r;
        }
 
        return 0;
 }
 
-- 
2.45.1


Reply via email to