Merge pull request ceph#62985 from connorfawcett/wip-exerciser-consistency-2604

common/io_exerciser: Add consistency checking functionality to IO exerciser

Author: connorfawcett

src/common/io_exerciser/EcIoSequence.cc

@@ -15,7 +15,8 @@ std::unique_ptr<IoSequence> EcIoSequence::generate_sequence(
     Sequence sequence, std::pair<int, int> obj_size_range,
     std::optional<std::pair<int, int>> km,
     std::optional<std::pair<std::string_view, std::string_view>> mappinglayers,
-    int seed) {
+    int seed,
+    bool check_consistency) {
   switch (sequence) {
     case Sequence::SEQUENCE_SEQ0:
       [[fallthrough]];
@@ -45,16 +46,16 @@ std::unique_ptr<IoSequence> EcIoSequence::generate_sequence(
       [[fallthrough]];
     case Sequence::SEQUENCE_SEQ14:
       return std::make_unique<ReadInjectSequence>(obj_size_range, seed,
-                                                  sequence, km, mappinglayers);
+                                                  sequence, km, mappinglayers, check_consistency);
     case Sequence::SEQUENCE_SEQ10:
-      return std::make_unique<Seq10>(obj_size_range, seed, km, mappinglayers);
+      return std::make_unique<Seq10>(obj_size_range, seed, km, mappinglayers, check_consistency);
     default:
       ceph_abort_msg("Unrecognised sequence");
   }
 }
 
-EcIoSequence::EcIoSequence(std::pair<int, int> obj_size_range, int seed)
-    : IoSequence(obj_size_range, seed),
+EcIoSequence::EcIoSequence(std::pair<int, int> obj_size_range, int seed, bool check_consistency)
+    : IoSequence(obj_size_range, seed, check_consistency),
       setup_inject(false),
       clear_inject(false),
       shard_to_inject(std::nullopt) {}
@@ -172,9 +173,10 @@ ceph::io_exerciser::ReadInjectSequence::ReadInjectSequence(
     int seed,
     Sequence s,
     std::optional<std::pair<int, int>> km,
-    std::optional<std::pair<std::string_view, std::string_view>> mappinglayers)
-    : EcIoSequence(obj_size_range, seed) {
-  child_sequence = IoSequence::generate_sequence(s, obj_size_range, seed);
+    std::optional<std::pair<std::string_view, std::string_view>> mappinglayers,
+    bool check_consistency)
+    : EcIoSequence(obj_size_range, seed, check_consistency) {
+  child_sequence = IoSequence::generate_sequence(s, obj_size_range, seed, check_consistency);
   select_random_data_shard_to_inject_read_error(km, mappinglayers);
   generate_random_read_inject_type();
 }
@@ -267,8 +269,9 @@ ceph::io_exerciser::ReadInjectSequence::_next() {
 ceph::io_exerciser::Seq10::Seq10(
     std::pair<int, int> obj_size_range, int seed,
     std::optional<std::pair<int, int>> km,
-    std::optional<std::pair<std::string_view, std::string_view>> mappinglayers)
-    : EcIoSequence(obj_size_range, seed),
+    std::optional<std::pair<std::string_view, std::string_view>> mappinglayers,
+    bool check_consistency)
+    : EcIoSequence(obj_size_range, seed, check_consistency),
       offset(0),
       length(1),
       inject_error_done(false),

src/common/io_exerciser/EcIoSequence.h

@@ -12,15 +12,16 @@ class EcIoSequence : public IoSequence {
       std::optional<std::pair<int, int>> km,
       std::optional<std::pair<std::string_view, std::string_view>>
           mappinglayers,
-      int seed);
+      int seed,
+      bool check_consistency);
 
  protected:
   bool setup_inject;
   bool clear_inject;
   std::optional<uint64_t> shard_to_inject;
   InjectOpType inject_op_type;
 
-  EcIoSequence(std::pair<int, int> obj_size_range, int seed);
+  EcIoSequence(std::pair<int, int> obj_size_range, int seed, bool check_consistency);
 
   // Writes cannot be sent to injected on shard zero, so selections seperated
   // out
@@ -50,7 +51,8 @@ class ReadInjectSequence : public EcIoSequence {
       std::pair<int, int> obj_size_range, int seed, Sequence s,
       std::optional<std::pair<int, int>> km,
       std::optional<std::pair<std::string_view, std::string_view>>
-          mappinglayers);
+          mappinglayers,
+      bool check_consistency);
 
   Sequence get_id() const override;
   std::string get_name() const override;
@@ -67,7 +69,8 @@ class Seq10 : public EcIoSequence {
   Seq10(std::pair<int, int> obj_size_range, int seed,
         std::optional<std::pair<int, int>> km,
         std::optional<std::pair<std::string_view, std::string_view>>
-            mappinglayers);
+            mappinglayers,
+        bool check_consistency);
 
   Sequence get_id() const override;
   std::string get_name() const override;

src/common/io_exerciser/IoOp.cc

@@ -10,6 +10,7 @@ using DoneOp = ceph::io_exerciser::DoneOp;
 using BarrierOp = ceph::io_exerciser::BarrierOp;
 using CreateOp = ceph::io_exerciser::CreateOp;
 using RemoveOp = ceph::io_exerciser::RemoveOp;
+using ConsistencyOp = ceph::io_exerciser::ConsistencyOp;
 using SingleReadOp = ceph::io_exerciser::SingleReadOp;
 using DoubleReadOp = ceph::io_exerciser::DoubleReadOp;
 using TripleReadOp = ceph::io_exerciser::TripleReadOp;
@@ -98,6 +99,16 @@ ceph::io_exerciser::ReadWriteOp<opType, numIOs>::ReadWriteOp(
   }
 }
 
+ConsistencyOp::ConsistencyOp() : TestOp<OpType::Consistency>() {}
+
+std::unique_ptr<ConsistencyOp> ConsistencyOp::generate() {
+  return std::make_unique<ConsistencyOp>();
+}
+
+std::string ConsistencyOp::to_string(uint64_t block_size) const {
+  return "Consistency";
+}
+
 template <OpType opType, int numIOs>
 std::string ceph::io_exerciser::ReadWriteOp<opType, numIOs>::to_string(
     uint64_t block_size) const {

src/common/io_exerciser/IoOp.h

@@ -61,6 +61,13 @@ class RemoveOp : public TestOp<OpType::Remove> {
   std::string to_string(uint64_t block_size) const override;
 };
 
+class ConsistencyOp : public TestOp<OpType::Consistency> {
+  public:
+   ConsistencyOp();
+   static std::unique_ptr<ConsistencyOp> generate();
+   std::string to_string(uint64_t block_size) const override;
+ };
+
 template <OpType opType, int numIOs>
 class ReadWriteOp : public TestOp<opType> {
  public: