Merge pull request ceph#61404 from JonBailey1993/JonBailey1993/ceph_test_rados_io_sequence_plugin_support

common/io_exerciser: ceph_test_rados_io_sequence plugin/profile support

Author: SrinivasaBharath

src/common/io_exerciser/EcIoSequence.cc

@@ -1,5 +1,6 @@
 #include "EcIoSequence.h"
 
+#include <algorithm>
 #include <memory>
 
 using IoOp = ceph::io_exerciser::IoOp;
@@ -11,7 +12,9 @@ using ReadInjectSequence = ceph::io_exerciser::ReadInjectSequence;
 bool EcIoSequence::is_supported(Sequence sequence) const { return true; }
 
 std::unique_ptr<IoSequence> EcIoSequence::generate_sequence(
-    Sequence sequence, std::pair<int, int> obj_size_range, int k, int m,
+    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) {
   switch (sequence) {
     case Sequence::SEQUENCE_SEQ0:
@@ -42,9 +45,9 @@ std::unique_ptr<IoSequence> EcIoSequence::generate_sequence(
       [[fallthrough]];
     case Sequence::SEQUENCE_SEQ14:
       return std::make_unique<ReadInjectSequence>(obj_size_range, seed,
-                                                  sequence, k, m);
+                                                  sequence, km, mappinglayers);
     case Sequence::SEQUENCE_SEQ10:
-      return std::make_unique<Seq10>(obj_size_range, seed, k, m);
+      return std::make_unique<Seq10>(obj_size_range, seed, km, mappinglayers);
     default:
       ceph_abort_msg("Unrecognised sequence");
   }
@@ -56,26 +59,99 @@ EcIoSequence::EcIoSequence(std::pair<int, int> obj_size_range, int seed)
       clear_inject(false),
       shard_to_inject(std::nullopt) {}
 
-void EcIoSequence::select_random_data_shard_to_inject_read_error(int k, int m) {
-  shard_to_inject = rng(k - 1);
+void EcIoSequence::select_random_data_shard_to_inject_read_error(
+    std::optional<std::pair<int, int>> km,
+    std::optional<std::pair<std::string_view, std::string_view>>
+        mappinglayers) {
+  if (km) {
+    shard_to_inject = rng(km->first - 1);
+  }
+  if (mappinglayers) {
+    int count = std::ranges::count(mappinglayers->first, 'D');
+    int data_shard_position = rng(count - 1);
+    shard_to_inject = 0;
+    for (int i = 0; i < data_shard_position; i++) {
+      shard_to_inject =
+          std::distance(std::find(mappinglayers->first.begin(),
+                                  mappinglayers->first.end(), *shard_to_inject),
+                        mappinglayers->first.begin());
+      ceph_assert(*shard_to_inject != std::string::npos);
+    }
+  }
   setup_inject = true;
 }
 
-void EcIoSequence::select_random_data_shard_to_inject_write_error(int k,
-                                                                  int m) {
+void EcIoSequence::select_random_data_shard_to_inject_write_error(
+    std::optional<std::pair<int, int>> km,
+    std::optional<std::pair<std::string_view, std::string_view>>
+        mappinglayers) {
   // Write errors do not support injecting to the primary OSD
-  shard_to_inject = rng(1, k - 1);
+  if (km) {
+    shard_to_inject = rng(1, km->first - 1);
+  }
+  if (mappinglayers) {
+    int count = std::ranges::count(mappinglayers->first, 'D');
+    if (mappinglayers->first[0] == 'D') {
+      count--;
+    }
+    int data_shard_position = rng(1, count - 1);
+    shard_to_inject = 0;
+    for (int i = 1; i < data_shard_position; i++) {
+      shard_to_inject =
+          std::distance(std::find(mappinglayers->first.begin(),
+                                  mappinglayers->first.end(), *shard_to_inject),
+                        mappinglayers->first.begin());
+      ceph_assert(*shard_to_inject != std::string::npos);
+    }
+  }
   setup_inject = true;
 }
 
-void EcIoSequence::select_random_shard_to_inject_read_error(int k, int m) {
-  shard_to_inject = rng(k + m - 1);
+void EcIoSequence::select_random_shard_to_inject_read_error(
+    std::optional<std::pair<int, int>> km,
+    std::optional<std::pair<std::string_view, std::string_view>>
+        mappinglayers) {
+  if (km) {
+    shard_to_inject = rng(km->first + km->second - 1);
+  }
+  if (mappinglayers) {
+    int count = std::ranges::count(mappinglayers->first, 'D');
+    int data_shard_position = rng(count - 1);
+    shard_to_inject = 0;
+    for (int i = 0; i < data_shard_position; i++) {
+      shard_to_inject =
+          std::distance(std::find(mappinglayers->first.begin(),
+                                  mappinglayers->first.end(), *shard_to_inject),
+                        mappinglayers->first.begin());
+      ceph_assert(*shard_to_inject != std::string::npos);
+    }
+  }
   setup_inject = true;
 }
 
-void EcIoSequence::select_random_shard_to_inject_write_error(int k, int m) {
+void EcIoSequence::select_random_shard_to_inject_write_error(
+    std::optional<std::pair<int, int>> km,
+    std::optional<std::pair<std::string_view, std::string_view>>
+        mappinglayers) {
   // Write errors do not support injecting to the primary OSD
-  shard_to_inject = rng(1, k + m - 1);
+  if (km) {
+    shard_to_inject = rng(1, km->first + km->second - 1);
+  }
+  if (mappinglayers) {
+    int count = std::ranges::count(mappinglayers->first, 'D');
+    if (mappinglayers->first[0] == 'D') {
+      count--;
+    }
+    int data_shard_position = rng(count - 1);
+    shard_to_inject = 0;
+    for (int i = 0; i < data_shard_position; i++) {
+      shard_to_inject =
+          std::distance(std::find(mappinglayers->first.begin(),
+                                  mappinglayers->first.end(), *shard_to_inject),
+                        mappinglayers->first.begin());
+      ceph_assert(*shard_to_inject != std::string::npos);
+    }
+  }
   setup_inject = true;
 }
 
@@ -92,10 +168,14 @@ void EcIoSequence::generate_random_write_inject_type() {
 }
 
 ceph::io_exerciser::ReadInjectSequence::ReadInjectSequence(
-    std::pair<int, int> obj_size_range, int seed, Sequence s, int k, int m)
+    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)
     : EcIoSequence(obj_size_range, seed) {
   child_sequence = IoSequence::generate_sequence(s, obj_size_range, seed);
-  select_random_data_shard_to_inject_read_error(k, m);
+  select_random_data_shard_to_inject_read_error(km, mappinglayers);
   generate_random_read_inject_type();
 }
 
@@ -104,26 +184,31 @@ Sequence ceph::io_exerciser::ReadInjectSequence::get_id() const {
 }
 
 std::string ceph::io_exerciser::ReadInjectSequence::get_name() const {
+  std::string injected_shard = "UNKNOWN";
+  if (shard_to_inject) {
+    injected_shard = std::to_string(*shard_to_inject);
+  }
+
   return child_sequence->get_name() +
-         " running with read errors injected on shard " +
-         std::to_string(*shard_to_inject);
+         " running with read errors injected on shard " + injected_shard;
 }
 
 std::unique_ptr<IoOp> ReadInjectSequence::next() {
   step++;
 
-  if (nextOp) {
-    std::unique_ptr<IoOp> retOp = nullptr;
-    nextOp.swap(retOp);
-    return retOp;
+  if (next_op) {
+    std::unique_ptr<IoOp> ret_op = nullptr;
+    next_op.swap(ret_op);
+    return ret_op;
   }
 
-  std::unique_ptr<IoOp> childOp = child_sequence->next();
+  std::unique_ptr<IoOp> child_op = child_sequence->next();
 
-  switch (childOp->getOpType()) {
+  switch (child_op->getOpType()) {
     case OpType::Remove:
-      nextOp.swap(childOp);
+      next_op.swap(child_op);
       switch (inject_op_type) {
+        ceph_assert(shard_to_inject.has_value());
         case InjectOpType::ReadEIO:
           return ClearReadErrorInjectOp::generate(*shard_to_inject, 0);
         case InjectOpType::ReadMissingShard:
@@ -141,19 +226,19 @@ std::unique_ptr<IoOp> ReadInjectSequence::next() {
     case OpType::Create:
       switch (inject_op_type) {
         case InjectOpType::ReadEIO:
-          nextOp = InjectReadErrorOp::generate(
+          next_op = InjectReadErrorOp::generate(
               *shard_to_inject, 0, 0, std::numeric_limits<uint64_t>::max());
           break;
         case InjectOpType::ReadMissingShard:
-          nextOp = InjectReadErrorOp::generate(
+          next_op = InjectReadErrorOp::generate(
               *shard_to_inject, 1, 0, std::numeric_limits<uint64_t>::max());
           break;
         case InjectOpType::WriteFailAndRollback:
-          nextOp = InjectWriteErrorOp::generate(
+          next_op = InjectWriteErrorOp::generate(
               *shard_to_inject, 0, 0, std::numeric_limits<uint64_t>::max());
           break;
         case InjectOpType::WriteOSDAbort:
-          nextOp = InjectWriteErrorOp::generate(
+          next_op = InjectWriteErrorOp::generate(
               *shard_to_inject, 3, 0, std::numeric_limits<uint64_t>::max());
           break;
         case InjectOpType::None:
@@ -167,7 +252,7 @@ std::unique_ptr<IoOp> ReadInjectSequence::next() {
       break;
   }
 
-  return childOp;
+  return child_op;
 }
 
 std::unique_ptr<ceph::io_exerciser::IoOp>
@@ -179,8 +264,10 @@ ceph::io_exerciser::ReadInjectSequence::_next() {
   return DoneOp::generate();
 }
 
-ceph::io_exerciser::Seq10::Seq10(std::pair<int, int> obj_size_range, int seed,
-                                 int k, int m)
+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),
       offset(0),
       length(1),
@@ -192,7 +279,7 @@ ceph::io_exerciser::Seq10::Seq10(std::pair<int, int> obj_size_range, int seed,
       test_all_sizes(
           false)  // Only test obj_size(rand()) due to time constraints
 {
-  select_random_shard_to_inject_write_error(k, m);
+  select_random_shard_to_inject_write_error(km, mappinglayers);
   // We will inject specifically as part of our sequence in this sequence
   setup_inject = false;
   if (!test_all_sizes) {

src/common/io_exerciser/EcIoSequence.h

@@ -1,3 +1,5 @@
+#pragma once
+
 #include "IoSequence.h"
 
 namespace ceph {
@@ -6,7 +8,11 @@ class EcIoSequence : public IoSequence {
  public:
   virtual bool is_supported(Sequence sequence) const override;
   static std::unique_ptr<IoSequence> generate_sequence(
-      Sequence s, std::pair<int, int> obj_size_range, int k, int m, int seed);
+      Sequence s, 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);
 
  protected:
   bool setup_inject;
@@ -18,18 +24,33 @@ class EcIoSequence : public IoSequence {
 
   // Writes cannot be sent to injected on shard zero, so selections seperated
   // out
-  void select_random_data_shard_to_inject_read_error(int k, int m);
-  void select_random_data_shard_to_inject_write_error(int k, int m);
-  void select_random_shard_to_inject_read_error(int k, int m);
-  void select_random_shard_to_inject_write_error(int k, int m);
+  void select_random_data_shard_to_inject_read_error(
+      std::optional<std::pair<int, int>> km,
+      std::optional<std::pair<std::string_view, std::string_view>>
+          mappinglayers);
+  void select_random_data_shard_to_inject_write_error(
+      std::optional<std::pair<int, int>> km,
+      std::optional<std::pair<std::string_view, std::string_view>>
+          mappinglayers);
+  void select_random_shard_to_inject_read_error(
+      std::optional<std::pair<int, int>> km,
+      std::optional<std::pair<std::string_view, std::string_view>>
+          mappinglayers);
+  void select_random_shard_to_inject_write_error(
+      std::optional<std::pair<int, int>> km,
+      std::optional<std::pair<std::string_view, std::string_view>>
+          mappinglayers);
   void generate_random_read_inject_type();
   void generate_random_write_inject_type();
 };
 
 class ReadInjectSequence : public EcIoSequence {
  public:
-  ReadInjectSequence(std::pair<int, int> obj_size_range, int seed, Sequence s,
-                     int k, int m);
+  ReadInjectSequence(
+      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);
 
   Sequence get_id() const override;
   std::string get_name() const override;
@@ -38,12 +59,15 @@ class ReadInjectSequence : public EcIoSequence {
 
  private:
   std::unique_ptr<IoSequence> child_sequence;
-  std::unique_ptr<IoOp> nextOp;
+  std::unique_ptr<IoOp> next_op;
 };
 
 class Seq10 : public EcIoSequence {
  public:
-  Seq10(std::pair<int, int> obj_size_range, int seed, int k, int m);
+  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);
 
   Sequence get_id() const override;
   std::string get_name() const override;

src/common/json/OSDStructures.cc

@@ -85,12 +85,17 @@ void OSDECProfileGetReply::dump(Formatter* f) const {
   encode_json("crush-osds-per-failure-domain", crush_osds_per_failure_domain,
               f);
   encode_json("crush-root", crush_root, f);
-  encode_json("jerasure-per-chunk-alignment", jerasure_per_chunk_alignment, f);
+  encode_json("plugin", plugin, f);
   encode_json("k", k, f);
   encode_json("m", m, f);
-  encode_json("plugin", plugin, f);
-  encode_json("technique", technique, f);
+  encode_json("l", l, f);
   encode_json("w", w, f);
+  encode_json("c", c, f);
+  encode_json("packetsize", packetsize, f);
+  encode_json("technique", technique, f);
+  encode_json("layers", layers, f);
+  encode_json("mapping", mapping, f);
+  encode_json("jerasure-per-chunk-alignment", jerasure_per_chunk_alignment, f);
 }
 
 void OSDECProfileGetReply::decode_json(JSONObj* obj) {
@@ -101,24 +106,31 @@ void OSDECProfileGetReply::decode_json(JSONObj* obj) {
   JSONDecoder::decode_json("crush-osds-per-failure-domain",
                            crush_osds_per_failure_domain, obj);
   JSONDecoder::decode_json("crush-root", crush_root, obj);
-  JSONDecoder::decode_json("jerasure-per-chunk-alignment",
-                           jerasure_per_chunk_alignment, obj);
+  JSONDecoder::decode_json("plugin", plugin, obj);
   JSONDecoder::decode_json("k", k, obj);
   JSONDecoder::decode_json("m", m, obj);
-  JSONDecoder::decode_json("plugin", plugin, obj);
-  JSONDecoder::decode_json("technique", technique, obj);
+  JSONDecoder::decode_json("l", l, obj);
   JSONDecoder::decode_json("w", w, obj);
+  JSONDecoder::decode_json("c", c, obj);
+  JSONDecoder::decode_json("packetsize", packetsize, obj);
+  JSONDecoder::decode_json("technique", technique, obj);
+  JSONDecoder::decode_json("layers", layers, obj);
+  JSONDecoder::decode_json("mapping", mapping, obj);
+  JSONDecoder::decode_json("jerasure-per-chunk-alignment",
+                           jerasure_per_chunk_alignment, obj);
 }
 
 void OSDECProfileSetRequest::dump(Formatter* f) const {
   encode_json("prefix", "osd erasure-code-profile set", f);
   encode_json("name", name, f);
   encode_json("profile", profile, f);
+  encode_json("force", force, f);
 }
 
 void OSDECProfileSetRequest::decode_json(JSONObj* obj) {
   JSONDecoder::decode_json("name", name, obj);
   JSONDecoder::decode_json("profile", profile, obj);
+  JSONDecoder::decode_json("force", force, obj);
 }
 
 void OSDECPoolCreateRequest::dump(Formatter* f) const {