os/bluestore: improve failed csum debug output

Signed-off-by: Sage Weil <sage@redhat.com>

diff --git a/src/common/Checksummer.h b/src/common/Checksummer.h
index eda44734ebf6c61b2cb2fba5f9de720768275ca2..6ddbf1d12dee537a9ee8323801a89427ee7a2648 100644 (file)
--- a/src/common/Checksummer.h
+++ b/src/common/Checksummer.h
@@ -156,7 +156,8 @@ public:
     size_t offset,
     size_t length,
     const bufferlist &bl,
-    const bufferptr& csum_data
+    const bufferptr& csum_data,
+    uint64_t *bad_csum=0
     ) {
     assert(length % csum_block_size == 0);
     bufferlist::const_iterator p = bl.begin();
@@ -172,6 +173,9 @@ public:
     while (length > 0) {
       typename Alg::value_t v = Alg::calc(state, csum_block_size, p);
       if (*pv != v) {
+       if (bad_csum) {
+         *bad_csum = v;
+       }
        return pos;
       }
       ++pv;

diff --git a/src/os/bluestore/BlueStore.cc b/src/os/bluestore/BlueStore.cc
index 1cb20155b4e9b5afe814769fc38594d55133bc6a..6f28b19a0d3a7975f1aed22981ef0427fc68f849 100644 (file)
--- a/src/os/bluestore/BlueStore.cc
+++ b/src/os/bluestore/BlueStore.cc
@@ -3904,19 +3904,23 @@ int BlueStore::_verify_csum(OnodeRef& o,
                            const bufferlist& bl) const
 {
   int bad;
-  int r = csum_type != bluestore_blob_t::CSUM_NONE ? blob->verify_csum(blob_xoffset, bl, &bad)  :0;
+  uint64_t bad_csum;
+  int r = csum_type != bluestore_blob_t::CSUM_NONE ?
+    blob->verify_csum(blob_xoffset, bl, &bad, &bad_csum)  :0;
   if (r < 0) {
     if (r == -1) {
       vector<bluestore_pextent_t> pex;
       blob->map(
-       blob_xoffset,
+       bad,
        blob->get_csum_chunk_size(),
        [&](uint64_t offset, uint64_t length) {
          pex.emplace_back(bluestore_pextent_t(offset, length));
        });
       derr << __func__ << " bad " << blob->get_csum_type_string(blob->csum_type)
           << "/0x" << std::hex << blob->get_csum_chunk_size()
-          << " checksum at blob offset 0x" << bad << std::dec
+          << " checksum at blob offset 0x" << bad
+          << ", got 0x" << bad_csum << ", expected 0x"
+          << blob->get_csum_item(bad / blob->get_csum_chunk_size()) << std::dec
           << ", device location " << pex
           << ", object " << o->oid << dendl;
     } else {

diff --git a/src/os/bluestore/bluestore_types.cc b/src/os/bluestore/bluestore_types.cc
index 97278b8d32c105a7a968f40547c6db630984371c..f61ce43b9d33edd7bfc21f91fbfd04769dc012a8 100644 (file)
--- a/src/os/bluestore/bluestore_types.cc
+++ b/src/os/bluestore/bluestore_types.cc
@@ -747,7 +747,7 @@ void bluestore_blob_t::calc_csum(uint64_t b_off, const bufferlist& bl)
 }
 
 int bluestore_blob_t::verify_csum(uint64_t b_off, const bufferlist& bl,
-  int* b_bad_off) const
+                                 int* b_bad_off, uint64_t *bad_csum) const
 {
   int r = 0;
 
@@ -757,23 +757,23 @@ int bluestore_blob_t::verify_csum(uint64_t b_off, const bufferlist& bl,
     break;
   case CSUM_XXHASH32:
     *b_bad_off = Checksummer::verify<Checksummer::xxhash32>(
-      get_csum_chunk_size(), b_off, bl.length(), bl, csum_data);
+      get_csum_chunk_size(), b_off, bl.length(), bl, csum_data, bad_csum);
     break;
   case CSUM_XXHASH64:
     *b_bad_off = Checksummer::verify<Checksummer::xxhash64>(
-      get_csum_chunk_size(), b_off, bl.length(), bl, csum_data);
+      get_csum_chunk_size(), b_off, bl.length(), bl, csum_data, bad_csum);
     break;
   case CSUM_CRC32C:
     *b_bad_off = Checksummer::verify<Checksummer::crc32c>(
-      get_csum_chunk_size(), b_off, bl.length(), bl, csum_data);
+      get_csum_chunk_size(), b_off, bl.length(), bl, csum_data, bad_csum);
     break;
   case CSUM_CRC32C_16:
     *b_bad_off = Checksummer::verify<Checksummer::crc32c_16>(
-      get_csum_chunk_size(), b_off, bl.length(), bl, csum_data);
+      get_csum_chunk_size(), b_off, bl.length(), bl, csum_data, bad_csum);
     break;
   case CSUM_CRC32C_8:
     *b_bad_off = Checksummer::verify<Checksummer::crc32c_8>(
-      get_csum_chunk_size(), b_off, bl.length(), bl, csum_data);
+      get_csum_chunk_size(), b_off, bl.length(), bl, csum_data, bad_csum);
     break;
   default:
     r = -EOPNOTSUPP;

diff --git a/src/os/bluestore/bluestore_types.h b/src/os/bluestore/bluestore_types.h
index 89135ba64d1991caa1f8151f7b05d27267ba84d5..5308efcab38fbf12e923637f6bea27be953c7b78 100644 (file)
--- a/src/os/bluestore/bluestore_types.h
+++ b/src/os/bluestore/bluestore_types.h
@@ -567,7 +567,8 @@ struct bluestore_blob_t {
   /// verify csum: return -EOPNOTSUPP for unsupported checksum type;
   /// return -1 and valid(nonnegative) b_bad_off for checksum error;
   /// return 0 if all is well.
-  int verify_csum(uint64_t b_off, const bufferlist& bl, int* b_bad_off) const;
+  int verify_csum(uint64_t b_off, const bufferlist& bl, int* b_bad_off,
+                 uint64_t *bad_csum) const;
 
 };
 WRITE_CLASS_ENCODER(bluestore_blob_t)

diff --git a/src/test/objectstore/test_bluestore_types.cc b/src/test/objectstore/test_bluestore_types.cc
index 99c919ebb05dda0d3718118b9b13daedc7be9b68..cd1e7bf146ef9ea52c883d0afb5fec0c36fdf791 100644 (file)
--- a/src/test/objectstore/test_bluestore_types.cc
+++ b/src/test/objectstore/test_bluestore_types.cc
@@ -522,46 +522,47 @@ TEST(bluestore_blob_t, calc_csum)
 
     bluestore_blob_t b;
     int bad_off;
-    ASSERT_EQ(0, b.verify_csum(0, bl, &bad_off));
+    uint64_t bad_csum;
+    ASSERT_EQ(0, b.verify_csum(0, bl, &bad_off, &bad_csum));
     ASSERT_EQ(-1, bad_off);
 
     b.init_csum(csum_type, 3, 24);
     cout << "  value size " << b.get_csum_value_size() << std::endl;
     b.calc_csum(0, bl);
-    ASSERT_EQ(0, b.verify_csum(0, bl, &bad_off));
+    ASSERT_EQ(0, b.verify_csum(0, bl, &bad_off, &bad_csum));
     ASSERT_EQ(-1, bad_off);
-    ASSERT_EQ(-1, b.verify_csum(0, bl2, &bad_off));
+    ASSERT_EQ(-1, b.verify_csum(0, bl2, &bad_off, &bad_csum));
     ASSERT_EQ(0, bad_off);
 
-    ASSERT_EQ(0, b.verify_csum(0, f, &bad_off));
+    ASSERT_EQ(0, b.verify_csum(0, f, &bad_off, &bad_csum));
     ASSERT_EQ(-1, bad_off);
-    ASSERT_EQ(-1, b.verify_csum(8, f, &bad_off));
+    ASSERT_EQ(-1, b.verify_csum(8, f, &bad_off, &bad_csum));
     ASSERT_EQ(8, bad_off);
-    ASSERT_EQ(-1, b.verify_csum(16, f, &bad_off));
+    ASSERT_EQ(-1, b.verify_csum(16, f, &bad_off, &bad_csum));
     ASSERT_EQ(16, bad_off);
 
-    ASSERT_EQ(-1, b.verify_csum(0, m, &bad_off));
+    ASSERT_EQ(-1, b.verify_csum(0, m, &bad_off, &bad_csum));
     ASSERT_EQ(0, bad_off);
-    ASSERT_EQ(0, b.verify_csum(8, m, &bad_off));
+    ASSERT_EQ(0, b.verify_csum(8, m, &bad_off, &bad_csum));
     ASSERT_EQ(-1, bad_off);
-    ASSERT_EQ(-1, b.verify_csum(16, m, &bad_off));
+    ASSERT_EQ(-1, b.verify_csum(16, m, &bad_off, &bad_csum));
     ASSERT_EQ(16, bad_off);
 
-    ASSERT_EQ(-1, b.verify_csum(0, e, &bad_off));
+    ASSERT_EQ(-1, b.verify_csum(0, e, &bad_off, &bad_csum));
     ASSERT_EQ(0, bad_off);
-    ASSERT_EQ(-1, b.verify_csum(8, e, &bad_off));
+    ASSERT_EQ(-1, b.verify_csum(8, e, &bad_off, &bad_csum));
     ASSERT_EQ(8, bad_off);
-    ASSERT_EQ(0, b.verify_csum(16, e, &bad_off));
+    ASSERT_EQ(0, b.verify_csum(16, e, &bad_off, &bad_csum));
     ASSERT_EQ(-1, bad_off);
 
     b.calc_csum(8, n);
-    ASSERT_EQ(0, b.verify_csum(0, f, &bad_off));
+    ASSERT_EQ(0, b.verify_csum(0, f, &bad_off, &bad_csum));
     ASSERT_EQ(-1, bad_off);
-    ASSERT_EQ(0, b.verify_csum(8, n, &bad_off));
+    ASSERT_EQ(0, b.verify_csum(8, n, &bad_off, &bad_csum));
     ASSERT_EQ(-1, bad_off);
-    ASSERT_EQ(0, b.verify_csum(16, e, &bad_off));
+    ASSERT_EQ(0, b.verify_csum(16, e, &bad_off, &bad_csum));
     ASSERT_EQ(-1, bad_off);
-    ASSERT_EQ(-1, b.verify_csum(0, bl, &bad_off));
+    ASSERT_EQ(-1, b.verify_csum(0, bl, &bad_off, &bad_csum));
     ASSERT_EQ(8, bad_off);
   }
 }