bluestore: make verify_csum can catch unsupported csum type error

Signed-off-by: xie xingguo <xie.xingguo@zte.com.cn>

diff --git a/src/os/bluestore/BlueStore.cc b/src/os/bluestore/BlueStore.cc
index 0b374f7b72a3a49bff9643368b4434afa1dead67..c28028dd9ef78e742906f58fd650931ce218541f 100644 (file)
--- a/src/os/bluestore/BlueStore.cc
+++ b/src/os/bluestore/BlueStore.cc
@@ -3398,12 +3398,19 @@ int BlueStore::_blob2read_to_extents2read(
 
 int BlueStore::_verify_csum(const bluestore_blob_t* blob, uint64_t blob_xoffset, const bufferlist& bl) const
 {
-  int bad = blob->verify_csum(blob_xoffset, bl);
-  if (bad >= 0) {
-    dout(20) << __func__ << " at blob offset 0x" << std::hex << bad << dendl;
-    return -1;
+  int bad;
+  int r = blob->verify_csum(blob_xoffset, bl, &bad);
+  if (r < 0) {
+    if (r == -1) {
+      dout(20) << __func__ << "bad checksum at blob offset 0x"
+               << std::hex << bad << dendl;
+    } else {
+      derr << __func__ << "failed with exit code: " << cpp_strerror(r) << dendl;
+    }
+    return r;
+  } else {
+    return 0;
   }
-  return 0;
 }
 
 int BlueStore::_decompress(bufferlist& source, bufferlist* result)

diff --git a/src/os/bluestore/bluestore_types.cc b/src/os/bluestore/bluestore_types.cc
index b98a6e1c295299fc6eae4f9b63bf4cd75d3654bb..a50b12a58a03c74ef89116bfa92d084a35349252 100644 (file)
--- a/src/os/bluestore/bluestore_types.cc
+++ b/src/os/bluestore/bluestore_types.cc
@@ -668,23 +668,38 @@ 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) const
+int bluestore_blob_t::verify_csum(uint64_t b_off, const bufferlist& bl,
+  int* b_bad_off) const
 {
+  int r = 0;
+
+  *b_bad_off = -1;
   switch (csum_type) {
   case CSUM_NONE:
-    return -1;
+    break;
   case CSUM_XXHASH32:
-    return Checksummer::verify<Checksummer::xxhash32>(
+    *b_bad_off = Checksummer::verify<Checksummer::xxhash32>(
       get_csum_block_size(), b_off, bl.length(), bl, csum_data);
+    break;
   case CSUM_XXHASH64:
-    return Checksummer::verify<Checksummer::xxhash64>(
+    *b_bad_off = Checksummer::verify<Checksummer::xxhash64>(
       get_csum_block_size(), b_off, bl.length(), bl, csum_data);
+    break;
   case CSUM_CRC32C:
-    return Checksummer::verify<Checksummer::crc32c>(
+    *b_bad_off = Checksummer::verify<Checksummer::crc32c>(
       get_csum_block_size(), b_off, bl.length(), bl, csum_data);
+    break;
   default:
-    return -EOPNOTSUPP;
+    r = -EOPNOTSUPP;
+    break;
   }
+
+  if (r < 0)
+    return r;
+  else if (*b_bad_off >= 0)
+    return -1; // bad checksum
+  else
+    return 0;
 }
 
 // bluestore_lextent_t

diff --git a/src/os/bluestore/bluestore_types.h b/src/os/bluestore/bluestore_types.h
index a4ce8cb8ea7884fa73419754505758d65453018d..4942358e188ddea0b1a45604b3009946a714b5f1 100644 (file)
--- a/src/os/bluestore/bluestore_types.h
+++ b/src/os/bluestore/bluestore_types.h
@@ -481,8 +481,10 @@ struct bluestore_blob_t {
   /// calculate csum for the buffer at the given b_off
   void calc_csum(uint64_t b_off, const bufferlist& bl);
 
-  /// verify csum: return offset of error, or -1 for no error.
-  int verify_csum(uint64_t b_off, const bufferlist& bl) const;
+  /// 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;
 
 };
 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 fa2840eee82e400bed4c0b3fc5cba1738fb55dd4..cd495a05b09e7139b305fd7d04dad07a7188d05e 100644 (file)
--- a/src/test/objectstore/test_bluestore_types.cc
+++ b/src/test/objectstore/test_bluestore_types.cc
@@ -515,31 +515,48 @@ TEST(bluestore_blob_t, calc_csum)
         << std::endl;
 
     bluestore_blob_t b;
-    ASSERT_EQ(-1, b.verify_csum(0, bl));
+    int bad_off;
+    ASSERT_EQ(0, b.verify_csum(0, bl, &bad_off));
+    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(-1, b.verify_csum(0, bl));
-    ASSERT_EQ(0, b.verify_csum(0, bl2));
-
-    ASSERT_EQ(-1, b.verify_csum(0, f));
-    ASSERT_EQ(8, b.verify_csum(8, f));
-    ASSERT_EQ(16, b.verify_csum(16, f));
-
-    ASSERT_EQ(0, b.verify_csum(0, m));
-    ASSERT_EQ(-1, b.verify_csum(8, m));
-    ASSERT_EQ(16, b.verify_csum(16, m));
-
-    ASSERT_EQ(0, b.verify_csum(0, e));
-    ASSERT_EQ(8, b.verify_csum(8, e));
-    ASSERT_EQ(-1, b.verify_csum(16, e));
+    ASSERT_EQ(0, b.verify_csum(0, bl, &bad_off));
+    ASSERT_EQ(-1, bad_off);
+    ASSERT_EQ(-1, b.verify_csum(0, bl2, &bad_off));
+    ASSERT_EQ(0, bad_off);
+
+    ASSERT_EQ(0, b.verify_csum(0, f, &bad_off));
+    ASSERT_EQ(-1, bad_off);
+    ASSERT_EQ(-1, b.verify_csum(8, f, &bad_off));
+    ASSERT_EQ(8, bad_off);
+    ASSERT_EQ(-1, b.verify_csum(16, f, &bad_off));
+    ASSERT_EQ(16, bad_off);
+
+    ASSERT_EQ(-1, b.verify_csum(0, m, &bad_off));
+    ASSERT_EQ(0, bad_off);
+    ASSERT_EQ(0, b.verify_csum(8, m, &bad_off));
+    ASSERT_EQ(-1, bad_off);
+    ASSERT_EQ(-1, b.verify_csum(16, m, &bad_off));
+    ASSERT_EQ(16, bad_off);
+
+    ASSERT_EQ(-1, b.verify_csum(0, e, &bad_off));
+    ASSERT_EQ(0, bad_off);
+    ASSERT_EQ(-1, b.verify_csum(8, e, &bad_off));
+    ASSERT_EQ(8, bad_off);
+    ASSERT_EQ(0, b.verify_csum(16, e, &bad_off));
+    ASSERT_EQ(-1, bad_off);
 
     b.calc_csum(8, n);
-    ASSERT_EQ(-1, b.verify_csum(0, f));
-    ASSERT_EQ(-1, b.verify_csum(8, n));
-    ASSERT_EQ(-1, b.verify_csum(16, e));
-    ASSERT_EQ(8, b.verify_csum(0, bl));
+    ASSERT_EQ(0, b.verify_csum(0, f, &bad_off));
+    ASSERT_EQ(-1, bad_off);
+    ASSERT_EQ(0, b.verify_csum(8, n, &bad_off));
+    ASSERT_EQ(-1, bad_off);
+    ASSERT_EQ(0, b.verify_csum(16, e, &bad_off));
+    ASSERT_EQ(-1, bad_off);
+    ASSERT_EQ(-1, b.verify_csum(0, bl, &bad_off));
+    ASSERT_EQ(8, bad_off);
   }
 }