dm persistent data: use DMERR_LIMIT for errors

Nearly all of persistent-data is in the IO path so throttle error
messages with DMERR_LIMIT to limit the amount logged when
something has gone wrong.

Signed-off-by: Mike Snitzer <snitzer@redhat.com>
Signed-off-by: Alasdair G Kergon <agk@redhat.com>

3 files changed, 20 insertions, 21 deletions

diff --git a/drivers/md/persistent-data/dm-block-manager.c b/drivers/md/persistent-data/dm-block-manager.c
index 47b683e67a7..ec4cb3c58a0 100644
--- a/drivers/md/persistent-data/dm-block-manager.c
+++ b/drivers/md/persistent-data/dm-block-manager.c
@@ -429,17 +429,16 @@ static int dm_bm_validate_buffer(struct dm_block_manager *bm,
                         return 0;
                 r = v->check(v, (struct dm_block *) buf, dm_bufio_get_block_size(bm->bufio));
                 if (unlikely(r)) {
-                        DMERR("%s validator check failed for block %llu", v->name,
-                              (unsigned long long) dm_bufio_get_block_number(buf));
+                        DMERR_LIMIT("%s validator check failed for block %llu", v->name,
+                                    (unsigned long long) dm_bufio_get_block_number(buf));
                         return r;
                 }
                 aux->validator = v;
         } else {
                 if (unlikely(aux->validator != v)) {
-                        DMERR("validator mismatch (old=%s vs new=%s) for block %llu",
-                                aux->validator->name, v ? v->name : "NULL",
-                                (unsigned long long)
-                                        dm_bufio_get_block_number(buf));
+                        DMERR_LIMIT("validator mismatch (old=%s vs new=%s) for block %llu",
+                                    aux->validator->name, v ? v->name : "NULL",
+                                    (unsigned long long) dm_bufio_get_block_number(buf));
                         return -EINVAL;
                 }
         }
diff --git a/drivers/md/persistent-data/dm-btree-spine.c b/drivers/md/persistent-data/dm-btree-spine.c
index 2f0805c3263..f199a0c4ed0 100644
--- a/drivers/md/persistent-data/dm-btree-spine.c
+++ b/drivers/md/persistent-data/dm-btree-spine.c
@@ -45,8 +45,8 @@ static int node_check(struct dm_block_validator *v,
         uint32_t flags;
 
         if (dm_block_location(b) != le64_to_cpu(h->blocknr)) {
-                DMERR("node_check failed blocknr %llu wanted %llu",
-                      le64_to_cpu(h->blocknr), dm_block_location(b));
+                DMERR_LIMIT("node_check failed: blocknr %llu != wanted %llu",
+                            le64_to_cpu(h->blocknr), dm_block_location(b));
                 return -ENOTBLK;
         }
 
@@ -54,8 +54,8 @@ static int node_check(struct dm_block_validator *v,
                                                block_size - sizeof(__le32),
                                                BTREE_CSUM_XOR));
         if (csum_disk != h->csum) {
-                DMERR("node_check failed csum %u wanted %u",
-                      le32_to_cpu(csum_disk), le32_to_cpu(h->csum));
+                DMERR_LIMIT("node_check failed: csum %u != wanted %u",
+                            le32_to_cpu(csum_disk), le32_to_cpu(h->csum));
                 return -EILSEQ;
         }
 
@@ -63,12 +63,12 @@ static int node_check(struct dm_block_validator *v,
 
         if (sizeof(struct node_header) +
             (sizeof(__le64) + value_size) * le32_to_cpu(h->max_entries) > block_size) {
-                DMERR("node_check failed: max_entries too large");
+                DMERR_LIMIT("node_check failed: max_entries too large");
                 return -EILSEQ;
         }
 
         if (le32_to_cpu(h->nr_entries) > le32_to_cpu(h->max_entries)) {
-                DMERR("node_check failed, too many entries");
+                DMERR_LIMIT("node_check failed: too many entries");
                 return -EILSEQ;
         }
 
@@ -77,7 +77,7 @@ static int node_check(struct dm_block_validator *v,
          */
         flags = le32_to_cpu(h->flags);
         if (!(flags & INTERNAL_NODE) && !(flags & LEAF_NODE)) {
-                DMERR("node_check failed, node is neither INTERNAL or LEAF");
+                DMERR_LIMIT("node_check failed: node is neither INTERNAL or LEAF");
                 return -EILSEQ;
         }
 
diff --git a/drivers/md/persistent-data/dm-space-map-common.c b/drivers/md/persistent-data/dm-space-map-common.c
index f3a9af8cdec..3e7a88d99eb 100644
--- a/drivers/md/persistent-data/dm-space-map-common.c
+++ b/drivers/md/persistent-data/dm-space-map-common.c
@@ -39,8 +39,8 @@ static int index_check(struct dm_block_validator *v,
         __le32 csum_disk;
 
         if (dm_block_location(b) != le64_to_cpu(mi_le->blocknr)) {
-                DMERR("index_check failed blocknr %llu wanted %llu",
-                      le64_to_cpu(mi_le->blocknr), dm_block_location(b));
+                DMERR_LIMIT("index_check failed: blocknr %llu != wanted %llu",
+                            le64_to_cpu(mi_le->blocknr), dm_block_location(b));
                 return -ENOTBLK;
         }
 
@@ -48,8 +48,8 @@ static int index_check(struct dm_block_validator *v,
                                                block_size - sizeof(__le32),
                                                INDEX_CSUM_XOR));
         if (csum_disk != mi_le->csum) {
-                DMERR("index_check failed csum %u wanted %u",
-                      le32_to_cpu(csum_disk), le32_to_cpu(mi_le->csum));
+                DMERR_LIMIT("index_check failed: csum %u != wanted %u",
+                            le32_to_cpu(csum_disk), le32_to_cpu(mi_le->csum));
                 return -EILSEQ;
         }
 
@@ -89,8 +89,8 @@ static int bitmap_check(struct dm_block_validator *v,
         __le32 csum_disk;
 
         if (dm_block_location(b) != le64_to_cpu(disk_header->blocknr)) {
-                DMERR("bitmap check failed blocknr %llu wanted %llu",
-                      le64_to_cpu(disk_header->blocknr), dm_block_location(b));
+                DMERR_LIMIT("bitmap check failed: blocknr %llu != wanted %llu",
+                            le64_to_cpu(disk_header->blocknr), dm_block_location(b));
                 return -ENOTBLK;
         }
 
@@ -98,8 +98,8 @@ static int bitmap_check(struct dm_block_validator *v,
                                                block_size - sizeof(__le32),
                                                BITMAP_CSUM_XOR));
         if (csum_disk != disk_header->csum) {
-                DMERR("bitmap check failed csum %u wanted %u",
-                      le32_to_cpu(csum_disk), le32_to_cpu(disk_header->csum));
+                DMERR_LIMIT("bitmap check failed: csum %u != wanted %u",
+                            le32_to_cpu(csum_disk), le32_to_cpu(disk_header->csum));
                 return -EILSEQ;
         }