16 files changed, 2419 insertions, 1648 deletions

diff --git a/src/common/io_exerciser/CMakeLists.txt b/src/common/io_exerciser/CMakeLists.txt
index 07091df86e1..ab2e64fc222 100644
--- a/src/common/io_exerciser/CMakeLists.txt
+++ b/src/common/io_exerciser/CMakeLists.txt
@@ -5,9 +5,11 @@ add_library(object_io_exerciser STATIC
   Model.cc
   ObjectModel.cc
   RadosIo.cc
+  EcIoSequence.cc
 )
 
 target_link_libraries(object_io_exerciser
-  librados 
+  librados
   global
+  json_structures
 )
\ No newline at end of file
diff --git a/src/common/io_exerciser/DataGenerator.cc b/src/common/io_exerciser/DataGenerator.cc
index 9aa77eeb6e9..701c32fa9ec 100644
--- a/src/common/io_exerciser/DataGenerator.cc
+++ b/src/common/io_exerciser/DataGenerator.cc
@@ -2,32 +2,28 @@
 // vim: ts=8 sw=2 smarttab
 #include "DataGenerator.h"
 
-#include "ObjectModel.h"
+#include <chrono>
+#include <iostream>
+#include <stdexcept>
 
+#include "ObjectModel.h"
 #include "common/debug.h"
 #include "common/dout.h"
-
 #include "fmt/format.h"
 #include "fmt/ranges.h"
 
-#include <chrono>
-#include <iostream>
-#include <stdexcept>
-
 #define dout_subsys ceph_subsys_rados
 #define dout_context g_ceph_context
 
 using DataGenerator = ceph::io_exerciser::data_generation::DataGenerator;
-using SeededRandomGenerator = ceph::io_exerciser::data_generation
-                                ::SeededRandomGenerator;
-using HeaderedSeededRandomGenerator = ceph::io_exerciser::data_generation
-                                        ::HeaderedSeededRandomGenerator;
+using SeededRandomGenerator =
+    ceph::io_exerciser::data_generation ::SeededRandomGenerator;
+using HeaderedSeededRandomGenerator =
+    ceph::io_exerciser::data_generation ::HeaderedSeededRandomGenerator;
 
 std::unique_ptr<DataGenerator> DataGenerator::create_generator(
-    GenerationType generationType, const ObjectModel& model)
-{
-  switch(generationType)
-  {
+    GenerationType generationType, const ObjectModel& model) {
+  switch (generationType) {
     case GenerationType::SeededRandom:
       return std::make_unique<SeededRandomGenerator>(model);
     case GenerationType::HeaderedSeededRandom:
@@ -39,28 +35,25 @@ std::unique_ptr<DataGenerator> DataGenerator::create_generator(
   return nullptr;
 }
 
-bufferlist DataGenerator::generate_wrong_data(uint64_t offset, uint64_t length)
-{
+bufferlist DataGenerator::generate_wrong_data(uint64_t offset,
+                                              uint64_t length) {
   bufferlist retlist;
   uint64_t block_size = m_model.get_block_size();
   char buffer[block_size];
-  for (uint64_t block_offset = offset;
-       block_offset < offset + length;
-       block_offset++)
-  {
+  for (uint64_t block_offset = offset; block_offset < offset + length;
+       block_offset++) {
     std::memset(buffer, 0, block_size);
     retlist.append(ceph::bufferptr(buffer, block_size));
   }
   return retlist;
 }
 
-bool DataGenerator::validate(bufferlist& bufferlist, uint64_t offset, uint64_t length)
-{
+bool DataGenerator::validate(bufferlist& bufferlist, uint64_t offset,
+                             uint64_t length) {
   return bufferlist.contents_equal(generate_data(offset, length));
 }
 
-ceph::bufferptr SeededRandomGenerator::generate_block(uint64_t block_offset)
-{
+ceph::bufferptr SeededRandomGenerator::generate_block(uint64_t block_offset) {
   uint64_t block_size = m_model.get_block_size();
   char buffer[block_size];
 
@@ -70,29 +63,26 @@ ceph::bufferptr SeededRandomGenerator::generate_block(uint64_t block_offset)
 
   constexpr size_t generation_length = sizeof(uint64_t);
 
-  for (uint64_t i = 0; i < block_size; i+=(2*generation_length), rand1++, rand2--)
-  {
+  for (uint64_t i = 0; i < block_size;
+       i += (2 * generation_length), rand1++, rand2--) {
     std::memcpy(buffer + i, &rand1, generation_length);
     std::memcpy(buffer + i + generation_length, &rand2, generation_length);
   }
 
   size_t remainingBytes = block_size % (generation_length * 2);
-  if (remainingBytes > generation_length)
-  {
+  if (remainingBytes > generation_length) {
     size_t remainingBytes2 = remainingBytes - generation_length;
     std::memcpy(buffer + block_size - remainingBytes, &rand1, remainingBytes);
     std::memcpy(buffer + block_size - remainingBytes2, &rand2, remainingBytes2);
-  }
-  else if (remainingBytes > 0)
-  {
+  } else if (remainingBytes > 0) {
     std::memcpy(buffer + block_size - remainingBytes, &rand1, remainingBytes);
   }
 
   return ceph::bufferptr(buffer, block_size);
 }
 
-ceph::bufferptr SeededRandomGenerator::generate_wrong_block(uint64_t block_offset)
-{
+ceph::bufferptr SeededRandomGenerator::generate_wrong_block(
+    uint64_t block_offset) {
   uint64_t block_size = m_model.get_block_size();
   char buffer[block_size];
 
@@ -102,141 +92,134 @@ ceph::bufferptr SeededRandomGenerator::generate_wrong_block(uint64_t block_offse
 
   constexpr size_t generation_length = sizeof(uint64_t);
 
-  for (uint64_t i = 0; i < block_size; i+=(2*generation_length), rand1++, rand2--)
-  {
+  for (uint64_t i = 0; i < block_size;
+       i += (2 * generation_length), rand1++, rand2--) {
     std::memcpy(buffer + i, &rand1, generation_length);
     std::memcpy(buffer + i + generation_length, &rand2, generation_length);
   }
 
   size_t remainingBytes = block_size % (generation_length * 2);
-  if (remainingBytes > generation_length)
-  {
+  if (remainingBytes > generation_length) {
     size_t remainingBytes2 = remainingBytes - generation_length;
     std::memcpy(buffer + block_size - remainingBytes, &rand1, remainingBytes);
     std::memcpy(buffer + block_size - remainingBytes2, &rand2, remainingBytes2);
-  }
-  else if (remainingBytes > 0)
-  {
+  } else if (remainingBytes > 0) {
     std::memcpy(buffer + block_size - remainingBytes, &rand1, remainingBytes);
   }
 
   return ceph::bufferptr(buffer, block_size);
 }
 
-bufferlist SeededRandomGenerator::generate_data(uint64_t offset, uint64_t length)
-{
+bufferlist SeededRandomGenerator::generate_data(uint64_t offset,
+                                                uint64_t length) {
   bufferlist retlist;
 
-  for (uint64_t block_offset = offset; block_offset < offset + length; block_offset++)
-  {
+  for (uint64_t block_offset = offset; block_offset < offset + length;
+       block_offset++) {
     retlist.append(generate_block(block_offset));
   }
 
   return retlist;
 }
 
-bufferlist SeededRandomGenerator::generate_wrong_data(uint64_t offset, uint64_t length)
-{
+bufferlist SeededRandomGenerator::generate_wrong_data(uint64_t offset,
+                                                      uint64_t length) {
   bufferlist retlist;
 
-  for (uint64_t block_offset = offset; block_offset < offset + length; block_offset++)
-  {
+  for (uint64_t block_offset = offset; block_offset < offset + length;
+       block_offset++) {
     retlist.append(generate_wrong_block(block_offset));
   }
 
   return retlist;
 }
 
-HeaderedSeededRandomGenerator
-  ::HeaderedSeededRandomGenerator(const ObjectModel& model,
-                                  std::optional<uint64_t> unique_run_id) :
-    SeededRandomGenerator(model),
-    unique_run_id(unique_run_id.value_or(generate_unique_run_id()))
-{
-
-}
+HeaderedSeededRandomGenerator ::HeaderedSeededRandomGenerator(
+    const ObjectModel& model, std::optional<uint64_t> unique_run_id)
+    : SeededRandomGenerator(model),
+      unique_run_id(unique_run_id.value_or(generate_unique_run_id())) {}
 
-uint64_t HeaderedSeededRandomGenerator::generate_unique_run_id()
-{
+uint64_t HeaderedSeededRandomGenerator::generate_unique_run_id() {
   std::mt19937_64 random_generator =
-        std::mt19937_64(duration_cast<std::chrono::milliseconds>(
-          std::chrono::system_clock::now().time_since_epoch()).count());
+      std::mt19937_64(duration_cast<std::chrono::milliseconds>(
+                          std::chrono::system_clock::now().time_since_epoch())
+                          .count());
 
-      return random_generator();
+  return random_generator();
 }
 
-ceph::bufferptr HeaderedSeededRandomGenerator::generate_block(uint64_t block_offset)
-{
+ceph::bufferptr HeaderedSeededRandomGenerator::generate_block(
+    uint64_t block_offset) {
   SeedBytes seed = m_model.get_seed(block_offset);
-  TimeBytes current_time = duration_cast<std::chrono::milliseconds>(
-      std::chrono::system_clock::now().time_since_epoch()).count();
+  TimeBytes current_time =
+      duration_cast<std::chrono::milliseconds>(
+          std::chrono::system_clock::now().time_since_epoch())
+          .count();
 
-  ceph::bufferptr bufferptr = SeededRandomGenerator::generate_block(block_offset);
+  ceph::bufferptr bufferptr =
+      SeededRandomGenerator::generate_block(block_offset);
 
-  std::memcpy(bufferptr.c_str() + uniqueIdStart(), &unique_run_id, uniqueIdLength());
+  std::memcpy(bufferptr.c_str() + uniqueIdStart(), &unique_run_id,
+              uniqueIdLength());
   std::memcpy(bufferptr.c_str() + seedStart(), &seed, seedLength());
   std::memcpy(bufferptr.c_str() + timeStart(), &current_time, timeLength());
 
   return bufferptr;
 }
 
-ceph::bufferptr HeaderedSeededRandomGenerator::generate_wrong_block(uint64_t block_offset)
-{
+ceph::bufferptr HeaderedSeededRandomGenerator::generate_wrong_block(
+    uint64_t block_offset) {
   return HeaderedSeededRandomGenerator::generate_block(block_offset % 8);
 }
 
 const HeaderedSeededRandomGenerator::UniqueIdBytes
-  HeaderedSeededRandomGenerator::readUniqueRunId(uint64_t block_offset,
-                                                 const bufferlist& bufferlist)
-{
+HeaderedSeededRandomGenerator::readUniqueRunId(uint64_t block_offset,
+                                               const bufferlist& bufferlist) {
   UniqueIdBytes read_unique_run_id = 0;
-  std::memcpy(&read_unique_run_id,
-              &bufferlist[(block_offset * m_model.get_block_size()) + uniqueIdStart()],
-              uniqueIdLength());
+  std::memcpy(
+      &read_unique_run_id,
+      &bufferlist[(block_offset * m_model.get_block_size()) + uniqueIdStart()],
+      uniqueIdLength());
   return read_unique_run_id;
 }
 
 const HeaderedSeededRandomGenerator::SeedBytes
-  HeaderedSeededRandomGenerator::readSeed(uint64_t block_offset,
-                                          const bufferlist& bufferlist)
-{
+HeaderedSeededRandomGenerator::readSeed(uint64_t block_offset,
+                                        const bufferlist& bufferlist) {
   SeedBytes read_seed = 0;
-  std::memcpy(&read_seed,
-              &bufferlist[(block_offset * m_model.get_block_size()) + seedStart()],
-              seedLength());
+  std::memcpy(
+      &read_seed,
+      &bufferlist[(block_offset * m_model.get_block_size()) + seedStart()],
+      seedLength());
   return read_seed;
 }
 
 const HeaderedSeededRandomGenerator::TimeBytes
-  HeaderedSeededRandomGenerator::readDateTime(uint64_t block_offset,
-                                              const bufferlist& bufferlist)
-{
+HeaderedSeededRandomGenerator::readDateTime(uint64_t block_offset,
+                                            const bufferlist& bufferlist) {
   TimeBytes read_time = 0;
-  std::memcpy(&read_time,
-              &bufferlist[(block_offset * m_model.get_block_size()) + timeStart()],
-              timeLength());
+  std::memcpy(
+      &read_time,
+      &bufferlist[(block_offset * m_model.get_block_size()) + timeStart()],
+      timeLength());
   return read_time;
 }
 
 bool HeaderedSeededRandomGenerator::validate(bufferlist& bufferlist,
-                                             uint64_t offset, uint64_t length)
-{
+                                             uint64_t offset, uint64_t length) {
   std::vector<uint64_t> invalid_block_offsets;
 
-  for (uint64_t block_offset = offset; block_offset < offset + length; block_offset++)
-  {
-    bool valid_block
-      = validate_block(block_offset,
-                       (bufferlist.c_str() + ((block_offset - offset) *
-                       m_model.get_block_size())));
-    if (!valid_block)
-    {
+  for (uint64_t block_offset = offset; block_offset < offset + length;
+       block_offset++) {
+    bool valid_block = validate_block(
+        block_offset, (bufferlist.c_str() +
+                       ((block_offset - offset) * m_model.get_block_size())));
+    if (!valid_block) {
       invalid_block_offsets.push_back(block_offset);
     }
   }
 
-  if (!invalid_block_offsets.empty())
-  {
+  if (!invalid_block_offsets.empty()) {
     printDebugInformationForOffsets(offset, invalid_block_offsets, bufferlist);
   }
 
@@ -244,59 +227,51 @@ bool HeaderedSeededRandomGenerator::validate(bufferlist& bufferlist,
 }
 
 bool HeaderedSeededRandomGenerator::validate_block(uint64_t block_offset,
-                                                   const char* buffer_start)
-{
+                                                   const char* buffer_start) {
   // We validate the block matches what we generate byte for byte
   // however we ignore the time section of the header
   ceph::bufferptr bufferptr = generate_block(block_offset);
   bool valid = strncmp(bufferptr.c_str(), buffer_start, timeStart()) == 0;
-  valid = valid ? strncmp(bufferptr.c_str() + timeEnd(),
-                          buffer_start + timeEnd(),
-                          m_model.get_block_size() - timeEnd()) == 0 : valid;
+  valid = valid
+              ? strncmp(bufferptr.c_str() + timeEnd(), buffer_start + timeEnd(),
+                        m_model.get_block_size() - timeEnd()) == 0
+              : valid;
   return valid;
 }
 
 const HeaderedSeededRandomGenerator::ErrorType
-  HeaderedSeededRandomGenerator::getErrorTypeForBlock(uint64_t read_offset,
-                                                      uint64_t block_offset,
-                                                      const bufferlist& bufferlist)
-{
-  try
-  {
-    UniqueIdBytes read_unique_run_id = readUniqueRunId(block_offset - read_offset,
-                                                       bufferlist);
-    if (unique_run_id != read_unique_run_id)
-    {
+HeaderedSeededRandomGenerator::getErrorTypeForBlock(
+    uint64_t read_offset, uint64_t block_offset, const bufferlist& bufferlist) {
+  try {
+    UniqueIdBytes read_unique_run_id =
+        readUniqueRunId(block_offset - read_offset, bufferlist);
+    if (unique_run_id != read_unique_run_id) {
       return ErrorType::RUN_ID_MISMATCH;
     }
 
     SeedBytes read_seed = readSeed(block_offset - read_offset, bufferlist);
-    if (m_model.get_seed(block_offset) != read_seed)
-    {
+    if (m_model.get_seed(block_offset) != read_seed) {
       return ErrorType::SEED_MISMATCH;
     }
 
     if (std::strncmp(&bufferlist[((block_offset - read_offset) *
-                      m_model.get_block_size()) + bodyStart()],
+                                  m_model.get_block_size()) +
+                                 bodyStart()],
                      generate_block(block_offset).c_str() + bodyStart(),
-                     m_model.get_block_size() - bodyStart()) != 0)
-    {
+                     m_model.get_block_size() - bodyStart()) != 0) {
       return ErrorType::DATA_MISMATCH;
     }
-  }
-  catch(const std::exception& e)
-  {
+  } catch (const std::exception& e) {
     return ErrorType::DATA_NOT_FOUND;
   }
 
   return ErrorType::UNKNOWN;
 }
 
-void HeaderedSeededRandomGenerator
-  ::printDebugInformationForBlock(uint64_t read_offset, uint64_t block_offset,
-                                  const bufferlist& bufferlist)
-{
-  ErrorType blockError = getErrorTypeForBlock(read_offset, block_offset, bufferlist);
+void HeaderedSeededRandomGenerator ::printDebugInformationForBlock(
+    uint64_t read_offset, uint64_t block_offset, const bufferlist& bufferlist) {
+  ErrorType blockError =
+      getErrorTypeForBlock(read_offset, block_offset, bufferlist);
 
   TimeBytes read_time = 0;
   std::time_t ttp;
@@ -304,433 +279,361 @@ void HeaderedSeededRandomGenerator
   char read_bytes[m_model.get_block_size()];
   char generated_bytes[m_model.get_block_size()];
 
-  if (blockError == ErrorType::DATA_MISMATCH || blockError == ErrorType::UNKNOWN)
-  {
+  if (blockError == ErrorType::DATA_MISMATCH ||
+      blockError == ErrorType::UNKNOWN) {
     read_time = readDateTime(block_offset - read_offset, bufferlist);
-    std::chrono::system_clock::time_point time_point{std::chrono::milliseconds{read_time}};
+    std::chrono::system_clock::time_point time_point{
+        std::chrono::milliseconds{read_time}};
     ttp = std::chrono::system_clock::to_time_t(time_point);
 
-    std::memcpy(&read_bytes,
-                &bufferlist[((block_offset - read_offset) * m_model.get_block_size())],
-                m_model.get_block_size() - bodyStart());
-    std::memcpy(&generated_bytes,
-                generate_block(block_offset).c_str(),
+    std::memcpy(
+        &read_bytes,
+        &bufferlist[((block_offset - read_offset) * m_model.get_block_size())],
+        m_model.get_block_size() - bodyStart());
+    std::memcpy(&generated_bytes, generate_block(block_offset).c_str(),
                 m_model.get_block_size() - bodyStart());
   }
 
   std::string error_string;
-  switch(blockError)
-  {
-    case ErrorType::RUN_ID_MISMATCH:
-    {
-      UniqueIdBytes read_unique_run_id = readUniqueRunId((block_offset - read_offset),
-                                                          bufferlist);
-      error_string = fmt::format("Header (Run ID) mismatch detected at block {} "
-        "(byte offset {}) Header expected run id {} but found id {}. "
-        "Block data corrupt or not written from this instance of this application.",
-      block_offset,
-      block_offset * m_model.get_block_size(),
-      unique_run_id,
-      read_unique_run_id);
-    }
-    break;
-
-    case ErrorType::SEED_MISMATCH:
-    {
+  switch (blockError) {
+    case ErrorType::RUN_ID_MISMATCH: {
+      UniqueIdBytes read_unique_run_id =
+          readUniqueRunId((block_offset - read_offset), bufferlist);
+      error_string = fmt::format(
+          "Header (Run ID) mismatch detected at block {} "
+          "(byte offset {}) Header expected run id {} but found id {}. "
+          "Block data corrupt or not written from this instance of this "
+          "application.",
+          block_offset, block_offset * m_model.get_block_size(), unique_run_id,
+          read_unique_run_id);
+    } break;
+
+    case ErrorType::SEED_MISMATCH: {
       SeedBytes read_seed = readSeed((block_offset - read_offset), bufferlist);
 
-      if (m_model.get_seed_offsets(read_seed).size() == 0)
-      {
-        error_string = fmt::format("Data (Seed) mismatch detected at block {}"
-          " (byte offset {}). Header expected seed {} but found seed {}. "
-          "Read data was not from any other recognised block in the object.",
-            block_offset,
-            block_offset * m_model.get_block_size(),
-            m_model.get_seed(block_offset),
-            read_seed);
-      }
-      else
-      {
+      if (m_model.get_seed_offsets(read_seed).size() == 0) {
+        error_string = fmt::format(
+            "Data (Seed) mismatch detected at block {}"
+            " (byte offset {}). Header expected seed {} but found seed {}. "
+            "Read data was not from any other recognised block in the object.",
+            block_offset, block_offset * m_model.get_block_size(),
+            m_model.get_seed(block_offset), read_seed);
+      } else {
         std::vector<int> seed_offsets = m_model.get_seed_offsets(read_seed);
-        error_string = fmt::format("Data (Seed) mismatch detected at block {}"
-          " (byte offset {}). Header expected seed {} but found seed {}."
-          " Read data was from a different block(s): {}",
-            block_offset,
-            block_offset * m_model.get_block_size(),
-            m_model.get_seed(block_offset),
-            read_seed,
+        error_string = fmt::format(
+            "Data (Seed) mismatch detected at block {}"
+            " (byte offset {}). Header expected seed {} but found seed {}."
+            " Read data was from a different block(s): {}",
+            block_offset, block_offset * m_model.get_block_size(),
+            m_model.get_seed(block_offset), read_seed,
             fmt::join(seed_offsets.begin(), seed_offsets.end(), ""));
       }
-    }
-    break;
-
-    case ErrorType::DATA_MISMATCH:
-    {
-      error_string = fmt::format("Data (Body) mismatch detected at block {}"
-        " (byte offset {}). Header data matches, data body does not."
-        " Data written at {}\nExpected data: \n{:02x}\nRead data:{:02x}",
-          block_offset,
-          block_offset * m_model.get_block_size(),
+    } break;
+
+    case ErrorType::DATA_MISMATCH: {
+      error_string = fmt::format(
+          "Data (Body) mismatch detected at block {}"
+          " (byte offset {}). Header data matches, data body does not."
+          " Data written at {}\nExpected data: \n{:02x}\nRead data:{:02x}",
+          block_offset, block_offset * m_model.get_block_size(),
           std::ctime(&ttp),
-          fmt::join(generated_bytes, generated_bytes + m_model.get_block_size(), ""),
+          fmt::join(generated_bytes, generated_bytes + m_model.get_block_size(),
+                    ""),
           fmt::join(read_bytes, read_bytes + m_model.get_block_size(), ""));
-    }
-    break;
+    } break;
 
-    case ErrorType::DATA_NOT_FOUND:
-    {
+    case ErrorType::DATA_NOT_FOUND: {
       uint64_t bufferlist_length = bufferlist.to_str().size();
-      error_string = fmt::format("Data (Body) could not be read at block {}"
-        " (byte offset {}) offset in bufferlist returned from read: {}"
-        " ({} bytes). Returned bufferlist length: {}.",
-          block_offset,
-          block_offset * m_model.get_block_size(),
+      error_string = fmt::format(
+          "Data (Body) could not be read at block {}"
+          " (byte offset {}) offset in bufferlist returned from read: {}"
+          " ({} bytes). Returned bufferlist length: {}.",
+          block_offset, block_offset * m_model.get_block_size(),
           (block_offset - read_offset),
           (block_offset - read_offset) * m_model.get_block_size(),
           bufferlist_length);
-    }
-    break;
+    } break;
 
     case ErrorType::UNKNOWN:
-      [[ fallthrough ]];
-
-    default:
-    {
-      error_string = fmt::format("Data mismatch detected at block {}"
-        " (byte offset {}).\nExpected data:\n{:02x}\nRead data:\n{:02x}",
-          block_offset,
-          block_offset * m_model.get_block_size(),
-          fmt::join(generated_bytes, generated_bytes + m_model.get_block_size(), ""),
+      [[fallthrough]];
+
+    default: {
+      error_string = fmt::format(
+          "Data mismatch detected at block {}"
+          " (byte offset {}).\nExpected data:\n{:02x}\nRead data:\n{:02x}",
+          block_offset, block_offset * m_model.get_block_size(),
+          fmt::join(generated_bytes, generated_bytes + m_model.get_block_size(),
+                    ""),
           fmt::join(read_bytes, read_bytes + m_model.get_block_size(), ""));
-    }
-    break;
+    } break;
   }
   dout(0) << error_string << dendl;
 }
 
-void HeaderedSeededRandomGenerator
-  ::printDebugInformationForRange(uint64_t read_offset,
-                                  uint64_t start_block_offset,
-                                  uint64_t range_length_in_blocks,
-                                  ErrorType rangeError,
-                                  const bufferlist& bufferlist)
-{
-  switch(rangeError)
-  {
-  case ErrorType::RUN_ID_MISMATCH:
-    printDebugInformationForRunIdMismatchRange(read_offset, start_block_offset,
-                                               range_length_in_blocks, bufferlist);
-    break;
-  case ErrorType::SEED_MISMATCH:
-    printDebugInformationForSeedMismatchRange(read_offset, start_block_offset,
-                                              range_length_in_blocks, bufferlist);
-    break;
-  case ErrorType::DATA_MISMATCH:
-    printDebugInformationDataBodyMismatchRange(read_offset, start_block_offset,
-                                               range_length_in_blocks, bufferlist);
-    break;
-  case ErrorType::DATA_NOT_FOUND:
-    printDebugInformationDataNotFoundRange(read_offset, start_block_offset,
-                                           range_length_in_blocks, bufferlist);
-    break;
-  case ErrorType::UNKNOWN:
-    [[ fallthrough ]];
-  default:
-    printDebugInformationCorruptRange(read_offset, start_block_offset,
-                                      range_length_in_blocks, bufferlist);
-    break;
+void HeaderedSeededRandomGenerator ::printDebugInformationForRange(
+    uint64_t read_offset, uint64_t start_block_offset,
+    uint64_t range_length_in_blocks, ErrorType rangeError,
+    const bufferlist& bufferlist) {
+  switch (rangeError) {
+    case ErrorType::RUN_ID_MISMATCH:
+      printDebugInformationForRunIdMismatchRange(
+          read_offset, start_block_offset, range_length_in_blocks, bufferlist);
+      break;
+    case ErrorType::SEED_MISMATCH:
+      printDebugInformationForSeedMismatchRange(
+          read_offset, start_block_offset, range_length_in_blocks, bufferlist);
+      break;
+    case ErrorType::DATA_MISMATCH:
+      printDebugInformationDataBodyMismatchRange(
+          read_offset, start_block_offset, range_length_in_blocks, bufferlist);
+      break;
+    case ErrorType::DATA_NOT_FOUND:
+      printDebugInformationDataNotFoundRange(
+          read_offset, start_block_offset, range_length_in_blocks, bufferlist);
+      break;
+    case ErrorType::UNKNOWN:
+      [[fallthrough]];
+    default:
+      printDebugInformationCorruptRange(read_offset, start_block_offset,
+                                        range_length_in_blocks, bufferlist);
+      break;
   }
 }
 
-void HeaderedSeededRandomGenerator
-  ::printDebugInformationForRunIdMismatchRange(uint64_t read_offset,
-                                               uint64_t start_block_offset,
-                                               uint64_t range_length_in_blocks,
-                                               const bufferlist& bufferlist)
-{
+void HeaderedSeededRandomGenerator ::printDebugInformationForRunIdMismatchRange(
+    uint64_t read_offset, uint64_t start_block_offset,
+    uint64_t range_length_in_blocks, const bufferlist& bufferlist) {
   uint64_t range_start = start_block_offset;
   uint64_t range_length = 0;
-  UniqueIdBytes initial_read_unique_run_id = readUniqueRunId(start_block_offset - read_offset,
-                                                             bufferlist);
+  UniqueIdBytes initial_read_unique_run_id =
+      readUniqueRunId(start_block_offset - read_offset, bufferlist);
   for (uint64_t i = start_block_offset;
-       i < start_block_offset + range_length_in_blocks; i++)
-  {
-    ceph_assert(getErrorTypeForBlock(read_offset, i, bufferlist)
-                == ErrorType::RUN_ID_MISMATCH);
+       i < start_block_offset + range_length_in_blocks; i++) {
+    ceph_assert(getErrorTypeForBlock(read_offset, i, bufferlist) ==
+                ErrorType::RUN_ID_MISMATCH);
 
-    UniqueIdBytes read_unique_run_id = readUniqueRunId(i - read_offset, bufferlist);
+    UniqueIdBytes read_unique_run_id =
+        readUniqueRunId(i - read_offset, bufferlist);
     if (initial_read_unique_run_id != read_unique_run_id ||
-        i == (start_block_offset + range_length_in_blocks - 1))
-    {
-      if (range_length == 1)
-      {
+        i == (start_block_offset + range_length_in_blocks - 1)) {
+      if (range_length == 1) {
         printDebugInformationForBlock(read_offset, i, bufferlist);
-      }
-      else if (range_length > 1)
-      {
-        dout(0) << fmt::format("Data (Run ID) Mismatch detected from block {} ({} bytes)"
-                    " and spanning a range of {} blocks ({} bytes). "
-                    "Expected run id {} for range but found id {}"
-                    " for all blocks in range. "
-                    "Block data corrupt or not written from this instance of this application.",
-                      range_start,
-                      range_start * m_model.get_block_size(),
-                      range_length,
-                      range_length * m_model.get_block_size(),
-                      unique_run_id,
-                      initial_read_unique_run_id) << dendl;
+      } else if (range_length > 1) {
+        dout(0)
+            << fmt::format(
+                   "Data (Run ID) Mismatch detected from block {} ({} bytes)"
+                   " and spanning a range of {} blocks ({} bytes). "
+                   "Expected run id {} for range but found id {}"
+                   " for all blocks in range. "
+                   "Block data corrupt or not written from this instance of "
+                   "this application.",
+                   range_start, range_start * m_model.get_block_size(),
+                   range_length, range_length * m_model.get_block_size(),
+                   unique_run_id, initial_read_unique_run_id)
+            << dendl;
       }
 
       range_start = i;
       range_length = 1;
       initial_read_unique_run_id = read_unique_run_id;
-    }
-    else
-    {
+    } else {
       range_length++;
     }
   }
 
-  if (range_length == 1)
-  {
-    printDebugInformationForBlock(read_offset,
-                                  start_block_offset + range_length_in_blocks - 1,
-                                  bufferlist);
-  }
-  else if (range_length > 1)
-  {
-    dout(0) << fmt::format("Data (Run ID) Mismatch detected from block {}"
-                " ({} bytes) and spanning a range of {} blocks ({} bytes). "
-                "Expected run id {} for range but found id for all blocks in range. "
-                "Block data corrupt or not written from this instance of this application.",
-                  range_start,
-                  range_start * m_model.get_block_size(),
-                  range_length,
-                  range_length * m_model.get_block_size(),
-                  unique_run_id,
-                  initial_read_unique_run_id)
+  if (range_length == 1) {
+    printDebugInformationForBlock(
+        read_offset, start_block_offset + range_length_in_blocks - 1,
+        bufferlist);
+  } else if (range_length > 1) {
+    dout(0) << fmt::format(
+                   "Data (Run ID) Mismatch detected from block {}"
+                   " ({} bytes) and spanning a range of {} blocks ({} bytes). "
+                   "Expected run id {} for range but found id for all blocks "
+                   "in range. "
+                   "Block data corrupt or not written from this instance of "
+                   "this application.",
+                   range_start, range_start * m_model.get_block_size(),
+                   range_length, range_length * m_model.get_block_size(),
+                   unique_run_id, initial_read_unique_run_id)
             << dendl;
   }
 }
 
-void HeaderedSeededRandomGenerator
-  ::printDebugInformationForSeedMismatchRange(uint64_t read_offset,
-                                              uint64_t start_block_offset,
-                                              uint64_t range_length_in_blocks,
-                                              const bufferlist& bufferlist)
-{
+void HeaderedSeededRandomGenerator ::printDebugInformationForSeedMismatchRange(
+    uint64_t read_offset, uint64_t start_block_offset,
+    uint64_t range_length_in_blocks, const bufferlist& bufferlist) {
   uint64_t range_start = start_block_offset;
   uint64_t range_length = 0;
 
   // Assert here if needed, as we can't support values
   // that can't be converted to a signed integer.
-  ceph_assert(m_model.get_block_size() < (std::numeric_limits<uint64_t>::max() / 2));
+  ceph_assert(m_model.get_block_size() <
+              (std::numeric_limits<uint64_t>::max() / 2));
   std::optional<int64_t> range_offset = 0;
 
   for (uint64_t i = start_block_offset;
-       i < start_block_offset + range_length_in_blocks; i++)
-  {
-    ceph_assert(getErrorTypeForBlock(read_offset, i, bufferlist)
-                == ErrorType::SEED_MISMATCH);
+       i < start_block_offset + range_length_in_blocks; i++) {
+    ceph_assert(getErrorTypeForBlock(read_offset, i, bufferlist) ==
+                ErrorType::SEED_MISMATCH);
     SeedBytes read_seed = readSeed(i - read_offset, bufferlist);
 
     std::vector<int> seed_found_offsets = m_model.get_seed_offsets(read_seed);
 
     if ((seed_found_offsets.size() == 1 &&
-        (static_cast<int64_t>(seed_found_offsets.front() - i) == range_offset)) ||
-        range_length == 0)
-    {
-      if (range_length == 0)
-      {
+         (static_cast<int64_t>(seed_found_offsets.front() - i) ==
+          range_offset)) ||
+        range_length == 0) {
+      if (range_length == 0) {
         range_start = i;
-        if (seed_found_offsets.size() > 0)
-        {
+        if (seed_found_offsets.size() > 0) {
           range_offset = seed_found_offsets.front() - i;
-        }
-        else
-        {
+        } else {
           range_offset = std::nullopt;
         }
       }
       range_length++;
-    }
-    else
-    {
-      if (range_length == 1)
-      {
+    } else {
+      if (range_length == 1) {
         printDebugInformationForBlock(read_offset, i - 1, bufferlist);
-      }
-      else if (range_length > 1 && range_offset.has_value())
-      {
-        dout(0) << fmt::format("Data (Seed) Mismatch detected from block {}"
-                    " ({} bytes) and spanning a range of {} blocks ({} bytes). "
-                    "Returned data located starting from block {} ({} bytes) "
-                    "and spanning a range of {} blocks ({} bytes).",
-                      range_start,
-                      range_start * m_model.get_block_size(),
-                      range_length, range_length * m_model.get_block_size(),
-                      static_cast<uint64_t>(*range_offset) + range_start,
-                      (static_cast<uint64_t>(*range_offset) + range_start)
-                        * m_model.get_block_size(),
-                      range_length,
-                      range_length * m_model.get_block_size())
-                << dendl;
-      }
-      else
-      {
-        dout(0) << fmt::format("Data (Seed) Mismatch detected from block {}"
-                    " ({} bytes) and spanning a range of {} blocks ({} bytes). "
-                    "Data seed mismatch spanning a range of {} blocks ({} bytes).",
-                      range_start,
-                      range_start * m_model.get_block_size(),
-                      range_length, range_length * m_model.get_block_size(),
-                      range_length,
-                      range_length * m_model.get_block_size())
-                << dendl;
+      } else if (range_length > 1 && range_offset.has_value()) {
+        dout(0)
+            << fmt::format(
+                   "Data (Seed) Mismatch detected from block {}"
+                   " ({} bytes) and spanning a range of {} blocks ({} bytes). "
+                   "Returned data located starting from block {} ({} bytes) "
+                   "and spanning a range of {} blocks ({} bytes).",
+                   range_start, range_start * m_model.get_block_size(),
+                   range_length, range_length * m_model.get_block_size(),
+                   static_cast<uint64_t>(*range_offset) + range_start,
+                   (static_cast<uint64_t>(*range_offset) + range_start) *
+                       m_model.get_block_size(),
+                   range_length, range_length * m_model.get_block_size())
+            << dendl;
+      } else {
+        dout(0)
+            << fmt::format(
+                   "Data (Seed) Mismatch detected from block {}"
+                   " ({} bytes) and spanning a range of {} blocks ({} bytes). "
+                   "Data seed mismatch spanning a range of {} blocks ({} "
+                   "bytes).",
+                   range_start, range_start * m_model.get_block_size(),
+                   range_length, range_length * m_model.get_block_size(),
+                   range_length, range_length * m_model.get_block_size())
+            << dendl;
       }
       range_length = 1;
       range_start = i;
-      if (seed_found_offsets.size() > 0)
-      {
+      if (seed_found_offsets.size() > 0) {
         range_offset = seed_found_offsets.front() - i;
-      }
-      else
-      {
+      } else {
         range_offset = std::nullopt;
       }
     }
   }
 
-  if (range_length == 1)
-  {
-    printDebugInformationForBlock(read_offset,
-                                  start_block_offset + range_length_in_blocks - 1,
-                                  bufferlist);
-  }
-  else if (range_length > 1 && range_offset.has_value())
-  {
-    dout(0) << fmt::format("Data (Seed) Mismatch detected from block {} ({} bytes) "
-                "and spanning a range of {} blocks ({} bytes). "
-                "Returned data located starting from block {} ({} bytes) "
-                "and spanning a range of {} blocks ({} bytes).",
-                  range_start,
-                  range_start * m_model.get_block_size(),
-                  range_length,
-                  range_length * m_model.get_block_size(),
-                  *range_offset + range_start,
-                  (*range_offset + range_start) * m_model.get_block_size(),
-                  range_length,
-                  range_length * m_model.get_block_size())
+  if (range_length == 1) {
+    printDebugInformationForBlock(
+        read_offset, start_block_offset + range_length_in_blocks - 1,
+        bufferlist);
+  } else if (range_length > 1 && range_offset.has_value()) {
+    dout(0) << fmt::format(
+                   "Data (Seed) Mismatch detected from block {} ({} bytes) "
+                   "and spanning a range of {} blocks ({} bytes). "
+                   "Returned data located starting from block {} ({} bytes) "
+                   "and spanning a range of {} blocks ({} bytes).",
+                   range_start, range_start * m_model.get_block_size(),
+                   range_length, range_length * m_model.get_block_size(),
+                   *range_offset + range_start,
+                   (*range_offset + range_start) * m_model.get_block_size(),
+                   range_length, range_length * m_model.get_block_size())
             << dendl;
-  }
-  else
-  {
-    dout(0) << fmt::format("Data (Seed) Mismatch detected from block {} ({} bytes) "
-                "and spanning a range of {} blocks ({} bytes). "
-                "and spanning a range of {} blocks ({} bytes).",
-                  range_start,
-                  range_start * m_model.get_block_size(),
-                  range_length,
-                  range_length * m_model.get_block_size(),
-                  range_length,
-                  range_length * m_model.get_block_size())
+  } else {
+    dout(0) << fmt::format(
+                   "Data (Seed) Mismatch detected from block {} ({} bytes) "
+                   "and spanning a range of {} blocks ({} bytes). "
+                   "and spanning a range of {} blocks ({} bytes).",
+                   range_start, range_start * m_model.get_block_size(),
+                   range_length, range_length * m_model.get_block_size(),
+                   range_length, range_length * m_model.get_block_size())
             << dendl;
   }
 }
 
-void HeaderedSeededRandomGenerator
-::printDebugInformationDataBodyMismatchRange(uint64_t read_offset,
-                                             uint64_t start_block_offset,
-                                             uint64_t range_length_in_blocks,
-                                             const bufferlist& bufferlist)
-{
-  dout(0) << fmt::format("Data Mismatch detected in blocks from {} to {}. "
-              "Headers look as expected for range, "
-              "but generated data body does not match. "
-              "More information given for individual blocks below.",
-                start_block_offset,
-                start_block_offset + range_length_in_blocks - 1)
+void HeaderedSeededRandomGenerator ::printDebugInformationDataBodyMismatchRange(
+    uint64_t read_offset, uint64_t start_block_offset,
+    uint64_t range_length_in_blocks, const bufferlist& bufferlist) {
+  dout(0) << fmt::format(
+                 "Data Mismatch detected in blocks from {} to {}. "
+                 "Headers look as expected for range, "
+                 "but generated data body does not match. "
+                 "More information given for individual blocks below.",
+                 start_block_offset,
+                 start_block_offset + range_length_in_blocks - 1)
           << dendl;
 
   for (uint64_t i = start_block_offset;
-       i < start_block_offset + range_length_in_blocks; i++)
-  {
+       i < start_block_offset + range_length_in_blocks; i++) {
     printDebugInformationForBlock(read_offset, i, bufferlist);
   }
 }
 
-void HeaderedSeededRandomGenerator
-  ::printDebugInformationCorruptRange(uint64_t read_offset,
-                                      uint64_t start_block_offset,
-                                      uint64_t range_length_in_blocks,
-                                      const bufferlist& bufferlist)
-{
-  dout(0) << fmt::format("Data Mismatch detected in blocks from {} to {}. "
-              "Headers look as expected for range, "
-              "but generated data body does not match. "
-              "More information given for individual blocks below.",
-                start_block_offset,
-                start_block_offset + range_length_in_blocks - 1)
+void HeaderedSeededRandomGenerator ::printDebugInformationCorruptRange(
+    uint64_t read_offset, uint64_t start_block_offset,
+    uint64_t range_length_in_blocks, const bufferlist& bufferlist) {
+  dout(0) << fmt::format(
+                 "Data Mismatch detected in blocks from {} to {}. "
+                 "Headers look as expected for range, "
+                 "but generated data body does not match. "
+                 "More information given for individual blocks below.",
+                 start_block_offset,
+                 start_block_offset + range_length_in_blocks - 1)
           << dendl;
 
   for (uint64_t i = start_block_offset;
-       i < start_block_offset + range_length_in_blocks; i++)
-  {
+       i < start_block_offset + range_length_in_blocks; i++) {
     printDebugInformationForBlock(read_offset, i, bufferlist);
   }
 }
 
-void HeaderedSeededRandomGenerator
-  ::printDebugInformationDataNotFoundRange(uint64_t read_offset,
-                                           uint64_t start_block_offset,
-                                           uint64_t range_length_in_blocks,
-                                           const bufferlist& bufferlist)
-{
-  dout(0) << fmt::format("Data not found for blocks from {} to {}. "
-              "More information given for individual blocks below.",
-                start_block_offset,
-                start_block_offset + range_length_in_blocks - 1)
+void HeaderedSeededRandomGenerator ::printDebugInformationDataNotFoundRange(
+    uint64_t read_offset, uint64_t start_block_offset,
+    uint64_t range_length_in_blocks, const bufferlist& bufferlist) {
+  dout(0) << fmt::format(
+                 "Data not found for blocks from {} to {}. "
+                 "More information given for individual blocks below.",
+                 start_block_offset,
+                 start_block_offset + range_length_in_blocks - 1)
           << dendl;
 
-  for (uint64_t i = start_block_offset; i < start_block_offset + range_length_in_blocks; i++)
-  {
+  for (uint64_t i = start_block_offset;
+       i < start_block_offset + range_length_in_blocks; i++) {
     printDebugInformationForBlock(read_offset, i, bufferlist);
   }
 }
 
-void HeaderedSeededRandomGenerator
-  ::printDebugInformationForOffsets(uint64_t read_offset,
-                                    std::vector<uint64_t> offsets,
-                                    const bufferlist& bufferlist)
-{
+void HeaderedSeededRandomGenerator ::printDebugInformationForOffsets(
+    uint64_t read_offset, std::vector<uint64_t> offsets,
+    const bufferlist& bufferlist) {
   uint64_t range_start = 0;
   uint64_t range_length = 0;
   ErrorType rangeError = ErrorType::UNKNOWN;
 
-  for (const uint64_t& block_offset : offsets)
-  {
-    ErrorType blockError = getErrorTypeForBlock(read_offset, block_offset,
-                                                bufferlist);
+  for (const uint64_t& block_offset : offsets) {
+    ErrorType blockError =
+        getErrorTypeForBlock(read_offset, block_offset, bufferlist);
 
-    if (range_start == 0 && range_length == 0)
-    {
+    if (range_start == 0 && range_length == 0) {
       range_start = block_offset;
       range_length = 1;
       rangeError = blockError;
-    }
-    else if (blockError == rangeError &&
-             range_start + range_length == block_offset)
-{
+    } else if (blockError == rangeError &&
+               range_start + range_length == block_offset) {
       range_length++;
-    }
-    else
-    {
-      if (range_length == 1)
-      {
+    } else {
+      if (range_length == 1) {
         printDebugInformationForBlock(read_offset, range_start, bufferlist);
-      }
-      else if (range_length > 1)
-      {
+      } else if (range_length > 1) {
         printDebugInformationForRange(read_offset, range_start, range_length,
                                       rangeError, bufferlist);
       }
@@ -741,12 +644,9 @@ void HeaderedSeededRandomGenerator
     }
   }
 
-  if (range_length == 1)
-  {
+  if (range_length == 1) {
     printDebugInformationForBlock(read_offset, range_start, bufferlist);
-  }
-  else if (range_length > 1)
-  {
+  } else if (range_length > 1) {
     printDebugInformationForRange(read_offset, range_start, range_length,
                                   rangeError, bufferlist);
   }
diff --git a/src/common/io_exerciser/DataGenerator.h b/src/common/io_exerciser/DataGenerator.h
index 1e5784a54cc..c497c78ed61 100644
--- a/src/common/io_exerciser/DataGenerator.h
+++ b/src/common/io_exerciser/DataGenerator.h
@@ -3,8 +3,8 @@
 #include <memory>
 #include <random>
 
-#include "include/buffer.h"
 #include "ObjectModel.h"
+#include "include/buffer.h"
 
 /* Overview
  *
@@ -23,149 +23,139 @@
  *
  * class HeaderedSeededRandomGenerator
  *   Inherits from SeededDataGenerator. Generates entirely random patterns
- *   based on the seed retrieved by the model, however also appends a 
+ *   based on the seed retrieved by the model, however also appends a
  *   header to the start of each block. This generator also provides
  *   a range of verbose debug options to help disagnose a miscompare
  *   whenever it detects unexpected data.
  */
 
 namespace ceph {
-  namespace io_exerciser {
-    namespace data_generation {
-      enum class GenerationType {
-        SeededRandom,
-        HeaderedSeededRandom
-        // CompressedGenerator
-        // MixedGenerator
-      };
-
-      class DataGenerator {
-      public:
-        virtual ~DataGenerator() = default;
-        static std::unique_ptr<DataGenerator>
-          create_generator(GenerationType generatorType,
-                           const ObjectModel& model);
-        virtual bufferlist generate_data(uint64_t length, uint64_t offset)=0;
-        virtual bool validate(bufferlist& bufferlist, uint64_t offset,
-                              uint64_t length);
-
-        // Used for testing debug outputs from data generation
-        virtual bufferlist generate_wrong_data(uint64_t offset, uint64_t length);
-
-      protected:
-        const ObjectModel& m_model;
-
-        DataGenerator(const ObjectModel& model) : m_model(model) {}
-      };
-
-      class SeededRandomGenerator : public DataGenerator
-      {
-        public:
-          SeededRandomGenerator(const ObjectModel& model)
-            : DataGenerator(model) {}
-
-          virtual bufferptr generate_block(uint64_t offset);
-          virtual bufferlist generate_data(uint64_t length, uint64_t offset);
-          virtual bufferptr generate_wrong_block(uint64_t offset);
-          virtual bufferlist generate_wrong_data(uint64_t offset, uint64_t length) override;
-      };
-
-      class HeaderedSeededRandomGenerator : public SeededRandomGenerator
-      {
-        public:
-          HeaderedSeededRandomGenerator(const ObjectModel& model,
-                                        std::optional<uint64_t> unique_run_id = std::nullopt);
-
-          bufferptr generate_block(uint64_t offset) override;
-          bufferptr generate_wrong_block(uint64_t offset) override;
-          bool validate(bufferlist& bufferlist, uint64_t offset,
-                        uint64_t length) override;
-
-        private:
-          using UniqueIdBytes = uint64_t;
-          using SeedBytes = int;
-          using TimeBytes = uint64_t;
-
-          enum class ErrorType {
-            RUN_ID_MISMATCH,
-            SEED_MISMATCH,
-            DATA_MISMATCH,
-            DATA_NOT_FOUND,
-            UNKNOWN
-          };
-
-          constexpr uint8_t headerStart() const
-            { return 0; };
-          constexpr uint8_t uniqueIdStart() const
-            { return headerStart(); };
-          constexpr uint8_t uniqueIdLength() const
-            { return sizeof(UniqueIdBytes); };
-          constexpr uint8_t seedStart() const
-            { return uniqueIdStart() + uniqueIdLength(); };
-          constexpr uint8_t seedLength() const
-            { return sizeof(SeedBytes); };
-          constexpr uint8_t timeStart() const
-            { return seedStart() + seedLength(); };
-          constexpr uint8_t timeLength() const
-            { return sizeof(TimeBytes); };
-          constexpr uint8_t timeEnd() const
-            { return timeStart() + timeLength(); };
-          constexpr uint8_t headerLength() const
-            { return uniqueIdLength() + seedLength() + timeLength(); };
-          constexpr uint8_t bodyStart() const
-            { return headerStart() + headerLength(); };
-
-          const UniqueIdBytes readUniqueRunId(uint64_t block_offset,
-                                              const bufferlist& bufferlist);
-          const SeedBytes readSeed(uint64_t block_offset,
-                                   const bufferlist& bufferlist);
-          const TimeBytes readDateTime(uint64_t block_offset,
+namespace io_exerciser {
+namespace data_generation {
+enum class GenerationType {
+  SeededRandom,
+  HeaderedSeededRandom
+  // CompressedGenerator
+  // MixedGenerator
+};
+
+class DataGenerator {
+ public:
+  virtual ~DataGenerator() = default;
+  static std::unique_ptr<DataGenerator> create_generator(
+      GenerationType generatorType, const ObjectModel& model);
+  virtual bufferlist generate_data(uint64_t length, uint64_t offset) = 0;
+  virtual bool validate(bufferlist& bufferlist, uint64_t offset,
+                        uint64_t length);
+
+  // Used for testing debug outputs from data generation
+  virtual bufferlist generate_wrong_data(uint64_t offset, uint64_t length);
+
+ protected:
+  const ObjectModel& m_model;
+
+  DataGenerator(const ObjectModel& model) : m_model(model) {}
+};
+
+class SeededRandomGenerator : public DataGenerator {
+ public:
+  SeededRandomGenerator(const ObjectModel& model) : DataGenerator(model) {}
+
+  virtual bufferptr generate_block(uint64_t offset);
+  bufferlist generate_data(uint64_t length, uint64_t offset) override;
+  virtual bufferptr generate_wrong_block(uint64_t offset);
+  bufferlist generate_wrong_data(uint64_t offset,
+                                         uint64_t length) override;
+};
+
+class HeaderedSeededRandomGenerator : public SeededRandomGenerator {
+ public:
+  HeaderedSeededRandomGenerator(
+      const ObjectModel& model,
+      std::optional<uint64_t> unique_run_id = std::nullopt);
+
+  bufferptr generate_block(uint64_t offset) override;
+  bufferptr generate_wrong_block(uint64_t offset) override;
+  bool validate(bufferlist& bufferlist, uint64_t offset,
+                uint64_t length) override;
+
+ private:
+  using UniqueIdBytes = uint64_t;
+  using SeedBytes = int;
+  using TimeBytes = uint64_t;
+
+  enum class ErrorType {
+    RUN_ID_MISMATCH,
+    SEED_MISMATCH,
+    DATA_MISMATCH,
+    DATA_NOT_FOUND,
+    UNKNOWN
+  };
+
+  constexpr uint8_t headerStart() const { return 0; };
+  constexpr uint8_t uniqueIdStart() const { return headerStart(); };
+  constexpr uint8_t uniqueIdLength() const { return sizeof(UniqueIdBytes); };
+  constexpr uint8_t seedStart() const {
+    return uniqueIdStart() + uniqueIdLength();
+  };
+  constexpr uint8_t seedLength() const { return sizeof(SeedBytes); };
+  constexpr uint8_t timeStart() const { return seedStart() + seedLength(); };
+  constexpr uint8_t timeLength() const { return sizeof(TimeBytes); };
+  constexpr uint8_t timeEnd() const { return timeStart() + timeLength(); };
+  constexpr uint8_t headerLength() const {
+    return uniqueIdLength() + seedLength() + timeLength();
+  };
+  constexpr uint8_t bodyStart() const {
+    return headerStart() + headerLength();
+  };
+
+  const UniqueIdBytes readUniqueRunId(uint64_t block_offset,
+                                      const bufferlist& bufferlist);
+  const SeedBytes readSeed(uint64_t block_offset, const bufferlist& bufferlist);
+  const TimeBytes readDateTime(uint64_t block_offset,
+                               const bufferlist& bufferlist);
+
+  const UniqueIdBytes unique_run_id;
+
+  uint64_t generate_unique_run_id();
+
+  bool validate_block(uint64_t block_offset, const char* buffer_start);
+
+  const ErrorType getErrorTypeForBlock(uint64_t read_offset,
+                                       uint64_t block_offset,
                                        const bufferlist& bufferlist);
 
-          const UniqueIdBytes unique_run_id;
-
-          uint64_t generate_unique_run_id();
-
-          bool validate_block(uint64_t block_offset, const char* buffer_start);
-
-          const ErrorType getErrorTypeForBlock(uint64_t read_offset,
-                                               uint64_t block_offset,
-                                               const bufferlist& bufferlist);
-
-          void printDebugInformationForBlock(uint64_t read_offset,
-                                             uint64_t block_offset,
-                                             const bufferlist& bufferlist);
-          void printDebugInformationForRange(uint64_t read_offset,
-                                             uint64_t start_block_offset,
-                                             uint64_t range_length_in_blocks,
-                                             ErrorType rangeError,
-                                             const bufferlist& bufferlist);
-
-          void printDebugInformationForRunIdMismatchRange(uint64_t read_offset,
-                                                          uint64_t start_block_offset,
-                                                          uint64_t range_length_in_blocks,
-                                                          const bufferlist& bufferlist);
-          void printDebugInformationForSeedMismatchRange(uint64_t read_offset,
-                                                         uint64_t start_block_offset,
-                                                         uint64_t range_length_in_blocks,
-                                                         const bufferlist& bufferlist);
-          void printDebugInformationDataBodyMismatchRange(uint64_t read_offset,
-                                                          uint64_t start_block_offset,
-                                                          uint64_t range_length_in_blocks,
-                                                          const bufferlist& bufferlist);
-          void printDebugInformationDataNotFoundRange(uint64_t ßread_offset,
-                                                      uint64_t start_block_offset,
-                                                      uint64_t range_length_in_blocks,
-                                                      const bufferlist& bufferlist);
-          void printDebugInformationCorruptRange(uint64_t read_offset,
-                                                 uint64_t start_block_offset,
-                                                 uint64_t range_length_in_blocks,
-                                                 const bufferlist& bufferlist);
-
-          void printDebugInformationForOffsets(uint64_t read_offset,
-                                               std::vector<uint64_t> offsets,
-                                               const bufferlist& bufferlist);
-      };
-    }
-  }
-}
+  void printDebugInformationForBlock(uint64_t read_offset,
+                                     uint64_t block_offset,
+                                     const bufferlist& bufferlist);
+  void printDebugInformationForRange(uint64_t read_offset,
+                                     uint64_t start_block_offset,
+                                     uint64_t range_length_in_blocks,
+                                     ErrorType rangeError,
+                                     const bufferlist& bufferlist);
+
+  void printDebugInformationForRunIdMismatchRange(
+      uint64_t read_offset, uint64_t start_block_offset,
+      uint64_t range_length_in_blocks, const bufferlist& bufferlist);
+  void printDebugInformationForSeedMismatchRange(
+      uint64_t read_offset, uint64_t start_block_offset,
+      uint64_t range_length_in_blocks, const bufferlist& bufferlist);
+  void printDebugInformationDataBodyMismatchRange(
+      uint64_t read_offset, uint64_t start_block_offset,
+      uint64_t range_length_in_blocks, const bufferlist& bufferlist);
+  void printDebugInformationDataNotFoundRange(uint64_t ßread_offset,
+                                              uint64_t start_block_offset,
+                                              uint64_t range_length_in_blocks,
+                                              const bufferlist& bufferlist);
+  void printDebugInformationCorruptRange(uint64_t read_offset,
+                                         uint64_t start_block_offset,
+                                         uint64_t range_length_in_blocks,
+                                         const bufferlist& bufferlist);
+
+  void printDebugInformationForOffsets(uint64_t read_offset,
+                                       std::vector<uint64_t> offsets,
+                                       const bufferlist& bufferlist);
+};
+}  // namespace data_generation
+}  // namespace io_exerciser
+}  // namespace ceph
diff --git a/src/common/io_exerciser/EcIoSequence.cc b/src/common/io_exerciser/EcIoSequence.cc
new file mode 100644
index 00000000000..611920c96e0
--- /dev/null
+++ b/src/common/io_exerciser/EcIoSequence.cc
@@ -0,0 +1,267 @@
+#include "EcIoSequence.h"
+
+#include <memory>
+
+using IoOp = ceph::io_exerciser::IoOp;
+using Sequence = ceph::io_exerciser::Sequence;
+using IoSequence = ceph::io_exerciser::IoSequence;
+using EcIoSequence = ceph::io_exerciser::EcIoSequence;
+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,
+    int seed) {
+  switch (sequence) {
+    case Sequence::SEQUENCE_SEQ0:
+      [[fallthrough]];
+    case Sequence::SEQUENCE_SEQ1:
+      [[fallthrough]];
+    case Sequence::SEQUENCE_SEQ2:
+      [[fallthrough]];
+    case Sequence::SEQUENCE_SEQ3:
+      [[fallthrough]];
+    case Sequence::SEQUENCE_SEQ4:
+      [[fallthrough]];
+    case Sequence::SEQUENCE_SEQ5:
+      [[fallthrough]];
+    case Sequence::SEQUENCE_SEQ6:
+      [[fallthrough]];
+    case Sequence::SEQUENCE_SEQ7:
+      [[fallthrough]];
+    case Sequence::SEQUENCE_SEQ8:
+      [[fallthrough]];
+    case Sequence::SEQUENCE_SEQ9:
+      return std::make_unique<ReadInjectSequence>(obj_size_range, seed,
+                                                  sequence, k, m);
+    case Sequence::SEQUENCE_SEQ10:
+      return std::make_unique<Seq10>(obj_size_range, seed, k, m);
+    default:
+      ceph_abort_msg("Unrecognised sequence");
+  }
+}
+
+EcIoSequence::EcIoSequence(std::pair<int, int> obj_size_range, int seed)
+    : IoSequence(obj_size_range, seed),
+      setup_inject(false),
+      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);
+  setup_inject = true;
+}
+
+void EcIoSequence::select_random_data_shard_to_inject_write_error(int k,
+                                                                  int m) {
+  // Write errors do not support injecting to the primary OSD
+  shard_to_inject = rng(1, k - 1);
+  setup_inject = true;
+}
+
+void EcIoSequence::select_random_shard_to_inject_read_error(int k, int m) {
+  shard_to_inject = rng(k + m - 1);
+  setup_inject = true;
+}
+
+void EcIoSequence::select_random_shard_to_inject_write_error(int k, int m) {
+  // Write errors do not support injecting to the primary OSD
+  shard_to_inject = rng(1, k + m - 1);
+  setup_inject = true;
+}
+
+void EcIoSequence::generate_random_read_inject_type() {
+  inject_op_type = static_cast<InjectOpType>(
+      rng(static_cast<int>(InjectOpType::ReadEIO),
+          static_cast<int>(InjectOpType::ReadMissingShard)));
+}
+
+void EcIoSequence::generate_random_write_inject_type() {
+  inject_op_type = static_cast<InjectOpType>(
+      rng(static_cast<int>(InjectOpType::WriteFailAndRollback),
+          static_cast<int>(InjectOpType::WriteOSDAbort)));
+}
+
+ceph::io_exerciser::ReadInjectSequence::ReadInjectSequence(
+    std::pair<int, int> obj_size_range, int seed, Sequence s, int k, int m)
+    : 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);
+  generate_random_read_inject_type();
+}
+
+Sequence ceph::io_exerciser::ReadInjectSequence::get_id() const {
+  return child_sequence->get_id();
+}
+
+std::string ceph::io_exerciser::ReadInjectSequence::get_name() const {
+  return child_sequence->get_name() +
+         " running with read errors injected on shard " +
+         std::to_string(*shard_to_inject);
+}
+
+std::unique_ptr<IoOp> ReadInjectSequence::next() {
+  step++;
+
+  if (nextOp) {
+    std::unique_ptr<IoOp> retOp = nullptr;
+    nextOp.swap(retOp);
+    return retOp;
+  }
+
+  std::unique_ptr<IoOp> childOp = child_sequence->next();
+
+  switch (childOp->getOpType()) {
+    case OpType::Remove:
+      nextOp.swap(childOp);
+      switch (inject_op_type) {
+        case InjectOpType::ReadEIO:
+          return ClearReadErrorInjectOp::generate(*shard_to_inject, 0);
+        case InjectOpType::ReadMissingShard:
+          return ClearReadErrorInjectOp::generate(*shard_to_inject, 1);
+        case InjectOpType::WriteFailAndRollback:
+          return ClearWriteErrorInjectOp::generate(*shard_to_inject, 0);
+        case InjectOpType::WriteOSDAbort:
+          return ClearWriteErrorInjectOp::generate(*shard_to_inject, 3);
+        case InjectOpType::None:
+          [[fallthrough]];
+        default:
+          ceph_abort_msg("Unsupported operation");
+      }
+      break;
+    case OpType::Create:
+      switch (inject_op_type) {
+        case InjectOpType::ReadEIO:
+          nextOp = InjectReadErrorOp::generate(
+              *shard_to_inject, 0, 0, std::numeric_limits<uint64_t>::max());
+          break;
+        case InjectOpType::ReadMissingShard:
+          nextOp = InjectReadErrorOp::generate(
+              *shard_to_inject, 1, 0, std::numeric_limits<uint64_t>::max());
+          break;
+        case InjectOpType::WriteFailAndRollback:
+          nextOp = InjectWriteErrorOp::generate(
+              *shard_to_inject, 0, 0, std::numeric_limits<uint64_t>::max());
+          break;
+        case InjectOpType::WriteOSDAbort:
+          nextOp = InjectWriteErrorOp::generate(
+              *shard_to_inject, 3, 0, std::numeric_limits<uint64_t>::max());
+          break;
+        case InjectOpType::None:
+          [[fallthrough]];
+        default:
+          ceph_abort_msg("Unsupported operation");
+      }
+      break;
+    default:
+      // Do nothing in default case
+      break;
+  }
+
+  return childOp;
+}
+
+std::unique_ptr<ceph::io_exerciser::IoOp>
+ceph::io_exerciser::ReadInjectSequence::_next() {
+  ceph_abort_msg(
+      "Should not reach this point, "
+      "this sequence should only consume complete sequences");
+
+  return DoneOp::generate();
+}
+
+ceph::io_exerciser::Seq10::Seq10(std::pair<int, int> obj_size_range, int seed,
+                                 int k, int m)
+    : EcIoSequence(obj_size_range, seed),
+      offset(0),
+      length(1),
+      inject_error_done(false),
+      failed_write_done(false),
+      read_done(false),
+      successful_write_done(false),
+      test_all_lengths(false),  // Only test length(1) due to time constraints
+      test_all_sizes(
+          false)  // Only test obj_size(rand()) due to time constraints
+{
+  select_random_shard_to_inject_write_error(k, m);
+  // We will inject specifically as part of our sequence in this sequence
+  setup_inject = false;
+  if (!test_all_sizes) {
+    select_random_object_size();
+  }
+}
+
+Sequence ceph::io_exerciser::Seq10::get_id() const {
+  return Sequence::SEQUENCE_SEQ10;
+}
+
+std::string ceph::io_exerciser::Seq10::get_name() const {
+  return "Sequential writes of length " + std::to_string(length) +
+         " with queue depth 1"
+         " first injecting a failed write and read it to ensure it rolls back, "
+         "then"
+         " successfully writing the data and reading the write the ensure it "
+         "is applied";
+}
+
+std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq10::_next() {
+  if (!inject_error_done) {
+    inject_error_done = true;
+    return InjectWriteErrorOp::generate(*shard_to_inject, 0, 0,
+                                        std::numeric_limits<uint64_t>::max());
+  } else if (!failed_write_done) {
+    failed_write_done = true;
+    read_done = false;
+    barrier = true;
+    return SingleFailedWriteOp::generate(offset, length);
+  } else if (failed_write_done && !read_done) {
+    read_done = true;
+    barrier = true;
+    return SingleReadOp::generate(offset, length);
+  } else if (!clear_inject_done) {
+    clear_inject_done = true;
+    return ClearWriteErrorInjectOp::generate(*shard_to_inject, 0);
+  } else if (!successful_write_done) {
+    successful_write_done = true;
+    read_done = false;
+    barrier = true;
+    return SingleWriteOp::generate(offset, length);
+  } else if (successful_write_done && !read_done) {
+    read_done = true;
+    return SingleReadOp::generate(offset, length);
+  } else if (successful_write_done && read_done) {
+    offset++;
+    inject_error_done = false;
+    failed_write_done = false;
+    read_done = false;
+    clear_inject_done = false;
+    successful_write_done = false;
+
+    if (offset + length >= obj_size) {
+      if (!test_all_lengths) {
+        remove = true;
+        done = true;
+        return BarrierOp::generate();
+      }
+
+      offset = 0;
+      length++;
+      if (length > obj_size) {
+        if (!test_all_sizes) {
+          remove = true;
+          done = true;
+          return BarrierOp::generate();
+        }
+
+        length = 1;
+        return increment_object_size();
+      }
+    }
+
+    return BarrierOp::generate();
+  } else {
+    ceph_abort_msg("Sequence in undefined state. Aborting");
+    return DoneOp::generate();
+  }
+}
\ No newline at end of file
diff --git a/src/common/io_exerciser/EcIoSequence.h b/src/common/io_exerciser/EcIoSequence.h
new file mode 100644
index 00000000000..37283b3906b
--- /dev/null
+++ b/src/common/io_exerciser/EcIoSequence.h
@@ -0,0 +1,65 @@
+#include "IoSequence.h"
+
+namespace ceph {
+namespace io_exerciser {
+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);
+
+ 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);
+
+  // 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 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);
+
+  Sequence get_id() const override;
+  std::string get_name() const override;
+  virtual std::unique_ptr<IoOp> next() override;
+  std::unique_ptr<IoOp> _next() override;
+
+ private:
+  std::unique_ptr<IoSequence> child_sequence;
+  std::unique_ptr<IoOp> nextOp;
+};
+
+class Seq10 : public EcIoSequence {
+ public:
+  Seq10(std::pair<int, int> obj_size_range, int seed, int k, int m);
+
+  Sequence get_id() const override;
+  std::string get_name() const override;
+  std::unique_ptr<IoOp> _next() override;
+
+ private:
+  uint64_t offset;
+  uint64_t length;
+
+  bool inject_error_done;
+  bool failed_write_done;
+  bool read_done;
+  bool clear_inject_done;
+  bool successful_write_done;
+  bool test_all_lengths;
+  bool test_all_sizes;
+};
+}  // namespace io_exerciser
+}  // namespace ceph
\ No newline at end of file
diff --git a/src/common/io_exerciser/IoOp.cc b/src/common/io_exerciser/IoOp.cc
index cd855ba6fff..493d1f435b4 100644
--- a/src/common/io_exerciser/IoOp.cc
+++ b/src/common/io_exerciser/IoOp.cc
@@ -1,188 +1,316 @@
 #include "IoOp.h"
 
-using IoOp = ceph::io_exerciser::IoOp;
+#include "fmt/format.h"
+#include "include/ceph_assert.h"
 
-IoOp::IoOp( OpType op,
-            uint64_t offset1, uint64_t length1,
-            uint64_t offset2, uint64_t length2,
-            uint64_t offset3, uint64_t length3) :
-  op(op),
-  offset1(offset1), length1(length1),
-  offset2(offset2), length2(length2),
-  offset3(offset3), length3(length3)
-{
+using IoOp = ceph::io_exerciser::IoOp;
+using OpType = ceph::io_exerciser::OpType;
 
-}
+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 SingleReadOp = ceph::io_exerciser::SingleReadOp;
+using DoubleReadOp = ceph::io_exerciser::DoubleReadOp;
+using TripleReadOp = ceph::io_exerciser::TripleReadOp;
+using SingleWriteOp = ceph::io_exerciser::SingleWriteOp;
+using DoubleWriteOp = ceph::io_exerciser::DoubleWriteOp;
+using TripleWriteOp = ceph::io_exerciser::TripleWriteOp;
+using SingleFailedWriteOp = ceph::io_exerciser::SingleFailedWriteOp;
+using DoubleFailedWriteOp = ceph::io_exerciser::DoubleFailedWriteOp;
+using TripleFailedWriteOp = ceph::io_exerciser::TripleFailedWriteOp;
 
-std::string IoOp::value_to_string(uint64_t v) const
-{
+namespace {
+std::string value_to_string(uint64_t v) {
   if (v < 1024 || (v % 1024) != 0) {
     return std::to_string(v);
-  }else if (v < 1024*1024 || (v % (1024 * 1024)) != 0 ) {
+  } else if (v < 1024 * 1024 || (v % (1024 * 1024)) != 0) {
     return std::to_string(v / 1024) + "K";
-  }else{
+  } else {
     return std::to_string(v / 1024 / 1024) + "M";
   }
 }
+}  // namespace
 
-std::unique_ptr<IoOp> IoOp
-  ::generate_done() {
+IoOp::IoOp() {}
 
-    return std::make_unique<IoOp>(OpType::Done);
-}
+template <OpType opType>
+ceph::io_exerciser::TestOp<opType>::TestOp() : IoOp() {}
+
+DoneOp::DoneOp() : TestOp<OpType::Done>() {}
 
-std::unique_ptr<IoOp> IoOp
-  ::generate_barrier() {
+std::string DoneOp::to_string(uint64_t block_size) const { return "Done"; }
 
-  return std::make_unique<IoOp>(OpType::BARRIER);
+std::unique_ptr<DoneOp> DoneOp::generate() {
+  return std::make_unique<DoneOp>();
 }
 
-std::unique_ptr<IoOp> IoOp
-  ::generate_create(uint64_t size) {
+BarrierOp::BarrierOp() : TestOp<OpType::Barrier>() {}
 
-  return std::make_unique<IoOp>(OpType::CREATE,0,size);
+std::unique_ptr<BarrierOp> BarrierOp::generate() {
+  return std::make_unique<BarrierOp>();
 }
 
-std::unique_ptr<IoOp> IoOp
-  ::generate_remove() {
-
-  return std::make_unique<IoOp>(OpType::REMOVE);
+std::string BarrierOp::to_string(uint64_t block_size) const {
+  return "Barrier";
 }
 
-std::unique_ptr<IoOp> IoOp
-  ::generate_read(uint64_t offset, uint64_t length) {
+CreateOp::CreateOp(uint64_t size) : TestOp<OpType::Create>(), size(size) {}
 
-  return std::make_unique<IoOp>(OpType::READ, offset, length);
+std::unique_ptr<CreateOp> CreateOp::generate(uint64_t size) {
+  return std::make_unique<CreateOp>(size);
 }
 
-std::unique_ptr<IoOp> IoOp
-  ::generate_read2(uint64_t offset1, uint64_t length1,
-                   uint64_t offset2, uint64_t length2) {
+std::string CreateOp::to_string(uint64_t block_size) const {
+  return "Create (size=" + value_to_string(size * block_size) + ")";
+}
 
-  if (offset1 < offset2) {
-    ceph_assert( offset1 + length1 <= offset2 );
-  } else {
-    ceph_assert( offset2 + length2 <= offset1 );
-  }
+RemoveOp::RemoveOp() : TestOp<OpType::Remove>() {}
 
-  return std::make_unique<IoOp>(OpType::READ2,
-                                offset1, length1,
-                                offset2, length2);
+std::unique_ptr<RemoveOp> RemoveOp::generate() {
+  return std::make_unique<RemoveOp>();
 }
 
-std::unique_ptr<IoOp> IoOp
-  ::generate_read3(uint64_t offset1, uint64_t length1,
-                   uint64_t offset2, uint64_t length2,
-                   uint64_t offset3, uint64_t length3) {
+std::string RemoveOp::to_string(uint64_t block_size) const { return "Remove"; }
 
-  if (offset1 < offset2) {
-    ceph_assert( offset1 + length1 <= offset2 );
-  } else {
-    ceph_assert( offset2 + length2 <= offset1 );
+template <OpType opType, int numIOs>
+ceph::io_exerciser::ReadWriteOp<opType, numIOs>::ReadWriteOp(
+    std::array<uint64_t, numIOs>&& offset,
+    std::array<uint64_t, numIOs>&& length)
+    : TestOp<opType>(), offset(offset), length(length) {
+  auto compare = [](uint64_t offset1, uint64_t length1, uint64_t offset2,
+                    uint64_t length2) {
+    if (offset1 < offset2) {
+      ceph_assert(offset1 + length1 <= offset2);
+    } else {
+      ceph_assert(offset2 + length2 <= offset1);
+    }
+  };
+
+  if (numIOs > 1) {
+    for (int i = 0; i < numIOs - 1; i++) {
+      for (int j = i + 1; j < numIOs; j++) {
+        compare(offset[i], length[i], offset[j], length[j]);
+      }
+    }
   }
-  if (offset1 < offset3) {
-    ceph_assert( offset1 + length1 <= offset3 );
-  } else {
-    ceph_assert( offset3 + length3 <= offset1 );
+}
+
+template <OpType opType, int numIOs>
+std::string ceph::io_exerciser::ReadWriteOp<opType, numIOs>::to_string(
+    uint64_t block_size) const {
+  std::string offset_length_desc;
+  if (numIOs > 0) {
+    offset_length_desc += fmt::format(
+        "offset1={}", value_to_string(this->offset[0] * block_size));
+    offset_length_desc += fmt::format(
+        ",length1={}", value_to_string(this->length[0] * block_size));
+    for (int i = 1; i < numIOs; i++) {
+      offset_length_desc += fmt::format(
+          ",offset{}={}", i + 1, value_to_string(this->offset[i] * block_size));
+      offset_length_desc += fmt::format(
+          ",length{}={}", i + 1, value_to_string(this->length[i] * block_size));
+    }
   }
-  if (offset2 < offset3) {
-    ceph_assert( offset2 + length2 <= offset3 );
-  } else {
-    ceph_assert( offset3 + length3 <= offset2 );
+  switch (opType) {
+    case OpType::Read:
+      [[fallthrough]];
+    case OpType::Read2:
+      [[fallthrough]];
+    case OpType::Read3:
+      return fmt::format("Read{} ({})", numIOs, offset_length_desc);
+    case OpType::Write:
+      [[fallthrough]];
+    case OpType::Write2:
+      [[fallthrough]];
+    case OpType::Write3:
+      return fmt::format("Write{} ({})", numIOs, offset_length_desc);
+    case OpType::FailedWrite:
+      [[fallthrough]];
+    case OpType::FailedWrite2:
+      [[fallthrough]];
+    case OpType::FailedWrite3:
+      return fmt::format("FailedWrite{} ({})", numIOs, offset_length_desc);
+    default:
+      ceph_abort_msg(
+          fmt::format("Unsupported op type by ReadWriteOp ({})", opType));
   }
-  return std::make_unique<IoOp>(OpType::READ3,
-                                offset1, length1,
-                                offset2, length2,
-                                offset3, length3);
 }
 
-std::unique_ptr<IoOp> IoOp::generate_write(uint64_t offset, uint64_t length) {
-  return std::make_unique<IoOp>(OpType::WRITE, offset, length);
+SingleReadOp::SingleReadOp(uint64_t offset, uint64_t length)
+    : ReadWriteOp<OpType::Read, 1>({offset}, {length}) {}
+
+std::unique_ptr<SingleReadOp> SingleReadOp::generate(uint64_t offset,
+                                                     uint64_t length) {
+  return std::make_unique<SingleReadOp>(offset, length);
 }
 
-std::unique_ptr<IoOp> IoOp::generate_write2(uint64_t offset1, uint64_t length1,
-                                            uint64_t offset2, uint64_t length2) {
-  if (offset1 < offset2) {
-    ceph_assert( offset1 + length1 <= offset2 );
-  } else {
-    ceph_assert( offset2 + length2 <= offset1 );
-  }
-  return std::make_unique<IoOp>(OpType::WRITE2,
-                                offset1, length1,
-                                offset2, length2);
+DoubleReadOp::DoubleReadOp(uint64_t offset1, uint64_t length1, uint64_t offset2,
+                           uint64_t length2)
+    : ReadWriteOp<OpType::Read2, 2>({offset1, offset2}, {length1, length2}) {}
+
+std::unique_ptr<DoubleReadOp> DoubleReadOp::generate(uint64_t offset1,
+                                                     uint64_t length1,
+                                                     uint64_t offset2,
+                                                     uint64_t length2) {
+  return std::make_unique<DoubleReadOp>(offset1, length1, offset2, length2);
 }
 
-std::unique_ptr<IoOp> IoOp::generate_write3(uint64_t offset1, uint64_t length1, 
-                                            uint64_t offset2, uint64_t length2,
-                                            uint64_t offset3, uint64_t length3) {
-  if (offset1 < offset2) {
-    ceph_assert( offset1 + length1 <= offset2 );
-  } else {
-    ceph_assert( offset2 + length2 <= offset1 );
-  }
-  if (offset1 < offset3) {
-    ceph_assert( offset1 + length1 <= offset3 );
-  } else {
-    ceph_assert( offset3 + length3 <= offset1 );
-  }
-  if (offset2 < offset3) {
-    ceph_assert( offset2 + length2 <= offset3 );
-  } else {
-    ceph_assert( offset3 + length3 <= offset2 );
-  }
-  return std::make_unique<IoOp>(OpType::WRITE3,
-                                offset1, length1,
-                                offset2, length2,
-                                offset3, length3);
-}
-
-bool IoOp::done() {
-  return (op == OpType::Done);
-}
-
-std::string IoOp::to_string(uint64_t block_size) const
-{
-  switch (op) {
-  case OpType::Done:
-    return "Done";
-  case OpType::BARRIER:
-    return "Barrier";
-  case OpType::CREATE:
-    return "Create (size=" + value_to_string(length1 * block_size) + ")";
-  case OpType::REMOVE:
-    return "Remove";
-  case OpType::READ:
-    return "Read (offset=" + value_to_string(offset1 * block_size) +
-           ",length=" + value_to_string(length1 * block_size) + ")";
-  case OpType::READ2:
-    return "Read2 (offset1=" + value_to_string(offset1 * block_size) +
-           ",length1=" + value_to_string(length1 * block_size) +
-           ",offset2=" + value_to_string(offset2 * block_size) +
-           ",length2=" + value_to_string(length2 * block_size) + ")";
-  case OpType::READ3:
-    return "Read3 (offset1=" + value_to_string(offset1 * block_size) +
-           ",length1=" + value_to_string(length1 * block_size) +
-           ",offset2=" + value_to_string(offset2 * block_size) +
-           ",length2=" + value_to_string(length2 * block_size) +
-           ",offset3=" + value_to_string(offset3 * block_size) +
-           ",length3=" + value_to_string(length3 * block_size) + ")";
-  case OpType::WRITE:
-    return "Write (offset=" + value_to_string(offset1 * block_size) +
-           ",length=" + value_to_string(length1 * block_size) + ")";
-  case OpType::WRITE2:
-    return "Write2 (offset1=" + value_to_string(offset1 * block_size) +
-           ",length1=" + value_to_string(length1 * block_size) +
-           ",offset2=" + value_to_string(offset2 * block_size) +
-           ",length2=" + value_to_string(length2 * block_size) + ")";
-  case OpType::WRITE3:
-    return "Write3 (offset1=" + value_to_string(offset1 * block_size) +
-           ",length1=" + value_to_string(length1 * block_size) +
-           ",offset2=" + value_to_string(offset2 * block_size) +
-           ",length2=" + value_to_string(length2 * block_size) +
-           ",offset3=" + value_to_string(offset3 * block_size) +
-           ",length3=" + value_to_string(length3 * block_size) + ")";
-  default:
-    break;
-  }
-  return "Unknown";
+TripleReadOp::TripleReadOp(uint64_t offset1, uint64_t length1, uint64_t offset2,
+                           uint64_t length2, uint64_t offset3, uint64_t length3)
+    : ReadWriteOp<OpType::Read3, 3>({offset1, offset2, offset3},
+                                    {length1, length2, length3}) {}
+
+std::unique_ptr<TripleReadOp> TripleReadOp::generate(
+    uint64_t offset1, uint64_t length1, uint64_t offset2, uint64_t length2,
+    uint64_t offset3, uint64_t length3) {
+  return std::make_unique<TripleReadOp>(offset1, length1, offset2, length2,
+                                        offset3, length3);
+}
+
+SingleWriteOp::SingleWriteOp(uint64_t offset, uint64_t length)
+    : ReadWriteOp<OpType::Write, 1>({offset}, {length}) {}
+
+std::unique_ptr<SingleWriteOp> SingleWriteOp::generate(uint64_t offset,
+                                                       uint64_t length) {
+  return std::make_unique<SingleWriteOp>(offset, length);
+}
+
+DoubleWriteOp::DoubleWriteOp(uint64_t offset1, uint64_t length1,
+                             uint64_t offset2, uint64_t length2)
+    : ReadWriteOp<OpType::Write2, 2>({offset1, offset2}, {length1, length2}) {}
+
+std::unique_ptr<DoubleWriteOp> DoubleWriteOp::generate(uint64_t offset1,
+                                                       uint64_t length1,
+                                                       uint64_t offset2,
+                                                       uint64_t length2) {
+  return std::make_unique<DoubleWriteOp>(offset1, length1, offset2, length2);
+}
+
+TripleWriteOp::TripleWriteOp(uint64_t offset1, uint64_t length1,
+                             uint64_t offset2, uint64_t length2,
+                             uint64_t offset3, uint64_t length3)
+    : ReadWriteOp<OpType::Write3, 3>({offset1, offset2, offset3},
+                                     {length1, length2, length3}) {}
+
+std::unique_ptr<TripleWriteOp> TripleWriteOp::generate(
+    uint64_t offset1, uint64_t length1, uint64_t offset2, uint64_t length2,
+    uint64_t offset3, uint64_t length3) {
+  return std::make_unique<TripleWriteOp>(offset1, length1, offset2, length2,
+                                         offset3, length3);
+}
+
+SingleFailedWriteOp::SingleFailedWriteOp(uint64_t offset, uint64_t length)
+    : ReadWriteOp<OpType::FailedWrite, 1>({offset}, {length}) {}
+
+std::unique_ptr<SingleFailedWriteOp> SingleFailedWriteOp::generate(
+    uint64_t offset, uint64_t length) {
+  return std::make_unique<SingleFailedWriteOp>(offset, length);
+}
+
+DoubleFailedWriteOp::DoubleFailedWriteOp(uint64_t offset1, uint64_t length1,
+                                         uint64_t offset2, uint64_t length2)
+    : ReadWriteOp<OpType::FailedWrite2, 2>({offset1, offset2},
+                                           {length1, length2}) {}
+
+std::unique_ptr<DoubleFailedWriteOp> DoubleFailedWriteOp::generate(
+    uint64_t offset1, uint64_t length1, uint64_t offset2, uint64_t length2) {
+  return std::make_unique<DoubleFailedWriteOp>(offset1, length1, offset2,
+                                               length2);
+}
+
+TripleFailedWriteOp::TripleFailedWriteOp(uint64_t offset1, uint64_t length1,
+                                         uint64_t offset2, uint64_t length2,
+                                         uint64_t offset3, uint64_t length3)
+    : ReadWriteOp<OpType::FailedWrite3, 3>({offset1, offset2, offset3},
+                                           {length1, length2, length3}) {}
+
+std::unique_ptr<TripleFailedWriteOp> TripleFailedWriteOp::generate(
+    uint64_t offset1, uint64_t length1, uint64_t offset2, uint64_t length2,
+    uint64_t offset3, uint64_t length3) {
+  return std::make_unique<TripleFailedWriteOp>(offset1, length1, offset2,
+                                               length2, offset3, length3);
+}
+
+template <ceph::io_exerciser::OpType opType>
+ceph::io_exerciser::InjectErrorOp<opType>::InjectErrorOp(
+    int shard, const std::optional<uint64_t>& type,
+    const std::optional<uint64_t>& when,
+    const std::optional<uint64_t>& duration)
+    : TestOp<opType>(),
+      shard(shard),
+      type(type),
+      when(when),
+      duration(duration) {}
+
+template <ceph::io_exerciser::OpType opType>
+std::string ceph::io_exerciser::InjectErrorOp<opType>::to_string(
+    uint64_t blocksize) const {
+  std::string_view inject_type = get_inject_type_string();
+  return fmt::format(
+      "Inject {} error on shard {} of type {}"
+      " after {} successful inject(s) lasting {} inject(s)",
+      inject_type, shard, type.value_or(0), when.value_or(0),
+      duration.value_or(1));
+}
+
+ceph::io_exerciser::InjectReadErrorOp::InjectReadErrorOp(
+    int shard, const std::optional<uint64_t>& type,
+    const std::optional<uint64_t>& when,
+    const std::optional<uint64_t>& duration)
+    : InjectErrorOp<OpType::InjectReadError>(shard, type, when, duration) {}
+
+std::unique_ptr<ceph::io_exerciser::InjectReadErrorOp>
+ceph::io_exerciser ::InjectReadErrorOp::generate(
+    int shard, const std::optional<uint64_t>& type,
+    const std::optional<uint64_t>& when,
+    const std::optional<uint64_t>& duration) {
+  return std::make_unique<InjectReadErrorOp>(shard, type, when, duration);
+}
+
+ceph::io_exerciser::InjectWriteErrorOp::InjectWriteErrorOp(
+    int shard, const std::optional<uint64_t>& type,
+    const std::optional<uint64_t>& when,
+    const std::optional<uint64_t>& duration)
+    : InjectErrorOp<OpType::InjectWriteError>(shard, type, when, duration) {}
+
+std::unique_ptr<ceph::io_exerciser::InjectWriteErrorOp>
+ceph::io_exerciser ::InjectWriteErrorOp::generate(
+    int shard, const std::optional<uint64_t>& type,
+    const std::optional<uint64_t>& when,
+    const std::optional<uint64_t>& duration) {
+  return std::make_unique<InjectWriteErrorOp>(shard, type, when, duration);
+}
+
+template <ceph::io_exerciser::OpType opType>
+ceph::io_exerciser::ClearErrorInjectOp<opType>::ClearErrorInjectOp(
+    int shard, const std::optional<uint64_t>& type)
+    : TestOp<opType>(), shard(shard), type(type) {}
+
+template <ceph::io_exerciser::OpType opType>
+std::string ceph::io_exerciser::ClearErrorInjectOp<opType>::to_string(
+    uint64_t blocksize) const {
+  std::string_view inject_type = get_inject_type_string();
+  return fmt::format("Clear {} injects on shard {} of type {}", inject_type,
+                     shard, type.value_or(0));
+}
+
+ceph::io_exerciser::ClearReadErrorInjectOp::ClearReadErrorInjectOp(
+    int shard, const std::optional<uint64_t>& type)
+    : ClearErrorInjectOp<OpType::ClearReadErrorInject>(shard, type) {}
+
+std::unique_ptr<ceph::io_exerciser::ClearReadErrorInjectOp>
+ceph::io_exerciser ::ClearReadErrorInjectOp::generate(
+    int shard, const std::optional<uint64_t>& type) {
+  return std::make_unique<ClearReadErrorInjectOp>(shard, type);
+}
+
+ceph::io_exerciser::ClearWriteErrorInjectOp::ClearWriteErrorInjectOp(
+    int shard, const std::optional<uint64_t>& type)
+    : ClearErrorInjectOp<OpType::ClearWriteErrorInject>(shard, type) {}
+
+std::unique_ptr<ceph::io_exerciser::ClearWriteErrorInjectOp>
+ceph::io_exerciser ::ClearWriteErrorInjectOp::generate(
+    int shard, const std::optional<uint64_t>& type) {
+  return std::make_unique<ClearWriteErrorInjectOp>(shard, type);
 }
\ No newline at end of file
diff --git a/src/common/io_exerciser/IoOp.h b/src/common/io_exerciser/IoOp.h
index 60c02a93d4e..1887eafcc1f 100644
--- a/src/common/io_exerciser/IoOp.h
+++ b/src/common/io_exerciser/IoOp.h
@@ -1,94 +1,248 @@
 #pragma once
 
-#include <string>
+#include <array>
 #include <memory>
-#include "include/ceph_assert.h"
+#include <optional>
+#include <string>
+
+#include "OpType.h"
 
 /* Overview
  *
- * enum OpType
- *   Enumeration of different types of I/O operation
- *
  * class IoOp
  *   Stores details for an I/O operation. Generated by IoSequences
  *   and applied by IoExerciser's
  */
 
 namespace ceph {
-  namespace io_exerciser {
-
-    enum class OpType {
-      Done,       // End of I/O sequence
-      BARRIER,    // Barrier - all prior I/Os must complete
-      CREATE,     // Create object and pattern with data
-      REMOVE,     // Remove object
-      READ,       // Read
-      READ2,      // 2 Reads in one op
-      READ3,      // 3 Reads in one op
-      WRITE,      // Write
-      WRITE2,     // 2 Writes in one op
-      WRITE3      // 3 Writes in one op
-    };
-
-    class IoOp {
-    protected:
-      std::string value_to_string(uint64_t v) const;
-
-    public:
-      OpType op;
-      uint64_t offset1;
-      uint64_t length1;
-      uint64_t offset2;
-      uint64_t length2;
-      uint64_t offset3;
-      uint64_t length3;
-
-      IoOp( OpType op,
-            uint64_t offset1 = 0, uint64_t length1 = 0,
-            uint64_t offset2 = 0, uint64_t length2 = 0,
-            uint64_t offset3 = 0, uint64_t length3 = 0 );
-
-      static std::unique_ptr<IoOp> generate_done();
-
-      static std::unique_ptr<IoOp> generate_barrier();
-
-      static std::unique_ptr<IoOp> generate_create(uint64_t size);
-
-      static std::unique_ptr<IoOp> generate_remove();
-
-      static std::unique_ptr<IoOp> generate_read(uint64_t offset,
+namespace io_exerciser {
+
+class IoOp {
+ public:
+  IoOp();
+  virtual ~IoOp() = default;
+  virtual std::string to_string(uint64_t block_size) const = 0;
+  virtual constexpr OpType getOpType() const = 0;
+};
+
+template <OpType opType>
+class TestOp : public IoOp {
+ public:
+  TestOp();
+  constexpr OpType getOpType() const override { return opType; }
+};
+
+class DoneOp : public TestOp<OpType::Done> {
+ public:
+  DoneOp();
+  static std::unique_ptr<DoneOp> generate();
+  std::string to_string(uint64_t block_size) const override;
+};
+
+class BarrierOp : public TestOp<OpType::Barrier> {
+ public:
+  BarrierOp();
+  static std::unique_ptr<BarrierOp> generate();
+  std::string to_string(uint64_t block_size) const override;
+};
+
+class CreateOp : public TestOp<OpType::Create> {
+ public:
+  CreateOp(uint64_t size);
+  static std::unique_ptr<CreateOp> generate(uint64_t size);
+  std::string to_string(uint64_t block_size) const override;
+  uint64_t size;
+};
+
+class RemoveOp : public TestOp<OpType::Remove> {
+ public:
+  RemoveOp();
+  static std::unique_ptr<RemoveOp> generate();
+  std::string to_string(uint64_t block_size) const override;
+};
+
+template <OpType opType, int numIOs>
+class ReadWriteOp : public TestOp<opType> {
+ public:
+  std::array<uint64_t, numIOs> offset;
+  std::array<uint64_t, numIOs> length;
+
+ protected:
+  ReadWriteOp(std::array<uint64_t, numIOs>&& offset,
+              std::array<uint64_t, numIOs>&& length);
+  std::string to_string(uint64_t block_size) const override;
+};
+
+class SingleReadOp : public ReadWriteOp<OpType::Read, 1> {
+ public:
+  SingleReadOp(uint64_t offset, uint64_t length);
+  static std::unique_ptr<SingleReadOp> generate(uint64_t offset,
+                                                uint64_t length);
+};
+
+class DoubleReadOp : public ReadWriteOp<OpType::Read2, 2> {
+ public:
+  DoubleReadOp(uint64_t offset1, uint64_t length1, uint64_t offset2,
+               uint64_t length2);
+  static std::unique_ptr<DoubleReadOp> generate(uint64_t offset1,
+                                                uint64_t length1,
+                                                uint64_t offset2,
+                                                uint64_t length2);
+};
+
+class TripleReadOp : public ReadWriteOp<OpType::Read3, 3> {
+ public:
+  TripleReadOp(uint64_t offset1, uint64_t length1, uint64_t offset2,
+               uint64_t length2, uint64_t offset3, uint64_t length3);
+  static std::unique_ptr<TripleReadOp> generate(
+      uint64_t offset1, uint64_t length1, uint64_t offset2, uint64_t length2,
+      uint64_t offset3, uint64_t length3);
+};
+
+class SingleWriteOp : public ReadWriteOp<OpType::Write, 1> {
+ public:
+  SingleWriteOp(uint64_t offset, uint64_t length);
+  static std::unique_ptr<SingleWriteOp> generate(uint64_t offset,
                                                  uint64_t length);
+};
+
+class DoubleWriteOp : public ReadWriteOp<OpType::Write2, 2> {
+ public:
+  DoubleWriteOp(uint64_t offset1, uint64_t length1, uint64_t offset2,
+                uint64_t length2);
+  static std::unique_ptr<DoubleWriteOp> generate(uint64_t offset1,
+                                                 uint64_t length1,
+                                                 uint64_t offset2,
+                                                 uint64_t length2);
+};
+
+class TripleWriteOp : public ReadWriteOp<OpType::Write3, 3> {
+ public:
+  TripleWriteOp(uint64_t offset1, uint64_t length1, uint64_t offset2,
+                uint64_t length2, uint64_t offset3, uint64_t length3);
+  static std::unique_ptr<TripleWriteOp> generate(
+      uint64_t offset1, uint64_t length1, uint64_t offset2, uint64_t length2,
+      uint64_t offset3, uint64_t length3);
+};
+
+class SingleFailedWriteOp : public ReadWriteOp<OpType::FailedWrite, 1> {
+ public:
+  SingleFailedWriteOp(uint64_t offset, uint64_t length);
+  static std::unique_ptr<SingleFailedWriteOp> generate(uint64_t offset,
+                                                       uint64_t length);
+};
+
+class DoubleFailedWriteOp : public ReadWriteOp<OpType::FailedWrite2, 2> {
+ public:
+  DoubleFailedWriteOp(uint64_t offset1, uint64_t length1, uint64_t offset2,
+                      uint64_t length2);
+  static std::unique_ptr<DoubleFailedWriteOp> generate(uint64_t offset1,
+                                                       uint64_t length1,
+                                                       uint64_t offset2,
+                                                       uint64_t length2);
+};
+
+class TripleFailedWriteOp : public ReadWriteOp<OpType::FailedWrite3, 3> {
+ public:
+  TripleFailedWriteOp(uint64_t offset1, uint64_t length1, uint64_t offset2,
+                      uint64_t length2, uint64_t offset3, uint64_t length3);
+  static std::unique_ptr<TripleFailedWriteOp> generate(
+      uint64_t offset1, uint64_t length1, uint64_t offset2, uint64_t length2,
+      uint64_t offset3, uint64_t length3);
+};
+
+template <ceph::io_exerciser::OpType opType>
+class InjectErrorOp : public TestOp<opType> {
+ public:
+  InjectErrorOp(int shard, const std::optional<uint64_t>& type,
+                const std::optional<uint64_t>& when,
+                const std::optional<uint64_t>& duration);
+
+  std::string to_string(uint64_t block_size) const override;
+
+  int shard;
+  std::optional<uint64_t> type;
+  std::optional<uint64_t> when;
+  std::optional<uint64_t> duration;
+
+ protected:
+  virtual inline constexpr std::string_view get_inject_type_string() const = 0;
+};
+
+class InjectReadErrorOp : public InjectErrorOp<OpType::InjectReadError> {
+ public:
+  InjectReadErrorOp(int shard, const std::optional<uint64_t>& type,
+                    const std::optional<uint64_t>& when,
+                    const std::optional<uint64_t>& duration);
+
+  static std::unique_ptr<InjectReadErrorOp> generate(
+      int shard, const std::optional<uint64_t>& type,
+      const std::optional<uint64_t>& when,
+      const std::optional<uint64_t>& duration);
+
+ protected:
+  inline constexpr std::string_view get_inject_type_string() const override {
+    return "read";
+  }
+};
+
+class InjectWriteErrorOp : public InjectErrorOp<OpType::InjectWriteError> {
+ public:
+  InjectWriteErrorOp(int shard, const std::optional<uint64_t>& type,
+                     const std::optional<uint64_t>& when,
+                     const std::optional<uint64_t>& duration);
+
+  static std::unique_ptr<InjectWriteErrorOp> generate(
+      int shard, const std::optional<uint64_t>& type,
+      const std::optional<uint64_t>& when,
+      const std::optional<uint64_t>& duration);
+
+ protected:
+  inline constexpr std::string_view get_inject_type_string() const override {
+    return "write";
+  }
+};
+
+template <ceph::io_exerciser::OpType opType>
+class ClearErrorInjectOp : public TestOp<opType> {
+ public:
+  ClearErrorInjectOp(int shard, const std::optional<uint64_t>& type);
+
+  std::string to_string(uint64_t block_size) const override;
+
+  int shard;
+  std::optional<uint64_t> type;
+
+ protected:
+  virtual inline constexpr std::string_view get_inject_type_string() const = 0;
+};
+
+class ClearReadErrorInjectOp
+    : public ClearErrorInjectOp<OpType::ClearReadErrorInject> {
+ public:
+  ClearReadErrorInjectOp(int shard, const std::optional<uint64_t>& type);
+
+  static std::unique_ptr<ClearReadErrorInjectOp> generate(
+      int shard, const std::optional<uint64_t>& type);
+
+ protected:
+  inline constexpr std::string_view get_inject_type_string() const override {
+    return "read";
+  }
+};
+
+class ClearWriteErrorInjectOp
+    : public ClearErrorInjectOp<OpType::ClearWriteErrorInject> {
+ public:
+  ClearWriteErrorInjectOp(int shard, const std::optional<uint64_t>& type);
+
+  static std::unique_ptr<ClearWriteErrorInjectOp> generate(
+      int shard, const std::optional<uint64_t>& type);
 
-      static std::unique_ptr<IoOp> generate_read2(uint64_t offset1,
-                                                  uint64_t length1,
-                                                  uint64_t offset2,
-                                                  uint64_t length2);
-
-      static std::unique_ptr<IoOp> generate_read3(uint64_t offset1,
-                                                  uint64_t length1,
-                                                  uint64_t offset2,
-                                                  uint64_t length2,
-                                                  uint64_t offset3,
-                                                  uint64_t length3);
-
-      static std::unique_ptr<IoOp> generate_write(uint64_t offset,
-                                                  uint64_t length);
-
-      static std::unique_ptr<IoOp> generate_write2(uint64_t offset1,
-                                                   uint64_t length1,
-                                                   uint64_t offset2,
-                                                   uint64_t length2);
-
-      static std::unique_ptr<IoOp> generate_write3(uint64_t offset1,
-                                                   uint64_t length1,
-                                                   uint64_t offset2,
-                                                   uint64_t length2,
-                                                   uint64_t offset3,
-                                                   uint64_t length3);
-
-      bool done();
-
-      std::string to_string(uint64_t block_size) const;
-    };
+ protected:
+  inline constexpr std::string_view get_inject_type_string() const override {
+    return "write";
   }
-}
\ No newline at end of file
+};
+}  // namespace io_exerciser
+}  // namespace ceph
\ No newline at end of file
diff --git a/src/common/io_exerciser/IoSequence.cc b/src/common/io_exerciser/IoSequence.cc
index 4a7ca0593d1..83f1cc595a5 100644
--- a/src/common/io_exerciser/IoSequence.cc
+++ b/src/common/io_exerciser/IoSequence.cc
@@ -1,12 +1,12 @@
 #include "IoSequence.h"
 
+using IoOp = ceph::io_exerciser::IoOp;
 using Sequence = ceph::io_exerciser::Sequence;
 using IoSequence = ceph::io_exerciser::IoSequence;
 
-std::ostream& ceph::io_exerciser::operator<<(std::ostream& os, const Sequence& seq)
-{
-  switch (seq)
-  {
+std::ostream& ceph::io_exerciser::operator<<(std::ostream& os,
+                                             const Sequence& seq) {
+  switch (seq) {
     case Sequence::SEQUENCE_SEQ0:
       os << "SEQUENCE_SEQ0";
       break;
@@ -37,6 +37,9 @@ std::ostream& ceph::io_exerciser::operator<<(std::ostream& os, const Sequence& s
     case Sequence::SEQUENCE_SEQ9:
       os << "SEQUENCE_SEQ9";
       break;
+    case Sequence::SEQUENCE_SEQ10:
+      os << "SEQUENCE_SEQ10";
+      break;
     case Sequence::SEQUENCE_END:
       os << "SEQUENCE_END";
       break;
@@ -44,19 +47,12 @@ std::ostream& ceph::io_exerciser::operator<<(std::ostream& os, const Sequence& s
   return os;
 }
 
-IoSequence::IoSequence(std::pair<int,int> obj_size_range,
-                                           int seed) :
-        min_obj_size(obj_size_range.first), max_obj_size(obj_size_range.second),
-        create(true), barrier(false), done(false), remove(false),
-        obj_size(min_obj_size), step(-1), seed(seed)
-{
-  rng.seed(seed);
+bool IoSequence::is_supported(Sequence sequence) const {
+  return sequence != Sequence::SEQUENCE_SEQ10;
 }
 
-std::unique_ptr<IoSequence> IoSequence::generate_sequence(Sequence s,
-                                                          std::pair<int,int> obj_size_range,
-                                                          int seed)
-{
+std::unique_ptr<IoSequence> IoSequence::generate_sequence(
+    Sequence s, std::pair<int, int> obj_size_range, int seed) {
   switch (s) {
     case Sequence::SEQUENCE_SEQ0:
       return std::make_unique<Seq0>(obj_size_range, seed);
@@ -78,24 +74,39 @@ std::unique_ptr<IoSequence> IoSequence::generate_sequence(Sequence s,
       return std::make_unique<Seq8>(obj_size_range, seed);
     case Sequence::SEQUENCE_SEQ9:
       return std::make_unique<Seq9>(obj_size_range, seed);
+    case Sequence::SEQUENCE_SEQ10:
+      ceph_abort_msg(
+          "Sequence 10 only supported for erasure coded pools "
+          "through the EcIoSequence interface");
+      return nullptr;
     default:
       break;
   }
   return nullptr;
 }
 
-int IoSequence::get_step() const
-{
-  return step;
+IoSequence::IoSequence(std::pair<int, int> obj_size_range, int seed)
+    : min_obj_size(obj_size_range.first),
+      max_obj_size(obj_size_range.second),
+      create(true),
+      barrier(false),
+      done(false),
+      remove(false),
+      obj_size(min_obj_size),
+      step(-1),
+      seed(seed) {
+  rng.seed(seed);
 }
 
-int IoSequence::get_seed() const
-{
-  return seed;
+std::string ceph::io_exerciser::IoSequence::get_name_with_seqseed() const {
+  return get_name() + " (seqseed " + std::to_string(get_seed()) + ")";
 }
 
-void IoSequence::set_min_object_size(uint64_t size)
-{
+int IoSequence::get_step() const { return step; }
+
+int IoSequence::get_seed() const { return seed; }
+
+void IoSequence::set_min_object_size(uint64_t size) {
   min_obj_size = size;
   if (obj_size < size) {
     obj_size = size;
@@ -105,23 +116,20 @@ void IoSequence::set_min_object_size(uint64_t size)
   }
 }
 
-void IoSequence::set_max_object_size(uint64_t size)
-{
+void IoSequence::set_max_object_size(uint64_t size) {
   max_obj_size = size;
   if (obj_size > size) {
     done = true;
   }
 }
 
-void IoSequence::select_random_object_size()
-{
+void IoSequence::select_random_object_size() {
   if (max_obj_size != min_obj_size) {
     obj_size = min_obj_size + rng(max_obj_size - min_obj_size);
   }
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> IoSequence::increment_object_size()
-{
+std::unique_ptr<IoOp> IoSequence::increment_object_size() {
   obj_size++;
   if (obj_size > max_obj_size) {
     done = true;
@@ -129,106 +137,118 @@ std::unique_ptr<ceph::io_exerciser::IoOp> IoSequence::increment_object_size()
   create = true;
   barrier = true;
   remove = true;
-  return IoOp::generate_barrier();
+  return BarrierOp::generate();
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> IoSequence::next()
-{
+Sequence IoSequence::getNextSupportedSequenceId() const {
+  Sequence sequence = get_id();
+  ++sequence;
+  for (; sequence < Sequence::SEQUENCE_END; ++sequence) {
+    if (is_supported(sequence)) {
+      return sequence;
+    }
+  }
+
+  return Sequence::SEQUENCE_END;
+}
+
+std::unique_ptr<IoOp> IoSequence::next() {
   step++;
   if (remove) {
     remove = false;
-    return IoOp::generate_remove();
+    return RemoveOp::generate();
   }
   if (barrier) {
     barrier = false;
-    return IoOp::generate_barrier();
+    return BarrierOp::generate();
   }
   if (done) {
-    return IoOp::generate_done();
+    return DoneOp::generate();
   }
   if (create) {
     create = false;
     barrier = true;
-    return IoOp::generate_create(obj_size);
+    return CreateOp::generate(obj_size);
   }
   return _next();
 }
 
-
-
-ceph::io_exerciser::Seq0::Seq0(std::pair<int,int> obj_size_range, int seed) :
-  IoSequence(obj_size_range, seed), offset(0)
-{
+ceph::io_exerciser::Seq0::Seq0(std::pair<int, int> obj_size_range, int seed)
+    : IoSequence(obj_size_range, seed), offset(0) {
   select_random_object_size();
   length = 1 + rng(obj_size - 1);
 }
 
-std::string ceph::io_exerciser::Seq0::get_name() const
-{
+Sequence ceph::io_exerciser::Seq0::get_id() const {
+  return Sequence::SEQUENCE_SEQ0;
+}
+
+std::string ceph::io_exerciser::Seq0::get_name() const {
   return "Sequential reads of length " + std::to_string(length) +
-    " with queue depth 1 (seqseed " + std::to_string(get_seed()) + ")";
+         " with queue depth 1";
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq0::_next()
-{
+std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq0::_next() {
   std::unique_ptr<IoOp> r;
   if (offset >= obj_size) {
     done = true;
     barrier = true;
     remove = true;
-    return IoOp::generate_barrier();
+    return BarrierOp::generate();
   }
   if (offset + length > obj_size) {
-    r = IoOp::generate_read(offset, obj_size - offset);
+    r = SingleReadOp::generate(offset, obj_size - offset);
   } else {
-    r = IoOp::generate_read(offset, length);
+    r = SingleReadOp::generate(offset, length);
   }
   offset += length;
   return r;
 }
 
-
-
-ceph::io_exerciser::Seq1::Seq1(std::pair<int,int> obj_size_range, int seed) :
-  IoSequence(obj_size_range, seed)
-{
+ceph::io_exerciser::Seq1::Seq1(std::pair<int, int> obj_size_range, int seed)
+    : IoSequence(obj_size_range, seed) {
   select_random_object_size();
   count = 3 * obj_size;
 }
 
-std::string ceph::io_exerciser::Seq1::get_name() const
-{
-  return "Random offset, random length read/write I/O with queue depth 1 (seqseed "
-    + std::to_string(get_seed()) + ")";
+Sequence ceph::io_exerciser::Seq1::get_id() const {
+  return Sequence::SEQUENCE_SEQ1;
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq1::_next()
-{
+std::string ceph::io_exerciser::Seq1::get_name() const {
+  return "Random offset, random length read/write I/O with queue depth 1";
+}
+
+std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq1::_next() {
   barrier = true;
   if (count-- == 0) {
     done = true;
     remove = true;
-    return IoOp::generate_barrier();
+    return BarrierOp::generate();
   }
 
   uint64_t offset = rng(obj_size - 1);
   uint64_t length = 1 + rng(obj_size - 1 - offset);
-  return (rng(2) != 0) ? IoOp::generate_write(offset, length) :
-    IoOp::generate_read(offset, length);
-}
 
+  if (rng(2) != 0) {
+    return SingleWriteOp::generate(offset, length);
+  } else {
+    return SingleReadOp::generate(offset, length);
+  }
+}
 
+ceph::io_exerciser::Seq2::Seq2(std::pair<int, int> obj_size_range, int seed)
+    : IoSequence(obj_size_range, seed), offset(0), length(0) {}
 
-ceph::io_exerciser::Seq2::Seq2(std::pair<int,int> obj_size_range, int seed) :
-  IoSequence(obj_size_range, seed), offset(0), length(0) {}
+Sequence ceph::io_exerciser::Seq2::get_id() const {
+  return Sequence::SEQUENCE_SEQ2;
+}
 
-std::string ceph::io_exerciser::Seq2::get_name() const
-{
+std::string ceph::io_exerciser::Seq2::get_name() const {
   return "Permutations of offset and length read I/O";
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq2::_next()
-{
+std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq2::_next() {
   length++;
   if (length > obj_size - offset) {
     length = 1;
@@ -239,24 +259,23 @@ std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq2::_next()
       return increment_object_size();
     }
   }
-  return IoOp::generate_read(offset, length);
+  return SingleReadOp::generate(offset, length);
 }
 
-
-
-ceph::io_exerciser::Seq3::Seq3(std::pair<int,int> obj_size_range, int seed) :
-  IoSequence(obj_size_range, seed), offset1(0), offset2(0)
-{
+ceph::io_exerciser::Seq3::Seq3(std::pair<int, int> obj_size_range, int seed)
+    : IoSequence(obj_size_range, seed), offset1(0), offset2(0) {
   set_min_object_size(2);
 }
 
-std::string ceph::io_exerciser::Seq3::get_name() const
-{
+Sequence ceph::io_exerciser::Seq3::get_id() const {
+  return Sequence::SEQUENCE_SEQ3;
+}
+
+std::string ceph::io_exerciser::Seq3::get_name() const {
   return "Permutations of offset 2-region 1-block read I/O";
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq3::_next()
-{
+std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq3::_next() {
   offset2++;
   if (offset2 >= obj_size - offset1) {
     offset2 = 1;
@@ -267,24 +286,23 @@ std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq3::_next()
       return increment_object_size();
     }
   }
-  return IoOp::generate_read2(offset1, 1, offset1 + offset2, 1);
+  return DoubleReadOp::generate(offset1, 1, offset1 + offset2, 1);
 }
 
-
-
-ceph::io_exerciser::Seq4::Seq4(std::pair<int,int> obj_size_range, int seed) :
-  IoSequence(obj_size_range, seed), offset1(0), offset2(1)
-{
+ceph::io_exerciser::Seq4::Seq4(std::pair<int, int> obj_size_range, int seed)
+    : IoSequence(obj_size_range, seed), offset1(0), offset2(1) {
   set_min_object_size(3);
 }
 
-std::string ceph::io_exerciser::Seq4::get_name() const
-{
+Sequence ceph::io_exerciser::Seq4::get_id() const {
+  return Sequence::SEQUENCE_SEQ4;
+}
+
+std::string ceph::io_exerciser::Seq4::get_name() const {
   return "Permutations of offset 3-region 1-block read I/O";
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq4::_next()
-{
+std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq4::_next() {
   offset2++;
   if (offset2 >= obj_size - offset1) {
     offset2 = 2;
@@ -295,33 +313,35 @@ std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq4::_next()
       return increment_object_size();
     }
   }
-  return IoOp::generate_read3(offset1, 1,
-                              offset1 + offset2, 1,
-                              (offset1 * 2 + offset2)/2, 1);
+  return TripleReadOp::generate(offset1, 1, (offset1 + offset2), 1,
+                                (offset1 * 2 + offset2) / 2, 1);
 }
 
+ceph::io_exerciser::Seq5::Seq5(std::pair<int, int> obj_size_range, int seed)
+    : IoSequence(obj_size_range, seed),
+      offset(0),
+      length(1),
+      doneread(false),
+      donebarrier(false) {}
 
+Sequence ceph::io_exerciser::Seq5::get_id() const {
+  return Sequence::SEQUENCE_SEQ5;
+}
 
-ceph::io_exerciser::Seq5::Seq5(std::pair<int,int> obj_size_range, int seed) :
-  IoSequence(obj_size_range, seed), offset(0), length(1),
-  doneread(false), donebarrier(false) {}
-
-std::string ceph::io_exerciser::Seq5::get_name() const
-{
+std::string ceph::io_exerciser::Seq5::get_name() const {
   return "Permutation of length sequential writes";
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq5::_next()
-{
+std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq5::_next() {
   if (offset >= obj_size) {
     if (!doneread) {
       if (!donebarrier) {
         donebarrier = true;
-        return IoOp::generate_barrier();
+        return BarrierOp::generate();
       }
       doneread = true;
       barrier = true;
-      return IoOp::generate_read(0, obj_size);
+      return SingleReadOp::generate(0, obj_size);
     }
     doneread = false;
     donebarrier = false;
@@ -333,33 +353,36 @@ std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq5::_next()
     }
   }
   uint64_t io_len = (offset + length > obj_size) ? (obj_size - offset) : length;
-  std::unique_ptr<IoOp> r = IoOp::generate_write(offset, io_len);
+  std::unique_ptr<IoOp> r = SingleWriteOp::generate(offset, io_len);
   offset += io_len;
   return r;
 }
 
+ceph::io_exerciser::Seq6::Seq6(std::pair<int, int> obj_size_range, int seed)
+    : IoSequence(obj_size_range, seed),
+      offset(0),
+      length(1),
+      doneread(false),
+      donebarrier(false) {}
 
+Sequence ceph::io_exerciser::Seq6::get_id() const {
+  return Sequence::SEQUENCE_SEQ6;
+}
 
-ceph::io_exerciser::Seq6::Seq6(std::pair<int,int> obj_size_range, int seed) :
-  IoSequence(obj_size_range, seed), offset(0), length(1),
-  doneread(false), donebarrier(false) {}
-
-std::string ceph::io_exerciser::Seq6::get_name() const
-{
+std::string ceph::io_exerciser::Seq6::get_name() const {
   return "Permutation of length sequential writes, different alignment";
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq6::_next()
-{
+std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq6::_next() {
   if (offset >= obj_size) {
     if (!doneread) {
       if (!donebarrier) {
         donebarrier = true;
-        return IoOp::generate_barrier();
+        return BarrierOp::generate();
       }
       doneread = true;
       barrier = true;
-      return IoOp::generate_read(0, obj_size);
+      return SingleReadOp::generate(0, obj_size);
     }
     doneread = false;
     donebarrier = false;
@@ -374,74 +397,72 @@ std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq6::_next()
   if (io_len == 0) {
     io_len = length;
   }
-  std::unique_ptr<IoOp> r = IoOp::generate_write(offset, io_len);
+  std::unique_ptr<IoOp> r = SingleWriteOp::generate(offset, io_len);
   offset += io_len;
   return r;
 }
 
-
-
-ceph::io_exerciser::Seq7::Seq7(std::pair<int,int> obj_size_range, int seed) :
-  IoSequence(obj_size_range, seed)
-{
+ceph::io_exerciser::Seq7::Seq7(std::pair<int, int> obj_size_range, int seed)
+    : IoSequence(obj_size_range, seed) {
   set_min_object_size(2);
   offset = obj_size;
 }
 
-std::string ceph::io_exerciser::Seq7::get_name() const
-{
+Sequence ceph::io_exerciser::Seq7::get_id() const {
+  return Sequence::SEQUENCE_SEQ7;
+}
+
+std::string ceph::io_exerciser::Seq7::get_name() const {
   return "Permutations of offset 2-region 1-block writes";
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq7::_next()
-{
+std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq7::_next() {
   if (!doneread) {
     if (!donebarrier) {
       donebarrier = true;
-      return IoOp::generate_barrier();
+      return BarrierOp::generate();
     }
     doneread = true;
     barrier = true;
-    return IoOp::generate_read(0, obj_size);
+    return SingleReadOp::generate(0, obj_size);
   }
   if (offset == 0) {
     doneread = false;
     donebarrier = false;
-    offset = obj_size+1;
+    offset = obj_size + 1;
     return increment_object_size();
   }
   offset--;
-  if (offset == obj_size/2) {
+  if (offset == obj_size / 2) {
     return _next();
   }
   doneread = false;
   donebarrier = false;
-  return IoOp::generate_write2(offset, 1, obj_size/2, 1);
+  return DoubleReadOp::generate(offset, 1, obj_size / 2, 1);
 }
 
-
-
-ceph::io_exerciser::Seq8::Seq8(std::pair<int,int> obj_size_range, int seed) :
-  IoSequence(obj_size_range, seed), offset1(0), offset2(1)
-{
+ceph::io_exerciser::Seq8::Seq8(std::pair<int, int> obj_size_range, int seed)
+    : IoSequence(obj_size_range, seed), offset1(0), offset2(1) {
   set_min_object_size(3);
 }
 
-std::string ceph::io_exerciser::Seq8::get_name() const
-{
+Sequence ceph::io_exerciser::Seq8::get_id() const {
+  return Sequence::SEQUENCE_SEQ8;
+}
+
+std::string ceph::io_exerciser::Seq8::get_name() const {
   return "Permutations of offset 3-region 1-block write I/O";
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq8::_next()
-{
+std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq8::_next() {
   if (!doneread) {
     if (!donebarrier) {
       donebarrier = true;
-      return IoOp::generate_barrier();
+      return BarrierOp::generate();
     }
     doneread = true;
     barrier = true;
-    return IoOp::generate_read(0, obj_size);
+    return SingleReadOp::generate(0, obj_size);
   }
   offset2++;
   if (offset2 >= obj_size - offset1) {
@@ -455,34 +476,30 @@ std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq8::_next()
   }
   doneread = false;
   donebarrier = false;
-  return IoOp::generate_write3(offset1, 1,
-                              offset1 + offset2, 1,
-                              (offset1 * 2 + offset2)/2, 1);
+  return TripleWriteOp::generate(offset1, 1, offset1 + offset2, 1,
+                                 (offset1 * 2 + offset2) / 2, 1);
 }
 
+ceph::io_exerciser::Seq9::Seq9(std::pair<int, int> obj_size_range, int seed)
+    : IoSequence(obj_size_range, seed), offset(0), length(0) {}
 
-
-ceph::io_exerciser::Seq9::Seq9(std::pair<int,int> obj_size_range, int seed) :
-  IoSequence(obj_size_range, seed), offset(0), length(0)
-{
-  
+Sequence ceph::io_exerciser::Seq9::get_id() const {
+  return Sequence::SEQUENCE_SEQ9;
 }
 
-std::string ceph::io_exerciser::Seq9::get_name() const
-{
+std::string ceph::io_exerciser::Seq9::get_name() const {
   return "Permutations of offset and length write I/O";
 }
 
-std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq9::_next()
-{
+std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq9::_next() {
   if (!doneread) {
     if (!donebarrier) {
       donebarrier = true;
-      return IoOp::generate_barrier();
+      return BarrierOp::generate();
     }
     doneread = true;
     barrier = true;
-    return IoOp::generate_read(0, obj_size);
+    return SingleReadOp::generate(0, obj_size);
   }
   length++;
   if (length > obj_size - offset) {
@@ -496,5 +513,5 @@ std::unique_ptr<ceph::io_exerciser::IoOp> ceph::io_exerciser::Seq9::_next()
   }
   doneread = false;
   donebarrier = false;
-  return IoOp::generate_write(offset, length);
+  return SingleWriteOp::generate(offset, length);
 }
\ No newline at end of file
diff --git a/src/common/io_exerciser/IoSequence.h b/src/common/io_exerciser/IoSequence.h
index 114ff76303f..b6c254cf096 100644
--- a/src/common/io_exerciser/IoSequence.h
+++ b/src/common/io_exerciser/IoSequence.h
@@ -3,7 +3,6 @@
 #pragma once
 
 #include "IoOp.h"
-
 #include "include/random.h"
 
 /* Overview
@@ -29,195 +28,209 @@
  */
 
 namespace ceph {
-  namespace io_exerciser {
-
-    enum class Sequence {
-      SEQUENCE_SEQ0,
-      SEQUENCE_SEQ1,
-      SEQUENCE_SEQ2,
-      SEQUENCE_SEQ3,
-      SEQUENCE_SEQ4,
-      SEQUENCE_SEQ5,
-      SEQUENCE_SEQ6,
-      SEQUENCE_SEQ7,
-      SEQUENCE_SEQ8,
-      SEQUENCE_SEQ9,
-      //
-      SEQUENCE_END,
-      SEQUENCE_BEGIN = SEQUENCE_SEQ0
-    };
-
-    inline Sequence operator++( Sequence& s )
-    {
-      return s = (Sequence)(((int)(s) + 1));
-    }
-
-    std::ostream& operator<<(std::ostream& os, const Sequence& seq);
-
-    /* I/O Sequences */
-
-    class IoSequence {
-    public:
-      virtual ~IoSequence() = default;
-
-      virtual std::string get_name() const = 0;
-      int get_step() const;
-      int get_seed() const;
-
-      std::unique_ptr<IoOp> next();
-
-      static std::unique_ptr<IoSequence>
-        generate_sequence(Sequence s, std::pair<int,int> obj_size_range, int seed );
-
-    protected:
-      uint64_t min_obj_size;
-      uint64_t max_obj_size;
-      bool create;
-      bool barrier;
-      bool done;
-      bool remove;
-      uint64_t obj_size;
-      int step;
-      int seed;
-      ceph::util::random_number_generator<int> rng =
-        ceph::util::random_number_generator<int>();
-
-      IoSequence(std::pair<int,int> obj_size_range, int seed);
-
-      virtual std::unique_ptr<IoOp> _next() = 0;
-
-      void set_min_object_size(uint64_t size);
-      void set_max_object_size(uint64_t size);
-      void select_random_object_size();
-      std::unique_ptr<IoOp> increment_object_size();
-
-    };
-
-    class Seq0: public IoSequence {
-    public:
-      Seq0(std::pair<int,int> obj_size_range, int seed);
-
-      std::string get_name() const override;
-      std::unique_ptr<IoOp> _next() override;
-
-    private:
-      uint64_t offset;
-      uint64_t length;
-    };
-
-    class Seq1: public IoSequence {  
-    public:
-      Seq1(std::pair<int,int> obj_size_range, int seed);
-
-      std::string get_name() const override;
-      std::unique_ptr<IoOp> _next();
-
-    private:
-      int count;
-    };
-      
-    class Seq2: public IoSequence {
-    public:
-      Seq2(std::pair<int,int> obj_size_range, int seed);
-
-      std::string get_name() const override;
-      std::unique_ptr<IoOp> _next() override;
-    
-    private:
-      uint64_t offset;
-      uint64_t length;
-    };
-
-    class Seq3: public IoSequence {
-    public:
-      Seq3(std::pair<int,int> obj_size_range, int seed);
-
-      std::string get_name() const override;
-      std::unique_ptr<IoOp> _next() override;
-    private:
-      uint64_t offset1;
-      uint64_t offset2;
-    };
-
-    class Seq4: public IoSequence {
-    public:
-      Seq4(std::pair<int,int> obj_size_range, int seed);
-
-      std::string get_name() const override;
-      std::unique_ptr<IoOp> _next() override;
-
-    private:
-      uint64_t offset1;
-      uint64_t offset2;
-    };
-
-    class Seq5: public IoSequence {
-    public:
-      Seq5(std::pair<int,int> obj_size_range, int seed);
-
-      std::string get_name() const override;
-      std::unique_ptr<IoOp> _next() override;
-
-    private:
-      uint64_t offset;
-      uint64_t length;
-      bool doneread;
-      bool donebarrier;
-    };
-
-    class Seq6: public IoSequence {
-    public:
-      Seq6(std::pair<int,int> obj_size_range, int seed);
-
-      std::string get_name() const override;
-      std::unique_ptr<IoOp> _next() override;
-
-    private:
-      uint64_t offset;
-      uint64_t length;
-      bool doneread;
-      bool donebarrier;
-    };
-
-    class Seq7: public IoSequence {
-    public:
-      Seq7(std::pair<int,int> obj_size_range, int seed);
-
-      std::string get_name() const override;
-      std::unique_ptr<IoOp> _next() override;
-
-    private:
-      uint64_t offset;
-      bool doneread = true;
-      bool donebarrier = false;
-    };
-
-    class Seq8: public IoSequence {
-    public:
-      Seq8(std::pair<int,int> obj_size_range, int seed);
-
-      std::string get_name() const override;
-      std::unique_ptr<IoOp> _next() override;
-    private:
-      uint64_t offset1;
-      uint64_t offset2;
-      bool doneread = true;
-      bool donebarrier = false;
-    };
-
-    class Seq9: public IoSequence {
-    private:
-      uint64_t offset;
-      uint64_t length;
-      bool doneread = true;
-      bool donebarrier = false;
-
-    public:
-      Seq9(std::pair<int,int> obj_size_range, int seed);
-
-      std::string get_name() const override;
-
-      std::unique_ptr<IoOp> _next() override;
-    };
-  }
-}
\ No newline at end of file
+namespace io_exerciser {
+
+enum class Sequence {
+  SEQUENCE_SEQ0,
+  SEQUENCE_SEQ1,
+  SEQUENCE_SEQ2,
+  SEQUENCE_SEQ3,
+  SEQUENCE_SEQ4,
+  SEQUENCE_SEQ5,
+  SEQUENCE_SEQ6,
+  SEQUENCE_SEQ7,
+  SEQUENCE_SEQ8,
+  SEQUENCE_SEQ9,
+  SEQUENCE_SEQ10,
+
+  SEQUENCE_END,
+  SEQUENCE_BEGIN = SEQUENCE_SEQ0
+};
+
+inline Sequence operator++(Sequence& s) {
+  return s = (Sequence)(((int)(s) + 1));
+}
+
+std::ostream& operator<<(std::ostream& os, const Sequence& seq);
+
+/* I/O Sequences */
+
+class IoSequence {
+ public:
+  virtual ~IoSequence() = default;
+
+  virtual Sequence get_id() const = 0;
+  virtual std::string get_name_with_seqseed() const;
+  virtual std::string get_name() const = 0;
+  int get_step() const;
+  int get_seed() const;
+
+  virtual Sequence getNextSupportedSequenceId() const;
+  virtual std::unique_ptr<IoOp> next();
+
+  virtual bool is_supported(Sequence sequence) const;
+  static std::unique_ptr<IoSequence> generate_sequence(
+      Sequence s, std::pair<int, int> obj_size_range, int seed);
+
+ protected:
+  uint64_t min_obj_size;
+  uint64_t max_obj_size;
+  bool create;
+  bool barrier;
+  bool done;
+  bool remove;
+  uint64_t obj_size;
+  int step;
+  int seed;
+  ceph::util::random_number_generator<int> rng =
+      ceph::util::random_number_generator<int>();
+
+  IoSequence(std::pair<int, int> obj_size_range, int seed);
+
+  virtual std::unique_ptr<IoOp> _next() = 0;
+
+  void set_min_object_size(uint64_t size);
+  void set_max_object_size(uint64_t size);
+  void select_random_object_size();
+  std::unique_ptr<IoOp> increment_object_size();
+};
+
+class Seq0 : public IoSequence {
+ public:
+  Seq0(std::pair<int, int> obj_size_range, int seed);
+
+  Sequence get_id() const override;
+  std::string get_name() const override;
+  std::unique_ptr<IoOp> _next() override;
+
+ private:
+  uint64_t offset;
+  uint64_t length;
+};
+
+class Seq1 : public IoSequence {
+ public:
+  Seq1(std::pair<int, int> obj_size_range, int seed);
+
+  Sequence get_id() const override;
+  std::string get_name() const override;
+  std::unique_ptr<IoOp> _next() override;
+
+ private:
+  int count;
+};
+
+class Seq2 : public IoSequence {
+ public:
+  Seq2(std::pair<int, int> obj_size_range, int seed);
+
+  Sequence get_id() const override;
+  std::string get_name() const override;
+  std::unique_ptr<IoOp> _next() override;
+
+ private:
+  uint64_t offset;
+  uint64_t length;
+};
+
+class Seq3 : public IoSequence {
+ public:
+  Seq3(std::pair<int, int> obj_size_range, int seed);
+
+  Sequence get_id() const override;
+  std::string get_name() const override;
+  std::unique_ptr<IoOp> _next() override;
+
+ private:
+  uint64_t offset1;
+  uint64_t offset2;
+};
+
+class Seq4 : public IoSequence {
+ public:
+  Seq4(std::pair<int, int> obj_size_range, int seed);
+
+  Sequence get_id() const override;
+  std::string get_name() const override;
+  std::unique_ptr<IoOp> _next() override;
+
+ private:
+  uint64_t offset1;
+  uint64_t offset2;
+};
+
+class Seq5 : public IoSequence {
+ public:
+  Seq5(std::pair<int, int> obj_size_range, int seed);
+
+  Sequence get_id() const override;
+  std::string get_name() const override;
+  std::unique_ptr<IoOp> _next() override;
+
+ private:
+  uint64_t offset;
+  uint64_t length;
+  bool doneread;
+  bool donebarrier;
+};
+
+class Seq6 : public IoSequence {
+ public:
+  Seq6(std::pair<int, int> obj_size_range, int seed);
+
+  Sequence get_id() const override;
+  std::string get_name() const override;
+  std::unique_ptr<IoOp> _next() override;
+
+ private:
+  uint64_t offset;
+  uint64_t length;
+  bool doneread;
+  bool donebarrier;
+};
+
+class Seq7 : public IoSequence {
+ public:
+  Seq7(std::pair<int, int> obj_size_range, int seed);
+
+  Sequence get_id() const override;
+  std::string get_name() const override;
+  std::unique_ptr<IoOp> _next() override;
+
+ private:
+  uint64_t offset;
+  bool doneread = true;
+  bool donebarrier = false;
+};
+
+class Seq8 : public IoSequence {
+ public:
+  Seq8(std::pair<int, int> obj_size_range, int seed);
+
+  Sequence get_id() const override;
+  std::string get_name() const override;
+  std::unique_ptr<IoOp> _next() override;
+
+ private:
+  uint64_t offset1;
+  uint64_t offset2;
+  bool doneread = true;
+  bool donebarrier = false;
+};
+
+class Seq9 : public IoSequence {
+ private:
+  uint64_t offset;
+  uint64_t length;
+  bool doneread = true;
+  bool donebarrier = false;
+
+ public:
+  Seq9(std::pair<int, int> obj_size_range, int seed);
+
+  Sequence get_id() const override;
+  std::string get_name() const override;
+  std::unique_ptr<IoOp> _next() override;
+};
+}  // namespace io_exerciser
+}  // namespace ceph
\ No newline at end of file
diff --git a/src/common/io_exerciser/Model.cc b/src/common/io_exerciser/Model.cc
index 50812ecbb15..6548e1eda7a 100644
--- a/src/common/io_exerciser/Model.cc
+++ b/src/common/io_exerciser/Model.cc
@@ -4,25 +4,11 @@
 
 using Model = ceph::io_exerciser::Model;
 
-Model::Model(const std::string& oid, uint64_t block_size) : 
-num_io(0),
-oid(oid),
-block_size(block_size)
-{
+Model::Model(const std::string& oid, uint64_t block_size)
+    : num_io(0), oid(oid), block_size(block_size) {}
 
-}
+const uint64_t Model::get_block_size() const { return block_size; }
 
-const uint64_t Model::get_block_size() const
-{
-  return block_size;
-}
+const std::string Model::get_oid() const { return oid; }
 
-const std::string Model::get_oid() const
-{
-  return oid;
-}
-
-int Model::get_num_io() const
-{
-  return num_io;
-}
\ No newline at end of file
+int Model::get_num_io() const { return num_io; }
\ No newline at end of file
diff --git a/src/common/io_exerciser/Model.h b/src/common/io_exerciser/Model.h
index 58d107409a6..9e421e79a78 100644
--- a/src/common/io_exerciser/Model.h
+++ b/src/common/io_exerciser/Model.h
@@ -1,15 +1,13 @@
 #pragma once
 
-#include "IoOp.h"
-
 #include <boost/asio/io_context.hpp>
 
-#include "librados/librados_asio.h"
-
-#include "include/interval_set.h"
-#include "global/global_init.h"
-#include "global/global_context.h"
+#include "IoOp.h"
 #include "common/Thread.h"
+#include "global/global_context.h"
+#include "global/global_init.h"
+#include "include/interval_set.h"
+#include "librados/librados_asio.h"
 
 /* Overview
  *
@@ -21,29 +19,27 @@
  */
 
 namespace ceph {
-  namespace io_exerciser {
-
-    class Model
-    {
-    protected:
-      int num_io{0};
-      std::string oid;
-      uint64_t block_size;
-
-    public:
-      Model(const std::string& oid, uint64_t block_size);
-      virtual ~Model() = default;
-
-      virtual bool readyForIoOp(IoOp& op) = 0;
-      virtual void applyIoOp(IoOp& op) = 0;
-      
-      const std::string get_oid() const;
-      const uint64_t get_block_size() const;
-      int get_num_io() const;
-    };
-
-    /* Simple RADOS I/O generator */
-
-    
-  }
-}
\ No newline at end of file
+namespace io_exerciser {
+
+class Model {
+ protected:
+  int num_io{0};
+  std::string oid;
+  uint64_t block_size;
+
+ public:
+  Model(const std::string& oid, uint64_t block_size);
+  virtual ~Model() = default;
+
+  virtual bool readyForIoOp(IoOp& op) = 0;
+  virtual void applyIoOp(IoOp& op) = 0;
+
+  const std::string get_oid() const;
+  const uint64_t get_block_size() const;
+  int get_num_io() const;
+};
+
+/* Simple RADOS I/O generator */
+
+}  // namespace io_exerciser
+}  // namespace ceph
\ No newline at end of file
diff --git a/src/common/io_exerciser/ObjectModel.cc b/src/common/io_exerciser/ObjectModel.cc
index 589f6434282..454d7254cf2 100644
--- a/src/common/io_exerciser/ObjectModel.cc
+++ b/src/common/io_exerciser/ObjectModel.cc
@@ -6,25 +6,20 @@
 
 using ObjectModel = ceph::io_exerciser::ObjectModel;
 
-ObjectModel::ObjectModel(const std::string& oid, uint64_t block_size, int seed) :
-  Model(oid, block_size), created(false)
-{
+ObjectModel::ObjectModel(const std::string& oid, uint64_t block_size, int seed)
+    : Model(oid, block_size), created(false) {
   rng.seed(seed);
 }
 
-int ObjectModel::get_seed(uint64_t offset) const
-{
+int ObjectModel::get_seed(uint64_t offset) const {
   ceph_assert(offset < contents.size());
   return contents[offset];
 }
 
-std::vector<int> ObjectModel::get_seed_offsets(int seed) const
-{
+std::vector<int> ObjectModel::get_seed_offsets(int seed) const {
   std::vector<int> offsets;
-  for (size_t i = 0; i < contents.size(); i++)
-  {
-    if (contents[i] == seed)
-    {
+  for (size_t i = 0; i < contents.size(); i++) {
+    if (contents[i] == seed) {
       offsets.push_back(i);
     }
   }
@@ -32,8 +27,7 @@ std::vector<int> ObjectModel::get_seed_offsets(int seed) const
   return offsets;
 }
 
-std::string ObjectModel::to_string(int mask) const
-{
+std::string ObjectModel::to_string(int mask) const {
   if (!created) {
     return "Object does not exist";
   }
@@ -48,107 +42,127 @@ std::string ObjectModel::to_string(int mask) const
   return result;
 }
 
-bool ObjectModel::readyForIoOp(IoOp& op)
-{
-  return true;
-}
-
-void ObjectModel::applyIoOp(IoOp& op)
-{
-  auto generate_random = [&rng = rng]() {
-    return rng();
-  };
-
-  switch (op.op) {
-  case OpType::BARRIER:
-    reads.clear();
-    writes.clear();
-    break;
-
-  case OpType::CREATE:
-    ceph_assert(!created);
-    ceph_assert(reads.empty());
-    ceph_assert(writes.empty());
-    created = true;
-    contents.resize(op.length1);
-    std::generate(std::execution::seq, contents.begin(), contents.end(),
-                  generate_random);
-    break;
-
-  case OpType::REMOVE:
-    ceph_assert(created);
-    ceph_assert(reads.empty());
-    ceph_assert(writes.empty());
-    created = false;
-    contents.resize(0);
-    break;
-
-  case OpType::READ3:
-    ceph_assert(created);
-    ceph_assert(op.offset3 + op.length3 <= contents.size());
-    // Not allowed: read overlapping with parallel write
-    ceph_assert(!writes.intersects(op.offset3, op.length3));
-    reads.union_insert(op.offset3, op.length3);
-    [[fallthrough]];
-
-  case OpType::READ2:
-    ceph_assert(created);
-    ceph_assert(op.offset2 + op.length2 <= contents.size());
-    // Not allowed: read overlapping with parallel write
-    ceph_assert(!writes.intersects(op.offset2, op.length2));
-    reads.union_insert(op.offset2, op.length2);
-    [[fallthrough]];
-
-  case OpType::READ:
-    ceph_assert(created);
-    ceph_assert(op.offset1 + op.length1 <= contents.size());
-    // Not allowed: read overlapping with parallel write
-    ceph_assert(!writes.intersects(op.offset1, op.length1));
-    reads.union_insert(op.offset1, op.length1);
-    num_io++;
-    break;
-
-  case OpType::WRITE3:
-    ceph_assert(created);
-    // Not allowed: write overlapping with parallel read or write
-    ceph_assert(!reads.intersects(op.offset3, op.length3));
-    ceph_assert(!writes.intersects(op.offset3, op.length3));
-    writes.union_insert(op.offset3, op.length3);
-    ceph_assert(op.offset3 + op.length3 <= contents.size());
-    std::generate(std::execution::seq,
-                  std::next(contents.begin(), op.offset3),
-                  std::next(contents.begin(), op.offset3 + op.length3),
-                  generate_random);
-    [[fallthrough]];
-
-  case OpType::WRITE2:
-    ceph_assert(created);
-    // Not allowed: write overlapping with parallel read or write
-    ceph_assert(!reads.intersects(op.offset2, op.length2));
-    ceph_assert(!writes.intersects(op.offset2, op.length2));
-    writes.union_insert(op.offset2, op.length2);
-    ceph_assert(op.offset2 + op.length2 <= contents.size());
-    std::generate(std::execution::seq,
-                  std::next(contents.begin(), op.offset2),
-                  std::next(contents.begin(), op.offset2 + op.length2),
-                  generate_random);
-    [[fallthrough]];
-
-  case OpType::WRITE:
-    ceph_assert(created);
-    // Not allowed: write overlapping with parallel read or write
-    ceph_assert(!reads.intersects(op.offset1, op.length1));
-    ceph_assert(!writes.intersects(op.offset1, op.length1));
-    writes.union_insert(op.offset1, op.length1);
-    ceph_assert(op.offset1 + op.length1 <= contents.size());
-    std::generate(std::execution::seq,
-                  std::next(contents.begin(), op.offset1),
-                  std::next(contents.begin(), op.offset1 + op.length1),
-                  generate_random);
-    num_io++;
-    break;
-  default:
-    break;
+bool ObjectModel::readyForIoOp(IoOp& op) { return true; }
+
+void ObjectModel::applyIoOp(IoOp& op) {
+  auto generate_random = [&rng = rng]() { return rng(); };
+
+  auto verify_and_record_read_op =
+      [&contents = contents, &created = created, &num_io = num_io,
+       &reads = reads,
+       &writes = writes]<OpType opType, int N>(ReadWriteOp<opType, N>& readOp) {
+        ceph_assert(created);
+        for (int i = 0; i < N; i++) {
+          ceph_assert(readOp.offset[i] + readOp.length[i] <= contents.size());
+          // Not allowed: read overlapping with parallel write
+          ceph_assert(!writes.intersects(readOp.offset[i], readOp.length[i]));
+          reads.union_insert(readOp.offset[i], readOp.length[i]);
+        }
+        num_io++;
+      };
+
+  auto verify_write_and_record_and_generate_seed =
+      [&generate_random, &contents = contents, &created = created,
+       &num_io = num_io, &reads = reads,
+       &writes = writes]<OpType opType, int N>(ReadWriteOp<opType, N> writeOp) {
+        ceph_assert(created);
+        for (int i = 0; i < N; i++) {
+          // Not allowed: write overlapping with parallel read or write
+          ceph_assert(!reads.intersects(writeOp.offset[i], writeOp.length[i]));
+          ceph_assert(!writes.intersects(writeOp.offset[i], writeOp.length[i]));
+          writes.union_insert(writeOp.offset[i], writeOp.length[i]);
+          ceph_assert(writeOp.offset[i] + writeOp.length[i] <= contents.size());
+          std::generate(std::execution::seq,
+                        std::next(contents.begin(), writeOp.offset[i]),
+                        std::next(contents.begin(),
+                                  writeOp.offset[i] + writeOp.length[i]),
+                        generate_random);
+        }
+        num_io++;
+      };
+
+  auto verify_failed_write_and_record =
+      [&contents = contents, &created = created, &num_io = num_io,
+       &reads = reads,
+       &writes = writes]<OpType opType, int N>(ReadWriteOp<opType, N> writeOp) {
+        // Ensure write should still be valid, even though we are expecting OSD
+        // failure
+        ceph_assert(created);
+        for (int i = 0; i < N; i++) {
+          // Not allowed: write overlapping with parallel read or write
+          ceph_assert(!reads.intersects(writeOp.offset[i], writeOp.length[i]));
+          ceph_assert(!writes.intersects(writeOp.offset[i], writeOp.length[i]));
+          writes.union_insert(writeOp.offset[i], writeOp.length[i]);
+          ceph_assert(writeOp.offset[i] + writeOp.length[i] <= contents.size());
+        }
+        num_io++;
+      };
+
+  switch (op.getOpType()) {
+    case OpType::Barrier:
+      reads.clear();
+      writes.clear();
+      break;
+
+    case OpType::Create:
+      ceph_assert(!created);
+      ceph_assert(reads.empty());
+      ceph_assert(writes.empty());
+      created = true;
+      contents.resize(static_cast<CreateOp&>(op).size);
+      std::generate(std::execution::seq, contents.begin(), contents.end(),
+                    generate_random);
+      break;
+
+    case OpType::Remove:
+      ceph_assert(created);
+      ceph_assert(reads.empty());
+      ceph_assert(writes.empty());
+      created = false;
+      contents.resize(0);
+      break;
+
+    case OpType::Read: {
+      SingleReadOp& readOp = static_cast<SingleReadOp&>(op);
+      verify_and_record_read_op(readOp);
+    } break;
+    case OpType::Read2: {
+      DoubleReadOp& readOp = static_cast<DoubleReadOp&>(op);
+      verify_and_record_read_op(readOp);
+    } break;
+    case OpType::Read3: {
+      TripleReadOp& readOp = static_cast<TripleReadOp&>(op);
+      verify_and_record_read_op(readOp);
+    } break;
+
+    case OpType::Write: {
+      ceph_assert(created);
+      SingleWriteOp& writeOp = static_cast<SingleWriteOp&>(op);
+      verify_write_and_record_and_generate_seed(writeOp);
+    } break;
+    case OpType::Write2: {
+      DoubleWriteOp& writeOp = static_cast<DoubleWriteOp&>(op);
+      verify_write_and_record_and_generate_seed(writeOp);
+    } break;
+    case OpType::Write3: {
+      TripleWriteOp& writeOp = static_cast<TripleWriteOp&>(op);
+      verify_write_and_record_and_generate_seed(writeOp);
+    } break;
+    case OpType::FailedWrite: {
+      ceph_assert(created);
+      SingleWriteOp& writeOp = static_cast<SingleWriteOp&>(op);
+      verify_failed_write_and_record(writeOp);
+    } break;
+    case OpType::FailedWrite2: {
+      DoubleWriteOp& writeOp = static_cast<DoubleWriteOp&>(op);
+      verify_failed_write_and_record(writeOp);
+    } break;
+    case OpType::FailedWrite3: {
+      TripleWriteOp& writeOp = static_cast<TripleWriteOp&>(op);
+      verify_failed_write_and_record(writeOp);
+    } break;
+    default:
+      break;
   }
 }
 
diff --git a/src/common/io_exerciser/ObjectModel.h b/src/common/io_exerciser/ObjectModel.h
index 93c70f41429..cad1307b84e 100644
--- a/src/common/io_exerciser/ObjectModel.h
+++ b/src/common/io_exerciser/ObjectModel.h
@@ -14,40 +14,41 @@
  */
 
 namespace ceph {
-  namespace io_exerciser {
-    /* Model of an object to track its data contents */
-
-    class ObjectModel : public Model {
-    private:
-      bool created;
-      std::vector<int> contents;
-      ceph::util::random_number_generator<int> rng =
-        ceph::util::random_number_generator<int>();
-
-      // Track read and write I/Os that can be submitted in
-      // parallel to detect violations:
-      //
-      // * Read may not overlap with a parallel write
-      // * Write may not overlap with a parallel read or write
-      // * Create / remove may not be in parallel with read or write
-      //
-      // Fix broken test cases by adding barrier ops to restrict
-      // I/O exercisers from issuing conflicting ops in parallel
-      interval_set<uint64_t> reads;
-      interval_set<uint64_t> writes;
-    public:
-      ObjectModel(const std::string& oid, uint64_t block_size, int seed);
-      
-      int get_seed(uint64_t offset) const;
-      std::vector<int> get_seed_offsets(int seed) const;
-
-      std::string to_string(int mask = -1) const;
-
-      bool readyForIoOp(IoOp& op);
-      void applyIoOp(IoOp& op);
-      
-      void encode(ceph::buffer::list& bl) const;
-      void decode(ceph::buffer::list::const_iterator& bl);
-    };
-  }
-}
\ No newline at end of file
+namespace io_exerciser {
+/* Model of an object to track its data contents */
+
+class ObjectModel : public Model {
+ private:
+  bool created;
+  std::vector<int> contents;
+  ceph::util::random_number_generator<int> rng =
+      ceph::util::random_number_generator<int>();
+
+  // Track read and write I/Os that can be submitted in
+  // parallel to detect violations:
+  //
+  // * Read may not overlap with a parallel write
+  // * Write may not overlap with a parallel read or write
+  // * Create / remove may not be in parallel with read or write
+  //
+  // Fix broken test cases by adding barrier ops to restrict
+  // I/O exercisers from issuing conflicting ops in parallel
+  interval_set<uint64_t> reads;
+  interval_set<uint64_t> writes;
+
+ public:
+  ObjectModel(const std::string& oid, uint64_t block_size, int seed);
+
+  int get_seed(uint64_t offset) const;
+  std::vector<int> get_seed_offsets(int seed) const;
+
+  std::string to_string(int mask = -1) const;
+
+  bool readyForIoOp(IoOp& op);
+  void applyIoOp(IoOp& op);
+
+  void encode(ceph::buffer::list& bl) const;
+  void decode(ceph::buffer::list::const_iterator& bl);
+};
+}  // namespace io_exerciser
+}  // namespace ceph
\ No newline at end of file
diff --git a/src/common/io_exerciser/OpType.h b/src/common/io_exerciser/OpType.h
new file mode 100644
index 00000000000..7cddb805e45
--- /dev/null
+++ b/src/common/io_exerciser/OpType.h
@@ -0,0 +1,91 @@
+#pragma once
+
+#include <fmt/format.h>
+#include <include/ceph_assert.h>
+
+/* Overview
+ *
+ * enum OpType
+ *   Enumeration of different types of I/O operation
+ *
+ */
+
+namespace ceph {
+namespace io_exerciser {
+enum class OpType {
+  Done,                  // End of I/O sequence
+  Barrier,               // Barrier - all prior I/Os must complete
+  Create,                // Create object and pattern with data
+  Remove,                // Remove object
+  Read,                  // Read
+  Read2,                 // Two reads in a single op
+  Read3,                 // Three reads in a single op
+  Write,                 // Write
+  Write2,                // Two writes in a single op
+  Write3,                // Three writes in a single op
+  FailedWrite,           // A write which should fail
+  FailedWrite2,          // Two writes in one op which should fail
+  FailedWrite3,          // Three writes in one op which should fail
+  InjectReadError,       // Op to tell OSD to inject read errors
+  InjectWriteError,      // Op to tell OSD to inject write errors
+  ClearReadErrorInject,  // Op to tell OSD to clear read error injects
+  ClearWriteErrorInject  // Op to tell OSD to clear write error injects
+};
+
+enum class InjectOpType {
+  None,
+  ReadEIO,
+  ReadMissingShard,
+  WriteFailAndRollback,
+  WriteOSDAbort
+};
+}  // namespace io_exerciser
+}  // namespace ceph
+
+template <>
+struct fmt::formatter<ceph::io_exerciser::OpType> {
+  constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
+
+  auto format(ceph::io_exerciser::OpType opType,
+              fmt::format_context& ctx) const -> fmt::format_context::iterator {
+    switch (opType) {
+      case ceph::io_exerciser::OpType::Done:
+        return fmt::format_to(ctx.out(), "Done");
+      case ceph::io_exerciser::OpType::Barrier:
+        return fmt::format_to(ctx.out(), "Barrier");
+      case ceph::io_exerciser::OpType::Create:
+        return fmt::format_to(ctx.out(), "Create");
+      case ceph::io_exerciser::OpType::Remove:
+        return fmt::format_to(ctx.out(), "Remove");
+      case ceph::io_exerciser::OpType::Read:
+        return fmt::format_to(ctx.out(), "Read");
+      case ceph::io_exerciser::OpType::Read2:
+        return fmt::format_to(ctx.out(), "Read2");
+      case ceph::io_exerciser::OpType::Read3:
+        return fmt::format_to(ctx.out(), "Read3");
+      case ceph::io_exerciser::OpType::Write:
+        return fmt::format_to(ctx.out(), "Write");
+      case ceph::io_exerciser::OpType::Write2:
+        return fmt::format_to(ctx.out(), "Write2");
+      case ceph::io_exerciser::OpType::Write3:
+        return fmt::format_to(ctx.out(), "Write3");
+      case ceph::io_exerciser::OpType::FailedWrite:
+        return fmt::format_to(ctx.out(), "FailedWrite");
+      case ceph::io_exerciser::OpType::FailedWrite2:
+        return fmt::format_to(ctx.out(), "FailedWrite2");
+      case ceph::io_exerciser::OpType::FailedWrite3:
+        return fmt::format_to(ctx.out(), "FailedWrite3");
+      case ceph::io_exerciser::OpType::InjectReadError:
+        return fmt::format_to(ctx.out(), "InjectReadError");
+      case ceph::io_exerciser::OpType::InjectWriteError:
+        return fmt::format_to(ctx.out(), "InjectWriteError");
+      case ceph::io_exerciser::OpType::ClearReadErrorInject:
+        return fmt::format_to(ctx.out(), "ClearReadErrorInject");
+      case ceph::io_exerciser::OpType::ClearWriteErrorInject:
+        return fmt::format_to(ctx.out(), "ClearWriteErrorInject");
+      default:
+        ceph_abort_msg("Unknown OpType");
+        return fmt::format_to(ctx.out(), "Unknown OpType");
+    }
+  }
+};
\ No newline at end of file
diff --git a/src/common/io_exerciser/RadosIo.cc b/src/common/io_exerciser/RadosIo.cc
index 44b82260263..a78c074228b 100644
--- a/src/common/io_exerciser/RadosIo.cc
+++ b/src/common/io_exerciser/RadosIo.cc
@@ -1,300 +1,453 @@
 #include "RadosIo.h"
 
+#include <fmt/format.h>
+#include <json_spirit/json_spirit.h>
+
+#include <ranges>
+
 #include "DataGenerator.h"
+#include "common/ceph_json.h"
+#include "common/json/OSDStructures.h"
 
 using RadosIo = ceph::io_exerciser::RadosIo;
 
-RadosIo::RadosIo(librados::Rados& rados,
-        boost::asio::io_context& asio,
-        const std::string& pool,
-        const std::string& oid,
-        uint64_t block_size,
-        int seed,
-	int threads,
-        ceph::mutex& lock,
-        ceph::condition_variable& cond) :
-  Model(oid, block_size),
-  rados(rados),
-  asio(asio),
-  om(std::make_unique<ObjectModel>(oid, block_size, seed)),
-  db(data_generation::DataGenerator::create_generator(
-      data_generation::GenerationType::HeaderedSeededRandom, *om)),
-  pool(pool),
-  threads(threads),
-  lock(lock),
-  cond(cond),
-  outstanding_io(0)
-{
+namespace {
+template <typename S>
+int send_osd_command(int osd, S& s, librados::Rados& rados, const char* name,
+                     ceph::buffer::list& inbl, ceph::buffer::list* outbl,
+                     Formatter* f) {
+  encode_json(name, s, f);
+
+  std::ostringstream oss;
+  f->flush(oss);
+  int rc = rados.osd_command(osd, oss.str(), inbl, outbl, nullptr);
+  return rc;
+}
+
+template <typename S>
+int send_mon_command(S& s, librados::Rados& rados, const char* name,
+                     ceph::buffer::list& inbl, ceph::buffer::list* outbl,
+                     Formatter* f) {
+  encode_json(name, s, f);
+
+  std::ostringstream oss;
+  f->flush(oss);
+  int rc = rados.mon_command(oss.str(), inbl, outbl, nullptr);
+  return rc;
+}
+}  // namespace
+
+RadosIo::RadosIo(librados::Rados& rados, boost::asio::io_context& asio,
+                 const std::string& pool, const std::string& oid,
+                 const std::optional<std::vector<int>>& cached_shard_order,
+                 uint64_t block_size, int seed, int threads, ceph::mutex& lock,
+                 ceph::condition_variable& cond)
+    : Model(oid, block_size),
+      rados(rados),
+      asio(asio),
+      om(std::make_unique<ObjectModel>(oid, block_size, seed)),
+      db(data_generation::DataGenerator::create_generator(
+          data_generation::GenerationType::HeaderedSeededRandom, *om)),
+      pool(pool),
+      cached_shard_order(cached_shard_order),
+      threads(threads),
+      lock(lock),
+      cond(cond),
+      outstanding_io(0) {
   int rc;
   rc = rados.ioctx_create(pool.c_str(), io);
   ceph_assert(rc == 0);
   allow_ec_overwrites(true);
 }
 
-RadosIo::~RadosIo()
-{
-}
+RadosIo::~RadosIo() {}
 
-void RadosIo::start_io()
-{
+void RadosIo::start_io() {
   std::lock_guard l(lock);
   outstanding_io++;
 }
 
-void RadosIo::finish_io()
-{
+void RadosIo::finish_io() {
   std::lock_guard l(lock);
   ceph_assert(outstanding_io > 0);
   outstanding_io--;
   cond.notify_all();
 }
 
-void RadosIo::wait_for_io(int count)
-{
+void RadosIo::wait_for_io(int count) {
   std::unique_lock l(lock);
   while (outstanding_io > count) {
     cond.wait(l);
   }
 }
 
-void RadosIo::allow_ec_overwrites(bool allow)
-{
+void RadosIo::allow_ec_overwrites(bool allow) {
   int rc;
   bufferlist inbl, outbl;
-  std::string cmdstr =
-    "{\"prefix\": \"osd pool set\", \"pool\": \"" + pool + "\", \
+  std::string cmdstr = "{\"prefix\": \"osd pool set\", \"pool\": \"" + pool +
+                       "\", \
       \"var\": \"allow_ec_overwrites\", \"val\": \"" +
-    (allow ? "true" : "false") + "\"}";
+                       (allow ? "true" : "false") + "\"}";
   rc = rados.mon_command(cmdstr, inbl, &outbl, nullptr);
   ceph_assert(rc == 0);
 }
 
-RadosIo::AsyncOpInfo::AsyncOpInfo(uint64_t offset1, uint64_t length1,
-                                  uint64_t offset2, uint64_t length2,
-                                  uint64_t offset3, uint64_t length3 ) :
-  offset1(offset1), length1(length1),
-  offset2(offset2), length2(length2),
-  offset3(offset3), length3(length3)
-{
+template <int N>
+RadosIo::AsyncOpInfo<N>::AsyncOpInfo(const std::array<uint64_t, N>& offset,
+                                     const std::array<uint64_t, N>& length)
+    : offset(offset), length(length) {}
 
-}
-
-bool RadosIo::readyForIoOp(IoOp &op)
-{
-  ceph_assert(ceph_mutex_is_locked_by_me(lock)); //Must be called with lock held
+bool RadosIo::readyForIoOp(IoOp& op) {
+  ceph_assert(
+      ceph_mutex_is_locked_by_me(lock));  // Must be called with lock held
   if (!om->readyForIoOp(op)) {
     return false;
   }
-  switch (op.op) {
-  case OpType::Done:
-  case OpType::BARRIER:
-    return outstanding_io == 0;
-  default:
-    return outstanding_io < threads;
+
+  switch (op.getOpType()) {
+    case OpType::Done:
+    case OpType::Barrier:
+      return outstanding_io == 0;
+    default:
+      return outstanding_io < threads;
   }
 }
 
-void RadosIo::applyIoOp(IoOp &op)
-{
-  std::shared_ptr<AsyncOpInfo> op_info;
-
+void RadosIo::applyIoOp(IoOp& op) {
   om->applyIoOp(op);
 
   // If there are thread concurrent I/Os in flight then wait for
   // at least one I/O to complete
-  wait_for_io(threads-1);
-  
-  switch (op.op) {
-  case OpType::Done:
-  [[ fallthrough ]];
-  case OpType::BARRIER:
-    // Wait for all outstanding I/O to complete
-    wait_for_io(0);
-    break;    
-
-  case OpType::CREATE:
-    {
+  wait_for_io(threads - 1);
+
+  switch (op.getOpType()) {
+    case OpType::Done:
+      [[fallthrough]];
+    case OpType::Barrier:
+      // Wait for all outstanding I/O to complete
+      wait_for_io(0);
+      break;
+
+    case OpType::Create: {
       start_io();
-      op_info = std::make_shared<AsyncOpInfo>(0, op.length1);
-      op_info->bl1 = db->generate_data(0, op.length1);
-      op_info->wop.write_full(op_info->bl1);
-      auto create_cb = [this] (boost::system::error_code ec,
-                               version_t ver) {
+      uint64_t opSize = static_cast<CreateOp&>(op).size;
+      std::shared_ptr<AsyncOpInfo<1>> op_info =
+          std::make_shared<AsyncOpInfo<1>>(std::array<uint64_t, 1>{0},
+                                           std::array<uint64_t, 1>{opSize});
+      op_info->bufferlist[0] = db->generate_data(0, opSize);
+      op_info->wop.write_full(op_info->bufferlist[0]);
+      auto create_cb = [this](boost::system::error_code ec, version_t ver) {
         ceph_assert(ec == boost::system::errc::success);
         finish_io();
       };
-      librados::async_operate(asio, io, oid,
-                              &op_info->wop, 0, nullptr, create_cb);
+      librados::async_operate(asio, io, oid, &op_info->wop, 0, nullptr,
+                              create_cb);
+      break;
     }
-    break;
 
-  case OpType::REMOVE:
-    {
+    case OpType::Remove: {
       start_io();
-      op_info = std::make_shared<AsyncOpInfo>();
+      auto op_info = std::make_shared<AsyncOpInfo<0>>();
       op_info->wop.remove();
-      auto remove_cb = [this] (boost::system::error_code ec,
-                               version_t ver) {
+      auto remove_cb = [this](boost::system::error_code ec, version_t ver) {
         ceph_assert(ec == boost::system::errc::success);
         finish_io();
       };
-      librados::async_operate(asio, io, oid,
-                              &op_info->wop, 0, nullptr, remove_cb);
+      librados::async_operate(asio, io, oid, &op_info->wop, 0, nullptr,
+                              remove_cb);
+      break;
     }
-    break;
+    case OpType::Read:
+      [[fallthrough]];
+    case OpType::Read2:
+      [[fallthrough]];
+    case OpType::Read3:
+      [[fallthrough]];
+    case OpType::Write:
+      [[fallthrough]];
+    case OpType::Write2:
+      [[fallthrough]];
+    case OpType::Write3:
+      [[fallthrough]];
+    case OpType::FailedWrite:
+      [[fallthrough]];
+    case OpType::FailedWrite2:
+      [[fallthrough]];
+    case OpType::FailedWrite3:
+      applyReadWriteOp(op);
+      break;
+    case OpType::InjectReadError:
+      [[fallthrough]];
+    case OpType::InjectWriteError:
+      [[fallthrough]];
+    case OpType::ClearReadErrorInject:
+      [[fallthrough]];
+    case OpType::ClearWriteErrorInject:
+      applyInjectOp(op);
+      break;
+    default:
+      ceph_abort_msg("Unrecognised Op");
+      break;
+  }
+}
 
-  case OpType::READ:
-    {
-      start_io();
-      op_info = std::make_shared<AsyncOpInfo>(op.offset1, op.length1);
-      op_info->rop.read(op.offset1 * block_size,
-                        op.length1 * block_size,
-                        &op_info->bl1, nullptr);
-      auto read_cb = [this, op_info] (boost::system::error_code ec,
-                                      version_t ver,
-                                      bufferlist bl) {
-        ceph_assert(ec == boost::system::errc::success);
-        ceph_assert(db->validate(op_info->bl1,
-                                 op_info->offset1,
-                                 op_info->length1));
-        finish_io();
-      };
-      librados::async_operate(asio, io, oid,
-                              &op_info->rop, 0, nullptr, read_cb);
-      num_io++;
+void RadosIo::applyReadWriteOp(IoOp& op) {
+  auto applyReadOp = [this]<OpType opType, int N>(
+                         ReadWriteOp<opType, N> readOp) {
+    auto op_info =
+        std::make_shared<AsyncOpInfo<N>>(readOp.offset, readOp.length);
+
+    for (int i = 0; i < N; i++) {
+      op_info->rop.read(readOp.offset[i] * block_size,
+                        readOp.length[i] * block_size, &op_info->bufferlist[i],
+                        nullptr);
     }
-    break;
+    auto read_cb = [this, op_info](boost::system::error_code ec, version_t ver,
+                                   bufferlist bl) {
+      ceph_assert(ec == boost::system::errc::success);
+      for (int i = 0; i < N; i++) {
+        ceph_assert(db->validate(op_info->bufferlist[i], op_info->offset[i],
+                                 op_info->length[i]));
+      }
+      finish_io();
+    };
+    librados::async_operate(asio, io, oid, &op_info->rop, 0, nullptr, read_cb);
+    num_io++;
+  };
 
-  case OpType::READ2:
-    {
-      start_io();
-      op_info = std::make_shared<AsyncOpInfo>(op.offset1,
-                                              op.length1,
-                                              op.offset2,
-                                              op.length2);
-
-      op_info->rop.read(op.offset1 * block_size,
-                        op.length1 * block_size,
-                        &op_info->bl1, nullptr);
-      op_info->rop.read(op.offset2 * block_size,
-                    op.length2 * block_size,
-                    &op_info->bl2, nullptr);
-      auto read2_cb = [this, op_info] (boost::system::error_code ec,
-                                       version_t ver,
-                                       bufferlist bl) {
-        ceph_assert(ec == boost::system::errc::success);
-        ceph_assert(db->validate(op_info->bl1,
-                                 op_info->offset1,
-                                 op_info->length1));
-        ceph_assert(db->validate(op_info->bl2,
-                                 op_info->offset2,
-                                 op_info->length2));
-        finish_io();
-      };
-      librados::async_operate(asio, io, oid,
-                              &op_info->rop, 0, nullptr, read2_cb);
-      num_io++;
+  auto applyWriteOp = [this]<OpType opType, int N>(
+                          ReadWriteOp<opType, N> writeOp) {
+    auto op_info =
+        std::make_shared<AsyncOpInfo<N>>(writeOp.offset, writeOp.length);
+    for (int i = 0; i < N; i++) {
+      op_info->bufferlist[i] =
+          db->generate_data(writeOp.offset[i], writeOp.length[i]);
+      op_info->wop.write(writeOp.offset[i] * block_size,
+                         op_info->bufferlist[i]);
     }
-    break;
+    auto write_cb = [this](boost::system::error_code ec, version_t ver) {
+      ceph_assert(ec == boost::system::errc::success);
+      finish_io();
+    };
+    librados::async_operate(asio, io, oid, &op_info->wop, 0, nullptr, write_cb);
+    num_io++;
+  };
 
-  case OpType::READ3:
-    {
-      start_io();
-      op_info = std::make_shared<AsyncOpInfo>(op.offset1, op.length1,
-                                              op.offset2, op.length2,
-                                              op.offset3, op.length3);
-      op_info->rop.read(op.offset1 * block_size,
-                    op.length1 * block_size,
-                    &op_info->bl1, nullptr);
-      op_info->rop.read(op.offset2 * block_size,
-                    op.length2 * block_size,
-                    &op_info->bl2, nullptr);
-      op_info->rop.read(op.offset3 * block_size,
-                    op.length3 * block_size,
-                    &op_info->bl3, nullptr);
-      auto read3_cb = [this, op_info] (boost::system::error_code ec,
-                                       version_t ver,
-                                       bufferlist bl) {
-        ceph_assert(ec == boost::system::errc::success);
-        ceph_assert(db->validate(op_info->bl1,
-                                 op_info->offset1,
-                                 op_info->length1));
-        ceph_assert(db->validate(op_info->bl2,
-                                 op_info->offset2,
-                                 op_info->length2));
-        ceph_assert(db->validate(op_info->bl3,
-                                 op_info->offset3,
-                                 op_info->length3));
-        finish_io();
-      };
-      librados::async_operate(asio, io, oid,
-                              &op_info->rop, 0, nullptr, read3_cb);
-      num_io++;
+  auto applyFailedWriteOp = [this]<OpType opType, int N>(
+                                ReadWriteOp<opType, N> writeOp) {
+    auto op_info =
+        std::make_shared<AsyncOpInfo<N>>(writeOp.offset, writeOp.length);
+    for (int i = 0; i < N; i++) {
+      op_info->bufferlist[i] =
+          db->generate_data(writeOp.offset[i], writeOp.length[i]);
+      op_info->wop.write(writeOp.offset[i] * block_size,
+                         op_info->bufferlist[i]);
     }
-    break;
+    auto write_cb = [this, writeOp](boost::system::error_code ec,
+                                    version_t ver) {
+      ceph_assert(ec != boost::system::errc::success);
+      finish_io();
+    };
+    librados::async_operate(asio, io, oid, &op_info->wop, 0, nullptr, write_cb);
+    num_io++;
+  };
 
-  case OpType::WRITE:
-    {
+  switch (op.getOpType()) {
+    case OpType::Read: {
       start_io();
-      op_info = std::make_shared<AsyncOpInfo>(op.offset1, op.length1);
-      op_info->bl1 = db->generate_data(op.offset1, op.length1);
-
-      op_info->wop.write(op.offset1 * block_size, op_info->bl1);
-      auto write_cb = [this] (boost::system::error_code ec,
-                              version_t ver) {
-        ceph_assert(ec == boost::system::errc::success);
-        finish_io();
-      };
-      librados::async_operate(asio, io, oid,
-                              &op_info->wop, 0, nullptr, write_cb);
-      num_io++;
+      SingleReadOp& readOp = static_cast<SingleReadOp&>(op);
+      applyReadOp(readOp);
+      break;
     }
-    break;
-
-  case OpType::WRITE2:
-    {
+    case OpType::Read2: {
       start_io();
-      op_info = std::make_shared<AsyncOpInfo>(op.offset1, op.length1,
-                                              op.offset2, op.length2);
-      op_info->bl1 = db->generate_data(op.offset1, op.length1);
-      op_info->bl2 = db->generate_data(op.offset2, op.length2);
-      op_info->wop.write(op.offset1 * block_size, op_info->bl1);
-      op_info->wop.write(op.offset2 * block_size, op_info->bl2);
-      auto write2_cb = [this] (boost::system::error_code ec,
-                               version_t ver) {
-        ceph_assert(ec == boost::system::errc::success);
-        finish_io();
-      };
-      librados::async_operate(asio, io, oid,
-                              &op_info->wop, 0, nullptr, write2_cb);
-      num_io++;
+      DoubleReadOp& readOp = static_cast<DoubleReadOp&>(op);
+      applyReadOp(readOp);
+      break;
+    }
+    case OpType::Read3: {
+      start_io();
+      TripleReadOp& readOp = static_cast<TripleReadOp&>(op);
+      applyReadOp(readOp);
+      break;
+    }
+    case OpType::Write: {
+      start_io();
+      SingleWriteOp& writeOp = static_cast<SingleWriteOp&>(op);
+      applyWriteOp(writeOp);
+      break;
+    }
+    case OpType::Write2: {
+      start_io();
+      DoubleWriteOp& writeOp = static_cast<DoubleWriteOp&>(op);
+      applyWriteOp(writeOp);
+      break;
+    }
+    case OpType::Write3: {
+      start_io();
+      TripleWriteOp& writeOp = static_cast<TripleWriteOp&>(op);
+      applyWriteOp(writeOp);
+      break;
     }
-    break;
 
-  case OpType::WRITE3:
-    {
+    case OpType::FailedWrite: {
       start_io();
-      op_info = std::make_shared<AsyncOpInfo>(op.offset1, op.length1,
-                                              op.offset2, op.length2,
-                                              op.offset3, op.length3);
-      op_info->bl1 = db->generate_data(op.offset1, op.length1);
-      op_info->bl2 = db->generate_data(op.offset2, op.length2);
-      op_info->bl3 = db->generate_data(op.offset3, op.length3);
-      op_info->wop.write(op.offset1 * block_size, op_info->bl1);
-      op_info->wop.write(op.offset2 * block_size, op_info->bl2);
-      op_info->wop.write(op.offset3 * block_size, op_info->bl3);
-      auto write3_cb = [this] (boost::system::error_code ec,
-                               version_t ver) {
-        ceph_assert(ec == boost::system::errc::success);
-        finish_io();
-      };
-      librados::async_operate(asio, io, oid,
-                              &op_info->wop, 0, nullptr, write3_cb);
-      num_io++;
+      SingleFailedWriteOp& writeOp = static_cast<SingleFailedWriteOp&>(op);
+      applyFailedWriteOp(writeOp);
+      break;
+    }
+    case OpType::FailedWrite2: {
+      start_io();
+      DoubleFailedWriteOp& writeOp = static_cast<DoubleFailedWriteOp&>(op);
+      applyFailedWriteOp(writeOp);
+      break;
+    }
+    case OpType::FailedWrite3: {
+      start_io();
+      TripleFailedWriteOp& writeOp = static_cast<TripleFailedWriteOp&>(op);
+      applyFailedWriteOp(writeOp);
+      break;
     }
-    break;
 
-  default:
-    break;
+    default:
+      ceph_abort_msg(
+          fmt::format("Unsupported Read/Write operation ({})", op.getOpType()));
+      break;
   }
 }
+
+void RadosIo::applyInjectOp(IoOp& op) {
+  bufferlist osdmap_inbl, inject_inbl, osdmap_outbl, inject_outbl;
+  auto formatter = std::make_unique<JSONFormatter>(false);
+
+  int osd = -1;
+  std::vector<int> shard_order;
+
+  ceph::messaging::osd::OSDMapRequest osdMapRequest{pool, get_oid(), ""};
+  int rc = send_mon_command(osdMapRequest, rados, "OSDMapRequest", osdmap_inbl,
+                            &osdmap_outbl, formatter.get());
+  ceph_assert(rc == 0);
+
+  JSONParser p;
+  bool success = p.parse(osdmap_outbl.c_str(), osdmap_outbl.length());
+  ceph_assert(success);
+
+  ceph::messaging::osd::OSDMapReply reply;
+  reply.decode_json(&p);
+
+  osd = reply.acting_primary;
+  shard_order = reply.acting;
+
+  switch (op.getOpType()) {
+    case OpType::InjectReadError: {
+      InjectReadErrorOp& errorOp = static_cast<InjectReadErrorOp&>(op);
+
+      if (errorOp.type == 0) {
+        ceph::messaging::osd::InjectECErrorRequest<InjectOpType::ReadEIO>
+            injectErrorRequest{pool,         oid,          errorOp.shard,
+                               errorOp.type, errorOp.when, errorOp.duration};
+        int rc = send_osd_command(osd, injectErrorRequest, rados,
+                                  "InjectECErrorRequest", inject_inbl,
+                                  &inject_outbl, formatter.get());
+        ceph_assert(rc == 0);
+      } else if (errorOp.type == 1) {
+        ceph::messaging::osd::InjectECErrorRequest<
+            InjectOpType::ReadMissingShard>
+            injectErrorRequest{pool,         oid,          errorOp.shard,
+                               errorOp.type, errorOp.when, errorOp.duration};
+        int rc = send_osd_command(osd, injectErrorRequest, rados,
+                                  "InjectECErrorRequest", inject_inbl,
+                                  &inject_outbl, formatter.get());
+        ceph_assert(rc == 0);
+      } else {
+        ceph_abort_msg("Unsupported inject type");
+      }
+      break;
+    }
+    case OpType::InjectWriteError: {
+      InjectWriteErrorOp& errorOp = static_cast<InjectWriteErrorOp&>(op);
+
+      if (errorOp.type == 0) {
+        ceph::messaging::osd::InjectECErrorRequest<
+            InjectOpType::WriteFailAndRollback>
+            injectErrorRequest{pool,         oid,          errorOp.shard,
+                               errorOp.type, errorOp.when, errorOp.duration};
+        int rc = send_osd_command(osd, injectErrorRequest, rados,
+                                  "InjectECErrorRequest", inject_inbl,
+                                  &inject_outbl, formatter.get());
+        ceph_assert(rc == 0);
+      } else if (errorOp.type == 3) {
+        ceph::messaging::osd::InjectECErrorRequest<InjectOpType::WriteOSDAbort>
+            injectErrorRequest{pool,         oid,          errorOp.shard,
+                               errorOp.type, errorOp.when, errorOp.duration};
+        int rc = send_osd_command(osd, injectErrorRequest, rados,
+                                  "InjectECErrorRequest", inject_inbl,
+                                  &inject_outbl, formatter.get());
+        ceph_assert(rc == 0);
+
+        // This inject is sent directly to the shard we want to inject the error
+        // on
+        osd = shard_order[errorOp.shard];
+      } else {
+        ceph_abort("Unsupported inject type");
+      }
+
+      break;
+    }
+    case OpType::ClearReadErrorInject: {
+      ClearReadErrorInjectOp& errorOp =
+          static_cast<ClearReadErrorInjectOp&>(op);
+
+      if (errorOp.type == 0) {
+        ceph::messaging::osd::InjectECClearErrorRequest<InjectOpType::ReadEIO>
+            clearErrorInject{pool, oid, errorOp.shard, errorOp.type};
+        int rc = send_osd_command(osd, clearErrorInject, rados,
+                                  "InjectECClearErrorRequest", inject_inbl,
+                                  &inject_outbl, formatter.get());
+        ceph_assert(rc == 0);
+      } else if (errorOp.type == 1) {
+        ceph::messaging::osd::InjectECClearErrorRequest<
+            InjectOpType::ReadMissingShard>
+            clearErrorInject{pool, oid, errorOp.shard, errorOp.type};
+        int rc = send_osd_command(osd, clearErrorInject, rados,
+                                  "InjectECClearErrorRequest", inject_inbl,
+                                  &inject_outbl, formatter.get());
+        ceph_assert(rc == 0);
+      } else {
+        ceph_abort("Unsupported inject type");
+      }
+
+      break;
+    }
+    case OpType::ClearWriteErrorInject: {
+      ClearReadErrorInjectOp& errorOp =
+          static_cast<ClearReadErrorInjectOp&>(op);
+
+      if (errorOp.type == 0) {
+        ceph::messaging::osd::InjectECClearErrorRequest<
+            InjectOpType::WriteFailAndRollback>
+            clearErrorInject{pool, oid, errorOp.shard, errorOp.type};
+        int rc = send_osd_command(osd, clearErrorInject, rados,
+                                  "InjectECClearErrorRequest", inject_inbl,
+                                  &inject_outbl, formatter.get());
+        ceph_assert(rc == 0);
+      } else if (errorOp.type == 3) {
+        ceph::messaging::osd::InjectECClearErrorRequest<
+            InjectOpType::WriteOSDAbort>
+            clearErrorInject{pool, oid, errorOp.shard, errorOp.type};
+        int rc = send_osd_command(osd, clearErrorInject, rados,
+                                  "InjectECClearErrorRequest", inject_inbl,
+                                  &inject_outbl, formatter.get());
+        ceph_assert(rc == 0);
+      } else {
+        ceph_abort("Unsupported inject type");
+      }
+
+      break;
+    }
+    default:
+      ceph_abort_msg(
+          fmt::format("Unsupported inject operation ({})", op.getOpType()));
+      break;
+  }
+}
\ No newline at end of file
diff --git a/src/common/io_exerciser/RadosIo.h b/src/common/io_exerciser/RadosIo.h
index 179c5bba3ae..a5c66ad4768 100644
--- a/src/common/io_exerciser/RadosIo.h
+++ b/src/common/io_exerciser/RadosIo.h
@@ -10,71 +10,65 @@
  *   in the object. Uses DataBuffer to create and validate
  *   data buffers. When there are not barrier I/Os this may
  *   issue multiple async I/Os in parallel.
- * 
+ *
  */
 
 namespace ceph {
-  namespace io_exerciser {
-    namespace data_generation {
-      class DataGenerator;
-    }
-    
-    class RadosIo: public Model {
-    protected:
-      librados::Rados& rados;
-      boost::asio::io_context& asio;
-      std::unique_ptr<ObjectModel> om;
-      std::unique_ptr<ceph::io_exerciser::data_generation::DataGenerator> db;
-      std::string pool;
-      int threads;
-      ceph::mutex& lock;
-      ceph::condition_variable& cond;
-      librados::IoCtx io;
-      int outstanding_io;
+namespace io_exerciser {
+namespace data_generation {
+class DataGenerator;
+}
+
+class RadosIo : public Model {
+ protected:
+  librados::Rados& rados;
+  boost::asio::io_context& asio;
+  std::unique_ptr<ObjectModel> om;
+  std::unique_ptr<ceph::io_exerciser::data_generation::DataGenerator> db;
+  std::string pool;
+  std::optional<std::vector<int>> cached_shard_order;
+  int threads;
+  ceph::mutex& lock;
+  ceph::condition_variable& cond;
+  librados::IoCtx io;
+  int outstanding_io;
+
+  void start_io();
+  void finish_io();
+  void wait_for_io(int count);
+
+ public:
+  RadosIo(librados::Rados& rados, boost::asio::io_context& asio,
+          const std::string& pool, const std::string& oid,
+          const std::optional<std::vector<int>>& cached_shard_order,
+          uint64_t block_size, int seed, int threads, ceph::mutex& lock,
+          ceph::condition_variable& cond);
 
-      void start_io();
-      void finish_io();
-      void wait_for_io(int count);
-      
-    public:
-      RadosIo(librados::Rados& rados,
-              boost::asio::io_context& asio,
-              const std::string& pool,
-              const std::string& oid,
-              uint64_t block_size,
-              int seed,
-              int threads,
-              ceph::mutex& lock,
-              ceph::condition_variable& cond);
+  ~RadosIo();
 
-      ~RadosIo();
+  void allow_ec_overwrites(bool allow);
 
-      void allow_ec_overwrites(bool allow);
+  template <int N>
+  class AsyncOpInfo {
+   public:
+    librados::ObjectReadOperation rop;
+    librados::ObjectWriteOperation wop;
+    std::array<ceph::bufferlist, N> bufferlist;
+    std::array<uint64_t, N> offset;
+    std::array<uint64_t, N> length;
 
-      class AsyncOpInfo {
-      public:
-        librados::ObjectReadOperation rop;
-        librados::ObjectWriteOperation wop;
-        ceph::buffer::list bl1;
-        ceph::buffer::list bl2;
-        ceph::buffer::list bl3;
-        uint64_t offset1;
-        uint64_t length1;
-        uint64_t offset2;
-        uint64_t length2;
-        uint64_t offset3;
-        uint64_t length3;
+    AsyncOpInfo(const std::array<uint64_t, N>& offset = {},
+                const std::array<uint64_t, N>& length = {});
+    ~AsyncOpInfo() = default;
+  };
 
-        AsyncOpInfo(uint64_t offset1 = 0, uint64_t length1 = 0,
-                uint64_t offset2 = 0, uint64_t length2 = 0,
-                uint64_t offset3 = 0, uint64_t length3 = 0 );
-        ~AsyncOpInfo() = default;
-      };
+  // Must be called with lock held
+  bool readyForIoOp(IoOp& op);
+  void applyIoOp(IoOp& op);
 
-      // Must be called with lock held
-      bool readyForIoOp(IoOp& op);
-      
-      void applyIoOp(IoOp& op);
-    };
-  }
-}
\ No newline at end of file
+ private:
+  void applyReadWriteOp(IoOp& op);
+  void applyInjectOp(IoOp& op);
+};
+}  // namespace io_exerciser
+}  // namespace ceph
\ No newline at end of file