diff --git a/src/llfs/confirm.hpp b/src/llfs/confirm.hpp
index d50215c..58e89df 100644
--- a/src/llfs/confirm.hpp
+++ b/src/llfs/confirm.hpp
@@ -10,6 +10,8 @@
 #ifndef LLFS_CONFIRM_HPP
 #define LLFS_CONFIRM_HPP
 
+#include <ostream>
+
 namespace llfs {
 
 enum struct ConfirmThisWillEraseAllMyData : bool {
@@ -17,6 +19,11 @@ enum struct ConfirmThisWillEraseAllMyData : bool {
   kYes = true,
 };
 
+inline std::ostream& operator<<(std::ostream& out, const ConfirmThisWillEraseAllMyData& t)
+{
+  return out << (bool)t;
+}
+
 }  // namespace llfs
 
 #endif  // LLFS_CONFIRM_HPP
diff --git a/src/llfs/ioring_log_config.cpp b/src/llfs/ioring_log_config.cpp
deleted file mode 100644
index a7d8328..0000000
--- a/src/llfs/ioring_log_config.cpp
+++ /dev/null
@@ -1,54 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#include <llfs/ioring_log_config.hpp>
-//
-
-#ifndef LLFS_DISABLE_IO_URING
-
-#include <llfs/log_block_calculator.hpp>
-#include <llfs/log_device_config.hpp>
-
-namespace llfs {
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-/*static*/ IoRingLogConfig IoRingLogConfig::from_packed(
-    const FileOffsetPtr<const PackedLogDeviceConfig&>& packed_config)
-{
-  return IoRingLogConfig{
-      .logical_size = packed_config->logical_size,
-      .physical_offset = packed_config.absolute_block_0_offset(),
-      .physical_size = packed_config->physical_size,
-      .pages_per_block_log2 = packed_config->pages_per_block_log2,
-  };
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-/*static*/ IoRingLogConfig IoRingLogConfig::from_logical_size(u64 logical_size,
-                                                              Optional<usize> opt_block_size,
-                                                              Optional<i64> opt_physical_offset)
-{
-  const usize block_size = opt_block_size.value_or(IoRingLogConfig::kDefaultBlockSize);
-  const i32 block_size_log2 = batt::log2_ceil(block_size);
-
-  BATT_CHECK_GE(block_size_log2, kLogPageSizeLog2);
-
-  return IoRingLogConfig{
-      .logical_size = logical_size,
-      .physical_offset = opt_physical_offset.value_or(0),
-      .physical_size =
-          LogBlockCalculator::disk_size_required_for_log_size(logical_size, block_size),
-      .pages_per_block_log2 = block_size_log2 - kLogPageSizeLog2,
-  };
-}
-
-}  // namespace llfs
-
-#endif  // LLFS_DISABLE_IO_URING
diff --git a/src/llfs/ioring_log_config.hpp b/src/llfs/ioring_log_config.hpp
deleted file mode 100644
index fe3c49f..0000000
--- a/src/llfs/ioring_log_config.hpp
+++ /dev/null
@@ -1,110 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#pragma once
-#ifndef LLFS_IORING_LOG_CONFIG_HPP
-#define LLFS_IORING_LOG_CONFIG_HPP
-
-#include <llfs/config.hpp>
-#include <llfs/constants.hpp>
-#include <llfs/file_offset_ptr.hpp>
-#include <llfs/int_types.hpp>
-#include <llfs/optional.hpp>
-#include <llfs/packed_log_page_header.hpp>
-
-namespace llfs {
-
-struct PackedLogDeviceConfig;
-
-//=#=#==#==#===============+=+=+=+=++=++++++++++++++-++-+--+-+----+---------------
-// Physical configuration of an IoRing-based LogDevice.
-//
-struct IoRingLogConfig {
-  static constexpr usize kDefaultBlockSize = 16 * kKiB;
-  static constexpr usize kDefaultPagesPerBlockLog2 = 5;
-
-  static_assert((1ull << (kDefaultPagesPerBlockLog2 + kLogAtomicWriteSizeLog2)) ==
-                    kDefaultBlockSize,
-                "");
-
-  // The in-memory (logical) size in bytes of the log.
-  //
-  u64 logical_size;
-
-  // The offset in bytes of the log from the beginning of the file.
-  //
-  i64 physical_offset;
-
-  // The physical size in bytes of the log.
-  //
-  u64 physical_size;
-
-  // Specifies the size of a "flush block," the size of a single write operation while flushing,
-  // in number of kLogAtomicWriteSize (default=512; see llfs/config.hpp) byte pages, log2.  For
-  // example:
-  //
-  //  | flush_block_pages_log2   | flush write buffer size   |
-  //  |--------------------------|---------------------------|
-  //  | 0                        | 512                       |
-  //  | 1                        | 1kb                       |
-  //  | 2                        | 2kb                       |
-  //  | 3                        | 4kb                       |
-  //  | 4                        | 8kb                       |
-  //  | 5                        | 16kb                      |
-  //  | 6                        | 32kb                      |
-  //  | 7                        | 64kb                      |
-  //
-  usize pages_per_block_log2 = kDefaultPagesPerBlockLog2;
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  static IoRingLogConfig from_packed(
-      const FileOffsetPtr<const PackedLogDeviceConfig&>& packed_config);
-
-  /** \brief Constructs and returns a config based on a given logical size.
-   *
-   * The block size defaults to IoRingLogConfig::kDefaultBlockSize.
-   * The physical offset defaults to 0.
-   * In all cases physical size is derived from logical size and block size.
-   *
-   * \return the new IoRingLogConfig
-   */
-  static IoRingLogConfig from_logical_size(u64 logical_size, Optional<usize> opt_block_size = None,
-                                           Optional<i64> opt_physical_offset = None);
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  usize pages_per_block() const
-  {
-    return usize{1} << this->pages_per_block_log2;
-  }
-
-  usize block_size() const
-  {
-    return kLogPageSize * this->pages_per_block();
-  }
-
-  usize block_capacity() const
-  {
-    return this->block_size() - sizeof(PackedLogPageHeader);
-  }
-
-  usize block_count() const
-  {
-    BATT_CHECK_EQ(this->physical_size % this->block_size(), 0u)
-        << "The physical size of the log must be a multiple of the block size!"
-        << BATT_INSPECT(this->physical_size) << BATT_INSPECT(this->block_size())
-        << BATT_INSPECT(this->pages_per_block_log2);
-
-    return this->physical_size / this->block_size();
-  }
-};
-
-}  // namespace llfs
-
-#endif  // LLFS_IORING_LOG_CONFIG_HPP
diff --git a/src/llfs/ioring_log_config2.cpp b/src/llfs/ioring_log_config2.cpp
index f55a8cc..720e356 100644
--- a/src/llfs/ioring_log_config2.cpp
+++ b/src/llfs/ioring_log_config2.cpp
@@ -11,6 +11,9 @@
 
 #include <llfs/log_device_config2.hpp>
 
+#include <batteries/checked_cast.hpp>
+#include <batteries/math.hpp>
+
 namespace llfs {
 
 //==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
@@ -27,4 +30,24 @@ namespace llfs {
   };
 }
 
+//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
+//
+/*static*/ IoRingLogConfig2 IoRingLogConfig2::from_logical_size(u64 logical_size,
+                                                                Optional<u64> opt_device_page_size,
+                                                                Optional<u64> opt_data_alignment)
+{
+  const u64 device_page_size = opt_device_page_size.value_or(Self::kDefaultDevicePageSize);
+  const u64 data_alignment = opt_data_alignment.value_or(Self::kDefaultDataAlignment);
+
+  const i32 device_page_size_log2 = batt::log2_ceil(device_page_size);
+  const i32 data_alignment_log2 = batt::log2_ceil(data_alignment);
+
+  return IoRingLogConfig2{
+      .control_block_offset = 0,
+      .log_capacity = batt::round_up_bits(data_alignment_log2, logical_size),
+      .device_page_size_log2 = BATT_CHECKED_CAST(u16, device_page_size_log2),
+      .data_alignment_log2 = BATT_CHECKED_CAST(u16, data_alignment_log2),
+  };
+}
+
 }  //namespace llfs
diff --git a/src/llfs/ioring_log_config2.hpp b/src/llfs/ioring_log_config2.hpp
index 02f1c5a..4108d73 100644
--- a/src/llfs/ioring_log_config2.hpp
+++ b/src/llfs/ioring_log_config2.hpp
@@ -15,16 +15,35 @@
 
 #include <llfs/file_offset_ptr.hpp>
 #include <llfs/int_types.hpp>
-#include <llfs/ioring_log_config2.hpp>
+#include <llfs/interval.hpp>
 
 namespace llfs {
 
 struct PackedLogDeviceConfig2;
 
 struct IoRingLogConfig2 {
+  using Self = IoRingLogConfig2;
+
+  //+++++++++++-+-+--+----- --- -- -  -  -   -
+
+  static constexpr usize kDefaultDevicePageSize = 512;
+  static constexpr usize kDefaultDataAlignment = 4096;
+
+  static constexpr u16 kDefaultDevicePageSizeLog2 = 9 /*=log2(512)*/;
+  static constexpr u16 kDefaultDataAlignmentLog2 = 12 /*=log2(4096)*/;
+
+  static_assert((usize{1} << Self::kDefaultDevicePageSizeLog2) == Self::kDefaultDevicePageSize);
+  static_assert((usize{1} << Self::kDefaultDataAlignmentLog2) == Self::kDefaultDataAlignment);
+
+  //+++++++++++-+-+--+----- --- -- -  -  -   -
+
   static IoRingLogConfig2 from_packed(
       const FileOffsetPtr<const PackedLogDeviceConfig2&>& packed_config);
 
+  static IoRingLogConfig2 from_logical_size(u64 logical_size,
+                                            Optional<u64> opt_device_page_size = None,
+                                            Optional<u64> opt_data_alignment = None);
+
   //+++++++++++-+-+--+----- --- -- -  -  -   -
 
   i64 control_block_offset;
@@ -38,6 +57,15 @@ struct IoRingLogConfig2 {
   {
     return i64{1} << this->data_alignment_log2;
   }
+
+  Interval<i64> offset_range() const noexcept
+  {
+    return Interval<i64>{
+        .lower_bound = this->control_block_offset,
+        .upper_bound = this->control_block_offset + this->control_block_size() +
+                       static_cast<i64>(this->log_capacity),
+    };
+  }
 };
 
 }  //namespace llfs
diff --git a/src/llfs/ioring_log_device.cpp b/src/llfs/ioring_log_device.cpp
deleted file mode 100644
index 60ccdd5..0000000
--- a/src/llfs/ioring_log_device.cpp
+++ /dev/null
@@ -1,20 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#include <llfs/ioring_log_device.hpp>
-//
-
-#include <llfs/config.hpp>
-
-#ifndef LLFS_DISABLE_IO_URING
-
-namespace llfs {
-
-}  // namespace llfs
-
-#endif  // LLFS_DISABLE_IO_URING
diff --git a/src/llfs/ioring_log_device.hpp b/src/llfs/ioring_log_device.hpp
deleted file mode 100644
index ccf79b2..0000000
--- a/src/llfs/ioring_log_device.hpp
+++ /dev/null
@@ -1,115 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#pragma once
-#ifndef LLFS_IORING_LOG_DEVICE_HPP
-#define LLFS_IORING_LOG_DEVICE_HPP
-
-#include <llfs/config.hpp>
-
-#ifndef LLFS_DISABLE_IO_URING
-
-#include <llfs/basic_ring_buffer_log_device.hpp>
-#include <llfs/confirm.hpp>
-#include <llfs/define_packed_type.hpp>
-#include <llfs/file_offset_ptr.hpp>
-#include <llfs/ioring.hpp>
-#include <llfs/ioring_log_config.hpp>
-#include <llfs/ioring_log_device_storage.hpp>
-#include <llfs/ioring_log_driver.hpp>
-#include <llfs/ioring_log_driver_options.hpp>
-#include <llfs/ioring_log_flush_op.hpp>
-#include <llfs/metrics.hpp>
-
-#include <batteries/async/mutex.hpp>
-#include <batteries/async/task.hpp>
-
-namespace llfs {
-
-using IoRingLogDevice = BasicRingBufferLogDevice<IoRingLogDriver>;
-
-//=#=#==#==#===============+=+=+=+=++=++++++++++++++-++-+--+-+----+---------------
-
-class IoRingLogDeviceFactory : public LogDeviceFactory
-{
- public:
-  explicit IoRingLogDeviceFactory(batt::TaskScheduler& task_scheduler, int fd,
-                                  const FileOffsetPtr<const PackedLogDeviceConfig&>& packed_config,
-                                  const IoRingLogDriverOptions& options) noexcept
-      : IoRingLogDeviceFactory{task_scheduler, fd, IoRingLogConfig::from_packed(packed_config),
-                               options}
-  {
-  }
-
-  explicit IoRingLogDeviceFactory(batt::TaskScheduler& task_scheduler, int fd,
-                                  const IoRingLogConfig& config,
-                                  const IoRingLogDriverOptions& options) noexcept
-      : task_scheduler_{task_scheduler}
-      , fd_{fd}
-      , config_{config}
-      , options_{options}
-  {
-  }
-
-  ~IoRingLogDeviceFactory() noexcept
-  {
-    if (this->fd_ != -1) {
-      ::close(this->fd_);
-    }
-  }
-
-  StatusOr<std::unique_ptr<IoRingLogDevice>> open_ioring_log_device()
-  {
-    LogBlockCalculator calculate{this->config_, this->options_};
-
-    BATT_ASSIGN_OK_RESULT(DefaultIoRingLogDeviceStorage storage,
-                          DefaultIoRingLogDeviceStorage::make_new(
-                              MaxQueueDepth{
-                                  calculate.queue_depth() * 2
-                                  //
-                                  // Double the number of flush ops, to give us some margin so the
-                                  // rings don't ever run out of space (TODO [tastolfi 2024-05-14]
-                                  // this seems excessive; investigate lowering this)
-                              },
-                              this->fd_));
-
-    this->fd_ = -1;
-
-    auto instance = std::make_unique<IoRingLogDevice>(
-        RingBuffer::TempFile{.byte_size = this->config_.logical_size}, this->task_scheduler_,
-        std::move(storage), this->config_, this->options_);
-
-    Status open_status = instance->open();
-    BATT_REQUIRE_OK(open_status);
-
-    return instance;
-  }
-
-  StatusOr<std::unique_ptr<LogDevice>> open_log_device(const LogScanFn& scan_fn) override
-  {
-    auto instance = this->open_ioring_log_device();
-    BATT_REQUIRE_OK(instance);
-
-    auto scan_status =
-        scan_fn(*(*instance)->new_reader(/*slot_lower_bound=*/None, LogReadMode::kDurable));
-    BATT_REQUIRE_OK(scan_status);
-
-    return instance;
-  }
-
- private:
-  batt::TaskScheduler& task_scheduler_;
-  int fd_;
-  IoRingLogConfig config_;
-  IoRingLogDriverOptions options_;
-};
-
-}  // namespace llfs
-
-#endif  // LLFS_DISABLE_IO_URING
-#endif  // LLFS_IORING_LOG_DEVICE_HPP
diff --git a/src/llfs/ioring_log_device.test.cpp b/src/llfs/ioring_log_device.test.cpp
deleted file mode 100644
index 9e3caa2..0000000
--- a/src/llfs/ioring_log_device.test.cpp
+++ /dev/null
@@ -1,257 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#include <llfs/ioring_log_device.hpp>
-//
-#include <llfs/ioring_log_device.hpp>
-
-#ifndef LLFS_DISABLE_IO_URING
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-#include <llfs/ioring.hpp>
-#include <llfs/ioring_log_device.test.hpp>
-#include <llfs/log_device_config.hpp>
-#include <llfs/storage_context.hpp>
-#include <llfs/uuid.hpp>
-
-#include <batteries/async/runtime.hpp>
-#include <batteries/env.hpp>
-#include <batteries/static_assert.hpp>
-
-#include <filesystem>
-
-namespace {
-
-using namespace batt::int_types;
-using namespace batt::constants;
-
-auto constexpr kLogDeviceFileName = "/tmp/llfs_IoringLogDeviceTest_StorageFile.llfs";
-
-constexpr usize kLogTotalSize = 16 * kKiB;
-constexpr usize kLogBlockSize = 1 * kKiB;
-constexpr usize kLogBlockCapacity = 960;
-constexpr usize kLogPagesPerBlockLog2 = 1;
-
-BATT_STATIC_ASSERT_EQ(kLogBlockSize, (usize{1} << kLogPagesPerBlockLog2) * llfs::kLogPageSize);
-
-TEST(IoringLogDeviceTest, StorageFile)
-{
-  for (usize amount_to_write :
-       {usize{1}, kLogBlockCapacity / 2, kLogBlockCapacity, kLogTotalSize}) {
-    const std::filesystem::path kLogDeviceFilePath = kLogDeviceFileName;
-
-    boost::uuids::uuid test_log_uuid = llfs::random_uuid();
-
-    auto scoped_ioring =
-        llfs::ScopedIoRing::make_new(llfs::MaxQueueDepth{256}, llfs::ThreadPoolSize{1});
-
-    ASSERT_TRUE(scoped_ioring.ok()) << BATT_INSPECT(scoped_ioring.status());
-
-    auto storage_context = batt::make_shared<llfs::StorageContext>(
-        batt::Runtime::instance().default_scheduler(), scoped_ioring->get_io_ring());
-
-    // Remove the file if it already exists.
-    //
-    std::filesystem::remove_all(kLogDeviceFilePath);
-    ASSERT_TRUE(!std::filesystem::exists(kLogDeviceFilePath));
-
-    // Create a log device file.
-    //
-    batt::Status add_file_status = storage_context->add_new_file(
-        kLogDeviceFilePath, [&](llfs::StorageFileBuilder& builder) -> batt::Status {
-          BATT_REQUIRE_OK(builder.add_object(llfs::LogDeviceConfigOptions{
-              .uuid = test_log_uuid,
-              .pages_per_block_log2 = kLogPagesPerBlockLog2,
-              .log_size = kLogTotalSize,
-          }));
-
-          return batt::OkStatus();
-        });
-
-    ASSERT_TRUE(add_file_status.ok()) << BATT_INSPECT(add_file_status);
-
-    {
-      // Recover the log config from the file.
-      //
-      batt::StatusOr<std::unique_ptr<llfs::IoRingLogDeviceFactory>> log_device_factory =
-          storage_context->recover_object(batt::StaticType<llfs::PackedLogDeviceConfig>{},
-                                          test_log_uuid,
-                                          llfs::IoRingLogDriverOptions::with_default_values()
-                                              .set_name("test_log")
-                                              .set_queue_depth(2));
-
-      ASSERT_TRUE(log_device_factory.ok()) << BATT_INSPECT(log_device_factory.status());
-
-      {
-        // Open the log using the recovered config.
-        //
-        batt::StatusOr<std::unique_ptr<llfs::IoRingLogDevice>> status_or_log_device =
-            (**log_device_factory).open_ioring_log_device();
-        ASSERT_TRUE(status_or_log_device.ok()) << BATT_INSPECT(status_or_log_device.status());
-
-        llfs::IoRingLogDevice& log_device = **status_or_log_device;
-
-        llfs::IoRingLogDriver& driver = log_device.driver().impl();
-        EXPECT_EQ(driver.calculate().block_capacity(), kLogBlockCapacity);
-
-        // Append some data.
-        //
-        llfs::LogDevice::Writer& writer = log_device.writer();
-
-        batt::StatusOr<llfs::MutableBuffer> dst_buffer = writer.prepare(amount_to_write);
-        ASSERT_TRUE(dst_buffer.ok()) << BATT_INSPECT(dst_buffer.status());
-        ASSERT_GE(dst_buffer->size(), amount_to_write);
-
-        std::memset(dst_buffer->data(), 'a', amount_to_write);
-
-        batt::StatusOr<llfs::slot_offset_type> commit_status = writer.commit(amount_to_write);
-        ASSERT_TRUE(commit_status.ok()) << BATT_INSPECT(commit_status);
-
-        batt::Status sync_status =
-            log_device.sync(llfs::LogReadMode::kDurable, llfs::SlotUpperBoundAt{amount_to_write});
-        ASSERT_TRUE(sync_status.ok()) << BATT_INSPECT(sync_status);
-
-        // Close the device.
-        //
-        batt::Status close_status = log_device.close();
-        ASSERT_TRUE(close_status.ok()) << BATT_INSPECT(close_status);
-      }
-    }
-
-    // Re-open the log.
-    //
-    {
-      // Recover the log config from the file.
-      //
-      batt::StatusOr<std::unique_ptr<llfs::IoRingLogDeviceFactory>> log_device_factory =
-          storage_context->recover_object(batt::StaticType<llfs::PackedLogDeviceConfig>{},
-                                          test_log_uuid,
-                                          llfs::IoRingLogDriverOptions::with_default_values()
-                                              .set_name("test_log")
-                                              .set_queue_depth(2));
-
-      ASSERT_TRUE(log_device_factory.ok()) << BATT_INSPECT(log_device_factory.status());
-
-      {
-        // Open the log using the recovered config.
-        //
-        batt::StatusOr<std::unique_ptr<llfs::IoRingLogDevice>> status_or_log_device =
-            (**log_device_factory).open_ioring_log_device();
-
-        ASSERT_TRUE(status_or_log_device.ok()) << BATT_INSPECT(status_or_log_device.status());
-      }
-    }
-  }
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-/** \brief Runs a LogDevice flush throughput microbenchmark.
- *
- * This is normally disabled; to enable it, define the env var LLFS_LOG_DEVICE_FILE to specify where
- * to create the llfs storage file that will contain the log device.
- *
- * The benchmark behavior is configured via env vars.  The basic workload is to create the storage
- * file with a log device of the specified size (LLFS_LOG_DEVICE_SIZE_KB) and pages per block
- * (LLFS_LOG_DEVICE_PAGES_PER_BLOCK), then launch two threads, an appender and a trimmer.
- *
- * The appender thread will write records of size LLFS_LOG_DEVICE_APPEND_SIZE bytes until it has
- * successfully appended a total of LLFS_LOG_DEVICE_WRITE_KB kilobytes worth of data.  Then the
- * appender waits for flush to complete, halts the LogDevice, and exits.
- *
- * The trimmer thread waits until the amount of active data in the log is at least
- * LLFS_LOG_DEVICE_TRIM_TRIGGER bytes, then trims exactly LLFS_LOG_DEVICE_TRIM_SIZE bytes, looping
- * until an error is encountered.  Under normal circumstances, this will happen when the appender
- * thread has finished and has halted the LogDevice.
- */
-TEST(IoringLogDeviceTest, Benchmark)
-{
-  using llfs::read_test_var;
-
-  const char* file_name =  //
-      std::getenv("LLFS_LOG_DEVICE_FILE");
-
-  if (!file_name) {
-    LLFS_LOG_INFO() << "LLFS_LOG_DEVICE_FILE not specified; skipping benchmark test";
-    return;
-  }
-
-  std::cout << "LLFS_LOG_DEVICE_FILE=" << batt::c_str_literal(file_name) << std::endl;
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  const usize queue_depth = read_test_var("LLFS_STORAGE_CONTEXT_QUEUE_DEPTH", usize{64});
-  const usize thread_pool_size = read_test_var("LLFS_STORAGE_CONTEXT_THREADS", usize{1});
-  const usize pages_per_block = read_test_var("LLFS_LOG_DEVICE_PAGES_PER_BLOCK", usize{32});
-  const usize log_queue_depth = read_test_var("LLFS_LOG_DEVICE_QUEUE_DEPTH", usize{1024});
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  llfs::run_log_device_benchmark([&](usize log_size, bool create, auto&& consume_log_fn) {
-    BATT_CHECK(create);
-
-    auto scoped_ioring = llfs::ScopedIoRing::make_new(llfs::MaxQueueDepth{queue_depth},
-                                                      llfs::ThreadPoolSize{thread_pool_size});
-
-    ASSERT_TRUE(scoped_ioring.ok()) << BATT_INSPECT(scoped_ioring.status());
-
-    auto storage_context = batt::make_shared<llfs::StorageContext>(
-        batt::Runtime::instance().default_scheduler(), scoped_ioring->get_io_ring());
-
-    // Remove the file if it already exists.
-    //
-    std::filesystem::path file_path{file_name};
-    std::filesystem::remove_all(file_path);
-    ASSERT_FALSE(std::filesystem::exists(file_path));
-
-    // Create a log device file.
-    //
-    const boost::uuids::uuid test_log_uuid = llfs::random_uuid();
-
-    batt::Status add_file_status = storage_context->add_new_file(
-        file_path, [&](llfs::StorageFileBuilder& builder) -> batt::Status {
-          BATT_REQUIRE_OK(builder.add_object(llfs::LogDeviceConfigOptions{
-              .uuid = test_log_uuid,
-              .pages_per_block_log2 = batt::log2_ceil(pages_per_block),
-              .log_size = log_size,
-          }));
-
-          return batt::OkStatus();
-        });
-
-    ASSERT_TRUE(add_file_status.ok()) << BATT_INSPECT(add_file_status);
-
-    // Recover the log config from the file.
-    //
-    batt::StatusOr<std::unique_ptr<llfs::IoRingLogDeviceFactory>> log_device_factory =
-        storage_context->recover_object(batt::StaticType<llfs::PackedLogDeviceConfig>{},
-                                        test_log_uuid,
-                                        llfs::IoRingLogDriverOptions::with_default_values()
-                                            .set_name("test_log")
-                                            .set_queue_depth(log_queue_depth));
-
-    // Open the log using the recovered config.
-    //
-    batt::StatusOr<std::unique_ptr<llfs::IoRingLogDevice>> status_or_log_device =
-        (**log_device_factory).open_ioring_log_device();
-
-    ASSERT_TRUE(status_or_log_device.ok()) << BATT_INSPECT(status_or_log_device.status());
-
-    llfs::IoRingLogDevice& log_device = **status_or_log_device;
-
-    // Run the workload.
-    //
-    consume_log_fn(log_device);
-  });
-}
-
-}  // namespace
-
-#endif  // LLFS_DISABLE_IO_URING
diff --git a/src/llfs/ioring_log_device2.cpp b/src/llfs/ioring_log_device2.cpp
index bb852e7..0c44ac6 100644
--- a/src/llfs/ioring_log_device2.cpp
+++ b/src/llfs/ioring_log_device2.cpp
@@ -13,8 +13,13 @@ namespace llfs {
 
 //==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
 //
-Status initialize_log_device2(RawBlockFile& file, const IoRingLogConfig2& config)
+Status initialize_log_device2(RawBlockFile& file, const IoRingLogConfig2& config,
+                              ConfirmThisWillEraseAllMyData confirm)
 {
+  if (confirm != ConfirmThisWillEraseAllMyData::kYes) {
+    return ::llfs::make_status(::llfs::StatusCode::kFileLogEraseNotConfirmed);
+  }
+
   using AlignedUnit = std::aligned_storage_t<kLogAtomicWriteSize, kLogAtomicWriteSize>;
 
   const usize device_page_size = usize{1} << config.device_page_size_log2;
diff --git a/src/llfs/ioring_log_device2.hpp b/src/llfs/ioring_log_device2.hpp
index ef1c151..6f54cbc 100644
--- a/src/llfs/ioring_log_device2.hpp
+++ b/src/llfs/ioring_log_device2.hpp
@@ -13,6 +13,7 @@
 #include <llfs/config.hpp>
 //
 #include <llfs/basic_ring_buffer_log_device.hpp>
+#include <llfs/confirm.hpp>
 #include <llfs/ioring_log_config2.hpp>
 #include <llfs/ioring_log_device2_metrics.hpp>
 #include <llfs/ioring_log_device_storage.hpp>
@@ -39,7 +40,8 @@ BATT_STRONG_TYPEDEF(slot_offset_type, CommitPos);
 /** \brief Initializes an IoRingLogDevice2 using the given storage device and configuration (which
  * includes offset within the passed device).
  */
-Status initialize_log_device2(RawBlockFile& file, const IoRingLogConfig2& config);
+Status initialize_log_device2(RawBlockFile& file, const IoRingLogConfig2& config,
+                              ConfirmThisWillEraseAllMyData confirm);
 
 template <typename StorageT>
 class IoRingLogDriver2
diff --git a/src/llfs/ioring_log_device2.test.cpp b/src/llfs/ioring_log_device2.test.cpp
index 533bad0..b7a4bca 100644
--- a/src/llfs/ioring_log_device2.test.cpp
+++ b/src/llfs/ioring_log_device2.test.cpp
@@ -171,7 +171,8 @@ class IoringLogDevice2SimTest : public ::testing::Test
       ASSERT_FALSE(storage.is_initialized());
 
       Status init_status =
-          llfs::initialize_log_device2(*storage.get_raw_block_file(), this->log_config);
+          llfs::initialize_log_device2(*storage.get_raw_block_file(), this->log_config,
+                                       llfs::ConfirmThisWillEraseAllMyData::kYes);
 
       ASSERT_TRUE(init_status.ok()) << BATT_INSPECT(init_status);
 
@@ -643,7 +644,8 @@ TEST(IoringLogDevice2Test, Benchmark)
       //+++++++++++-+-+--+----- --- -- -  -  -   -
       // Write the initial contents of the file.
       //
-      llfs::Status init_status = llfs::initialize_log_device2(file, config);
+      llfs::Status init_status =
+          llfs::initialize_log_device2(file, config, llfs::ConfirmThisWillEraseAllMyData::kYes);
 
       ASSERT_TRUE(init_status.ok()) << BATT_INSPECT(init_status);
     }
diff --git a/src/llfs/ioring_log_driver.cpp b/src/llfs/ioring_log_driver.cpp
deleted file mode 100644
index 2544b2e..0000000
--- a/src/llfs/ioring_log_driver.cpp
+++ /dev/null
@@ -1,22 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#include <llfs/ioring_log_driver.hpp>
-//
-
-#ifndef LLFS_DISABLE_IO_URING
-
-#include <llfs/ioring_log_driver.ipp>
-
-namespace llfs {
-
-template class BasicIoRingLogDriver<BasicIoRingLogFlushOp, DefaultIoRingLogDeviceStorage>;
-
-}  // namespace llfs
-
-#endif  // LLFS_DISABLE_IO_URING
diff --git a/src/llfs/ioring_log_driver.hpp b/src/llfs/ioring_log_driver.hpp
deleted file mode 100644
index 25a32fb..0000000
--- a/src/llfs/ioring_log_driver.hpp
+++ /dev/null
@@ -1,357 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#pragma once
-#ifndef LLFS_IORING_LOG_DRIVER_HPP
-#define LLFS_IORING_LOG_DRIVER_HPP
-
-#include <llfs/config.hpp>
-//
-
-#ifndef LLFS_DISABLE_IO_URING
-
-#include <llfs/basic_log_storage_driver.hpp>
-#include <llfs/int_types.hpp>
-#include <llfs/ioring_log_config.hpp>
-#include <llfs/ioring_log_device_storage.hpp>
-#include <llfs/ioring_log_driver_fwd.hpp>
-#include <llfs/ioring_log_driver_options.hpp>
-#include <llfs/ioring_log_flush_op.hpp>
-#include <llfs/log_block_calculator.hpp>
-#include <llfs/metrics.hpp>
-#include <llfs/optional.hpp>
-#include <llfs/packed_log_page_header.hpp>
-
-#include <batteries/async/watch.hpp>
-
-BATT_SUPPRESS("-Wunused-parameter")
-
-#include <boost/heap/d_ary_heap.hpp>
-#include <boost/heap/policies.hpp>
-
-BATT_UNSUPPRESS()
-
-#include <atomic>
-#include <string>
-#include <vector>
-
-namespace llfs {
-
-using IoRingLogDriver = BasicIoRingLogDriver<BasicIoRingLogFlushOp, DefaultIoRingLogDeviceStorage>;
-
-//=#=#==#==#===============+=+=+=+=++=++++++++++++++-++-+--+-+----+---------------
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-class BasicIoRingLogDriver
-{
- public:
-  using Self = BasicIoRingLogDriver;
-  using FlushOp = FlushOpImpl<Self>;
-
-  //==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  static usize disk_size_required_for_log_size(u64 logical_size, u64 block_size)
-  {
-    return LogBlockCalculator::disk_size_required_for_log_size(logical_size, block_size);
-  }
-
-  //==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-  //
-  struct Metrics {
-    LatencyMetric flush_write_latency;
-    CountMetric<u64> logical_bytes_flushed{0};
-    CountMetric<u64> physical_bytes_flushed{0};
-  };
-
-  //==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  explicit BasicIoRingLogDriver(LogStorageDriverContext& context,     //
-                                batt::TaskScheduler& task_scheduler,  //
-                                StorageT&& storage,                   //
-                                const IoRingLogConfig& config,        //
-                                const IoRingLogDriverOptions& options) noexcept;
-
-  ~BasicIoRingLogDriver() noexcept;
-
-  std::string_view name() const
-  {
-    return this->name_;
-  }
-
-  //==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-  // A storage driver impl must provide these 9 methods.
-  //
-  Status set_trim_pos(slot_offset_type trim_pos);
-
-  slot_offset_type get_trim_pos() const
-  {
-    return this->trim_pos_.get_value();
-  }
-
-  StatusOr<slot_offset_type> await_trim_pos(slot_offset_type trim_pos)
-  {
-    return await_slot_offset(trim_pos, this->trim_pos_);
-  }
-
-  //----
-
-  // There is no set_flush_pos because it's up to the storage driver to flush log data and update
-  // the flush pos in the background.
-
-  slot_offset_type get_flush_pos() const
-  {
-    return this->flush_pos_.get_value();
-  }
-
-  StatusOr<slot_offset_type> await_flush_pos(slot_offset_type flush_pos);
-
-  //----
-
-  Status set_commit_pos(slot_offset_type commit_pos);
-
-  slot_offset_type get_commit_pos() const
-  {
-    return this->commit_pos_.get_value();
-  }
-
-  StatusOr<slot_offset_type> await_commit_pos(slot_offset_type commit_pos)
-  {
-    return await_slot_offset(commit_pos, this->commit_pos_);
-  }
-
-  //----
-
-  Status open();
-
-  Status close()
-  {
-    this->halt();
-    this->join();
-    return this->storage_close_status_;
-  }
-
-  void halt();
-
-  void join();
-
-  const Metrics& metrics() const
-  {
-    return this->metrics_;
-  }
-
-  const LogBlockCalculator& calculate() const
-  {
-    return this->calculate_;
-  }
-
-  usize index_of_flush_op(const FlushOp* flush_op) const
-  {
-    return std::distance(this->flush_ops_.data(), flush_op);
-  }
-
-  // Returns the known upper bound flush position for the given flush operation.
-  //
-  slot_offset_type get_flush_op_durable_upper_bound(usize flush_op_index) const
-  {
-    BATT_CHECK_LT(flush_op_index, this->flush_ops_.size());
-    return this->flush_ops_[flush_op_index].durable_flush_pos();
-  }
-
-  void wait_for_commit(slot_offset_type least_upper_bound);
-
-  void poll_flush_state();
-
-  /** \brief Called by flush ops to report I/O failures.
-   */
-  void report_flush_error(Status error_status);
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  ConstBuffer get_data(slot_offset_type slot_offset) const
-  {
-    return this->context_.buffer_.get(slot_offset);
-  }
-
-  template <typename Handler>
-  void async_write_some(i64 file_offset, const ConstBuffer& data, i32 buf_index, Handler&& handler)
-  {
-    this->storage_.async_write_some_fixed(file_offset, data, buf_index, BATT_FORWARD(handler));
-  }
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  void update_durable_trim_pos(slot_offset_type pos)
-  {
-    clamp_min_slot(this->durable_trim_pos_, pos);
-  }
-
-  slot_offset_type get_durable_trim_pos() const
-  {
-    return this->durable_trim_pos_.get_value();
-  }
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  /** \brief Clamps the initialized physical block index upper bound to at least index.
-   */
-  void update_init_upper_bound(LogBlockCalculator::PhysicalBlockIndex index)
-  {
-    this->init_upper_bound_.clamp_min_value(index);
-  }
-
-  /** \brief Returns the current initialized physical block index upper bound.  This value is one
-   * plus the highest known initialized physical block index.
-   */
-  usize get_init_upper_bound() const noexcept
-  {
-    return this->init_upper_bound_.get_value();
-  }
-
-  /** \brief Invokes the passed handler asynchronously as soon as the initialized upper bound
-   *  (physical block index) is not equal to last_known_value.
-   *
-   * \param last_known_value The value to compare against the init_upper_bound_ Watch
-   * \param handler A callable with signature void(StatusOr<usize>)
-   */
-  template <typename Handler = void(StatusOr<usize>)>
-  void async_wait_init_upper_bound(usize last_known_value, Handler&& handler)
-  {
-    this->init_upper_bound_.async_wait(last_known_value, BATT_FORWARD(handler));
-  }
-
- private:
-  using SlotOffsetHeap = boost::heap::d_ary_heap<slot_offset_type,                   //
-                                                 boost::heap::arity<2>,              //
-                                                 boost::heap::compare<SlotGreater>,  //
-                                                 boost::heap::mutable_<true>         //
-                                                 >;
-
-  class FlushState
-  {
-   public:
-    explicit FlushState(BasicIoRingLogDriver* driver) noexcept;
-
-    void poll(BasicIoRingLogDriver* driver);
-
-    slot_offset_type get_flushed_upper_bound() const;
-
-   private:
-    slot_offset_type flushed_upper_bound_;
-    LogBlockCalculator::FlushOpIndex next_flush_op_index_;
-    slot_offset_type flush_op_slot_upper_bound_;
-  };
-
-  //==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  Status read_log_data();
-
-  void start_flush_task();
-
-  void flush_task_main();
-
-  void poll_commit_state();
-
-  void handle_commit_pos_update(const StatusOr<slot_offset_type>& updated_commit_pos);
-
-  /** \brief Signals the entering of the storage I/O event loop; the first time this is called
-   * (before a corresponding call to this->storage_work_finished()), calls
-   * this->storage_.on_work_started() to increment the work count.
-   */
-  void storage_work_started();
-
-  /** \brief Signals that storage I/O work is now in the process of shutting down.  The first time
-   * this is called (after this->storage_work_started()), calls this->storage_.on_work_finished() to
-   * decrement the work count, allowing the storage I/O event loop to exit once all activity has
-   * completed.
-   *
-   * This may be called in response to a fatal error or an external call to this->halt().
-   */
-  void storage_work_finished();
-
-  //==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  // Used to access the RingBuffer.
-  //
-  LogStorageDriverContext& context_;
-
-  batt::TaskScheduler& task_scheduler_;
-
-  // The physical log configuration plus cached derived values.
-  //
-  const IoRingLogConfig config_;
-
-  // Runtime options for the log driver plus cached derived values.
-  //
-  const IoRingLogDriverOptions options_;
-  const std::string& name_ = this->options_.name;
-
-  // Calculator for all derived values that depend on the config and options.
-  //
-  const LogBlockCalculator calculate_;
-
-  // Interface to the low-level storage media used to save log data.
-  //
-  StorageT storage_;
-
-  // The return value of this->storage_.close().
-  //
-  Status storage_close_status_ = batt::StatusCode::kUnknown;
-
-  // Set to true once when halt is first called; used to detect unexpected/premature exit of
-  // background tasks.
-  //
-  std::atomic<bool> halt_requested_{false};
-
-  // While in normal operation, we maintain a positive work count on the storage object; eventually
-  // we will release this count as part of shutting down; this field acts as a gate to make sure we
-  // only call this->storage_.on_work_started()/on_work_finished() once at the boundary of this time
-  // interval.
-  //
-  std::atomic<bool> storage_working_{false};
-
-  // The standard log state variables.
-  //
-  batt::Watch<slot_offset_type> trim_pos_{0};
-  batt::Watch<slot_offset_type> flush_pos_{0};
-  batt::Watch<slot_offset_type> commit_pos_{0};
-
-  // One past the highest physical log block index that has been initialized.
-  //
-  batt::Watch<usize> init_upper_bound_{0};
-
-  // The highest trim_pos confirmed to be durably written to the log file by one of the flush ops.
-  //
-  batt::Watch<slot_offset_type> durable_trim_pos_{0};
-
-  // The log is segmented into blocks of 512-byte pages; these blocks are flushed in parallel, by
-  // the FlushOp objects below.
-  //
-  std::vector<FlushOp> flush_ops_;
-
-  // A binary min-heap (priority queue) of flush ops that are blocked waiting for the commit pos
-  // variable to advance; the heap is ordered by the value of commit_pos each op requires, so that
-  // we can quickly activate the right ops when commit_pos advances, thus avoiding a thundering
-  // herd bottle neck (the naive solution to this problem would be for each op to just wait
-  // directly on `this->commit_pos_`, which doesn't scale).
-  //
-  SlotOffsetHeap waiting_for_commit_;
-
-  batt::HandlerMemory<128> commit_handler_memory_;
-  bool commit_pos_listener_active_ = false;
-  bool inside_poll_commit_state_ = false;
-
-  Optional<FlushState> flush_state_;
-  Metrics metrics_;
-  Optional<batt::Task> flush_task_;
-};
-
-}  // namespace llfs
-
-#endif  // LLFS_DISABLE_IO_URING
-
-#endif  // LLFS_IORING_LOG_DRIVER_HPP
diff --git a/src/llfs/ioring_log_driver.ipp b/src/llfs/ioring_log_driver.ipp
deleted file mode 100644
index 6a92584..0000000
--- a/src/llfs/ioring_log_driver.ipp
+++ /dev/null
@@ -1,574 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#pragma once
-#ifndef LLFS_IORING_LOG_DRIVER_IPP
-#define LLFS_IORING_LOG_DRIVER_IPP
-
-#include <llfs/config.hpp>
-//
-
-#ifndef LLFS_DISABLE_IO_URING
-
-#include <llfs/data_reader.hpp>
-#include <llfs/ioring_log_driver.hpp>
-#include <llfs/ioring_log_initializer.hpp>
-#include <llfs/ioring_log_recovery.hpp>
-#include <llfs/metrics.hpp>
-#include <llfs/slot_interval_map.hpp>
-
-#include <batteries/async/runtime.hpp>
-#include <batteries/metrics/metric_collectors.hpp>
-#include <batteries/seq/boxed.hpp>
-#include <batteries/stream_util.hpp>
-
-namespace llfs {
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline BasicIoRingLogDriver<FlushOpImpl, StorageT>::BasicIoRingLogDriver(
-    LogStorageDriverContext& context, batt::TaskScheduler& task_scheduler, StorageT&& storage,
-    const IoRingLogConfig& config, const IoRingLogDriverOptions& options) noexcept
-    : context_{context}
-    , task_scheduler_{task_scheduler}
-    , config_{config}
-    , options_{options}
-    , calculate_{config, options}
-    , storage_{std::move(storage)}
-    , flush_ops_(std::max(usize{2}, this->calculate().queue_depth()))
-//                        ^ we require at least two flush ops for lazy init:
-//                           one to flush a full block at the end of the log and one to
-//                           initialize the next (empty) block header.
-
-{
-  BATT_CHECK_GE(this->calculate().block_count(), this->calculate().queue_depth())
-      << "Queue Depth (== number of concurrent flush ops) may not exceed the number of blocks in "
-         "the log; please use different options!";
-
-  const auto metric_name = [this](const std::string_view& property) {
-    return batt::to_string("IoRingLogDevice_", this->name_, "_", property);
-  };
-
-  global_metric_registry()
-      .add(metric_name("trim_pos"), this->trim_pos_)
-      .add(metric_name("flush_pos"), this->flush_pos_)
-      .add(metric_name("commit_pos"), this->commit_pos_);
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline BasicIoRingLogDriver<FlushOpImpl, StorageT>::~BasicIoRingLogDriver() noexcept
-{
-  global_metric_registry()  //
-      .remove(this->trim_pos_)
-      .remove(this->flush_pos_)
-      .remove(this->commit_pos_);
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline Status BasicIoRingLogDriver<FlushOpImpl, StorageT>::open()
-{
-  // Read all blocks into the ring buffer.
-  //
-  Status data_read = this->read_log_data();
-  BATT_REQUIRE_OK(data_read) << BATT_INSPECT(this->name_);
-
-  Status fd_registered = this->storage_.register_fd();
-  BATT_REQUIRE_OK(fd_registered);
-
-  // First initialize all ops in the queue pipeline to point back at this driver.  IMPORTANT: this
-  // must be done before we allow the commit_pos to change!
-  //
-  for (auto& op : this->flush_ops_) {
-    op.initialize(this);
-  }
-
-  StatusOr<usize> buffers_registered = this->storage_.register_buffers(
-      as_seq(this->flush_ops_) | seq::map([](const Self::FlushOp& op) {
-        return op.get_buffer();
-      }) |
-      seq::boxed());
-
-  BATT_REQUIRE_OK(buffers_registered);
-
-  this->start_flush_task();
-
-  return OkStatus();
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline Status BasicIoRingLogDriver<FlushOpImpl, StorageT>::read_log_data()
-{
-  BATT_CHECK(!this->flush_task_);
-
-  // Each IoRing log device gets its own IoRing.  We must start it on a background thread to process
-  // the read operations in the loop below.  After we are done, we must stop this background thread
-  // and return the IoRing to its original state so that device driver can start up.
-  //
-  this->storage_.on_work_started();
-
-  // The background thread to process IO completions.
-  //
-  typename StorageT::EventLoopTask event_loop{this->storage_, this->name_};
-
-  // Shut down the ioring and reset when we leave this scope.
-  //
-  const auto stop_ioring_thread = batt::finally([&] {
-    LLFS_VLOG(1) << "Stopping ioring (IoRingLogDriver::read_log_data)";
-    this->storage_.on_work_finished();
-    event_loop.join();
-    this->storage_.reset_event_loop();
-  });
-
-  IoRingLogRecovery recovery{
-      this->config_, this->context_.buffer_,
-      /*read_data_fn=*/[this](i64 file_offset, MutableBuffer buffer) -> Status {
-        return this->storage_.read_all(file_offset + this->config_.physical_offset, buffer);
-      }};
-
-  LLFS_VLOG(1) << "Starting log recovery..." << BATT_INSPECT(this->name_);
-  Status recovery_status = recovery.run();
-  LLFS_VLOG(1) << "Log recovery finished: " << BATT_INSPECT(recovery_status);
-  BATT_REQUIRE_OK(recovery_status);
-
-  this->trim_pos_.set_value(recovery.get_trim_pos());
-  this->flush_pos_.set_value(recovery.get_flush_pos());
-  this->commit_pos_.set_value(recovery.get_flush_pos());
-  this->durable_trim_pos_.set_value(recovery.get_trim_pos());
-
-  // Calculate the highest physical block index that has been initialized.
-  {
-    // If the flush pos is at the end of a block, then the logical block index calculated below will
-    // be equal to the first empty block, which must have been initialized in order for the last
-    // full block's header to be written.  Otherwise the index will be a non-full block (the last
-    // and only such block in the log); in either case, we add one to get the upper bound. be
-    //
-    const auto logical_init_upper_bound = LogBlockCalculator::LogicalBlockIndex{
-        this->calculate_.logical_block_index_from(SlotLowerBoundAt{recovery.get_flush_pos()}) + 1};
-
-    // If we are at or beyond the block count, set init_upper_bound_ to its maximum value.
-    //
-    if (logical_init_upper_bound >= this->calculate_.block_count()) {
-      this->init_upper_bound_.set_value(this->calculate_.block_count());
-    } else {
-      this->init_upper_bound_.set_value(
-          this->calculate_.physical_block_index_from(logical_init_upper_bound));
-    }
-  }
-
-  // Initialize state according to recovered values.
-  //
-  this->flush_state_.emplace(this);
-
-  LLFS_VLOG(1) << "log recovery complete; total: "
-               << (this->config_.block_size() * this->config_.block_count()) << ";"
-               << BATT_INSPECT(this->trim_pos_.get_value())
-               << BATT_INSPECT(this->flush_pos_.get_value())
-               << BATT_INSPECT(this->commit_pos_.get_value());
-
-  return OkStatus();
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline Status BasicIoRingLogDriver<FlushOpImpl, StorageT>::set_trim_pos(slot_offset_type trim_pos)
-{
-  LLFS_VLOG(1) << "BasicIoRingLogDriver::set_trim_pos(" << trim_pos << ")"
-               << BATT_INSPECT(this->trim_pos_.get_value());
-
-  clamp_min_slot(this->trim_pos_, trim_pos);
-
-  return OkStatus();
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline StatusOr<slot_offset_type> BasicIoRingLogDriver<FlushOpImpl, StorageT>::await_flush_pos(
-    slot_offset_type flush_pos)
-{
-  StatusOr<slot_offset_type> status_or = await_slot_offset(flush_pos, this->flush_pos_);
-
-  // If the flush_pos Watch has been closed, it may indicate there was an I/O error; check the
-  // LogStorageDriverContext and report any error status we find.
-  //
-  if (status_or.status() == batt::StatusCode::kClosed) {
-    BATT_REQUIRE_OK(this->context_.get_error_status());
-  }
-
-  return status_or;
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline Status BasicIoRingLogDriver<FlushOpImpl, StorageT>::set_commit_pos(
-    slot_offset_type commit_pos)
-{
-  clamp_min_slot(this->commit_pos_, commit_pos);
-
-  return OkStatus();
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline void BasicIoRingLogDriver<FlushOpImpl, StorageT>::halt()
-{
-  const bool previously_halted = this->halt_requested_.exchange(true);
-  if (!previously_halted) {
-    LLFS_VLOG(1) << "BasicIoRingLogDriver::halt() - (driver=" << this->name_
-                 << " trim=" << this->trim_pos_.get_value()
-                 << " flush=" << this->flush_pos_.get_value()
-                 << " commit=" << this->commit_pos_.get_value() << ")";
-
-    this->trim_pos_.close();
-    this->flush_pos_.close();
-    this->commit_pos_.close();
-
-    this->storage_work_finished();
-  }
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline void BasicIoRingLogDriver<FlushOpImpl, StorageT>::join()
-{
-  if (this->flush_task_) {
-    BATT_DEBUG_INFO(
-        BATT_INSPECT(this->halt_requested_)
-        << BATT_INSPECT(this->trim_pos_.is_closed()) << BATT_INSPECT(this->flush_pos_.is_closed())
-        << BATT_INSPECT(this->commit_pos_.is_closed()) << BATT_INSPECT(this->storage_working_));
-
-    this->flush_task_->join();
-    this->flush_task_ = None;
-
-    LLFS_VLOG(1) << "IoRingLogDriver stopped;" << BATT_INSPECT(this->get_trim_pos())
-                 << BATT_INSPECT(this->get_flush_pos()) << BATT_INSPECT(this->get_commit_pos());
-  }
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline void BasicIoRingLogDriver<FlushOpImpl, StorageT>::start_flush_task()
-{
-  this->flush_task_.emplace(
-      this->task_scheduler_.schedule_task(),
-      [this] {
-        this->flush_task_main();
-      },
-      batt::to_string("IoRingLogDriver::flush_task(", this->name_, ")"));
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline void BasicIoRingLogDriver<FlushOpImpl, StorageT>::flush_task_main()
-{
-  Status status = [&]() -> Status {
-    const u64 total_size = this->calculate().physical_size();
-    LLFS_VLOG(1) << "(driver=" << this->name_ << ") log physical size=0x" << std::hex << total_size
-                 << " block_size=0x" << this->calculate().block_size() << " block_capacity=0x"
-                 << this->calculate().block_capacity() << " queue_depth=" << std::dec
-                 << this->calculate().queue_depth();
-    LLFS_VLOG(1) << "(driver=" << this->name_ << ")";
-
-    // Now tell the ops to start flushing data.  They will write in parallel but only one at a
-    // time will perform an async_wait on `commit_pos_`, to prevent thundering herd bottlenecks.
-    //
-    for (auto& op : this->flush_ops_) {
-      op.activate();
-    }
-
-    BATT_DEBUG_INFO([&](std::ostream& out) {
-      usize op_i = 0;
-      const usize block_count = this->calculate().block_count();
-      for (auto& op : this->flush_ops_) {
-        out << "FlushOp[" << op_i << "]: " << op.debug_info_message()
-            << " (block=" << op.get_current_log_block_index() << "/" << block_count << "), ";
-        op_i += 1;
-      }
-      out << BATT_INSPECT(this->trim_pos_) << BATT_INSPECT(this->flush_pos_)
-          << BATT_INSPECT(commit_pos_);
-    });
-
-    this->storage_work_started();
-    this->poll_flush_state();
-    this->poll_commit_state();
-
-    // Process I/O events concurrently in the background so as not to tie up the executor on which
-    // this task is running.
-    //
-    typename StorageT::EventLoopTask event_loop{this->storage_, this->name_};
-
-    // Wait for the event loop to exit.
-    //
-    event_loop.join();
-
-    // Now it is safe to close the storage layer (i.e. direct I/O block file).
-    //
-    this->storage_close_status_ = this->storage_.close();
-
-    if (!this->storage_close_status_.ok()) {
-      if (default_ioring_quiet_failure_logging()) {
-        LLFS_VLOG(1) << "Failed to close storage for IoRingLogDevice;"
-                     << BATT_INSPECT_STR(this->name_) << BATT_INSPECT(this->storage_close_status_);
-      } else {
-        LLFS_LOG_WARNING() << "Failed to close storage for IoRingLogDevice;"
-                           << BATT_INSPECT_STR(this->name_)
-                           << BATT_INSPECT(this->storage_close_status_);
-      }
-    }
-
-    return OkStatus();
-  }();
-
-  if (!this->halt_requested_.load() && this->storage_working_.load()) {
-    LLFS_LOG_WARNING() << "[IoRingLogDriver::flush_task] exited unexpectedly with status="
-                       << status;
-  } else {
-    LLFS_VLOG(1) << "[IoRingLogDriver::flush_task] exited with status=" << status;
-  }
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline void BasicIoRingLogDriver<FlushOpImpl, StorageT>::poll_flush_state()
-{
-  this->flush_state_->poll(this);
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline void BasicIoRingLogDriver<FlushOpImpl, StorageT>::report_flush_error(Status error_status)
-{
-  this->context_.update_error_status(error_status);
-  this->flush_pos_.close();
-  this->storage_work_finished();
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline void BasicIoRingLogDriver<FlushOpImpl, StorageT>::poll_commit_state()
-{
-  LLFS_VLOG(2) << "(driver=" << this->name_ << ") poll_commit_state() entered";
-
-  // Don't recursively re-enter `poll_commit_state`.
-  //
-  if (this->inside_poll_commit_state_) {
-    LLFS_VLOG(2) << "(driver=" << this->name_ << ") poll_commit_state() recursive call - returning";
-    return;
-  }
-  this->inside_poll_commit_state_ = true;
-  auto on_scope_exit = batt::finally([&] {
-    this->inside_poll_commit_state_ = false;
-  });
-
-  // Return immediately if there are no flush ops waiting for `commit_pos_` to advance.
-  //
-  if (this->waiting_for_commit_.empty()) {
-    LLFS_VLOG(2) << "(driver=" << this->name_
-                 << ") poll_commit_state() waiting_for_commit_ is empty - returning";
-    return;
-  }
-
-  // Load the current value of commit_pos_; we are going to poll all flush ops that were waiting
-  // for commit_pos to reach or exceed this value.
-  //
-  const slot_offset_type known_commit_pos = this->commit_pos_.get_value();
-  LLFS_VLOG(2) << "(driver=" << this->name_ << ") observed commit_pos=" << known_commit_pos;
-
-  // Keep notifying flush ops until we catch up or run out of waiters.
-  //
-  while (!this->waiting_for_commit_.empty()) {
-    // Pop the next commit_pos minimum from the priority queue.
-    //
-    const slot_offset_type next_wait_pos = this->waiting_for_commit_.top();
-    if (slot_less_than(known_commit_pos, next_wait_pos)) {
-      // If we're already waiting for Watch notification on `this->commit_pos_`, then nothing to
-      // do!
-      //
-      if (!this->commit_pos_listener_active_) {
-        this->commit_pos_listener_active_ = true;
-
-        LLFS_VLOG(2) << "(driver=" << this->name_ << ") waiting on commit_pos;"
-                     << BATT_INSPECT(known_commit_pos) << BATT_INSPECT(next_wait_pos)
-                     << BATT_INSPECT(this->commit_pos_.is_closed());
-
-        // If we break out of this loop before we completely drain `waiting_for_commit_`, we must
-        // start another wait operation.
-        //
-        this->commit_pos_.async_wait(          //
-            known_commit_pos,                  //
-            make_custom_alloc_handler(         //
-                this->commit_handler_memory_,  //
-                [this](const StatusOr<slot_offset_type>& updated_commit_pos) {
-                  LLFS_VLOG(2) << "(driver=" << this->name_
-                               << ") commit_pos_ updated: " << updated_commit_pos;
-                  this->handle_commit_pos_update(updated_commit_pos);
-                }));
-      }
-      break;
-    }
-    this->waiting_for_commit_.pop();
-
-    // Figure out which op must have been waiting on the given pos.
-    //
-    const usize op_index = this->calculate().flush_op_index_from(SlotUpperBoundAt{next_wait_pos});
-
-    LLFS_VLOG(2) << "(driver=" << this->name_ << ") commit_pos=" << known_commit_pos
-                 << " waking op[" << op_index
-                 << "], which was waiting on commit_pos >= " << next_wait_pos;
-
-    this->flush_ops_[op_index].handle_commit(known_commit_pos);
-  }
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline void BasicIoRingLogDriver<FlushOpImpl, StorageT>::wait_for_commit(
-    slot_offset_type least_upper_bound)
-{
-  this->waiting_for_commit_.push(least_upper_bound);
-  this->poll_commit_state();
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline void BasicIoRingLogDriver<FlushOpImpl, StorageT>::handle_commit_pos_update(
-    const StatusOr<slot_offset_type>& updated_commit_pos)
-{
-  // VERY IMPORTANT: we must execute the actual handler logic on the ioring thread to avoid data
-  // races!
-  //
-  this->storage_.post_to_event_loop(make_custom_alloc_handler(  //
-      this->commit_handler_memory_,                             //
-      [this, updated_commit_pos](const StatusOr<i32>& post_result) {
-        LLFS_VLOG(2) << "(driver=" << this->name_ << ") handle_commit_pos_update("
-                     << updated_commit_pos << ")" << BATT_INSPECT(post_result);
-
-        this->commit_pos_listener_active_ = false;
-
-        if (!updated_commit_pos.ok() || !post_result.ok()) {
-          this->storage_work_finished();
-          return;
-        }
-
-        this->poll_commit_state();
-      }));
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline void BasicIoRingLogDriver<FlushOpImpl, StorageT>::storage_work_started()
-{
-  const bool was_working = this->storage_working_.exchange(true);
-  BATT_CHECK(!was_working);
-
-  this->storage_.on_work_started();
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline void BasicIoRingLogDriver<FlushOpImpl, StorageT>::storage_work_finished()
-{
-  const bool was_working = this->storage_working_.exchange(false);
-  if (was_working) {
-    this->storage_.on_work_finished();
-  }
-  // else:
-  //   Don't assert/check here, since there are multiple legitimate places where we could call
-  //   `on_work_finished`.
-}
-
-//=#=#==#==#===============+=+=+=+=++=++++++++++++++-++-+--+-+----+---------------
-// class FlushState
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline BasicIoRingLogDriver<FlushOpImpl, StorageT>::FlushState::FlushState(
-    BasicIoRingLogDriver* driver) noexcept
-    : flushed_upper_bound_{driver->get_flush_pos()}
-
-    , next_flush_op_index_{driver->calculate().flush_op_index_from(SlotUpperBoundAt{
-          .offset = this->flushed_upper_bound_ + 1,
-      })}
-
-    , flush_op_slot_upper_bound_{driver->calculate()
-                                     .block_slot_range_from(SlotUpperBoundAt{
-                                         .offset = this->flushed_upper_bound_ + 1,
-                                     })
-                                     .upper_bound}
-{
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline void BasicIoRingLogDriver<FlushOpImpl, StorageT>::FlushState::poll(
-    BasicIoRingLogDriver* driver)
-{
-  bool update = false;
-
-  for (;;) {
-    const slot_offset_type op_durable_upper_bound =
-        slot_min(this->flush_op_slot_upper_bound_,
-                 driver->get_flush_op_durable_upper_bound(this->next_flush_op_index_));
-
-    if (slot_less_than(this->flushed_upper_bound_, op_durable_upper_bound)) {
-      this->flushed_upper_bound_ = op_durable_upper_bound;
-      update = true;
-    }
-
-    if (op_durable_upper_bound != this->flush_op_slot_upper_bound_) {
-      break;
-    }
-
-    this->next_flush_op_index_ =
-        driver->calculate().next_flush_op_index(this->next_flush_op_index_);
-
-    this->flush_op_slot_upper_bound_ += driver->calculate().block_capacity();
-  }
-  if (update) {
-    LLFS_VLOG(1) << "(driver=" << driver->name_ << ") FlushState update=true;"
-                 << BATT_INSPECT(flushed_upper_bound_)
-                 << BATT_INSPECT(driver->flush_pos_.get_value());
-
-    clamp_min_slot(driver->flush_pos_, this->flushed_upper_bound_);
-  }
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <template <typename> class FlushOpImpl, typename StorageT>
-inline slot_offset_type
-BasicIoRingLogDriver<FlushOpImpl, StorageT>::FlushState::get_flushed_upper_bound() const
-{
-  return this->flushed_upper_bound_;
-}
-
-}  // namespace llfs
-
-#endif  // LLFS_DISABLE_IO_URING
-
-#endif  // LLFS_IORING_LOG_DRIVER_IPP
diff --git a/src/llfs/ioring_log_driver.test.cpp b/src/llfs/ioring_log_driver.test.cpp
deleted file mode 100644
index befa562..0000000
--- a/src/llfs/ioring_log_driver.test.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#include <llfs/ioring_log_driver.hpp>
-#include <llfs/ioring_log_driver.ipp>
-//
-#include <llfs/ioring_log_driver.hpp>
-#include <llfs/ioring_log_driver.ipp>
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-namespace {
-
-TEST(IoringLogDriver, Test)
-{
-}
-
-}  // namespace
diff --git a/src/llfs/ioring_log_driver_fwd.hpp b/src/llfs/ioring_log_driver_fwd.hpp
deleted file mode 100644
index 6d2d45d..0000000
--- a/src/llfs/ioring_log_driver_fwd.hpp
+++ /dev/null
@@ -1,26 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#pragma once
-#ifndef LLFS_IORING_LOG_DRIVER_FWD_HPP
-#define LLFS_IORING_LOG_DRIVER_FWD_HPP
-
-#include <llfs/config.hpp>
-
-namespace llfs {
-
-#ifndef LLFS_DISABLE_IO_URING
-
-template <template <typename> class FlushOpImpl, typename StorageT>
-class BasicIoRingLogDriver;
-
-#endif  // LLFS_DISABLE_IO_URING
-
-}  //namespace llfs
-
-#endif  // LLFS_IORING_LOG_DRIVER_FWD_HPP
diff --git a/src/llfs/ioring_log_driver_options.hpp b/src/llfs/ioring_log_driver_options.hpp
deleted file mode 100644
index 8eb52de..0000000
--- a/src/llfs/ioring_log_driver_options.hpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#pragma once
-#ifndef LLFS_IORING_LOG_DRIVER_OPTIONS_HPP
-#define LLFS_IORING_LOG_DRIVER_OPTIONS_HPP
-
-#include <llfs/config.hpp>
-//
-
-#include <llfs/log_device_runtime_options.hpp>
-
-namespace llfs {
-
-using IoRingLogDriverOptions = LogDeviceRuntimeOptions;
-
-}  // namespace llfs
-
-#endif  // LLFS_IORING_LOG_DRIVER_OPTIONS_HPP
diff --git a/src/llfs/ioring_log_flush_op.cpp b/src/llfs/ioring_log_flush_op.cpp
deleted file mode 100644
index b8a35b2..0000000
--- a/src/llfs/ioring_log_flush_op.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#include <llfs/ioring_log_flush_op.hpp>
-//
-
-#ifndef LLFS_DISABLE_IO_URING
-
-#include <llfs/ioring_log_device.hpp>
-#include <llfs/ioring_log_flush_op.ipp>
-#include <llfs/metrics.hpp>
-
-namespace llfs {
-
-template class BasicIoRingLogFlushOp<IoRingLogDriver>;
-
-}  // namespace llfs
-
-#endif  // LLFS_DISABLE_IO_URING
diff --git a/src/llfs/ioring_log_flush_op.hpp b/src/llfs/ioring_log_flush_op.hpp
deleted file mode 100644
index 3e42e2d..0000000
--- a/src/llfs/ioring_log_flush_op.hpp
+++ /dev/null
@@ -1,312 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#pragma once
-#ifndef LLFS_IORING_LOG_FLUSH_OP_HPP
-#define LLFS_IORING_LOG_FLUSH_OP_HPP
-
-#include <llfs/config.hpp>
-
-#ifndef LLFS_DISABLE_IO_URING
-
-#include <llfs/data_layout.hpp>
-#include <llfs/int_types.hpp>
-#include <llfs/ioring.hpp>
-#include <llfs/ioring_log_device_storage.hpp>
-#include <llfs/ioring_log_driver_fwd.hpp>
-#include <llfs/log_block_calculator.hpp>
-#include <llfs/metrics.hpp>
-#include <llfs/packed_log_page_buffer.hpp>
-#include <llfs/packed_log_page_header.hpp>
-#include <llfs/page_buffer.hpp>
-#include <llfs/slot.hpp>
-#include <llfs/status.hpp>
-
-#include <batteries/metrics/metric_collectors.hpp>
-
-#include <batteries/async/handler.hpp>
-#include <batteries/async/watch.hpp>
-
-namespace llfs {
-
-template <typename DriverImpl>
-class BasicIoRingLogFlushOp;
-
-using IoRingLogFlushOp = BasicIoRingLogFlushOp<
-    BasicIoRingLogDriver<BasicIoRingLogFlushOp, DefaultIoRingLogDeviceStorage>>;
-
-/** \brief The global default setting for whether IoRingLogDevices should log failures at INFO or
- * higher level by default.
- *
- * This exists mostly as a convenience for testing, so that the test output doesn't contain a large
- * number of injected/simulated failure log messages.
- */
-inline std::atomic<bool>& default_ioring_quiet_failure_logging()
-{
-  static std::atomic<bool> be_quiet_{false};
-  return be_quiet_;
-}
-
-/** \brief Flushes data from the in-memory ring buffer to log storage asynchronously.
- *
- * Concurrent flush operations are implemented by instantiating a number of objects of this type.
- */
-template <typename DriverImpl>
-class BasicIoRingLogFlushOp
-{
- public:
-  enum struct WritingPart {
-    kHead = 0,
-    kTail = 1,
-    kTrimPos = 2,
-  };
-
-  struct Metrics {
-    LatencyMetric write_latency;
-    CountMetric<u64> bytes_written{0};
-  };
-
-  //==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  BasicIoRingLogFlushOp() = default;
-
-  BasicIoRingLogFlushOp(const BasicIoRingLogFlushOp&) = delete;
-  BasicIoRingLogFlushOp& operator=(const BasicIoRingLogFlushOp&) = delete;
-
-  ~BasicIoRingLogFlushOp() noexcept;
-
-  //-----
-
-  void initialize(DriverImpl* driver);
-
-  void activate();
-
-  //-----
-
-  void handle_commit(slot_offset_type known_commit_pos);
-
-  //-----
-
-  usize self_index() const;
-
-  PackedLogPageHeader* get_header() const;
-
-  // Copy data from the device ring buffer to this->page_block; return true if some data was copied.
-  //
-  bool fill_buffer(slot_offset_type known_commit_pos);
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  slot_offset_type durable_flush_pos() const
-  {
-    return this->durable_flush_pos_;
-  }
-
-  MutableBuffer get_buffer() const;
-
-  const Metrics& metrics() const
-  {
-    return this->metrics_;
-  }
-
-  /** \brief Returns the physical log block index to which this op is currently flushing.
-   */
-  LogBlockCalculator::PhysicalBlockIndex get_current_log_block_index() const
-  {
-    PackedLogPageHeader* const header = this->get_header();
-    return LogBlockCalculator::PhysicalBlockIndex{
-        this->driver_->calculate().physical_block_index_from(
-            SlotLowerBoundAt{header->slot_offset})};
-  }
-
-  /** \brief Returns one past the physical log block index to which this op is currently flushing.
-   */
-  LogBlockCalculator::PhysicalBlockIndex get_current_block_upper_bound() const
-  {
-    return LogBlockCalculator::PhysicalBlockIndex{this->get_current_log_block_index() + 1u};
-  }
-
-  /** \brief Returns the physical log block index of the block immediately after this op's current
-   * flush destination; NOTE: this is *not* the next block index that will be used by this op (which
-   * depends on the queue depth, i.e. the number of concurrent flush ops), but rather the next block
-   * in the log's physical layout (with wrap).
-   */
-  LogBlockCalculator::PhysicalBlockIndex get_next_log_block_index() const
-  {
-    PackedLogPageHeader* const header = this->get_header();
-    return LogBlockCalculator::PhysicalBlockIndex{
-        this->driver_->calculate().physical_block_index_from(
-            SlotLowerBoundAt{header->slot_offset + this->block_capacity_})};
-  }
-
-  /** \brief Returns true iff the header for this op's current log block is known to have been
-   * written at least once.
-   */
-  bool is_current_log_block_initialized() const
-  {
-    return this->driver_->get_init_upper_bound() > this->get_current_log_block_index();
-  }
-
-  /** \brief Returns true iff the header for the block immediately after this op's current block is
-   * known to have been written at least once.
-   */
-  bool is_next_log_block_initialized() const
-  {
-    return this->driver_->get_init_upper_bound() > this->get_next_log_block_index();
-  }
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  const char* debug_info_message() const
-  {
-    return this->debug_info_message_;
-  }
-
-  std::atomic<bool> quiet_failure_logging{default_ioring_quiet_failure_logging().load()};
-
- private:
-  // Return the committed data portion of the block buffer, aligned to 512-byte boundaries.
-  //
-  ConstBuffer get_writable_data() const;
-
-  // Update the log offset pointers from the driver.
-  //
-  void update_log_positions();
-
-  // Start writing the first atomic write block.
-  //
-  void flush_head();
-
-  void handle_flush_head(const StatusOr<i32>& result);
-
-  auto get_flush_head_handler()
-  {
-    return make_custom_alloc_handler(this->handler_memory_, [this](const StatusOr<i32>& result) {
-      this->handle_flush_head(result);
-    });
-  }
-
-  ConstBuffer unflushed_tail_data() const;
-
-  // Start writing everything after the first atomic write block.
-  //
-  void flush_tail();
-
-  void handle_flush_tail(const StatusOr<i32>& result);
-
-  auto get_flush_tail_handler()
-  {
-    return make_custom_alloc_handler(this->handler_memory_, [this](const StatusOr<i32>& result) {
-      this->handle_flush_tail(result);
-    });
-  }
-
-  // Should be called first after each async write... returns true if the caller should NOT continue
-  // processing the result.
-  //
-  bool handle_errors(const StatusOr<i32>& result, WritingPart writing_part);
-
-  // If the trim_pos needs to be updated for this block before writing tail pages in order to avoid
-  // possible data loss, this function will return the trim_pos value to be written.  If there is no
-  // risk of such data loss, it returns `None`.
-  //
-  Optional<slot_offset_type> need_to_update_trim_pos();
-
-  // Start writing the first (head) block for the sake of updating the durable trim pos.  This
-  // function will temporarily set the commit_size of this block to zero and, if successful, call
-  // flush_tail() afterwards.
-  //
-  void flush_trim_pos(slot_offset_type known_trim_pos);
-
-  void handle_flush_trim_pos(const StatusOr<i32>& result);
-
-  auto get_flush_trim_pos_handler()
-  {
-    return make_custom_alloc_handler(this->handler_memory_, [this](const StatusOr<i32>& result) {
-      this->handle_flush_trim_pos(result);
-    });
-  }
-  //----- --- -- -  -  -   -
-
-  // Suspends this flush op until the driver's init_upper_bound is different from last_known_value.
-  // This op will resume inside handle_init_upper_bound_changed.
-  //
-  void await_init_upper_bound_changed(usize last_known_value);
-
-  // Invoked to resume this flush op when the driver's init_upper_bound has changed.  This is used
-  // to make sure that we never commit a full block (by flushing the header) until we are sure that
-  // the next physical block has been initialized, so that recovery doesn't get confused.
-  //
-  void handle_init_upper_bound_changed(const StatusOr<usize>& result);
-
-  // Returns a bound version of handle_init_upper_bound_changed with custom memory allocation that
-  // uses this object's inline scratch buffer (this->handler_memory_).
-  //
-  auto get_init_upper_bound_changed_handler()
-  {
-    return make_custom_alloc_handler(this->handler_memory_, [this](const StatusOr<usize>& result) {
-      this->handle_init_upper_bound_changed(result);
-    });
-  }
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  Metrics metrics_;
-
-  DriverImpl* driver_ = nullptr;
-
-  std::unique_ptr<PackedLogPageBuffer[]> page_block_;
-
-  // The highest slot number confirmed to be written to device by this op.
-  //
-  slot_offset_type durable_flush_pos_ = 0;
-
-  // The known commit_size written to the device by this op.
-  //
-  u64 durable_commit_size_ = 0;
-
-  // Dedicated static memory buffer to lower the overhead of asynchronous calls.
-  //
-  batt::HandlerMemory<128> handler_memory_;
-
-  // The offset within the log file to which this op's current page should be flushed.
-  //
-  i64 file_offset_ = 0;
-
-  // `flushed_tail_range_` and `tail_write_range_` are byte offsets relative to the start of the
-  // current block.
-  //
-  batt::Interval<usize> flushed_tail_range_{0, 0};
-  Optional<batt::Interval<usize>> tail_write_range_ = None;
-
-  u64 most_recent_tail_flush_size_ = 0;
-
-  // Cached value from the driver.
-  //
-  u64 block_capacity_ = 0;
-
-  // Active only during an asynchronous write (flush) operation.
-  //
-  Optional<LatencyTimer> write_timer_;
-
-  // Temporary storage to save the `commit_size` field of the header while writing on behalf of
-  // flush_trim_pos().
-  //
-  Optional<u64> saved_commit_size_;
-
-  // A human-readable representation of the state of this object for diagnostic purposes.
-  //
-  const char* debug_info_message_ = "created";
-};
-
-BATT_STATIC_ASSERT_EQ(sizeof(PackedLogPageHeader), 64);
-
-}  // namespace llfs
-
-#endif  // LLFS_DISABLE_IO_URING
-#endif  // LLFS_IORING_LOG_FLUSH_OP_HPP
diff --git a/src/llfs/ioring_log_flush_op.ipp b/src/llfs/ioring_log_flush_op.ipp
deleted file mode 100644
index 7391400..0000000
--- a/src/llfs/ioring_log_flush_op.ipp
+++ /dev/null
@@ -1,672 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#pragma once
-#ifndef LLFS_IORING_LOG_FLUSH_OP_IPP
-#define LLFS_IORING_LOG_FLUSH_OP_IPP
-
-#include <llfs/config.hpp>
-//
-#ifndef LLFS_DISABLE_IO_URING
-
-#include <llfs/ioring_log_flush_op.hpp>
-
-#include <llfs/metrics.hpp>
-
-namespace llfs {
-
-#define THIS_VLOG(lvl)                                                                             \
-  LLFS_VLOG(lvl) << "(driver=" << this->driver_->name() << ") LogFlushOp[" << this->self_index()   \
-                 << "] "
-
-#define THIS_LOG(lvl)                                                                              \
-  LOG(lvl) << "(driver=" << this->driver_->name() << ") LogFlushOp[" << this->self_index() << "] "
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename DriverImpl>
-inline void BasicIoRingLogFlushOp<DriverImpl>::initialize(DriverImpl* driver)
-{
-  BATT_CHECK_NOT_NULLPTR(driver);
-
-  this->debug_info_message_ = "initializing";
-
-  this->driver_ = driver;
-  this->page_block_.reset(new PackedLogPageBuffer[this->driver_->calculate().pages_per_block()]);
-
-  BATT_CHECK_EQ(this->driver_->calculate().pages_per_block() * sizeof(PackedLogPageBuffer),
-                this->driver_->calculate().block_size());
-
-  const usize my_index = this->self_index();
-
-  // Figure out which flush op will be responsible for writing the next committed byte.  If that's
-  // us, we need to seed our page buffer with data from the log.
-  //
-  const auto next_flush_slot_offset = SlotUpperBoundAt{driver->get_flush_pos() + 1};
-
-  const LogBlockCalculator::FlushOpIndex next_flush_op_index =
-      driver->calculate().flush_op_index_from(next_flush_slot_offset);
-
-  BATT_CHECK_LT(next_flush_op_index, driver->calculate().queue_depth());
-
-  const SlotRange next_flush_block_slot_range =
-      driver->calculate().block_slot_range_from(next_flush_slot_offset);
-
-  // Calculate how many blocks ahead of the current commit point this op is... (0 == we are the op
-  // responsible for the next flushed data).
-  //
-  const usize ahead_of_next = [&] {
-    if (my_index < next_flush_op_index) {
-      return my_index + driver->calculate().queue_depth() - next_flush_op_index;
-    } else {
-      return my_index - next_flush_op_index;
-    }
-  }();
-
-  this->flushed_tail_range_.lower_bound = kLogAtomicWriteSize;
-
-  // Initialize the log page header.
-  {
-    PackedLogPageHeader* const header = this->get_header();
-
-    header->magic = PackedLogPageHeader::kMagic;
-    header->crc64 = -1;
-
-    header->slot_offset = next_flush_block_slot_range.lower_bound +
-                          driver->calculate().block_capacity() * ahead_of_next;
-
-    if (ahead_of_next == 0) {
-      header->commit_size = driver->get_flush_pos() - header->slot_offset;
-    } else {
-      header->commit_size = 0;
-    }
-    BATT_CHECK_LT(header->commit_size, driver->calculate().block_capacity());
-
-    this->flushed_tail_range_.upper_bound =
-        std::max<usize>(kLogAtomicWriteSize, header->commit_size + sizeof(PackedLogPageHeader));
-
-    if (header->commit_size > 0) {
-      const ConstBuffer src = driver->get_data(header->slot_offset);
-      const MutableBuffer dst{header + 1, driver->calculate().block_capacity()};
-      std::memcpy(dst.data(), src.data(), header->commit_size);
-    }
-
-    header->trim_pos = driver->get_trim_pos();
-    header->flush_pos = driver->get_flush_pos();
-    header->commit_pos = driver->get_commit_pos();
-
-    this->file_offset_ =
-        driver->calculate().block_start_file_offset_from(SlotLowerBoundAt{header->slot_offset});
-
-    this->durable_flush_pos_ = driver->get_flush_pos();
-
-    // Initially these are in sync, since we just recovered the log data and haven't started
-    // appending new slots.
-    //
-    this->durable_commit_size_ = header->commit_size;
-
-    THIS_VLOG(1) << "initialize() -" << BATT_INSPECT(ahead_of_next)
-                 << BATT_INSPECT(header->slot_offset) << BATT_INSPECT(header->commit_size)
-                 << BATT_INSPECT(this->flushed_tail_range_);
-  }
-
-  this->block_capacity_ = driver->calculate().block_capacity();
-
-  THIS_VLOG(1) << "initialized";
-
-  const auto metric_name = [&](std::string_view property) {
-    return batt::to_string("IoRingLogFlushOp_", my_index, "_", this->driver_->name(), "_",
-                           property);
-  };
-
-#define ADD_METRIC_(n) global_metric_registry().add(metric_name(#n), this->metrics_.n)
-
-  ADD_METRIC_(write_latency);
-  ADD_METRIC_(bytes_written);
-
-#undef ADD_METRIC_
-
-  this->debug_info_message_ = "initialized";
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename DriverImpl>
-inline BasicIoRingLogFlushOp<DriverImpl>::~BasicIoRingLogFlushOp() noexcept
-{
-  global_metric_registry()  //
-      .remove(this->metrics_.write_latency)
-      .remove(this->metrics_.bytes_written);
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename DriverImpl>
-inline void BasicIoRingLogFlushOp<DriverImpl>::activate()
-{
-  THIS_VLOG(1) << "activated; slot_offset=" << this->get_header()->slot_offset;
-
-  this->debug_info_message_ = "activated";
-
-  this->handle_commit(this->driver_->get_commit_pos());
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename DriverImpl>
-inline void BasicIoRingLogFlushOp<DriverImpl>::handle_commit(slot_offset_type known_commit_pos)
-{
-  PackedLogPageHeader* const header = this->get_header();
-
-  const slot_offset_type known_flush_pos = header->slot_offset + header->commit_size;
-  const bool have_data_to_flush = slot_less_than(known_flush_pos, known_commit_pos);
-
-  THIS_VLOG(1) << "handle_commit(known_commit_pos=" << known_commit_pos << ")"
-               << BATT_INSPECT(header->slot_offset) << BATT_INSPECT(header->commit_size)
-               << BATT_INSPECT(known_flush_pos) << BATT_INSPECT(have_data_to_flush);
-
-  // We should only suspend this op waiting for data if the current log block is known to be
-  // initialized; otherwise we continue and flush whatever data we have (even if it is zero bytes)
-  // to unblock the previous flush op.
-  //
-  if (this->is_current_log_block_initialized() && !have_data_to_flush) {
-    THIS_VLOG(1) << "caught up; waiting for commit_pos to advance..."
-                 << BATT_INSPECT(known_commit_pos);
-
-    this->debug_info_message_ = "wait_for_commit";
-
-    this->driver_->wait_for_commit(/*min_required=*/known_flush_pos + 1);
-    return;
-  }
-
-  // This may be false if we are flushing in order to (lazily) initialize the current log block
-  // header.
-  //
-  if (have_data_to_flush) {
-    const bool data_copied = this->fill_buffer(known_commit_pos);
-    BATT_CHECK(data_copied);
-  }
-
-  // When the head sector is written, it commits the block, so we must always flush the tail data
-  // first to maintain consistency.  Because the log is append-only, it is fine if we crash while
-  // flushing tail data; since individual sector writes are atomic and the sector that overlaps the
-  // current end of data will be same up to the previous value of header->commit_size, the integrity
-  // of the data will be preserved.
-  //
-  if (this->get_header()->commit_size > kLogAtomicWriteSize - sizeof(PackedLogPageHeader)) {
-    this->flush_tail();
-  } else {
-    this->flush_head();
-  }
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename DriverImpl>
-inline ConstBuffer BasicIoRingLogFlushOp<DriverImpl>::get_writable_data() const
-{
-  const usize byte_count = batt::round_up_bits(
-      kLogAtomicWriteSizeLog2, sizeof(PackedLogPageHeader) + this->get_header()->commit_size);
-
-  return ConstBuffer{this->page_block_.get(), byte_count};
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename DriverImpl>
-inline Optional<slot_offset_type> BasicIoRingLogFlushOp<DriverImpl>::need_to_update_trim_pos()
-{
-  PackedLogPageHeader* const header = this->get_header();
-
-  const slot_offset_type window_size = this->driver_->calculate().physical_window_size();
-
-  const SlotRange current_range =
-      this->driver_->calculate().block_slot_range_from(SlotLowerBoundAt{header->slot_offset});
-
-  const SlotRange prior_range{
-      .lower_bound = current_range.lower_bound - window_size,
-      .upper_bound = current_range.upper_bound - window_size,
-  };
-
-  slot_offset_type durable_trim_pos = this->driver_->get_durable_trim_pos();
-
-  // If there is no overlap between the durable trim pos and the prior range for the current block,
-  // then there is no need to flush the current trim before writing new data.
-  //
-  if (slot_at_least(durable_trim_pos, prior_range.upper_bound)) {
-    return None;
-  }
-
-  // We need to write the current trim_pos from the driver to our block header before
-  // continuing.  This essentially invalidates this block so that if we crash midway through the
-  // write, we won't falsely recover a "torn" write (tail data from newer range, head data from
-  // older).
-  //
-  slot_offset_type known_trim_pos = this->driver_->get_trim_pos();
-
-  THIS_VLOG(1) << "Need to flush trim_pos;" << BATT_INSPECT(durable_trim_pos)
-               << BATT_INSPECT(current_range) << BATT_INSPECT(prior_range)
-               << BATT_INSPECT(known_trim_pos);
-
-  BATT_CHECK(slot_at_most(durable_trim_pos, known_trim_pos))
-      << "The durable trim pos should never get ahead of the in-memory trim_pos!";
-
-  BATT_CHECK(!slot_less_than(known_trim_pos, prior_range.upper_bound))
-      << "Log data is being overwritten before it is trimmed!  Something isn't configured "
-         "correctly or there is a bug!";
-
-  return known_trim_pos;
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename DriverImpl>
-inline void BasicIoRingLogFlushOp<DriverImpl>::flush_tail()
-{
-  THIS_VLOG(1) << "flush_tail()";
-
-  this->debug_info_message_ = "flush_tail entered";
-
-  // Make sure we are not overwriting trimmed data *before* the fact that it has been trimmed is
-  // durably preserved.
-  //
-  Optional<slot_offset_type> trim_pos_to_flush = this->need_to_update_trim_pos();
-  if (trim_pos_to_flush) {
-    this->flush_trim_pos(*trim_pos_to_flush);
-    return;
-  }
-
-  BATT_CHECK(!this->tail_write_range_);
-
-  const ConstBuffer writable_data = this->get_writable_data();
-
-  this->tail_write_range_.emplace();
-  this->tail_write_range_->lower_bound = this->flushed_tail_range_.upper_bound;
-  this->tail_write_range_->upper_bound =
-      sizeof(PackedLogPageHeader) + this->get_header()->commit_size;
-
-  const usize unflushed_tail_offset =
-      batt::round_down_bits(kLogAtomicWriteSizeLog2, this->tail_write_range_->lower_bound);
-
-  const ConstBuffer unflushed_tail_data = writable_data + unflushed_tail_offset;
-
-  BATT_CHECK_GT(unflushed_tail_data.size(), 0u);
-
-  const i64 dst_file_offset = this->file_offset_ + unflushed_tail_offset;
-
-  this->write_timer_.emplace(this->metrics_.write_latency);
-
-  this->driver_->async_write_some(dst_file_offset, unflushed_tail_data,
-                                  /*buf_index=*/this->self_index(), this->get_flush_tail_handler());
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename DriverImpl>
-inline void BasicIoRingLogFlushOp<DriverImpl>::handle_flush_tail(const StatusOr<i32>& result)
-{
-  THIS_VLOG(1) << "handle_flush_tail(result=" << result << ")";
-
-  this->debug_info_message_ = "flush_tail complete";
-
-  auto* const header = this->get_header();
-  {
-    auto on_scope_exit = batt::finally([&] {
-      this->tail_write_range_ = None;
-    });
-
-    if (this->handle_errors(result, WritingPart::kTail)) {
-      this->debug_info_message_ = "flush_tail ERROR";
-      return;
-    }
-
-    BATT_CHECK_GT(*result, 0);
-    BATT_CHECK(this->tail_write_range_);
-
-    const usize confirmed_upper_bound =
-        batt::round_down_bits(kLogAtomicWriteSizeLog2, this->tail_write_range_->lower_bound) +
-        *result;
-
-    this->flushed_tail_range_.upper_bound =
-        std::min(confirmed_upper_bound, this->tail_write_range_->upper_bound);
-  }
-
-  // Try to fetch more data from the driver now.
-  //
-  if (header->commit_size < this->driver_->calculate().block_capacity()) {
-    const slot_offset_type known_commit_pos = this->driver_->get_commit_pos();
-    if (slot_less_than(header->slot_offset + header->commit_size, known_commit_pos)) {
-      this->fill_buffer(known_commit_pos);
-    }
-  }
-
-  // If we can, flush more tail data; otherwise write the head to make writes durable.
-  //
-  if (this->flushed_tail_range_.upper_bound < sizeof(PackedLogPageHeader) + header->commit_size) {
-    this->flush_tail();
-  } else {
-    this->flush_head();
-  }
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename DriverImpl>
-inline void BasicIoRingLogFlushOp<DriverImpl>::flush_trim_pos(slot_offset_type known_trim_pos)
-{
-  THIS_VLOG(1) << "flush_trim_pos(" << known_trim_pos << ")";
-
-  this->debug_info_message_ = "flush_trim_pos entered";
-
-  PackedLogPageHeader* const header = this->get_header();
-
-  BATT_CHECK(!this->saved_commit_size_);
-  this->saved_commit_size_ = header->commit_size;
-
-  BATT_CHECK_EQ(this->durable_commit_size_, 0u)
-      << "This flush op has already overwritten live data on device!";
-
-  header->commit_size = this->durable_commit_size_;
-  header->trim_pos = known_trim_pos;
-  header->flush_pos = this->driver_->get_flush_pos();
-  header->commit_pos = this->driver_->get_commit_pos();
-
-  auto head_data = ConstBuffer{this->page_block_.get(), kLogAtomicWriteSize};
-
-  this->write_timer_.emplace(this->metrics_.write_latency);
-
-  this->driver_->async_write_some(this->file_offset_, head_data, /*buf_index=*/this->self_index(),
-                                  this->get_flush_trim_pos_handler());
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename DriverImpl>
-inline void BasicIoRingLogFlushOp<DriverImpl>::handle_flush_trim_pos(const StatusOr<i32>& result)
-{
-  THIS_VLOG(1) << "handle_flush_trim_pos(result=" << result << ")";
-
-  this->debug_info_message_ = "flush_trim_pos completed";
-
-  PackedLogPageHeader* const header = this->get_header();
-
-  BATT_CHECK(this->saved_commit_size_);
-  header->commit_size = *this->saved_commit_size_;
-  this->saved_commit_size_ = None;
-
-  if (this->handle_errors(result, WritingPart::kTrimPos)) {
-    this->debug_info_message_ = "flush_trim_pos ERROR";
-    return;
-  }
-
-  BATT_CHECK_EQ(*result, kLogAtomicWriteSize);
-
-  // Update the driver's durable trim pos.
-  //
-  this->driver_->update_durable_trim_pos(header->trim_pos);
-
-  // See if we can grab more data while we're here...
-  //
-  const slot_offset_type latest_commit_pos = this->driver_->get_commit_pos();
-  if (slot_less_than(header->slot_offset + header->commit_size, latest_commit_pos)) {
-    this->fill_buffer(latest_commit_pos);
-  }
-
-  // Continue where we left off...
-  //
-  this->flush_tail();
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename DriverImpl>
-inline void BasicIoRingLogFlushOp<DriverImpl>::flush_head()
-{
-  THIS_VLOG(1) << "flush_head()";
-
-  this->debug_info_message_ = "flush_head entered";
-
-  PackedLogPageHeader* const header = this->get_header();
-
-  // Before we commit a full block, we must make sure that the _next_ physical log block has been
-  // initialized, otherwise fast recovery will not be able to accurately determine that the valid
-  // data range of the log ends on a block boundary.
-  //
-  if (header->commit_size == this->block_capacity_) {
-    THIS_VLOG(1) << "checking init_upper_bound...";
-
-    const usize current_init_upper_bound = this->driver_->get_init_upper_bound();
-    const usize next_physical_log_block = this->get_next_log_block_index();
-    const bool next_block_is_initialized = current_init_upper_bound > next_physical_log_block;
-    if (!next_block_is_initialized) {
-      THIS_VLOG(1) << "Waiting for the next block to be initialized "
-                   << BATT_INSPECT(current_init_upper_bound)
-                   << BATT_INSPECT(next_physical_log_block);
-      this->await_init_upper_bound_changed(current_init_upper_bound);
-      return;
-    }
-  }
-
-  auto head_data = ConstBuffer{this->page_block_.get(), kLogAtomicWriteSize};
-
-  this->write_timer_.emplace(this->metrics_.write_latency);
-
-  this->driver_->async_write_some(this->file_offset_, head_data, /*buf_index=*/this->self_index(),
-                                  this->get_flush_head_handler());
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename DriverImpl>
-inline void BasicIoRingLogFlushOp<DriverImpl>::await_init_upper_bound_changed(
-    usize last_known_value)
-{
-  this->debug_info_message_ = "await_init_upper_bound_changed entered";
-
-  this->driver_->async_wait_init_upper_bound(last_known_value,
-                                             this->get_init_upper_bound_changed_handler());
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename DriverImpl>
-inline void BasicIoRingLogFlushOp<DriverImpl>::handle_init_upper_bound_changed(
-    const StatusOr<usize>& result)
-{
-  this->debug_info_message_ = "await_init_upper_bound_changed completed";
-
-  if (*result > this->get_current_log_block_index()) {
-    this->flush_head();
-    return;
-  }
-
-  this->await_init_upper_bound_changed(*result);
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename DriverImpl>
-inline void BasicIoRingLogFlushOp<DriverImpl>::handle_flush_head(const StatusOr<i32>& result)
-{
-  THIS_VLOG(1) << "handle_flush_head(result=" << result << ")";
-
-  this->debug_info_message_ = "flush_head completed";
-
-  if (this->handle_errors(result, WritingPart::kHead)) {
-    this->debug_info_message_ = "flush_head ERROR";
-    return;
-  }
-
-  BATT_CHECK_EQ(*result, kLogAtomicWriteSize);
-
-  PackedLogPageHeader* const header = this->get_header();
-
-  // Update the driver's durable trim pos.  We do this first (before updating the driver on flush
-  // pos) because it can unblock other flush ops.
-  //
-  this->driver_->update_durable_trim_pos(header->trim_pos);
-
-  // Update this op's durable commit_size, since we just got confirmation that a write succeeded.
-  //
-  this->durable_commit_size_ = header->commit_size;
-
-  // THIS SHOULD BE THE ONLY PLACE WE UPDATE `this->durable_flush_pos_`!
-  //
-  this->durable_flush_pos_ = header->slot_offset + header->commit_size;
-  THIS_VLOG(1) << " -- " << BATT_INSPECT(this->durable_flush_pos_);
-  this->driver_->poll_flush_state();
-  this->driver_->update_init_upper_bound(this->get_current_block_upper_bound());
-
-  // Check to see whether we can advance to the next block.
-  //
-  if (header->commit_size == this->driver_->calculate().block_capacity()) {
-    header->commit_size = 0;
-    this->durable_commit_size_ = 0;
-
-    header->slot_offset +=
-        this->driver_->calculate().block_capacity() * this->driver_->calculate().queue_depth();
-
-    this->file_offset_ = this->driver_->calculate().block_start_file_offset_from(
-        SlotLowerBoundAt{header->slot_offset});
-
-    this->flushed_tail_range_.lower_bound = kLogAtomicWriteSize;
-    this->flushed_tail_range_.upper_bound = kLogAtomicWriteSize;
-  }
-
-  this->handle_commit(this->driver_->get_commit_pos());
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename DriverImpl>
-inline bool BasicIoRingLogFlushOp<DriverImpl>::handle_errors(const StatusOr<i32>& result,
-                                                             WritingPart writing_part)
-{
-  this->write_timer_ = None;
-
-  if (!result.ok()) {
-    if (batt::status_is_retryable(result.status())) {
-      THIS_VLOG(1) << "EAGAIN; retrying...";
-      if (writing_part == WritingPart::kHead) {
-        this->flush_head();
-      } else if (writing_part == WritingPart::kTail) {
-        this->flush_tail();
-      } else {
-        BATT_CHECK_EQ(writing_part, WritingPart::kTrimPos);
-        this->flush_trim_pos(this->get_header()->trim_pos);
-      }
-      return true;
-    }
-
-    const bool normal_shutdown_error =
-        (result.status() == ::llfs::make_status(StatusCode::kIoRingShutDown));
-
-    if (!this->quiet_failure_logging && !normal_shutdown_error) {
-      LLFS_LOG_INFO() << "flush failed: " << result.status();
-    } else {
-      LLFS_VLOG(1) << "flush failed: " << result.status();
-    }
-
-    if (!normal_shutdown_error) {
-      this->driver_->report_flush_error(result.status());
-    }
-    return true;
-  }
-
-  this->metrics_.bytes_written.fetch_add(*result);
-
-  return false;
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename DriverImpl>
-inline usize BasicIoRingLogFlushOp<DriverImpl>::self_index() const
-{
-  return this->driver_->index_of_flush_op(this);
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename DriverImpl>
-inline auto BasicIoRingLogFlushOp<DriverImpl>::get_header() const -> PackedLogPageHeader*
-{
-  return reinterpret_cast<PackedLogPageHeader*>(this->page_block_.get());
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename DriverImpl>
-inline MutableBuffer BasicIoRingLogFlushOp<DriverImpl>::get_buffer() const
-{
-  return MutableBuffer{
-      this->page_block_.get(),
-      this->driver_->calculate().block_size(),
-  };
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename DriverImpl>
-inline bool BasicIoRingLogFlushOp<DriverImpl>::fill_buffer(slot_offset_type known_commit_pos)
-{
-  PackedLogPageHeader* const header = this->get_header();
-  const slot_offset_type prior_commit_pos = header->slot_offset + header->commit_size;
-
-  header->trim_pos = this->driver_->get_trim_pos();
-  header->flush_pos = this->driver_->get_flush_pos();
-  header->commit_pos = known_commit_pos;
-
-  BATT_CHECK(!slot_less_than(known_commit_pos, prior_commit_pos))
-      << "commit_pos should never go backwards!";
-
-  auto dst =
-      MutableBuffer{
-          header + 1,
-          this->driver_->calculate().block_capacity(),
-      } +
-      header->commit_size;
-
-  const usize n_to_copy = std::min(known_commit_pos - prior_commit_pos, dst.size());
-
-  THIS_VLOG(1) << "fill_buffer() -> [" << n_to_copy
-               << " bytes], commit_size=" << header->commit_size << "->"
-               << (header->commit_size + n_to_copy) << "/"
-               << this->driver_->calculate().block_capacity();
-
-  if (n_to_copy == 0) {
-    return false;
-  }
-
-  // Copy from the ring buffer to this block.
-  //
-  auto src = this->driver_->get_data(prior_commit_pos);
-  std::memcpy(dst.data(), src.data(), n_to_copy);
-
-  // This should be the ONLY place where commit_size is increased!
-  //
-  header->commit_size += n_to_copy;
-
-  // Prevent deadlock when initializing the log headers for the first time.
-  //
-  if (!this->is_current_log_block_initialized() && header->commit_size == this->block_capacity_) {
-    BATT_CHECK_GT(header->commit_size, 0u);
-    header->commit_size -= 1;
-  }
-
-  return true;
-}
-
-#undef THIS_LOG
-#undef THIS_VLOG
-
-}  // namespace llfs
-
-#endif  // LLFS_DISABLE_IO_URING
-
-#endif  // LLFS_IORING_LOG_FLUSH_OP_IPP
diff --git a/src/llfs/ioring_log_flush_op.test.cpp b/src/llfs/ioring_log_flush_op.test.cpp
deleted file mode 100644
index d2c7f15..0000000
--- a/src/llfs/ioring_log_flush_op.test.cpp
+++ /dev/null
@@ -1,644 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#include <llfs/ioring_log_flush_op.hpp>
-#include <llfs/ioring_log_flush_op.ipp>
-//
-#include <llfs/ioring_log_flush_op.hpp>
-#include <llfs/ioring_log_flush_op.ipp>
-
-#ifndef LLFS_DISABLE_IO_URING
-
-#include <llfs/ioring_log_flush_op.test.hpp>
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-#include <llfs/buffer.hpp>
-#include <llfs/config.hpp>
-#include <llfs/constants.hpp>
-#include <llfs/int_types.hpp>
-#include <llfs/logging.hpp>
-#include <llfs/optional.hpp>
-#include <llfs/slot.hpp>
-#include <llfs/status.hpp>
-
-#include <batteries/checked_cast.hpp>
-#include <batteries/small_fn.hpp>
-#include <batteries/small_vec.hpp>
-#include <batteries/state_machine_model.hpp>
-
-#include <boost/functional/hash.hpp>
-#include <boost/operators.hpp>
-
-#include <memory>
-#include <thread>
-#include <unordered_map>
-#include <vector>
-
-namespace llfs {
-
-//=#=#==#==#===============+=+=+=+=++=++++++++++++++-++-+--+-+----+---------------
-//
-struct IoRingLogFlushOpState : boost::equality_comparable<IoRingLogFlushOpState> {
-  struct Hash {
-    usize operator()(const IoRingLogFlushOpState& s) const
-    {
-      return s.done;
-    }
-  };
-
-  friend bool operator==(const IoRingLogFlushOpState& l, const IoRingLogFlushOpState& r)
-  {
-    return l.done == r.done;
-  }
-
-  bool is_terminal() const
-  {
-    return this->done;
-  }
-
-  bool done = false;
-};
-
-}  // namespace llfs
-
-namespace batt {
-
-template <>
-struct StateMachineTraits<::llfs::IoRingLogFlushOpState> {
-  static constexpr usize kRadixQueueSize = 1024;
-};
-
-}  // namespace batt
-
-namespace {
-
-using namespace llfs::int_types;
-using namespace llfs::constants;
-
-std::atomic<usize> step_count{0};
-
-using llfs::ConstBuffer;
-using llfs::IoRingLogFlushOpState;
-using llfs::MutableBuffer;
-using llfs::None;
-using llfs::OkStatus;
-using llfs::Optional;
-using llfs::slot_offset_type;
-using llfs::Status;
-using llfs::StatusOr;
-
-// Test Plan:
-//
-//  Parameters:
-//   Number of Ops: 1, 2, 4
-//   Block Size (pages): 1, 2, 4
-//   Driver recovery state: 0 (brand new), >0 at Op, >0 before Op, >0 after Op
-//   Commit increments (bytes):
-//      - primes (37, 109, 263, 317, 509, 701, 997)
-//      - powers of 2 (8, 64, 256, 512)
-//      - mixed (all of the above)
-//   Commit size variation: true|false
-//   Log size (* flush ops * block capacity): smaller (one page less), equal, 2x, 3x, 4x
-//   Number of writes until device failure: 0...
-
-constexpr usize kMaxSteps = 100;
-constexpr usize kMaxPagesPerBlockLog2 = 4;
-constexpr usize kMaxPagesPerBlock = usize{1} << kMaxPagesPerBlockLog2;
-
-//=#=#==#==#===============+=+=+=+=++=++++++++++++++-++-+--+-+----+---------------
-//
-class IoRingLogFlushOpModel
-    : public batt::StateMachineModel<IoRingLogFlushOpState, IoRingLogFlushOpState::Hash>
-{
- public:
-  using ActionFn = batt::SmallFn<Status()>;
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  static ConstBuffer fake_log_data()
-  {
-    static std::array<little_u64, 1 * kMiB / sizeof(u64)> storage_;
-    static ConstBuffer buffer_ = [] {
-      u64 value = 0;
-      for (little_u64& dst : storage_) {
-        dst = value;
-        ++value;
-      }
-      return ConstBuffer{storage_.data(), sizeof(storage_)};
-    }();
-
-    return buffer_;
-  }
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  IoRingLogFlushOpState initialize() override
-  {
-    return IoRingLogFlushOpState{};
-  }
-
-  void enter_state(const IoRingLogFlushOpState& s) override
-  {
-    this->check_failed_ = false;
-    this->state_ = s;
-  }
-
-  void step() override
-  {
-    if (this->state_.is_terminal()) {
-      return;
-    }
-
-    auto on_scope_exit =
-        batt::finally([saved_level = batt::require_fail_thread_default_log_level(), this] {
-          this->state_.done = true;
-          batt::require_fail_thread_default_log_level() = saved_level;
-        });
-
-    batt::require_fail_thread_default_log_level() = batt::LogLevel::kError;
-
-    step_count.fetch_add(1);
-
-    Status step_status = [&]() -> Status {
-      // Pick the params we will be using for this test.
-      //
-      this->pick_test_params();
-
-      // Driver variables (state).
-      //
-      this->fake_log_.emplace(
-          *this->calculate_, this->fake_data_,
-          this->get_ring_buffer(/*byte_size=*/this->calculate_->logical_size()));
-
-      // Create and configure the driver mock.
-      //
-      this->initialize_mock_driver();
-
-      // Instantiate the system-under-test.
-      //
-      this->op_.emplace();
-      this->op_->quiet_failure_logging = true;
-
-      // Initialize and verify.
-      //
-      this->expected_state_->on_initialize(*this->fake_log_);
-      this->op_->initialize(&*this->driver_);
-
-      BATT_REQUIRE_OK(this->expected_state_->verify(*this->op_));
-
-      // Activate.
-      //
-      BATT_REQUIRE_OK(this->expected_state_->on_activate(*this->fake_log_));
-      this->op_->activate();
-
-      usize step_i = 0;
-      bool finished = false;
-      for (; step_i < kMaxSteps; ++step_i) {
-        BATT_REQUIRE_OK(this->expected_state_->async_write_some_status);
-        BATT_REQUIRE_OK(this->expected_state_->wait_for_commit_status);
-
-        // Verify that the expected and actual flush op state match.
-        //
-        BATT_REQUIRE_OK(this->expected_state_->verify(*this->op_));
-
-        batt::SmallVec<ActionFn, 3> actions;
-        this->generate_actions(&actions);
-
-        if (actions.empty()) {
-          finished = true;
-          break;
-        }
-
-        const usize action_i = this->pick_int(0, actions.size() - 1);
-        BATT_REQUIRE_OK(actions[action_i]());
-      }
-
-      if (this->failure_count_ == 0 && finished) {
-        BATT_CHECK_EQ(this->fake_log_->flush_pos(), this->max_flush_pos_) << BATT_INSPECT(step_i);
-      }
-
-      return OkStatus();
-    }();
-
-    this->check_failed_ = !step_status.ok();
-  }
-
-  IoRingLogFlushOpState leave_state() override
-  {
-    this->op_ = None;
-    this->driver_ = None;
-    this->fake_log_ = None;
-    this->calculate_ = None;
-
-    return this->state_;
-  }
-
-  bool check_invariants() override
-  {
-    return !this->check_failed_;
-  }
-
-  IoRingLogFlushOpState normalize(const IoRingLogFlushOpState& s) override
-  {
-    return s;
-  }
-
-  usize max_concurrency() const override
-  {
-    return 1;  // std::thread::hardware_concurrency();
-    // TODO [tastolfi 2022-08-11] figure out why this isn't scaling...
-  }
-
-  void report_progress(const batt::StateMachineResult& r) override
-  {
-    LLFS_LOG_INFO() << r;
-  }
-
-  AdvancedOptions advanced_options() const override
-  {
-    auto options = AdvancedOptions::with_default_values();
-    options.min_running_time_ms = 10 * 1000;
-    options.starting_seed = 0;
-    return options;
-  }
-
-  std::unique_ptr<batt::StateMachineModel<IoRingLogFlushOpState, IoRingLogFlushOpState::Hash>>
-  clone() const override
-  {
-    return std::make_unique<IoRingLogFlushOpModel>();
-  }
-
- private:
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-  //
-  void pick_test_params()
-  {
-    this->queue_depth_ = this->pick_one_of({1, 2, 4});
-    this->op_index_ = this->pick_int(0, this->queue_depth_ - 1);
-
-    this->pages_per_block_ = this->pick_one_of({1, 2, 4});
-
-    this->pages_per_block_log2_ = batt::log2_ceil(this->pages_per_block_);
-    BATT_CHECK_EQ(1ull << this->pages_per_block_log2_, this->pages_per_block_);
-
-    this->block_size_ = llfs::kLogPageSize * this->pages_per_block_;
-    this->block_capacity_ = this->block_size_ - sizeof(llfs::PackedLogPageHeader);
-
-    // Pick the log size; include the case where there are more flush ops than log capacity, so
-    // long as it doesn't lead to a "negative" log size.
-    //
-    this->log_size_ = batt::round_up_bits(12, [&] {
-      if (this->queue_depth_ > 1 && this->block_capacity_ > 4096 && this->pick_branch()) {
-        return this->queue_depth_ * this->block_capacity_ - 4096;
-      } else {
-        return this->pick_one_of({
-            this->queue_depth_ * this->block_capacity_,
-            this->queue_depth_ * this->block_capacity_ * 2,
-            this->queue_depth_ * this->block_capacity_ * 3,
-            this->queue_depth_ * this->block_capacity_ * 4,
-        });
-      }
-    }());
-
-    this->max_flush_pos_ = (this->queue_depth_ + this->op_index_ + 1) * this->block_capacity_;
-
-    // Start the log device blocks at file_offset=0 or some irregular large-ish value.
-    //
-    this->base_file_offset_ = this->pick_one_of({0ull, 7777ull * llfs::kLogAtomicWriteSize});
-
-    // We use the built-in calculator for the physical layout size.
-    //
-    this->physical_size_ = llfs::LogBlockCalculator::disk_size_required_for_log_size(
-        this->log_size_, this->block_size_);
-
-    LLFS_VLOG(1) << "\n\n==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -\n"
-                 << BATT_INSPECT(this->queue_depth_) << BATT_INSPECT(this->op_index_)
-                 << BATT_INSPECT(this->block_size_) << BATT_INSPECT(this->block_capacity_)
-                 << BATT_INSPECT(this->log_size_) << BATT_INSPECT(this->base_file_offset_)
-                 << BATT_INSPECT(this->physical_size_);
-
-    // Now the calculator has everything it needs.
-    //
-    this->calculate_.emplace(
-        llfs::IoRingLogConfig{
-            .logical_size = this->log_size_,
-            .physical_offset = this->base_file_offset_,
-            .physical_size = this->physical_size_,
-            .pages_per_block_log2 = this->pages_per_block_log2_,
-        },
-        llfs::IoRingLogDriverOptions::with_default_values()  //
-            .set_queue_depth(this->queue_depth_));
-  }
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-  //
-  void initialize_mock_driver()
-  {
-    this->driver_.emplace();
-
-    EXPECT_CALL(*this->driver_, calculate())  //
-        .WillRepeatedly(::testing::ReturnRef(*this->calculate_));
-
-    EXPECT_CALL(*this->driver_, get_trim_pos())  //
-        .WillRepeatedly(::testing::Invoke([this] {
-          BATT_CHECK(this->fake_log_);
-          return this->fake_log_->trim_pos();
-        }));
-
-    EXPECT_CALL(*this->driver_, get_flush_pos())  //
-        .WillRepeatedly(::testing::Invoke([this] {
-          BATT_CHECK(this->fake_log_);
-          return this->fake_log_->flush_pos();
-        }));
-
-    EXPECT_CALL(*this->driver_, get_commit_pos())  //
-        .WillRepeatedly(::testing::Invoke([this] {
-          BATT_CHECK(this->fake_log_);
-          return this->fake_log_->commit_pos();
-        }));
-
-    EXPECT_CALL(*this->driver_, name())  //
-        .WillRepeatedly(::testing::Return(llfs::MockIoRingLogDriver::default_name()));
-
-    EXPECT_CALL(*this->driver_, index_of_flush_op(&*this->op_))  //
-        .WillRepeatedly(::testing::Return(this->op_index_));
-
-    EXPECT_CALL(*this->driver_, update_durable_trim_pos(::testing::_))  //
-        .WillRepeatedly(::testing::Invoke([this](slot_offset_type trim_pos) {
-          llfs::clamp_min_slot(this->fake_log_->durable_trim_pos, trim_pos);
-        }));
-
-    EXPECT_CALL(*this->driver_, get_durable_trim_pos())  //
-        .WillRepeatedly(::testing::Invoke([this]() {
-          return this->fake_log_->durable_trim_pos.get_value();
-        }));
-
-    EXPECT_CALL(*this->driver_,
-                update_init_upper_bound(::testing::AllOf(
-                    ::testing::Ge(1u), ::testing::Le(this->calculate_->block_count()))))
-        .WillRepeatedly(::testing::Return());
-
-    EXPECT_CALL(*this->driver_, get_init_upper_bound())
-        .WillRepeatedly(::testing::Return(this->calculate_->block_count()));
-
-    EXPECT_CALL(*this->driver_,
-                async_wait_init_upper_bound(::testing::Lt(this->calculate_->block_count()),
-                                            ::testing::_ /*handler*/))
-        .WillRepeatedly(::testing::InvokeArgument<1>(this->calculate_->block_count()));
-
-    EXPECT_CALL(*this->driver_, report_flush_error(::testing::_ /*error status*/))
-        .WillRepeatedly(::testing::Return());
-
-    //----- --- -- -  -  -   -
-
-    // Create the expected flush op state.
-    //
-    this->expected_state_.emplace(*this->driver_, this->op_index_);
-
-    // Reset failure state.
-    //
-    this->failure_count_ = 0;
-  }
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-  //
-  void generate_actions(batt::SmallVecBase<ActionFn>* actions)
-  {
-    BATT_CHECK(this->fake_log_);
-    BATT_CHECK(this->expected_state_);
-    BATT_CHECK(this->op_);
-
-    const llfs::slot_offset_type next_trim_pos =
-        llfs::slot_min(this->fake_log_->commit_pos(), this->op_->get_header()->slot_offset);
-
-    LLFS_VLOG(1) << "generate_actions() " << BATT_INSPECT(this->fake_log_->commit_pos())
-                 << BATT_INSPECT(this->op_->get_header()->slot_offset)
-                 << BATT_INSPECT(this->fake_log_->trim_pos()) << BATT_INSPECT(next_trim_pos);
-
-    //----- --- -- -  -  -   -
-    // Complete a write (if there is one pending).
-    //
-    if (this->expected_state_->pending_write) {
-      actions->emplace_back([this]() -> Status {
-        LLFS_VLOG(1) << "ACTION: Complete Async Write";
-
-        std::bitset<kMaxPagesPerBlock> page_will_fail{0};
-
-        if (this->failure_count_ < this->max_failures_ && this->pick_branch()) {
-          this->failure_count_ += 1;
-
-          usize atomic_write_count =
-              this->expected_state_->pending_write->buffer.size() / llfs::kLogAtomicWriteSize;
-
-          u64 failure_mask = this->pick_int(1, (1 << atomic_write_count) - 1);
-
-          page_will_fail = std::bitset<kMaxPagesPerBlock>{failure_mask};
-          LLFS_VLOG(1) << " -- " << BATT_INSPECT(page_will_fail);
-        }
-
-        Status write_status = this->fake_log_->write_data(
-            this->expected_state_->pending_write->file_offset,
-            this->expected_state_->pending_write->buffer, /*inject_block_failure=*/
-            [i = usize{0}, page_will_fail]() mutable {
-              bool failure = page_will_fail[i];
-              LLFS_VLOG(1) << BATT_INSPECT(failure) << BATT_INSPECT(i);
-              ++i;
-              return failure;
-            },
-            this->expected_state_->pending_write->buf_index);
-
-        BATT_REQUIRE_OK(write_status);
-
-        auto result = [&]() -> StatusOr<i32> {
-          if (page_will_fail.any()) {
-            return llfs::make_status(llfs::StatusCode::kIoRingLogFlushOpExpectedFailure);
-          }
-          return {this->expected_state_->pending_write->buffer.size()};
-        }();
-
-        auto on_scope_exit =
-            batt::finally([saved_level = batt::require_fail_thread_default_log_level()] {
-              batt::require_fail_thread_default_log_level() = saved_level;
-            });
-
-        if (page_will_fail.any()) {
-          batt::require_fail_thread_default_log_level() = batt::LogLevel::kVerbose;
-        }
-
-        Status complete_write_status =
-            this->expected_state_->on_complete_async_write(result, *this->fake_log_);
-
-        BATT_REQUIRE_OK(complete_write_status);
-
-        // Simulate a recovery by reconstructing the op.
-        //
-        if (page_will_fail.any()) {
-          BATT_CHECK(!this->expected_state_->waiting_for_commit);
-          BATT_CHECK(!this->expected_state_->pending_write);
-
-          LLFS_VLOG(1) << "EVENT: Recreating FlushOp and Expected State;"
-                       << BATT_INSPECT(this->fake_log_->flush_pos())
-                       << BATT_INSPECT(this->block_capacity_);
-
-          const slot_offset_type expected_slot_offset = this->expected_state_->slot_offset;
-
-          this->op_ = None;
-          this->expected_state_ = None;
-          this->expected_state_.emplace(*this->driver_, this->op_index_);
-          this->op_.emplace();
-          this->op_->quiet_failure_logging = true;
-
-          LLFS_VLOG(1) << "EVENT: Initializing FlushOp after simulated crash";
-          this->expected_state_->on_initialize(*this->fake_log_);
-          this->op_->initialize(&*this->driver_);
-
-          EXPECT_EQ(expected_slot_offset, this->expected_state_->slot_offset)
-              << BATT_INSPECT(this->op_index_) << BATT_INSPECT(this->queue_depth_);
-
-          LLFS_VLOG(1) << "EVENT: Activating FlushOp after simulated crash";
-          Status activate_status = this->expected_state_->on_activate(*this->fake_log_);
-          BATT_REQUIRE_OK(activate_status);
-
-          this->op_->activate();
-        }
-
-        return batt::OkStatus();
-      });
-    }
-
-    //----- --- -- -  -  -   -
-    // Commit more data (if we are below the max_flush_pos).
-    //
-    if (this->fake_log_->commit_pos() < this->max_flush_pos_ && this->fake_log_->space() > 0) {
-      actions->emplace_back([this]() -> Status {
-        LLFS_VLOG(1) << "ACTION: Commit Data";
-
-        const usize max_to_commit = std::min(this->fake_log_->space(),
-                                             this->max_flush_pos_ - this->fake_log_->commit_pos());
-
-        const usize min_to_commit = std::min<usize>(max_to_commit, 317);
-
-        const usize size_to_commit = this->pick_int(min_to_commit, max_to_commit);
-
-        const slot_offset_type new_commit_pos = this->fake_log_->commit_pos() + size_to_commit;
-
-        LLFS_VLOG(1) << " -- " << BATT_INSPECT(size_to_commit) << " from range [" << min_to_commit
-                     << ", " << max_to_commit << "]" << BATT_INSPECT(new_commit_pos)
-                     << BATT_INSPECT(this->expected_state_->waiting_for_commit);
-
-        // This prepares the driver mock to return updated values/data.
-        //
-        this->fake_log_->commit_to_slot(new_commit_pos);
-
-        // If this commit should wake up the flush op, do so.
-        //
-        if (this->expected_state_->waiting_for_commit &&
-            llfs::slot_greater_or_equal(new_commit_pos,
-                                        this->expected_state_->waiting_for_commit->offset)) {
-          BATT_REQUIRE_OK(this->expected_state_->on_complete_wait_for_commit(*this->fake_log_));
-
-          this->op_->handle_commit(new_commit_pos);
-        }
-
-        return batt::OkStatus();
-      });
-    }
-
-    //----- --- -- -  -  -   -
-    // Trim the log.
-    //
-    if (llfs::slot_less_than(this->fake_log_->trim_pos(), next_trim_pos)) {
-      actions->emplace_back([this, next_trim_pos]() -> Status {
-        LLFS_VLOG(1) << "ACTION: Trim (" << this->fake_log_->trim_pos() << " -> " << next_trim_pos
-                     << ")";
-
-        this->fake_log_->trim_to_slot(next_trim_pos);
-
-        return batt::OkStatus();
-      });
-    }
-  }
-
-  llfs::RingBuffer& get_ring_buffer(usize byte_size)
-  {
-    auto iter = this->ring_buffer_cache_.find(byte_size);
-
-    if (iter == this->ring_buffer_cache_.end()) {
-      iter = this->ring_buffer_cache_
-                 .emplace(byte_size, std::make_unique<llfs::RingBuffer>(llfs::RingBuffer::TempFile{
-                                         .byte_size = byte_size,
-                                     }))
-                 .first;
-    }
-    BATT_CHECK_NOT_NULLPTR(iter->second);
-    return *iter->second;
-  }
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  bool check_failed_ = false;
-
-  ConstBuffer fake_data_{IoRingLogFlushOpModel::fake_log_data()};
-
-  IoRingLogFlushOpState state_;
-
-  // The number of simulated flush ops for the current test run.
-  //
-  usize queue_depth_ = 0;
-
-  // The index of the op-under-test for the current test run.
-  //
-  usize op_index_ = 0;
-
-  usize pages_per_block_ = 0;
-  usize pages_per_block_log2_ = 0;
-  usize block_size_ = 0;
-  usize block_capacity_ = 0;
-  usize log_size_ = 0;
-  i64 base_file_offset_ = 0;
-  u64 physical_size_ = 0;
-  slot_offset_type max_flush_pos_ = 0;
-
-  const usize max_failures_ = 2;
-  usize failure_count_ = 0;
-
-  Optional<llfs::LogBlockCalculator> calculate_;
-
-  std::unordered_map<usize, std::unique_ptr<llfs::RingBuffer>> ring_buffer_cache_;
-
-  Optional<llfs::FakeLogState> fake_log_;
-
-  Optional<llfs::BasicIoRingLogFlushOp<::testing::StrictMock<llfs::MockIoRingLogDriver>>> op_;
-
-  Optional<::testing::StrictMock<llfs::MockIoRingLogDriver>> driver_;
-
-  Optional<llfs::ExpectedFlushOpState> expected_state_;
-};
-
-TEST(IoRingLogFlushOpTest, StateMachineSimulation)
-{
-  auto on_scope_exit = batt::finally([saved_level = batt::require_fail_thread_default_log_level()] {
-    batt::require_fail_thread_default_log_level() = saved_level;
-  });
-
-  batt::require_fail_thread_default_log_level() = batt::LogLevel::kError;
-
-  IoRingLogFlushOpModel model;
-
-  IoRingLogFlushOpModel::Result result =
-      model.check_model(batt::StaticType<batt::StochasticModelChecker<IoRingLogFlushOpModel>>{});
-  EXPECT_TRUE(result.ok);
-
-  LLFS_LOG_INFO() << result << BATT_INSPECT(step_count);
-}
-
-}  // namespace
-
-#endif  // LLFS_DISABLE_IO_URING
diff --git a/src/llfs/ioring_log_flush_op.test.hpp b/src/llfs/ioring_log_flush_op.test.hpp
deleted file mode 100644
index 0f6c339..0000000
--- a/src/llfs/ioring_log_flush_op.test.hpp
+++ /dev/null
@@ -1,680 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#pragma once
-#ifndef LLFS_IORING_LOG_FLUSH_OP_TEST_HPP
-#define LLFS_IORING_LOG_FLUSH_OP_TEST_HPP
-
-#include <llfs/config.hpp>
-//
-
-#ifndef LLFS_DISABLE_IO_URING
-
-#include <llfs/buffer.hpp>
-#include <llfs/int_types.hpp>
-#include <llfs/ioring_log_flush_op.hpp>
-#include <llfs/ioring_log_flush_op.ipp>
-#include <llfs/log_block_calculator.hpp>
-#include <llfs/optional.hpp>
-#include <llfs/ring_buffer.hpp>
-#include <llfs/slot.hpp>
-#include <llfs/status.hpp>
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-#include <batteries/require.hpp>
-
-#include <functional>
-#include <string_view>
-
-namespace llfs {
-
-//=#=#==#==#===============+=+=+=+=++=++++++++++++++-++-+--+-+----+---------------
-//
-class MockIoRingLogDriver
-{
- public:
-  using Self = MockIoRingLogDriver;
-
-  // The default string returned by Self::name();
-  //
-  static std::string_view default_name()
-  {
-    return "TheFakeDriver";
-  }
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  MOCK_METHOD(const LogBlockCalculator&, calculate, (), (const));
-
-  MOCK_METHOD(slot_offset_type, get_trim_pos, (), (const));
-
-  MOCK_METHOD(slot_offset_type, get_flush_pos, (), (const));
-
-  MOCK_METHOD(slot_offset_type, get_commit_pos, (), (const));
-
-  MOCK_METHOD(ConstBuffer, get_data, (slot_offset_type slot_offset), (const));
-
-  MOCK_METHOD(std::string_view, name, (), (const));
-
-  MOCK_METHOD(usize, index_of_flush_op,
-              (const BasicIoRingLogFlushOp<::testing::StrictMock<Self>>* flush_op), (const));
-
-  MOCK_METHOD(void, async_write_some,
-              (i64 log_offset, const ConstBuffer& data, i32 buf_index,
-               std::function<void(StatusOr<i32>)> handler),
-              ());
-
-  MOCK_METHOD(void, wait_for_commit, (slot_offset_type least_upper_bound), ());
-
-  MOCK_METHOD(void, poll_flush_state, (), ());
-
-  MOCK_METHOD(void, report_flush_error, (Status), ());
-
-  MOCK_METHOD(void, update_init_upper_bound, (LogBlockCalculator::PhysicalBlockIndex), ());
-
-  MOCK_METHOD(usize, get_init_upper_bound, (), (const));
-
-  MOCK_METHOD(void, async_wait_init_upper_bound,
-              (usize last_known_value, std::function<void(StatusOr<usize>)> handler), ());
-
-  MOCK_METHOD(void, update_durable_trim_pos, (slot_offset_type pos), ());
-
-  MOCK_METHOD(slot_offset_type, get_durable_trim_pos, (), (const));
-};
-
-//=#=#==#==#===============+=+=+=+=++=++++++++++++++-++-+--+-+----+---------------
-// Maintains a simulated on-disk log device plus in-memory ring buffer for testing.
-//
-class FakeLogState
-{
- public:
-  static constexpr u8 kUninitializedMemoryByte = 0xfe;
-  static constexpr u8 kUninitializedDiskByte = 0xba;
-
-  static Status verify_log_data(slot_offset_type slot_offset, ConstBuffer actual)
-  {
-    u64 expected_value = slot_offset / sizeof(u64);
-    const little_u64* next_actual = (const little_u64*)(actual.data());
-    for (usize i = 0; i < actual.size(); i += sizeof(u64), ++next_actual, ++expected_value) {
-      if (i + sizeof(u64) > actual.size()) {
-        little_u64 tmp_new = *next_actual;
-        little_u64 tmp_old = expected_value;
-        usize valid_bytes = (actual.size() - i);
-        BATT_CHECK_EQ(valid_bytes, actual.size() % sizeof(u64));
-        std::memcpy(&tmp_new, &tmp_old, valid_bytes);
-        expected_value = tmp_new;
-      }
-      if (expected_value != *next_actual) {
-        LLFS_LOG_ERROR() << "The data is wrong at slot_offset=" << (i + slot_offset)
-                         << BATT_INSPECT(actual.size()) << BATT_INSPECT(expected_value)
-                         << BATT_INSPECT(*next_actual) << std::hex << BATT_INSPECT(expected_value)
-                         << std::hex << BATT_INSPECT(*next_actual);
-        return batt::StatusCode::kDataLoss;
-      }
-    }
-    return batt::OkStatus();
-  }
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  // Create a fake log with the specified configuration.
-  //
-  explicit FakeLogState(const llfs::LogBlockCalculator& calculate, ConstBuffer fake_data,
-                        RingBuffer& ring_buffer) noexcept
-      : calculate_{calculate}
-      , trim_pos_{0}
-      , flush_pos_{0}
-      , commit_pos_{0}
-      , fake_data_{fake_data}
-      , ring_buffer_{ring_buffer}
-      , disk_(this->calculate_.physical_size(), kUninitializedDiskByte)
-  {
-    BATT_CHECK_EQ(this->calculate_.begin_file_offset() % llfs::kLogAtomicWriteSize, 0);
-    BATT_CHECK_EQ(this->calculate_.end_file_offset() % llfs::kLogAtomicWriteSize, 0);
-
-    MutableBuffer dst = this->ring_buffer_.get_mut(0);
-    std::memset(dst.data(), kUninitializedMemoryByte, dst.size());
-  }
-
-  u64 bytes_available() const
-  {
-    BATT_CHECK(!slot_less_than(this->commit_pos(), this->trim_pos()));
-
-    return this->commit_pos() - this->trim_pos();
-  }
-
-  u64 space() const
-  {
-    return this->calculate_.logical_size() - this->bytes_available();
-  }
-
-  slot_offset_type trim_pos() const
-  {
-    return this->trim_pos_;
-  }
-
-  slot_offset_type flush_pos() const
-  {
-    return this->flush_pos_;
-  }
-
-  slot_offset_type commit_pos() const
-  {
-    return this->commit_pos_;
-  }
-
-  void trim_to_slot(slot_offset_type slot_lower_bound)
-  {
-    BATT_CHECK(slot_less_or_equal(slot_lower_bound, this->commit_pos_))
-        << "Log trimmed beyond commit_pos!" << BATT_INSPECT(slot_lower_bound)
-        << BATT_INSPECT(this->commit_pos_) << BATT_INSPECT(this->trim_pos_);
-
-    this->trim_pos_ = slot_lower_bound;
-  }
-
-  void commit_to_slot(slot_offset_type slot_upper_bound)
-  {
-    BATT_CHECK_LT(this->commit_pos_ - this->trim_pos_, this->calculate_.logical_size())
-        << "Log grown beyond capacity!" << BATT_INSPECT(this->trim_pos_)
-        << BATT_INSPECT(this->commit_pos_) << BATT_INSPECT(slot_upper_bound);
-
-    BATT_CHECK_GE(slot_upper_bound, this->commit_pos_) << "Commit pos must not go backwards!";
-    {
-      const usize n_to_commit = std::max(this->commit_pos_, slot_upper_bound) - this->commit_pos_;
-      MutableBuffer dst = this->ring_buffer_.get_mut(this->commit_pos_);
-      if (n_to_commit <= dst.size()) {
-        std::memcpy(dst.data(), (this->fake_data_ + this->commit_pos_).data(), n_to_commit);
-      } else {
-        BATT_PANIC() << "gcc can't figure out that the condition above is impossible...";
-        BATT_UNREACHABLE();
-      }
-    }
-    this->commit_pos_ = slot_upper_bound;
-  }
-
-  ConstBuffer get_data(slot_offset_type offset) const
-  {
-    return this->ring_buffer_.get(offset);
-  }
-
-  Status write_data(i64 file_offset, ConstBuffer src, std::function<bool()> inject_block_failure,
-                    usize /*flush_op_index*/)
-  {
-    //TODO [tastolfi 2023-05-22] use/verify `flush_op_index` arg
-
-    const i64 end_file_offset = file_offset + BATT_CHECKED_CAST(i64, src.size());
-
-    // Make sure the entire range of written data is within the range of valid disk blocks.
-    //
-    if (file_offset < this->calculate_.begin_file_offset() ||
-        end_file_offset > this->calculate_.end_file_offset()) {
-      LLFS_LOG_ERROR() << "[FakeLogState::write_data] Requested write range [" << file_offset
-                       << ", " << end_file_offset
-                       << ") is outside the valid log file offset range: ["
-                       << this->calculate_.begin_file_offset() << ", "
-                       << this->calculate_.end_file_offset() << ")";
-
-      return batt::StatusCode::kOutOfRange;
-    }
-
-    // Check alignment requirements for direct I/O.
-    //
-    if ((file_offset % llfs::kLogAtomicWriteSize) != 0 ||
-        (src.size() % llfs::kLogAtomicWriteSize) != 0 ||
-        ((std::intptr_t)src.data() % llfs::kLogAtomicWriteSize) != 0) {
-      LLFS_LOG_ERROR() << "[FakeLogState::write_data] Start/size of `src` isn't aligned to "
-                       << llfs::kLogAtomicWriteSize << "-byte boundary";
-
-      return batt::StatusCode::kInvalidArgument;
-    }
-
-    // Verify the write.
-    //
-    Optional<slot_offset_type> updated_flush_pos = None;
-    {
-      const llfs::LogBlockCalculator::PhysicalFileOffset block_file_offset =
-          this->calculate_.block_start_file_offset_from(
-              llfs::LogBlockCalculator::PhysicalFileOffset{file_offset});
-
-      if (block_file_offset == file_offset) {
-        auto* header = (const llfs::PackedLogPageHeader*)src.data();
-
-        if (src.size() < sizeof(llfs::PackedLogPageHeader)) {
-          LLFS_LOG_ERROR() << "Write is too small to contain log page header!";
-          return batt::StatusCode::kInvalidArgument;
-        }
-
-        if (src.size() > llfs::kLogAtomicWriteSize) {
-          LLFS_LOG_ERROR() << "Write is too big to be atomic (header must be atomic)!";
-          return batt::StatusCode::kInvalidArgument;
-        }
-
-        if (header->magic != llfs::PackedLogPageHeader::kMagic) {
-          LLFS_LOG_ERROR() << "The log page header doesn't contain the magic number!";
-          return batt::StatusCode::kInvalidArgument;
-        }
-
-        if (slot_greater_than(header->trim_pos, this->trim_pos_)) {
-          LLFS_LOG_ERROR() << "The log page header's trim_pos is too high!";
-          return batt::StatusCode::kInvalidArgument;
-        }
-
-        if (slot_greater_than(header->flush_pos, this->flush_pos_)) {
-          LLFS_LOG_ERROR() << "The log page header's flush_pos is too high!";
-          return batt::StatusCode::kInvalidArgument;
-        }
-
-        if (slot_greater_than(header->commit_pos, this->commit_pos_)) {
-          LLFS_LOG_ERROR() << "The log page header's commit_pos is too high!";
-          return batt::StatusCode::kInvalidArgument;
-        }
-
-        if (block_file_offset != this->calculate_.block_start_file_offset_from(
-                                     llfs::SlotLowerBoundAt{header->slot_offset})) {
-          LLFS_LOG_ERROR() << "Log page header is being written to the wrong block!";
-          return batt::StatusCode::kInvalidArgument;
-        }
-
-        if (header->commit_size == 0) {
-          // commit_size == 0 can be valid, iff we are flushing the trim_pos; check that here
-          //
-          if (slot_greater_than(header->trim_pos, this->durable_trim_pos.get_value())) {
-            LLFS_VLOG(1) << "Detected flush trim_pos: " << BATT_INSPECT(header->trim_pos)
-                         << BATT_INSPECT(this->durable_trim_pos.get_value());
-          } else {
-            LLFS_LOG_ERROR() << "Flush op wrote page with commit_size 0!";
-            return batt::StatusCode::kInvalidArgument;
-          }
-        }
-
-        //----- --- -- -  -  -   -
-        // If we are writing the header, then the entire block must be correct.  Reconstruct it here
-        // and verify.
-        //----- --- -- -  -  -   -
-
-        // Grab the payload section of the head page (src).
-        //
-        const ConstBuffer head_payload =
-            resize_buffer(src, std::min(usize{header->commit_size}, llfs::kLogAtomicWriteSize)) +
-            sizeof(llfs::PackedLogPageHeader);
-
-        Status head_payload_match = verify_log_data(header->slot_offset, head_payload);
-        BATT_REQUIRE_OK(head_payload_match);
-
-        // If the committed portion of the block extends beyond the initial page, then compare the
-        // on-disk data with the expected data within that range.
-        //
-        if (header->commit_size > llfs::kLogAtomicWriteSize - sizeof(llfs::PackedLogPageHeader)) {
-          const ConstBuffer block_on_disk{
-              this->disk_.data() + (block_file_offset - this->calculate_.begin_file_offset()),
-              header->commit_size};
-          const ConstBuffer tail_payload = block_on_disk + llfs::kLogAtomicWriteSize;
-          const slot_offset_type tail_slot_offset =
-              header->slot_offset + llfs::kLogAtomicWriteSize - sizeof(llfs::PackedLogPageHeader);
-
-          Status tail_payload_match = verify_log_data(tail_slot_offset, tail_payload);
-          BATT_REQUIRE_OK(tail_payload_match);
-        }
-
-        updated_flush_pos = header->slot_offset + header->commit_size;
-
-        LLFS_VLOG(1) << "The write looks OK!" << BATT_INSPECT(updated_flush_pos);
-      }
-    }
-
-    // Step through the write one atomic block at a time, and allow the caller to inject block
-    // failures.
-    //
-    MutableBuffer dst{this->disk_.data() + (file_offset - this->calculate_.begin_file_offset()),
-                      src.size()};
-
-    bool no_failures = true;
-
-    while (dst.size() > 0) {
-      BATT_CHECK_GE(src.size(), llfs::kLogAtomicWriteSize);
-      if (!inject_block_failure()) {
-        std::memcpy(dst.data(), src.data(), llfs::kLogAtomicWriteSize);
-      } else {
-        no_failures = false;
-      }
-      dst += llfs::kLogAtomicWriteSize;
-      src += llfs::kLogAtomicWriteSize;
-    }
-
-    //----- --- -- -  -  -   -
-    BATT_SUPPRESS_IF_GCC("-Wmaybe-uninitialized")
-    //
-    if (no_failures && updated_flush_pos) {
-      this->flush_pos_ = *updated_flush_pos;
-      LLFS_VLOG(1) << BATT_INSPECT(updated_flush_pos);
-    }
-    //
-    BATT_UNSUPPRESS_IF_GCC()
-    //----- --- -- -  -  -   -
-
-    LLFS_VLOG(1) << BATT_INSPECT((int)no_failures);
-
-    return batt::OkStatus();
-  }
-
-  batt::Watch<slot_offset_type> durable_trim_pos{0};
-
- private:
-  LogBlockCalculator calculate_;
-  slot_offset_type trim_pos_;
-  slot_offset_type flush_pos_;
-  slot_offset_type commit_pos_;
-  ConstBuffer fake_data_;
-  RingBuffer& ring_buffer_;
-  std::vector<u8> disk_;
-};
-
-//=#=#==#==#===============+=+=+=+=++=++++++++++++++-++-+--+-+----+---------------
-//
-class ExpectedFlushOpState
-{
- public:
-  struct PendingWrite {
-    i64 file_offset;
-    ConstBuffer buffer;
-    i32 buf_index;
-    std::function<void(StatusOr<i32>)> handler;
-  };
-
-  using FlushOp = BasicIoRingLogFlushOp<::testing::StrictMock<MockIoRingLogDriver>>;
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  ::testing::StrictMock<MockIoRingLogDriver>& driver;
-  usize op_index;
-  slot_offset_type slot_offset;
-  u64 commit_size;
-  i64 file_offset;
-  slot_offset_type trim_pos;
-  slot_offset_type flush_pos;
-  slot_offset_type commit_pos;
-
-  Optional<SlotUpperBoundAt> waiting_for_commit;
-  Optional<PendingWrite> pending_write;
-
-  Status async_write_some_status = OkStatus();
-  Status wait_for_commit_status = OkStatus();
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  explicit ExpectedFlushOpState(::testing::StrictMock<MockIoRingLogDriver>& mock_driver,
-                                usize op_index) noexcept
-      : driver{mock_driver}
-      , op_index{op_index}
-      , slot_offset{0}
-      , commit_size{0}
-      , file_offset{0}
-      , trim_pos{0}
-      , flush_pos{0}
-      , commit_pos{0}
-      , pending_write{None}
-  {
-  }
-
-  Status verify(const FlushOp& actual) const
-  {
-    const PackedLogPageHeader* const header = actual.get_header();
-
-    BATT_REQUIRE_EQ(PackedLogPageHeader::kMagic, header->magic);
-    BATT_REQUIRE_EQ(this->slot_offset, header->slot_offset);
-    if (this->commit_size == 0 || header->commit_size != 0) {
-      BATT_REQUIRE_EQ(this->commit_size, header->commit_size);
-    }
-    BATT_REQUIRE_EQ(this->trim_pos, header->trim_pos);
-    BATT_REQUIRE_EQ(this->flush_pos, header->flush_pos);
-    BATT_REQUIRE_EQ(this->commit_pos, header->commit_pos);
-
-    return OkStatus();
-  }
-
-  void on_initialize(FakeLogState& fake_log)
-  {
-    const auto block_capacity = this->driver.calculate().block_capacity();
-
-    // Start at the beginning of the log.
-    //
-    this->slot_offset = this->op_index * block_capacity;
-
-    // Calculate the slot range of the block to which data is currently being committed.
-    //
-    SlotRange active_range = this->driver.calculate().block_slot_range_from(
-        llfs::SlotLowerBoundAt{this->driver.get_flush_pos()});
-
-    // Calculate the total log space covered by all flush ops.
-    //
-    const u64 window_size = block_capacity * this->driver.calculate().queue_depth();
-
-    // Step the slot_offset forward until we catch up to where the log is.
-    //
-    while (this->slot_offset + block_capacity <= active_range.lower_bound) {
-      this->slot_offset += window_size;
-    }
-    this->commit_size = 0;
-
-    if (slot_less_than(this->slot_offset, this->driver.get_flush_pos())) {
-      LLFS_VLOG(1) << "EXPECT: get_data() - recover flushed data";
-
-      EXPECT_CALL(this->driver, get_data(this->slot_offset))  //
-          .WillOnce(::testing::Invoke([&fake_log](slot_offset_type requested_offset) {
-            LLFS_VLOG(1) << "MockDriver::get_data()";
-            return fake_log.get_data(requested_offset);
-          }));
-
-      this->commit_size = std::min(fake_log.flush_pos() - this->slot_offset,
-                                   this->driver.calculate().block_capacity());
-    }
-
-    this->trim_pos = this->driver.get_trim_pos();
-    this->flush_pos = this->driver.get_flush_pos();
-    this->commit_pos = this->driver.get_commit_pos();
-  }
-
-  Status on_activate(FakeLogState& fake_log)
-  {
-    BATT_REQUIRE_EQ(this->waiting_for_commit, None);
-    BATT_REQUIRE_EQ(this->pending_write, None);
-
-    if (slot_less_than(this->slot_offset + this->commit_size, this->driver.get_commit_pos())) {
-      this->expect_fill_buffer(fake_log);
-      BATT_REQUIRE_OK(this->expect_async_write_some());
-    } else {
-      BATT_REQUIRE_OK(this->expect_wait_for_commit());
-    }
-
-    return OkStatus();
-  }
-
-  Status on_wait_for_commit(slot_offset_type least_upper_bound)
-  {
-    LLFS_VLOG(1) << "MockDriver::wait_for_commit(" << least_upper_bound << ")";
-
-    BATT_REQUIRE_FALSE(this->waiting_for_commit);
-    BATT_REQUIRE_FALSE(this->pending_write);
-
-    this->waiting_for_commit.emplace(SlotUpperBoundAt{
-        .offset = least_upper_bound,
-    });
-
-    return OkStatus();
-  }
-
-  Status on_complete_wait_for_commit(FakeLogState& fake_log)
-  {
-    BATT_REQUIRE_EQ(bool{this->waiting_for_commit}, true);
-    BATT_REQUIRE_EQ(this->pending_write, None);
-    BATT_REQUIRE_GE(this->driver.get_commit_pos(), this->waiting_for_commit->offset);
-
-    this->waiting_for_commit = None;
-
-    this->expect_fill_buffer(fake_log);
-    BATT_REQUIRE_OK(this->expect_async_write_some());
-
-    return OkStatus();
-  }
-
-  Status on_async_write_some(i64 file_offset, ConstBuffer buffer, i32 buf_index,
-                             std::function<void(StatusOr<i32>)> handler)
-  {
-    LLFS_VLOG(1) << "MockDriver::async_write_some(file_offset=" << file_offset << ", buffer=["
-                 << buffer.size() << "], buf_index=" << buf_index << ")";
-
-    BATT_REQUIRE_FALSE(this->waiting_for_commit);
-    BATT_REQUIRE_FALSE(this->pending_write);
-
-    this->pending_write.emplace(PendingWrite{file_offset, buffer, buf_index, handler});
-
-    return OkStatus();
-  }
-
-  Status on_complete_async_write(StatusOr<i32> result, FakeLogState& fake_log)
-  {
-    BATT_REQUIRE_TRUE(this->pending_write);
-    BATT_REQUIRE_FALSE(this->waiting_for_commit);
-
-    auto local_handler = std::move(this->pending_write->handler);
-    this->pending_write = None;
-
-    // If the result is a simulated fatal failure, then don't expect any further activity from
-    // the op.
-    //
-    if (!result.ok() && !batt::status_is_retryable(result.status())) {
-      local_handler(result);
-      return OkStatus();
-    }
-
-    const bool flush_complete =
-        !slot_less_than(fake_log.flush_pos(), this->slot_offset + this->commit_size);
-
-    const bool block_was_full = this->commit_size == this->driver.calculate().block_capacity();
-
-    if (flush_complete && block_was_full) {
-      this->slot_offset +=
-          (this->driver.calculate().block_capacity() * this->driver.calculate().queue_depth());
-      this->commit_size = 0;
-      LLFS_VLOG(1) << "EVENT: Block completely flushed; advancing window"
-                   << BATT_INSPECT(this->slot_offset);
-    }
-
-    const bool data_available =
-        (this->commit_size < this->driver.calculate().block_capacity()) &&
-        slot_less_than(this->slot_offset + this->commit_size, fake_log.commit_pos());
-
-    if (flush_complete) {
-      this->expect_poll_flush_state();
-
-      if (data_available) {
-        this->expect_fill_buffer(fake_log);
-        BATT_REQUIRE_OK(this->expect_async_write_some());
-      } else {
-        BATT_REQUIRE_OK(this->expect_wait_for_commit());
-      }
-    } else {
-      if (data_available) {
-        this->expect_fill_buffer(fake_log);
-      }
-      BATT_REQUIRE_OK(this->expect_async_write_some());
-    }
-
-    local_handler(result);
-
-    return OkStatus();
-  }
-
-  void expect_fill_buffer(FakeLogState& fake_log)
-  {
-    LLFS_VLOG(1) << "EXPECT: fill_buffer()";
-
-    const slot_offset_type old_commit_pos = this->slot_offset + this->commit_size;
-
-    EXPECT_CALL(this->driver, get_data(old_commit_pos))  //
-        .WillOnce(::testing::Invoke([&fake_log](slot_offset_type requested_offset) {
-          LLFS_VLOG(1) << "MockDriver::get_data()";
-          return fake_log.get_data(requested_offset);
-        }));
-
-    this->commit_size = std::min(fake_log.commit_pos() - this->slot_offset,
-                                 this->driver.calculate().block_capacity());
-
-    this->trim_pos = fake_log.trim_pos();
-    this->flush_pos = fake_log.flush_pos();
-    this->commit_pos = fake_log.commit_pos();
-  }
-
-  void expect_poll_flush_state()
-  {
-    LLFS_VLOG(1) << "EXPECT: poll_flush_state()";
-
-    EXPECT_CALL(this->driver, poll_flush_state())  //
-        .WillOnce(::testing::Invoke([] {
-          LLFS_VLOG(1) << "MockDriver::poll_flush_state()";
-        }));
-  }
-
-  Status expect_async_write_some()
-  {
-    LLFS_VLOG(1) << "EXPECT: async_write_some()";
-
-    BATT_REQUIRE_FALSE(this->pending_write);
-    BATT_REQUIRE_FALSE(slot_less_than(this->driver.get_commit_pos(), this->slot_offset))
-        << "If the driver commit_pos is less than the starting slot range for this op, then "
-           "the op "
-           "should not be writing anything.";
-
-    const i64 op_file_offset =
-        this->driver.calculate().block_start_file_offset_from(SlotLowerBoundAt{this->slot_offset});
-
-    // Expect the op to copy up to the commit_pos (but not more than the block capacity).
-    //
-    this->commit_size = std::min<u64>(this->driver.get_commit_pos() - this->slot_offset,
-                                      this->driver.calculate().block_capacity());
-
-    EXPECT_CALL(this->driver,
-                async_write_some(
-                    ::testing::AllOf(
-                        ::testing::Ge(op_file_offset),
-                        ::testing::Lt(op_file_offset +
-                                      BATT_CHECKED_CAST(i64, sizeof(llfs::PackedLogPageHeader) +
-                                                                 this->commit_size))),
-                    ::testing::Truly([&](ConstBuffer actual_data) {
-                      return actual_data.size() > 0;
-                    }),
-                    /*buf_index=*/op_index, ::testing::_))
-        .WillOnce(::testing::Invoke([this](auto&&... args) {
-          this->async_write_some_status.Update(this->on_async_write_some(BATT_FORWARD(args)...));
-        }));
-
-    return OkStatus();
-  }
-
-  Status expect_wait_for_commit()
-  {
-    LLFS_VLOG(1) << "EXPECT: wait_for_commit()";
-
-    BATT_REQUIRE_FALSE(this->waiting_for_commit);
-
-    EXPECT_CALL(this->driver, wait_for_commit(this->slot_offset + this->commit_size + 1))  //
-        .WillOnce(::testing::Invoke([this](slot_offset_type least_upper_bound) {
-          this->wait_for_commit_status.Update(this->on_wait_for_commit(least_upper_bound));
-        }));
-
-    return OkStatus();
-  }
-};  // namespace llfs
-
-}  // namespace llfs
-
-#endif  // LLFS_DISABLE_IO_URING
-
-#endif  // LLFS_IORING_LOG_FLUSH_OP_TEST_HPP
diff --git a/src/llfs/ioring_log_initializer.cpp b/src/llfs/ioring_log_initializer.cpp
deleted file mode 100644
index cd02a0d..0000000
--- a/src/llfs/ioring_log_initializer.cpp
+++ /dev/null
@@ -1,78 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#include <llfs/ioring_log_initializer.hpp>
-//
-
-#ifndef LLFS_DISABLE_IO_URING
-
-#include <llfs/ioring_log_initializer.ipp>
-#include <llfs/logging.hpp>
-
-#include <batteries/metrics/metric_collectors.hpp>
-
-namespace llfs {
-
-template class BasicIoRingLogInitializer<IoRing>;
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-Status initialize_ioring_log_device(RawBlockFile& file, const IoRingLogConfig& config,
-                                    ConfirmThisWillEraseAllMyData /*confirm*/)
-{
-  LLFS_VLOG(1) << "initializing IoRingLogDevice; " << BATT_INSPECT(config.block_count())
-               << BATT_INSPECT(config.block_size()) << BATT_INSPECT(config.block_capacity());
-
-  batt::LatencyMetric block_write_latency;
-  {
-    batt::LatencyTimer block_write_timer{block_write_latency, config.block_count()};
-
-    IoRing::File* ioring_file = file.get_io_ring_file();
-
-    const u64 n_blocks_to_init = [&] {
-      if (kFastIoRingLogDeviceInit) {
-        return u64{1};
-      }
-      return config.block_count();
-    }();
-
-    if (ioring_file) {
-      IoRingLogInitializer initializer{/*n_tasks=*/std::min<usize>(1024, n_blocks_to_init),
-                                       *ioring_file, config, n_blocks_to_init};
-
-      batt::Status init_status = initializer.run();
-
-      BATT_REQUIRE_OK(init_status);
-
-    } else {
-      LLFS_LOG_INFO_FIRST_N(10) << "Using slow path for log device initialization";
-
-      PackedLogPageBuffer buffer;
-      buffer.clear();
-      buffer.header.reset();
-
-      u64 file_offset = config.physical_offset;
-      for (u64 block_i = 0; block_i < n_blocks_to_init; ++block_i) {
-        LLFS_VLOG(2) << "writing initial block header; " << BATT_INSPECT(buffer.header.slot_offset)
-                     << BATT_INSPECT(file_offset);
-        Status write_status = write_all(file, file_offset, buffer.as_const_buffer());
-        BATT_REQUIRE_OK(write_status);
-        buffer.header.slot_offset += config.block_capacity();
-        file_offset += config.block_size();
-      }
-    }
-  }  // LatencyTimer
-
-  LLFS_VLOG(1) << "Success! " << block_write_latency.rate_per_second() << " blocks/sec";
-
-  return OkStatus();
-}
-
-}  // namespace llfs
-
-#endif  // LLFS_DISABLE_IO_URING
diff --git a/src/llfs/ioring_log_initializer.hpp b/src/llfs/ioring_log_initializer.hpp
deleted file mode 100644
index 0965a2a..0000000
--- a/src/llfs/ioring_log_initializer.hpp
+++ /dev/null
@@ -1,135 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#pragma once
-#ifndef LLFS_IORING_LOG_INITIALIZER_HPP
-#define LLFS_IORING_LOG_INITIALIZER_HPP
-
-#include <llfs/config.hpp>
-//
-#ifndef LLFS_DISABLE_IO_URING
-
-#include <llfs/confirm.hpp>
-#include <llfs/int_types.hpp>
-#include <llfs/ioring.hpp>
-#include <llfs/ioring_log_config.hpp>
-#include <llfs/packed_log_page_buffer.hpp>
-#include <llfs/raw_block_file.hpp>
-
-#include <batteries/async/handler.hpp>
-#include <batteries/async/watch.hpp>
-#include <batteries/status.hpp>
-
-#include <atomic>
-#include <vector>
-
-namespace llfs {
-
-// Write an empty log device to the given fd.
-//
-Status initialize_ioring_log_device(RawBlockFile& file, const IoRingLogConfig& config,
-                                    ConfirmThisWillEraseAllMyData confirm);
-
-template <typename IoRingImpl>
-class BasicIoRingLogInitializer;
-
-using IoRingLogInitializer = BasicIoRingLogInitializer<IoRing>;
-
-//=#=#==#==#===============+=+=+=+=++=++++++++++++++-++-+--+-+----+---------------
-//
-template <typename IoRingImpl>
-class BasicIoRingLogInitializer
-{
- public:
-  //==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-  //
-  struct Subtask {
-    // Must be first (to guarantee that each Subtask state is cpu-cache-line-isolated); the buffer
-    // to hold log page header information.
-    //
-    PackedLogPageBuffer buffer;
-
-    // The BasicIoRingLogInitializer object to which this Subtask belongs.
-    //
-    BasicIoRingLogInitializer* that = nullptr;
-
-    // The current destination file offset to which this Subtask is writing information.
-    //
-    i64 file_offset = 0;
-
-    // The number of bytes that have been written in the current block.
-    //
-    i32 block_progress = sizeof(this->buffer);
-
-    // Embedded memory for handler-related allocation.
-    //
-    batt::HandlerMemory<128> handler_memory;
-
-    // Used to aggregate the success/error disposition of the initializer.  Should be set only once
-    // per Subtask.
-    //
-    batt::Status final_status;
-
-    // Set to `true` once the Subtask finishes.
-    //
-    bool done = false;
-
-    //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-    //
-    //
-    void start_write();
-
-    void handle_write(const batt::StatusOr<i32>& n_written);
-
-    void finish(const batt::Status& status);
-
-    usize self_index() const;
-  };
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  explicit BasicIoRingLogInitializer(usize n_tasks, typename IoRingImpl::File& file,
-                                     const IoRingLogConfig& config, u64 n_blocks_to_init) noexcept;
-
-  batt::Status run();
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
- private:
-  // The file to which this initializer is writing log information.
-  //
-  typename IoRingImpl::File& file_;
-
-  // The configuration of the log which this object is initializing.
-  //
-  IoRingLogConfig config_;
-
-  // The next log block index which hasn't been assigned to a Subtask; used by the Subtasks to
-  // coordinate the distribution of work.
-  //
-  std::atomic<usize> next_block_i_{0};
-
-  // Subtasks are responsible to increment this variable by 1 when they are finished; this is how
-  // the initializer knows when we are done.
-  //
-  batt::Watch<usize> finished_count_{0};
-
-  // The Subtask states.
-  //
-  std::vector<Subtask> subtasks_;
-
-  // The maximum number of block headers to initialize.
-  //
-  u64 n_blocks_to_init_;
-};
-
-}  // namespace llfs
-
-#endif  // LLFS_DISABLE_IO_URING
-
-#endif  // LLFS_IORING_LOG_INITIALIZER_HPP
diff --git a/src/llfs/ioring_log_initializer.ipp b/src/llfs/ioring_log_initializer.ipp
deleted file mode 100644
index bbb3ce4..0000000
--- a/src/llfs/ioring_log_initializer.ipp
+++ /dev/null
@@ -1,182 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#pragma once
-#ifndef LLFS_IORING_LOG_INITIALIZER_IPP
-#define LLFS_IORING_LOG_INITIALIZER_IPP
-
-#include <llfs/config.hpp>
-//
-#ifndef LLFS_DISABLE_IO_URING
-
-namespace llfs {
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename IoRingImpl>
-/*explicit*/ inline BasicIoRingLogInitializer<IoRingImpl>::BasicIoRingLogInitializer(
-    usize n_tasks, typename IoRingImpl::File& file, const IoRingLogConfig& config,
-    u64 n_blocks_to_init) noexcept
-    : file_{file}
-    , config_{config}
-    , subtasks_(n_tasks)
-    , n_blocks_to_init_{n_blocks_to_init}
-{
-  for (auto& task : this->subtasks_) {
-    task.that = this;
-    task.buffer.clear();
-    task.buffer.header.reset();
-  }
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename IoRingImpl>
-inline batt::Status BasicIoRingLogInitializer<IoRingImpl>::run()
-{
-  LLFS_VLOG(1) << "IoRingLogInitializer::run() Entered; "
-               << BATT_INSPECT(this->config_.block_count())
-               << BATT_INSPECT(this->config_.block_size())
-               << BATT_INSPECT(this->config_.block_capacity())
-               << BATT_INSPECT(this->n_blocks_to_init_);
-  {
-    batt::MutableBuffer memory{this->subtasks_.data(), this->subtasks_.size() * sizeof(Subtask)};
-
-    LLFS_VLOG(1) << "memory = " << (const void*)memory.data() << ".."
-                 << (const void*)(this->subtasks_.data() + this->subtasks_.size());
-
-    // Cache the file descriptor information in the kernel for faster access.
-    //
-    Status fd_status = this->file_.register_fd();
-    BATT_REQUIRE_OK(fd_status);
-
-    // Map our memory buffer to the kernel for faster I/O.
-    //
-    StatusOr<usize> buffers_status = this->file_.get_io_ring_impl()->register_buffers(
-        seq::single_item(std::move(memory)) | seq::boxed(), /*update=*/false);
-
-    LLFS_VLOG(2) << "register_buffers status=" << buffers_status;
-    BATT_REQUIRE_OK(buffers_status);
-  }
-  auto on_scope_exit = batt::finally([&] {
-    this->file_.get_io_ring_impl()->unregister_buffers().IgnoreError();
-    LLFS_VLOG(1) << "IoRingLogInitializer::run() Finished";
-  });
-
-  for (auto& task : this->subtasks_) {
-    task.start_write();
-  }
-  Status all_finished = this->finished_count_.await_equal(this->subtasks_.size());
-  BATT_REQUIRE_OK(all_finished);
-
-  for (auto& task : this->subtasks_) {
-    BATT_REQUIRE_OK(task.final_status);
-  }
-
-  return OkStatus();
-}
-
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename IoRingImpl>
-inline void BasicIoRingLogInitializer<IoRingImpl>::Subtask::start_write()
-{
-  LLFS_VLOG(2) << "[Subtask:" << this->self_index()
-               << "] IoRingLogInitializer::Subtask::start_write()"
-               << BATT_INSPECT(this->block_progress) << BATT_INSPECT(this->file_offset);
-
-  BasicIoRingLogInitializer* const that = this->that;
-  const IoRingLogConfig& config = that->config_;
-
-  batt::ConstBuffer bytes = this->buffer.as_const_buffer() + this->block_progress;
-  if (bytes.size() == 0) {
-    LLFS_VLOG(2) << " -- At end of buffer; fetching next block index...";
-
-    const usize block_i = that->next_block_i_.fetch_add(1);
-
-    LLFS_VLOG(2) << " -- " << BATT_INSPECT(block_i) << "/" << that->n_blocks_to_init_;
-
-    // If `block_i` is at or past the end of the log, we are done!  Increment the finished count
-    // and return.
-    //
-    if (block_i >= that->n_blocks_to_init_) {
-      LLFS_VLOG(2) << " -- FINISHED (all blocks written)";
-      this->finish(batt::OkStatus());
-      return;
-    }
-
-    // We have a new block to write.  Reset our state and continue.
-    //
-    this->file_offset = config.physical_offset + config.block_size() * block_i;
-    this->block_progress = 0;
-    this->buffer.header.slot_offset = config.block_capacity() * block_i;
-    bytes = this->buffer.as_const_buffer();
-  }
-
-  LLFS_VLOG(2) << " -- async_write_some(offset=" << this->file_offset << ", bytes=[" << bytes.size()
-               << "])";
-
-  that->file_.async_write_some_fixed(
-      this->file_offset, bytes, /*buf_index=*/0,
-      batt::make_custom_alloc_handler(this->handler_memory,
-                                      [this](const batt::StatusOr<i32>& n_written) {
-                                        this->handle_write(n_written);
-                                      }));
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename IoRingImpl>
-inline void BasicIoRingLogInitializer<IoRingImpl>::Subtask::handle_write(
-    const batt::StatusOr<i32>& n_written)
-{
-  LLFS_VLOG(2) << "[Subtask:" << this->self_index()
-               << "] IoRingLogInitializer::Subtask::handle_write(status=" << n_written.status()
-               << ", n_written=" << (n_written.ok() ? *n_written : -1) << ")";
-
-  if (!n_written.ok()) {
-    this->finish(n_written.status());
-    return;
-  }
-
-  BATT_CHECK_GE(*n_written, 0);
-
-  this->block_progress += *n_written;
-  this->file_offset += *n_written;
-  this->start_write();
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename IoRingImpl>
-inline void BasicIoRingLogInitializer<IoRingImpl>::Subtask::finish(const batt::Status& status)
-{
-  BATT_CHECK(!this->done);
-
-  this->done = true;
-  this->final_status.Update(status);
-  const auto prior_finished_count = this->that->finished_count_.fetch_add(1);
-
-  LLFS_VLOG(2) << BATT_INSPECT(prior_finished_count);
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-template <typename IoRingImpl>
-inline usize BasicIoRingLogInitializer<IoRingImpl>::Subtask::self_index() const
-{
-  return this - this->that->subtasks_.data();
-}
-
-}  // namespace llfs
-
-#endif  // LLFS_DISABLE_IO_URING
-
-#endif  // LLFS_IORING_LOG_INITIALIZER_IPP
diff --git a/src/llfs/ioring_log_recovery.cpp b/src/llfs/ioring_log_recovery.cpp
deleted file mode 100644
index 7adedd1..0000000
--- a/src/llfs/ioring_log_recovery.cpp
+++ /dev/null
@@ -1,330 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#include <llfs/ioring_log_recovery.hpp>
-//
-#include <llfs/data_reader.hpp>
-#include <llfs/logging.hpp>
-#include <llfs/slot_writer.hpp>
-
-#include <batteries/stream_util.hpp>
-
-namespace llfs {
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-/*explicit*/ IoRingLogRecovery::IoRingLogRecovery(const IoRingLogConfig& config,
-                                                  RingBuffer& ring_buffer, ReadDataFn&& read_data)
-    : config_{config}
-    , ring_buffer_{ring_buffer}
-    , read_data_{std::move(read_data)}
-    , block_storage_{
-          new PackedLogPageBuffer[this->config_.block_size() / sizeof(PackedLogPageBuffer)]}
-{
-  BATT_CHECK_EQ(this->config_.block_size() % sizeof(PackedLogPageBuffer), 0u);
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-Status IoRingLogRecovery::run()
-{
-  LLFS_VLOG(1) << "IoRingLogRecovery::run()";
-  i64 file_offset = 0;
-  Optional<slot_offset_type> old_trim_pos = this->trim_pos_;
-
-  usize known_valid_blocks = 1;
-  const usize block_count = this->config_.block_count();
-  const usize wrap_around_size = block_count * this->config_.block_capacity();
-
-  for (usize block_i = 0; block_i < known_valid_blocks;
-       ++block_i, file_offset += this->config_.block_size()) {
-    //----- --- -- -  -  -   -
-    LLFS_VLOG(2) << "Reading " << BATT_INSPECT(block_i) << "/" << block_count << " from "
-                 << BATT_INSPECT(file_offset) << BATT_INSPECT(this->block_buffer().size());
-
-    BATT_CHECK_LE(known_valid_blocks, block_count);
-
-    // Read the next block into the buffer.
-    //
-    Status read_status = this->read_data_(file_offset, this->block_buffer());
-    BATT_REQUIRE_OK(read_status);
-
-    // Update the known_valid_blocks count.
-    //
-    if (known_valid_blocks < block_count) {
-      if (this->block_header().slot_offset >= wrap_around_size) {
-        LLFS_VLOG(1) << " -- block slot_offset over (" << BATT_INSPECT(wrap_around_size)
-                     << " ); setting known_valid_blocks to " << BATT_INSPECT(block_count);
-        known_valid_blocks = block_count;
-      } else {
-        if (this->block_header().commit_size == this->config_.block_capacity()) {
-          BATT_CHECK_GT(block_i + 2, known_valid_blocks);
-          LLFS_VLOG(2) << " -- block is full; known_valid_blocks = " << known_valid_blocks << " -> "
-                       << (block_i + 2);
-          known_valid_blocks = block_i + 2;
-        }
-      }
-    }
-
-    // Run data integrity checks.
-    //
-    Status block_valid = this->validate_block();
-    BATT_REQUIRE_OK(block_valid);
-
-    // Update the trim position (this must be valid later when we find the "true" flush_pos).
-    //
-    clamp_min_slot(&this->trim_pos_, this->block_header().trim_pos);
-    if (this->trim_pos_ != old_trim_pos) {
-      LLFS_VLOG(1) << "Updating trim_pos: " << old_trim_pos << " => " << this->trim_pos_;
-      old_trim_pos = this->trim_pos_;
-    } else {
-      LLFS_VLOG(2) << BATT_INSPECT(this->trim_pos_);
-    }
-
-    // Copy data from this block into the ring buffer, if possible.
-    //
-    this->recover_block_data();
-  }
-
-  // Scan recovered data to find the true flushed upper bound.
-  //
-  this->recover_flush_pos();
-
-  // Done!
-  //
-  LLFS_VLOG(1) << "Finished log recovery;" << BATT_INSPECT(this->trim_pos_)
-               << BATT_INSPECT(this->flush_pos_)
-               << " logical_size=" << batt::dump_size_exact(this->config_.logical_size)
-               << " ring_buffer.size=" << batt::dump_size_exact(this->ring_buffer_.size());
-
-  return batt::OkStatus();
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-Status IoRingLogRecovery::validate_block() const
-{
-  if (this->block_header().magic != PackedLogPageHeader::kMagic) {
-    LLFS_LOG_ERROR() << "Bad magic number;" << BATT_INSPECT(this->block_header());
-    return make_status(StatusCode::kLogBlockBadMagic);
-  }
-  if (this->block_header().commit_size > this->config_.block_capacity()) {
-    return make_status(StatusCode::kLogBlockCommitSizeOverflow);
-  }
-
-  return batt::OkStatus();
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-MutableBuffer IoRingLogRecovery::block_buffer()
-{
-  return MutableBuffer{(void*)this->block_storage_.get(), this->config_.block_size()};
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-const PackedLogPageHeader& IoRingLogRecovery::block_header() const
-{
-  return this->block_storage_[0].header;
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-void IoRingLogRecovery::recover_block_data()
-{
-  const auto& header = this->block_header();
-
-  LLFS_VLOG(1) << "IoRingLogRecovery::recover_block_data()" << BATT_INSPECT(header);
-
-  // Record this slot interval so we know how much contiguous data we have starting at the trim pos
-  // upper bound when we are done.
-  //
-  const auto slot_offset_range = OffsetRange{
-      .lower_bound = (isize)header.slot_offset,
-      .upper_bound = (isize)(header.slot_offset + header.commit_size),
-  };
-  LLFS_VLOG(2) << " -- " << BATT_INSPECT(slot_offset_range);
-
-  this->committed_data_.update(slot_offset_range, 1);
-  LLFS_VLOG(2) << " -- " << BATT_INSPECT(this->committed_data_);
-
-  // If there is no committed data in this block, we are done here.
-  //
-  if (header.commit_size == 0) {
-    LLFS_VLOG(2) << " -- (no data; returning)";
-    return;
-  }
-
-  LLFS_VLOG(1) << "Found committed data;" << BATT_INSPECT(slot_offset_range);
-
-  const u64 begin_offset = header.slot_offset;
-  const u64 end_offset = begin_offset + header.commit_size;
-
-  const batt::Interval<isize> logical_slots{
-      .lower_bound = BATT_CHECKED_CAST(isize, begin_offset),
-      .upper_bound = BATT_CHECKED_CAST(isize, end_offset),
-  };
-
-  ConstBuffer data = this->block_payload();
-
-  // It may seem cumbersome to explicitly account for buffer wrap-around here, potentially
-  // splitting our logical data slice into multiple parts, but handling that here helps prevent
-  // SlotIntervalMap from getting too complicated.
-  //
-  for (const batt::Interval<isize> slice :
-       this->ring_buffer_.physical_offsets_from_logical(logical_slots)) {
-    //
-    // Update the map and then read back our physical interval to see which parts contain
-    // up-to-date data that should be copied to the ring buffer.
-    //
-    this->latest_slot_range_.update(slice, header.slot_offset);
-
-    LLFS_VLOG(1) << " -- ring buffer " << BATT_INSPECT(slice);
-
-    for (const SlotIntervalMap::Entry& entry : this->latest_slot_range_.query(slice)) {
-      LLFS_VLOG(1) << " ---- " << BATT_INSPECT(entry);
-      if (entry.slot == header.slot_offset) {
-        MutableBuffer dst = this->ring_buffer_.get_mut(entry.offset_range.lower_bound);
-        auto src_i = entry.offset_range.shift_down(slice.lower_bound);
-        ConstBuffer src = slice_buffer(data, src_i);
-        LLFS_VLOG(1) << " ---- " << BATT_INSPECT(src_i) << BATT_INSPECT(src.size());
-        std::memcpy(dst.data(), src.data(), src.size());
-      } else {
-        LLFS_VLOG(1) << " ---- skipping entry;" << BATT_INSPECT(entry.slot)
-                     << BATT_INSPECT(header.slot_offset);
-      }
-    }
-
-    data += slice.size();
-  }
-
-  LLFS_VLOG(1) << "Updated " << BATT_INSPECT(this->committed_data_);
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-void IoRingLogRecovery::recover_flush_pos()
-{
-  LLFS_VLOG(1) << "IoRingLogRecovery::recover_flush_pos()";
-
-  // Start at the trim pos and step forward through the recovered data, slot by slot, to discover
-  // the true flushed upper bound.
-
-  slot_offset_type slot_offset = this->get_trim_pos();
-
-  // Start at the recovered trim_pos and query up to a full buffer's worth of commit ranges.
-  //
-  const auto query_range = OffsetRange{
-      .lower_bound = static_cast<isize>(slot_offset),
-      .upper_bound = static_cast<isize>(slot_offset + this->ring_buffer_.size()),
-  };
-
-  // The first entry of the returned container represents the largest contiguous interval of
-  // committed data slot offsets recovered from all log blocks.
-  //
-  const auto committed_ranges = this->committed_data_.query(query_range);
-
-  LLFS_VLOG(1) << " -- " << BATT_INSPECT_RANGE(committed_ranges);
-
-  // If there is no committed data at the recovered trim pos, we are done here.
-  //
-  if (committed_ranges.empty()) {
-    this->flush_pos_ = this->trim_pos_;
-    return;
-  }
-
-  BATT_CHECK_EQ(committed_ranges.front().offset_range.lower_bound, static_cast<isize>(slot_offset));
-
-  if (committed_ranges.size() > 1) {
-    BATT_CHECK(slot_less_than(committed_ranges[0].offset_range.upper_bound,
-                              committed_ranges[1].offset_range.lower_bound))
-        << "SlotIntervalMap should have merged these two intervals!";
-  }
-
-  constexpr usize kUpdateCadence = 500;
-
-  ConstBuffer committed_bytes = resize_buffer(this->ring_buffer_.get(slot_offset),
-                                              committed_ranges.front().offset_range.size());
-
-  slot_offset_type confirmed_flush_pos = slot_offset;
-  bool inside_atomic_range = false;
-
-  for (;;) {
-    LLFS_VLOG_EVERY_N(2, kUpdateCadence)
-        << " -- attempting to recover log entry at " << BATT_INSPECT(slot_offset);
-
-    DataReader reader{committed_bytes};
-    const usize bytes_available_before = reader.bytes_available();
-    Optional<u64> slot_body_size = reader.read_varint();
-
-    LLFS_VLOG_EVERY_N(2, kUpdateCadence) << " -- " << BATT_INSPECT(slot_body_size);
-
-    if (!slot_body_size) {
-      // Partially committed slot (couldn't even read a whole varint for the slot header!)  Break
-      // out of the loop.
-      //
-      LLFS_VLOG(1) << " -- Incomplete slot header, exiting loop;" << BATT_INSPECT(slot_offset)
-                   << BATT_INSPECT(bytes_available_before);
-      break;
-    }
-
-    const usize bytes_available_after = reader.bytes_available();
-    const usize slot_header_size = bytes_available_before - bytes_available_after;
-    const usize slot_size = slot_header_size + *slot_body_size;
-
-    LLFS_VLOG_EVERY_N(2, kUpdateCadence)
-        << " -- " << BATT_INSPECT(slot_size) << BATT_INSPECT(committed_bytes.size());
-
-    if (slot_size > committed_bytes.size()) {
-      // Partially committed slot; break out of the loop without updating slot_offset (we're
-      // done!)
-      //
-      LLFS_VLOG(1) << " -- Incomplete slot body, exiting loop;" << BATT_INSPECT(slot_offset)
-                   << BATT_INSPECT(bytes_available_before) << BATT_INSPECT(bytes_available_after)
-                   << BATT_INSPECT(slot_header_size) << BATT_INSPECT(slot_body_size)
-                   << BATT_INSPECT(slot_size);
-      break;
-    }
-
-    // Check for control token; this indicates the beginning or end of an atomic slot range.
-    //
-    if (*slot_body_size == 0) {
-      if (slot_header_size == SlotWriter::WriterLock::kBeginAtomicRangeTokenSize) {
-        inside_atomic_range = true;
-      } else if (slot_header_size == SlotWriter::WriterLock::kEndAtomicRangeTokenSize) {
-        inside_atomic_range = false;
-      }
-    }
-
-    committed_bytes += slot_size;
-    slot_offset += slot_size;
-
-    // If inside an atomic slot range, we hold off on updating the confirmed_flush_pos, just in case
-    // the flushed data is cut off before the end of the atomic range.
-    //
-    if (!inside_atomic_range) {
-      confirmed_flush_pos = slot_offset;
-    }
-  }
-
-  LLFS_VLOG(1) << " -- Slot scan complete;" << BATT_INSPECT(slot_offset);
-
-  this->flush_pos_ = confirmed_flush_pos;
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-ConstBuffer IoRingLogRecovery::block_payload() const
-{
-  return ConstBuffer{this->block_storage_.get(),
-                     sizeof(PackedLogPageHeader) + this->block_header().commit_size} +
-         sizeof(PackedLogPageHeader);
-}
-
-}  // namespace llfs
diff --git a/src/llfs/ioring_log_recovery.hpp b/src/llfs/ioring_log_recovery.hpp
deleted file mode 100644
index a19a0d8..0000000
--- a/src/llfs/ioring_log_recovery.hpp
+++ /dev/null
@@ -1,95 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#pragma once
-#ifndef LLFS_IORING_LOG_RECOVERY_HPP
-#define LLFS_IORING_LOG_RECOVERY_HPP
-
-#include <llfs/buffer.hpp>
-#include <llfs/int_types.hpp>
-#include <llfs/ioring_log_config.hpp>
-#include <llfs/optional.hpp>
-#include <llfs/packed_log_page_buffer.hpp>
-#include <llfs/ring_buffer.hpp>
-#include <llfs/slot.hpp>
-#include <llfs/slot_interval_map.hpp>
-#include <llfs/status.hpp>
-
-#include <functional>
-
-namespace llfs {
-
-/*! \brief Manages log data and state recovery from on-disk information.
- */
-class IoRingLogRecovery
-{
- public:
-  using ReadDataFn = std::function<Status(i64 file_offset, MutableBuffer dst_buffer)>;
-
-  explicit IoRingLogRecovery(const IoRingLogConfig& config, RingBuffer& ring_buffer,
-                             ReadDataFn&& read_data);
-
-  Status run();
-
-  slot_offset_type get_trim_pos() const
-  {
-    return this->trim_pos_.value_or(0);
-  }
-
-  slot_offset_type get_flush_pos() const
-  {
-    return this->flush_pos_.value_or(this->get_trim_pos());
-  }
-
- private:
-  Status validate_block() const;
-
-  MutableBuffer block_buffer();
-
-  const PackedLogPageHeader& block_header() const;
-
-  ConstBuffer block_payload() const;
-
-  void recover_block_data();
-
-  void recover_flush_pos();
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  // The physical log configuration plus cached derived values.
-  //
-  const IoRingLogConfig config_;
-
-  // The destination log ring buffer we are trying to reconstruct.
-  //
-  RingBuffer& ring_buffer_;
-
-  // Callback used to read data into the block storage buffer; passed in at creation time.
-  //
-  ReadDataFn read_data_;
-
-  // The maximum trim_pos field value read from all valid block headers.
-  //
-  Optional<slot_offset_type> trim_pos_;
-
-  // The true slot upper bound for valid flushed data.
-  //
-  Optional<slot_offset_type> flush_pos_;
-
-  // The memory used to load individual log blocks.
-  //
-  std::unique_ptr<PackedLogPageBuffer[]> block_storage_;
-
-  SlotIntervalMap latest_slot_range_;
-
-  SlotIntervalMap committed_data_;
-};
-
-}  // namespace llfs
-
-#endif  // LLFS_IORING_LOG_RECOVERY_HPP
diff --git a/src/llfs/log_block_calculator.cpp b/src/llfs/log_block_calculator.cpp
deleted file mode 100644
index a139709..0000000
--- a/src/llfs/log_block_calculator.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#include <llfs/log_block_calculator.hpp>
-//
-
-namespace llfs {
-}
diff --git a/src/llfs/log_block_calculator.hpp b/src/llfs/log_block_calculator.hpp
deleted file mode 100644
index 94b10b6..0000000
--- a/src/llfs/log_block_calculator.hpp
+++ /dev/null
@@ -1,274 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#pragma once
-#ifndef LLFS_LOG_BLOCK_CALCULATOR_HPP
-#define LLFS_LOG_BLOCK_CALCULATOR_HPP
-
-#include <llfs/int_types.hpp>
-#include <llfs/ioring_log_config.hpp>
-#include <llfs/ioring_log_driver_options.hpp>
-#include <llfs/log_device.hpp>
-#include <llfs/slot.hpp>
-
-#include <batteries/checked_cast.hpp>
-#include <batteries/strong_typedef.hpp>
-
-namespace llfs {
-
-// Calculates derived values from IoRing log config and options.
-//
-class LogBlockCalculator
-{
- public:
-  BATT_STRONG_TYPEDEF(usize, LogicalBlockIndex);
-  BATT_STRONG_TYPEDEF(usize, PhysicalBlockIndex);
-  BATT_STRONG_TYPEDEF(i64, PhysicalFileOffset);
-  BATT_STRONG_TYPEDEF(usize, FlushOpIndex);
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  static usize disk_size_required_for_log_size(u64 logical_size, u64 block_size)
-  {
-    const u64 block_capacity = block_size - sizeof(PackedLogPageHeader);
-    const u64 block_count =
-        (logical_size + block_capacity - 1) / block_capacity + (1 /* for wrap-around */);
-
-    return block_size * block_count;
-  }
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  explicit LogBlockCalculator(const IoRingLogConfig& config,
-                              const IoRingLogDriverOptions& options) noexcept
-      : config_{config}
-      , options_{options}
-  {
-  }
-
-  usize pages_per_block() const
-  {
-    return this->config_.pages_per_block();
-  }
-
-  // Returns the size in bytes of a log block.
-  //
-  usize block_size() const
-  {
-    return this->block_size_;
-  }
-
-  // Returns the size in bytes of the payload section of a log block; this is the block size minus
-  // the log page header.
-  //
-  usize block_capacity() const
-  {
-    return this->block_capacity_;
-  }
-
-  // Returns the total number of blocks in the log.
-  //
-  usize block_count() const
-  {
-    return this->block_count_;
-  }
-
-  // Returns the size (capacity) in bytes of the log.
-  //
-  u64 logical_size() const
-  {
-    return this->config_.logical_size;
-  }
-
-  // Returns the size in bytes of the on-disk image of the log.
-  //
-  u64 physical_size() const
-  {
-    return this->log_end_ - this->log_start_;
-  }
-
-  // Returns the slot delta between successive generations of data written to the same physical
-  // block.
-  //
-  slot_offset_type physical_window_size() const
-  {
-    return this->block_capacity() * this->block_count();
-  }
-
-  // Returns the number of concurrent flush operations configured for this log.
-  //
-  usize queue_depth() const
-  {
-    return this->queue_depth_;
-  }
-
-  // The starting offset within the file of the beginning of the log blocks.
-  //
-  i64 begin_file_offset() const
-  {
-    return this->log_start_;
-  }
-
-  // The file offset that is one past the last byte of the last log block.
-  //
-  i64 end_file_offset() const
-  {
-    return this->log_end_;
-  }
-
-  // Returns the index of the logical block that contains the given slot offset.
-  //
-  LogicalBlockIndex logical_block_index_from(SlotLowerBoundAt slot_lower_bound) const
-  {
-    return LogicalBlockIndex{slot_lower_bound.offset / this->block_capacity()};
-  }
-
-  // Returns the index of the highest-offset logical block that is bounded by `slot_upper_bound`.
-  //
-  LogicalBlockIndex logical_block_index_from(SlotUpperBoundAt slot_upper_bound) const
-  {
-    return this->logical_block_index_from(SlotLowerBoundAt{
-        .offset = slot_upper_bound.offset - 1,
-    });
-  }
-
-  PhysicalBlockIndex physical_block_index_from(LogicalBlockIndex logical_block_index) const
-  {
-    return PhysicalBlockIndex{logical_block_index.value() % this->block_count()};
-  }
-
-  // Returns the index of the physical block that contains the given slot offset.
-  //
-  PhysicalBlockIndex physical_block_index_from(SlotLowerBoundAt slot_lower_bound) const
-  {
-    return this->physical_block_index_from(this->logical_block_index_from(slot_lower_bound));
-  }
-
-  // Returns the index of the highest-offset physical block that is bounded by `slot_upper_bound`.
-  //
-  PhysicalBlockIndex physical_block_index_from(SlotUpperBoundAt slot_upper_bound) const
-  {
-    return this->physical_block_index_from(this->logical_block_index_from(slot_upper_bound));
-  }
-
-  // Returns the index of the physical block containing the passed file offset.
-  //
-  PhysicalBlockIndex physical_block_index_from(PhysicalFileOffset file_offset) const
-  {
-    BATT_CHECK_GE(file_offset, this->log_start_.value());
-    BATT_CHECK_LT(file_offset, this->log_end_.value());
-
-    return PhysicalBlockIndex{(file_offset - this->log_start_.value()) / this->block_size()};
-  }
-
-  // Returns the SlotRange of the specified block.
-  //
-  SlotRange block_slot_range_from(LogicalBlockIndex logical_block_index) const
-  {
-    const slot_offset_type lower_bound = logical_block_index.value() * this->block_capacity();
-
-    return SlotRange{
-        .lower_bound = lower_bound,
-        .upper_bound = lower_bound + this->block_capacity(),
-    };
-  }
-
-  // Returns the SlotRange of the highest-offset block that contains `slot_lower_bound`.
-  //
-  SlotRange block_slot_range_from(SlotLowerBoundAt slot_lower_bound) const
-  {
-    return this->block_slot_range_from(this->logical_block_index_from(slot_lower_bound));
-  }
-
-  // Returns the SlotRange of the highest-offset block that is bounded by `slot_upper_bound`.
-  //
-  SlotRange block_slot_range_from(SlotUpperBoundAt slot_upper_bound) const
-  {
-    return this->block_slot_range_from(this->logical_block_index_from(slot_upper_bound));
-  }
-
-  FlushOpIndex flush_op_index_from(LogicalBlockIndex logical_block_index) const
-  {
-    return FlushOpIndex{logical_block_index.value() & this->queue_depth_mask_};
-  }
-
-  // Returns the index of the flush op object assigned to handle flushing from the given log offset.
-  //
-  FlushOpIndex flush_op_index_from(SlotLowerBoundAt slot_lower_bound) const
-  {
-    return this->flush_op_index_from(this->logical_block_index_from(slot_lower_bound));
-  }
-
-  // Returns the index of the flush op object assigned to handle flushing from the given log offset.
-  //
-  FlushOpIndex flush_op_index_from(SlotUpperBoundAt slot_upper_bound) const
-  {
-    return this->flush_op_index_from(this->logical_block_index_from(slot_upper_bound));
-  }
-
-  // Returns the next flush_op index, wrapping around at `queue_depth`.
-  //
-  FlushOpIndex next_flush_op_index(FlushOpIndex index) const
-  {
-    return FlushOpIndex{(index.value() + 1) & this->queue_depth_mask_};
-  }
-
-  // Returns the physical file offset of the specified physical block.
-  //
-  PhysicalFileOffset block_start_file_offset_from(PhysicalBlockIndex physical_block_index) const
-  {
-    return PhysicalFileOffset{BATT_CHECKED_CAST(
-        i64, this->log_start_.value() + physical_block_index.value() * this->block_size())};
-  }
-
-  // Returns the physical file offset of the specified logical block.
-  //
-  PhysicalFileOffset block_start_file_offset_from(LogicalBlockIndex logical_block_index) const
-  {
-    return this->block_start_file_offset_from(this->physical_block_index_from(logical_block_index));
-  }
-
-  // Returns the physical file offset of the block that contains the given logical slot offset.
-  //
-  PhysicalFileOffset block_start_file_offset_from(SlotLowerBoundAt slot_lower_bound) const
-  {
-    return this->block_start_file_offset_from(this->physical_block_index_from(slot_lower_bound));
-  }
-
-  // Returns the physical file offset of the highest index block that is bounded by the given slot
-  // offset.
-  //
-  PhysicalFileOffset block_start_file_offset_from(SlotUpperBoundAt slot_upper_bound) const
-  {
-    return this->block_start_file_offset_from(this->physical_block_index_from(slot_upper_bound));
-  }
-
-  PhysicalFileOffset block_start_file_offset_from(PhysicalFileOffset file_offset) const
-  {
-    return block_start_file_offset_from(this->physical_block_index_from(file_offset));
-  }
-
- private:
-  IoRingLogConfig config_;
-  PhysicalFileOffset log_start_{this->config_.physical_offset};
-  PhysicalFileOffset log_end_{this->log_start_ +
-                              BATT_CHECKED_CAST(i64, this->config_.physical_size)};
-  usize block_size_ = this->config_.block_size();
-  usize block_capacity_ = this->config_.block_capacity();
-  usize block_count_ = this->config_.block_count();
-
-  // Runtime options for the log driver plus cached derived values.
-  //
-  IoRingLogDriverOptions options_;
-  usize queue_depth_ = this->options_.queue_depth();
-  usize queue_depth_mask_ = this->options_.queue_depth_mask();
-};
-
-}  // namespace llfs
-
-#endif  // LLFS_LOG_BLOCK_CALCULATOR_HPP
diff --git a/src/llfs/log_block_calculator.test.cpp b/src/llfs/log_block_calculator.test.cpp
deleted file mode 100644
index 2021aa2..0000000
--- a/src/llfs/log_block_calculator.test.cpp
+++ /dev/null
@@ -1,165 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#include <llfs/log_block_calculator.hpp>
-//
-#include <llfs/log_block_calculator.hpp>
-
-#include <gmock/gmock.h>
-#include <gtest/gtest.h>
-
-#include <llfs/constants.hpp>
-#include <llfs/int_types.hpp>
-
-#include <batteries/checked_cast.hpp>
-
-namespace {
-
-using namespace llfs::int_types;
-using namespace llfs::constants;
-
-TEST(LogBlockCalculator, Test)
-{
-  ASSERT_EQ(sizeof(llfs::PackedLogPageHeader), 64u);
-
-  const usize log_size = 1 * kMiB;
-
-  for (const usize queue_depth : {1, 2, 4, 4096}) {
-    for (const usize block_size :
-         {usize{512}, usize{1 * kKiB}, usize{16 * kKiB}, usize{64 * kKiB}}) {
-      ASSERT_EQ(block_size % llfs::kLogPageSize, 0u);
-
-      for (const i64 begin_file_offset : {i64(0), i64(llfs::kLogPageSize * 3)}) {
-        const usize pages_per_block = block_size / llfs::kLogPageSize;
-
-        const usize pages_per_block_log2 = batt::log2_ceil(pages_per_block);
-
-        const u64 physical_size =
-            llfs::LogBlockCalculator::disk_size_required_for_log_size(log_size, block_size);
-
-        const i64 end_file_offset =
-            BATT_CHECKED_CAST(i64, BATT_CHECKED_CAST(u64, begin_file_offset) + physical_size);
-
-        ASSERT_EQ(1ull << pages_per_block_log2, pages_per_block);
-        ASSERT_EQ(pages_per_block * llfs::kLogPageSize, block_size);
-
-        llfs::LogBlockCalculator calculate{
-            llfs::IoRingLogConfig{
-                .logical_size = log_size,
-                .physical_offset = begin_file_offset,
-                .physical_size = physical_size,
-                .pages_per_block_log2 = pages_per_block_log2,
-            },
-            llfs::IoRingLogDriverOptions::with_default_values()  //
-                .set_queue_depth(queue_depth),
-        };
-
-        EXPECT_EQ(calculate.pages_per_block(), pages_per_block);
-        EXPECT_EQ(calculate.block_size(), block_size);
-        EXPECT_EQ(calculate.block_capacity(), block_size - 64);
-        EXPECT_GE(calculate.block_capacity() * calculate.block_count(), log_size);
-        EXPECT_EQ(calculate.block_count(),
-                  (log_size + block_size - 64 - 1) / (block_size - 64) + 1);
-        EXPECT_EQ(calculate.physical_size(), physical_size);
-        EXPECT_GT(physical_size, log_size);
-        EXPECT_EQ(physical_size, calculate.block_count() * calculate.block_size());
-        EXPECT_LT(log_size, calculate.block_count() * calculate.block_capacity());
-        EXPECT_EQ(calculate.queue_depth(), queue_depth);
-
-        {
-          usize logical_block_index = 0;
-          usize physical_block_index = 0;
-          usize flush_op_index = 0;
-          i64 file_offset = begin_file_offset;
-
-          for (llfs::slot_offset_type slot_offset = 0; slot_offset < log_size * 3;) {
-            const llfs::slot_offset_type slot_begin = slot_offset;
-            const llfs::slot_offset_type slot_end = slot_offset + calculate.block_capacity();
-
-            EXPECT_EQ(physical_block_index,
-                      calculate.physical_block_index_from(
-                          llfs::LogBlockCalculator::LogicalBlockIndex{logical_block_index}));
-
-            EXPECT_EQ((llfs::SlotRange{slot_begin, slot_end}),
-                      calculate.block_slot_range_from(
-                          llfs::LogBlockCalculator::LogicalBlockIndex{logical_block_index}));
-
-            EXPECT_EQ(flush_op_index,
-                      calculate.flush_op_index_from(
-                          llfs::LogBlockCalculator::LogicalBlockIndex{logical_block_index}));
-
-            EXPECT_EQ(file_offset,
-                      calculate.block_start_file_offset_from(
-                          llfs::LogBlockCalculator::PhysicalBlockIndex{physical_block_index}));
-
-            EXPECT_EQ(file_offset,
-                      calculate.block_start_file_offset_from(
-                          llfs::LogBlockCalculator::LogicalBlockIndex{logical_block_index}));
-
-            for (usize i = 0; i < calculate.block_capacity(); ++i, ++slot_offset) {
-              EXPECT_EQ(logical_block_index,
-                        calculate.logical_block_index_from(llfs::SlotLowerBoundAt{slot_offset}));
-
-              EXPECT_EQ(logical_block_index, calculate.logical_block_index_from(
-                                                 llfs::SlotUpperBoundAt{slot_offset + 1}));
-
-              EXPECT_EQ(physical_block_index,
-                        calculate.physical_block_index_from(llfs::SlotLowerBoundAt{slot_offset}));
-
-              EXPECT_EQ(physical_block_index, calculate.physical_block_index_from(
-                                                  llfs::SlotUpperBoundAt{slot_offset + 1}));
-
-              EXPECT_EQ((llfs::SlotRange{slot_begin, slot_end}),
-                        calculate.block_slot_range_from(llfs::SlotLowerBoundAt{slot_offset}));
-
-              EXPECT_EQ((llfs::SlotRange{slot_begin, slot_end}),
-                        calculate.block_slot_range_from(llfs::SlotUpperBoundAt{slot_offset + 1}));
-
-              EXPECT_EQ(flush_op_index,
-                        calculate.flush_op_index_from(llfs::SlotLowerBoundAt{slot_offset}));
-
-              EXPECT_EQ(flush_op_index,
-                        calculate.flush_op_index_from(llfs::SlotUpperBoundAt{slot_offset + 1}));
-
-              EXPECT_EQ(file_offset, calculate.block_start_file_offset_from(
-                                         llfs::SlotLowerBoundAt{slot_offset}));
-
-              EXPECT_EQ(file_offset, calculate.block_start_file_offset_from(
-                                         llfs::SlotUpperBoundAt{slot_offset + 1}));
-            }
-
-            logical_block_index += 1;
-
-            physical_block_index += 1;
-            if (physical_block_index >= calculate.block_count()) {
-              physical_block_index = 0;
-            }
-
-            const usize prev_flush_op_index = flush_op_index;
-            flush_op_index += 1;
-            if (flush_op_index >= queue_depth) {
-              flush_op_index = 0;
-            }
-
-            EXPECT_EQ(flush_op_index,
-                      calculate.next_flush_op_index(
-                          llfs::LogBlockCalculator::FlushOpIndex{prev_flush_op_index}));
-
-            file_offset += block_size;
-            if (file_offset >= end_file_offset) {
-              file_offset -= physical_size;
-              EXPECT_EQ(file_offset, begin_file_offset);
-            }
-          }
-        }
-      }
-    }
-  }
-}
-
-}  // namespace
diff --git a/src/llfs/log_device_config.cpp b/src/llfs/log_device_config.cpp
deleted file mode 100644
index 500dc2e..0000000
--- a/src/llfs/log_device_config.cpp
+++ /dev/null
@@ -1,99 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#include <llfs/log_device_config.hpp>
-//
-
-#ifndef LLFS_DISABLE_IO_URING
-
-#include <llfs/ioring_log_device.hpp>
-#include <llfs/ioring_log_initializer.hpp>
-#include <llfs/raw_block_file.hpp>
-
-#include <batteries/checked_cast.hpp>
-#include <batteries/stream_util.hpp>
-
-#include <boost/uuid/random_generator.hpp>
-
-namespace llfs {
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-BATT_PRINT_OBJECT_IMPL(PackedLogDeviceConfig,  //
-                       (block_0_offset)        //
-                       (physical_size)         //
-                       (logical_size)          //
-                       (pages_per_block_log2)  //
-)
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-Status configure_storage_object(StorageFileBuilder::Transaction& txn,
-                                FileOffsetPtr<PackedLogDeviceConfig&> p_config,
-                                const LogDeviceConfigOptions& options)
-{
-  const i64 logical_size = round_up_to_page_size_multiple(options.log_size);
-  const u32 pages_per_block_log2 =
-      options.pages_per_block_log2.value_or(IoRingLogConfig::kDefaultPagesPerBlockLog2);
-  const u64 pages_per_block = u64{1} << pages_per_block_log2;
-  const u64 block_size = pages_per_block * kLogPageSize;
-  const i64 physical_size =
-      IoRingLogDriver::disk_size_required_for_log_size(logical_size, block_size);
-
-  Interval<i64> blocks_offset = txn.reserve_aligned(/*bits=*/kLogPageSizeLog2, physical_size);
-
-  BATT_CHECK_EQ(blocks_offset.size(), physical_size)
-      << BATT_INSPECT(logical_size) << BATT_INSPECT(block_size) << BATT_INSPECT(options.log_size);
-
-  p_config.absolute_block_0_offset(blocks_offset.lower_bound);
-  p_config->physical_size = physical_size;
-  p_config->logical_size = logical_size;
-  p_config->pages_per_block_log2 = pages_per_block_log2;
-  p_config->uuid = options.uuid.value_or(boost::uuids::random_generator{}());
-
-  // Initialize the log page headers before flushing config slot.
-  //
-  txn.require_pre_flush_action(
-      [config = IoRingLogConfig::from_packed(p_config),
-       blocks_offset](RawBlockFile& file) -> Status  //
-      {
-        BATT_CHECK_EQ(BATT_CHECKED_CAST(i64, config.physical_offset + config.physical_size),
-                      blocks_offset.upper_bound);
-        Status truncate_status =
-            file.truncate_at_least(config.physical_offset + config.physical_size);
-        BATT_REQUIRE_OK(truncate_status);
-
-        return initialize_ioring_log_device(file, config, ConfirmThisWillEraseAllMyData{true});
-      });
-
-  return OkStatus();
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-StatusOr<std::unique_ptr<IoRingLogDeviceFactory>> recover_storage_object(
-    const batt::SharedPtr<StorageContext>& storage_context, const std::string& file_name,
-    const FileOffsetPtr<const PackedLogDeviceConfig&>& p_config, IoRingLogDriverOptions options)
-{
-  BATT_ASSIGN_OK_RESULT(usize block_count, p_config->block_count());
-  options.limit_queue_depth(block_count);
-
-  const int flags = O_DIRECT | O_SYNC | O_RDWR;
-
-  int fd = batt::syscall_retry([&] {
-    return system_open2(file_name.c_str(), flags);
-  });
-  BATT_REQUIRE_OK(batt::status_from_retval(fd));
-
-  return std::make_unique<IoRingLogDeviceFactory>(storage_context->get_scheduler(), fd, p_config,
-                                                  options);
-}
-
-}  // namespace llfs
-
-#endif  // LLFS_DISABLE_IO_URING
diff --git a/src/llfs/log_device_config.hpp b/src/llfs/log_device_config.hpp
deleted file mode 100644
index b016960..0000000
--- a/src/llfs/log_device_config.hpp
+++ /dev/null
@@ -1,177 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#pragma once
-#ifndef LLFS_PACKED_LOG_DEVICE_CONFIG_HPP
-#define LLFS_PACKED_LOG_DEVICE_CONFIG_HPP
-
-#include <llfs/config.hpp>
-//
-
-#ifndef LLFS_DISABLE_IO_URING
-
-#include <llfs/constants.hpp>
-#include <llfs/int_types.hpp>
-#include <llfs/ioring_log_device.hpp>
-#include <llfs/ioring_log_driver_options.hpp>
-#include <llfs/log_device.hpp>
-#include <llfs/optional.hpp>
-#include <llfs/packed_config.hpp>
-#include <llfs/storage_context.hpp>
-#include <llfs/storage_file_builder.hpp>
-
-#include <batteries/static_assert.hpp>
-
-#include <boost/uuid/uuid.hpp>
-
-#include <ostream>
-#include <variant>
-
-namespace llfs {
-
-struct LogDeviceConfigOptions;
-struct PackedLogDeviceConfig;
-
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-Status configure_storage_object(StorageFileBuilder::Transaction&,
-                                FileOffsetPtr<PackedLogDeviceConfig&> p_config,
-                                const LogDeviceConfigOptions& options);
-
-StatusOr<std::unique_ptr<IoRingLogDeviceFactory>> recover_storage_object(
-    const batt::SharedPtr<StorageContext>& storage_context, const std::string& file_name,
-    const FileOffsetPtr<const PackedLogDeviceConfig&>& p_config, IoRingLogDriverOptions options);
-
-//=#=#==#==#===============+=+=+=+=++=++++++++++++++-++-+--+-+----+---------------
-//
-struct LogDeviceConfigOptions {
-  using PackedConfigType = PackedLogDeviceConfig;
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  static constexpr u64 kDefaultBlockSizeBytes = 16384;
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  // The unique identifier for the log; if None, a random UUID will be generated.
-  //
-  Optional<boost::uuids::uuid> uuid;
-
-  // log2 of the number of 4kib (memory) pages per flush block.
-  // Higher values == higher (better) throughput, higher (worse) latency.
-  //
-  Optional<u16> pages_per_block_log2;
-
-  // The capacity in bytes of the log.
-  //
-  usize log_size;
-
-  // +++++++++++-+-+--+----- --- -- -  -  -   -
-
-  // Returns the log flush block size in bytes.
-  //
-  u64 block_size() const
-  {
-    static const u64 kDefaultPagesPerBlockLog2 =
-        batt::log2_ceil(kDefaultBlockSizeBytes / kLogPageSize);
-
-    return u64{1} << this->pages_per_block_log2.value_or(kDefaultPagesPerBlockLog2);
-  }
-
-  // Sets the log flush block size in bytes; `n` must be a power of 2, >= kLogPageSize
-  // (default=4096).
-  //
-  void block_size(u64 n_bytes)
-  {
-    const u64 n_pages = n_bytes / kLogPageSize;
-    this->pages_per_block_log2 = batt::log2_ceil(n_pages);
-
-    BATT_CHECK_EQ((u64{1} << *this->pages_per_block_log2) * kLogPageSize, n_bytes)
-        << BATT_INSPECT(n_bytes) << BATT_INSPECT(n_pages) << BATT_INSPECT(kLogPageSize);
-  }
-};
-
-inline bool operator==(const LogDeviceConfigOptions& l, const LogDeviceConfigOptions& r)
-{
-  return l.uuid == r.uuid                                     //
-         && l.pages_per_block_log2 == r.pages_per_block_log2  //
-         && l.log_size == r.log_size;
-}
-
-inline bool operator!=(const LogDeviceConfigOptions& l, const LogDeviceConfigOptions& r)
-{
-  return !(l == r);
-}
-
-//=#=#==#==#===============+=+=+=+=++=++++++++++++++-++-+--+-+----+---------------
-//
-struct PackedLogDeviceConfig : PackedConfigSlotHeader {
-  static constexpr usize kSize = PackedConfigSlot::kSize;
-
-  // The log2 of the number of 4096-byte pages per flush block.
-  //
-  little_u16 pages_per_block_log2;
-
-  // The offset of flush block 0 relative to this structure.
-  //
-  little_i64 block_0_offset;
-
-  // The total size of the log in bytes.
-  //
-  little_u64 physical_size;
-
-  // The logical size of the log; this excludes all block headers.
-  //
-  little_u64 logical_size;
-
-  // Reserved for future use (set to 0 for now).
-  //
-  u8 pad1_[18];
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  usize pages_per_block() const
-  {
-    return usize{1} << pages_per_block_log2;
-  }
-
-  usize block_size() const
-  {
-    return kLogPageSize * this->pages_per_block();
-  }
-
-  StatusOr<usize> block_count() const
-  {
-    // If there isn't a whole number of blocks, then this config is corrupted/invalid.
-    //
-    if (this->physical_size % this->block_size()) {
-      return {batt::StatusCode::kDataLoss};
-    }
-
-    return this->physical_size / this->block_size();
-  }
-};
-
-BATT_STATIC_ASSERT_EQ(sizeof(PackedLogDeviceConfig), PackedLogDeviceConfig::kSize);
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-
-template <>
-struct PackedConfigTagFor<PackedLogDeviceConfig> {
-  static constexpr u32 value = PackedConfigSlot::Tag::kLogDevice;
-};
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-
-std::ostream& operator<<(std::ostream& out, const PackedLogDeviceConfig& t);
-
-}  // namespace llfs
-
-#endif  // LLFS_DISABLE_IO_URING
-
-#endif  // LLFS_PACKED_LOG_DEVICE_CONFIG_HPP
diff --git a/src/llfs/log_device_config2.cpp b/src/llfs/log_device_config2.cpp
index 33f4188..75a41ce 100644
--- a/src/llfs/log_device_config2.cpp
+++ b/src/llfs/log_device_config2.cpp
@@ -6,7 +6,7 @@
 //
 //+++++++++++-+-+--+----- --- -- -  -  -   -
 
-#include <llfs/log_device_config.hpp>
+#include <llfs/log_device_config2.hpp>
 //
 
 #ifndef LLFS_DISABLE_IO_URING
@@ -68,16 +68,16 @@ Status configure_storage_object(StorageFileBuilder::Transaction& txn,
 
   // Initialize the log page headers before flushing config slot.
   //
-  txn.require_pre_flush_action([config = IoRingLogConfig2::from_packed(p_config),
-                                blocks_offset](RawBlockFile& file) -> Status  //
-                               {
-                                 Status truncate_status =
-                                     file.truncate_at_least(blocks_offset.upper_bound);
+  txn.require_pre_flush_action(
+      [config = IoRingLogConfig2::from_packed(p_config),
+       blocks_offset](RawBlockFile& file) -> Status  //
+      {
+        Status truncate_status = file.truncate_at_least(blocks_offset.upper_bound);
 
-                                 BATT_REQUIRE_OK(truncate_status);
+        BATT_REQUIRE_OK(truncate_status);
 
-                                 return initialize_log_device2(file, config);
-                               });
+        return initialize_log_device2(file, config, llfs::ConfirmThisWillEraseAllMyData::kYes);
+      });
 
   return OkStatus();
 }
diff --git a/src/llfs/log_device_config2.hpp b/src/llfs/log_device_config2.hpp
index 299b7c1..dc783b6 100644
--- a/src/llfs/log_device_config2.hpp
+++ b/src/llfs/log_device_config2.hpp
@@ -7,8 +7,8 @@
 //+++++++++++-+-+--+----- --- -- -  -  -   -
 
 #pragma once
-#ifndef LLFS_PACKED_LOG_DEVICE_CONFIG2_HPP
-#define LLFS_PACKED_LOG_DEVICE_CONFIG2_HPP
+#ifndef LLFS_LOG_DEVICE_CONFIG2_HPP
+#define LLFS_LOG_DEVICE_CONFIG2_HPP
 
 #include <llfs/config.hpp>
 //
@@ -17,6 +17,7 @@
 
 #include <llfs/constants.hpp>
 #include <llfs/int_types.hpp>
+#include <llfs/ioring_log_config2.hpp>
 #include <llfs/ioring_log_device2.hpp>
 #include <llfs/log_device.hpp>
 #include <llfs/log_device_runtime_options.hpp>
@@ -52,8 +53,8 @@ StatusOr<std::unique_ptr<IoRingLogDevice2Factory>> recover_storage_object(
 struct LogDeviceConfigOptions2 {
   using PackedConfigType = PackedLogDeviceConfig2;
 
-  static constexpr u16 kDefaultDevicePageSizeLog2 = 9 /*=log2(512)*/;
-  static constexpr u16 kDefaultDataAlignmentLog2 = 12 /*=log2(4096)*/;
+  static constexpr u16 kDefaultDevicePageSizeLog2 = IoRingLogConfig2::kDefaultDevicePageSizeLog2;
+  static constexpr u16 kDefaultDataAlignmentLog2 = IoRingLogConfig2::kDefaultDataAlignmentLog2;
 
   //+++++++++++-+-+--+----- --- -- -  -  -   -
 
@@ -129,4 +130,4 @@ std::ostream& operator<<(std::ostream& out, const PackedLogDeviceConfig2& t);
 
 #endif  // LLFS_DISABLE_IO_URING
 
-#endif  // LLFS_PACKED_LOG_DEVICE_CONFIG_HPP
+#endif  // LLFS_LOG_DEVICE_CONFIG2_HPP
diff --git a/src/llfs/log_device_runtime_options.hpp b/src/llfs/log_device_runtime_options.hpp
index 18f0103..294e9dc 100644
--- a/src/llfs/log_device_runtime_options.hpp
+++ b/src/llfs/log_device_runtime_options.hpp
@@ -47,12 +47,17 @@ struct LogDeviceRuntimeOptions {
 
   //+++++++++++-+-+--+----- --- -- -  -  -   -
 
-  // The debug name of this log.
-  //
+  /** \brief The debug name of this log.
+   */
   std::string name = batt::to_string("(anonymous log ", Self::next_id(), ")");
 
+  /** \brief If there is already a write-back flush operation going on, require at least this many
+   * unflushed bytes in order to start another concurrent write.
+   */
   usize flush_delay_threshold = kDefaultFlushDelayThreshold;
 
+  /** \brief The hard limit on number of concurrent flush writes operations.
+   */
   usize max_concurrent_writes = kDefaultMaxConcurrentWrites;
 
   bool optimize_burst_mode = kDefaultOptimizeBurstMode;
diff --git a/src/llfs/nested_log_device_config.hpp b/src/llfs/nested_log_device_config.hpp
index 13f5ce1..bdbbee8 100644
--- a/src/llfs/nested_log_device_config.hpp
+++ b/src/llfs/nested_log_device_config.hpp
@@ -14,7 +14,6 @@
 //
 
 #include <llfs/int_types.hpp>
-#include <llfs/log_device_config.hpp>
 #include <llfs/log_device_config2.hpp>
 #include <llfs/optional.hpp>
 #include <llfs/uuid.hpp>
@@ -28,42 +27,6 @@ namespace llfs {
 // LogDevice configs.
 //
 
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-struct CreateNewLogDevice {
-  LogDeviceConfigOptions options;
-};
-
-inline bool operator==(const CreateNewLogDevice& l, const CreateNewLogDevice& r)
-{
-  return l.options == r.options;
-}
-
-inline bool operator!=(const CreateNewLogDevice& l, const CreateNewLogDevice& r)
-{
-  return !(l == r);
-}
-
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-struct CreateNewLogDeviceWithDefaultSize {
-  Optional<boost::uuids::uuid> uuid;
-  Optional<u16> pages_per_block_log2;
-};
-
-inline bool operator==(const CreateNewLogDeviceWithDefaultSize& l,
-                       const CreateNewLogDeviceWithDefaultSize& r)
-{
-  return l.uuid == r.uuid  //
-         && l.pages_per_block_log2 == r.pages_per_block_log2;
-}
-
-inline bool operator!=(const CreateNewLogDeviceWithDefaultSize& l,
-                       const CreateNewLogDeviceWithDefaultSize& r)
-{
-  return !(l == r);
-}
-
 //+++++++++++-+-+--+----- --- -- -  -  -   -
 //
 struct LinkToExistingLogDevice {
@@ -120,9 +83,10 @@ inline bool operator!=(const CreateNewLogDevice2WithDefaultSize& l,
 
 //+++++++++++-+-+--+----- --- -- -  -  -   -
 
-using NestedLogDeviceConfig =
-    std::variant<CreateNewLogDevice, CreateNewLogDeviceWithDefaultSize, LinkToExistingLogDevice,
-                 CreateNewLogDevice2, CreateNewLogDevice2WithDefaultSize>;
+using NestedLogDeviceConfig = std::variant<LinkToExistingLogDevice,            //
+                                           CreateNewLogDevice2,                //
+                                           CreateNewLogDevice2WithDefaultSize  //
+                                           >;
 
 }  //namespace llfs
 
diff --git a/src/llfs/page_allocator_config.cpp b/src/llfs/page_allocator_config.cpp
index 1101684..12299c8 100644
--- a/src/llfs/page_allocator_config.cpp
+++ b/src/llfs/page_allocator_config.cpp
@@ -27,7 +27,7 @@ namespace llfs {
       .uuid = None,
       .max_attachments = 64,
       .page_count = PageCount{0},
-      .log_device = CreateNewLogDeviceWithDefaultSize{},
+      .log_device = CreateNewLogDevice2WithDefaultSize{},
       .page_size_log2 = PageSizeLog2{0},
       .page_device = LinkToNewPageDevice{},
   };
@@ -63,34 +63,6 @@ Status configure_storage_object(StorageFileBuilder::Transaction& txn,
       batt::case_of(
           options.log_device,
 
-          //----- --- -- -  -  -   -
-          [&](const CreateNewLogDevice& create_new) -> StatusOr<boost::uuids::uuid> {
-            if (create_new.options.log_size < minimum_log_size) {
-              // TODO [tastolfi 2022-07-27] custom code
-              return {batt::StatusCode::kInvalidArgument};
-            }
-
-            BATT_ASSIGN_OK_RESULT(
-                const FileOffsetPtr<const PackedLogDeviceConfig&> p_log_device_config,
-                txn.add_object(create_new.options));
-
-            return p_log_device_config->uuid;
-          },
-
-          //----- --- -- -  -  -   -
-          [&](const CreateNewLogDeviceWithDefaultSize& log_options)
-              -> StatusOr<boost::uuids::uuid> {
-            BATT_ASSIGN_OK_RESULT(
-                const FileOffsetPtr<const PackedLogDeviceConfig&> p_log_device_config,
-                txn.add_object(LogDeviceConfigOptions{
-                    .uuid = log_options.uuid,
-                    .pages_per_block_log2 = log_options.pages_per_block_log2,
-                    .log_size = minimum_log_size,
-                }));
-
-            return p_log_device_config->uuid;
-          },
-
           //----- --- -- -  -  -   -
           [&](const LinkToExistingLogDevice& link_to_existing) -> StatusOr<boost::uuids::uuid> {
             return link_to_existing.uuid;
@@ -172,7 +144,7 @@ StatusOr<std::unique_ptr<PageAllocator>> recover_storage_object(
     const std::string& /*file_name*/,                                           //
     const FileOffsetPtr<const PackedPageAllocatorConfig&>& p_allocator_config,  //
     const PageAllocatorRuntimeOptions& allocator_options,                       //
-    const IoRingLogDriverOptions& log_options)
+    const LogDeviceRuntimeOptions& log_options)
 {
   StatusOr<std::unique_ptr<LogDeviceFactory>> log_factory =
       storage_context->recover_log_device(p_allocator_config->log_device_uuid, log_options);
diff --git a/src/llfs/page_allocator_config.hpp b/src/llfs/page_allocator_config.hpp
index 288b509..e558dc3 100644
--- a/src/llfs/page_allocator_config.hpp
+++ b/src/llfs/page_allocator_config.hpp
@@ -18,6 +18,7 @@
 #include <llfs/page_allocator_runtime_options.hpp>
 
 #include <llfs/int_types.hpp>
+#include <llfs/log_device_runtime_options.hpp>
 #include <llfs/nested_log_device_config.hpp>
 #include <llfs/optional.hpp>
 #include <llfs/packed_config.hpp>
@@ -49,7 +50,7 @@ StatusOr<std::unique_ptr<PageAllocator>> recover_storage_object(
     const std::string& file_name,                                     //
     const FileOffsetPtr<const PackedPageAllocatorConfig&>& p_config,  //
     const PageAllocatorRuntimeOptions& options,                       //
-    const IoRingLogDriverOptions& log_options);
+    const LogDeviceRuntimeOptions& log_options);
 
 //=#=#==#==#===============+=+=+=+=++=++++++++++++++-++-+--+-+----+---------------
 //
diff --git a/src/llfs/page_arena_config.cpp b/src/llfs/page_arena_config.cpp
index a516549..e42b936 100644
--- a/src/llfs/page_arena_config.cpp
+++ b/src/llfs/page_arena_config.cpp
@@ -10,7 +10,6 @@
 //
 
 #include <llfs/crc.hpp>
-#include <llfs/ioring_log_device.hpp>
 #include <llfs/page_allocator.hpp>
 #include <llfs/uuid.hpp>
 
@@ -173,7 +172,7 @@ StatusOr<PageArena> recover_storage_object(
     const std::string& /*file_name*/,                             //
     const FileOffsetPtr<const PackedPageArenaConfig&>& p_config,  //
     const PageAllocatorRuntimeOptions& allocator_options,         //
-    const IoRingLogDriverOptions& allocator_log_options,          //
+    const LogDeviceRuntimeOptions& allocator_log_options,         //
     const IoRingFileRuntimeOptions& page_device_file_options)
 {
   StatusOr<std::unique_ptr<PageAllocator>> page_allocator = storage_context->recover_object(
diff --git a/src/llfs/page_arena_config.hpp b/src/llfs/page_arena_config.hpp
index a42f9f3..8dcfe1e 100644
--- a/src/llfs/page_arena_config.hpp
+++ b/src/llfs/page_arena_config.hpp
@@ -11,7 +11,7 @@
 #define LLFS_PAGE_ARENA_CONFIG_HPP
 
 #include <llfs/int_types.hpp>
-#include <llfs/ioring_log_flush_op.hpp>
+#include <llfs/log_device_runtime_options.hpp>
 #include <llfs/packed_config.hpp>
 #include <llfs/page_allocator_config.hpp>
 #include <llfs/page_arena.hpp>
@@ -36,7 +36,7 @@ StatusOr<PageArena> recover_storage_object(                       //
     const std::string& file_name,                                 //
     const FileOffsetPtr<const PackedPageArenaConfig&>& p_config,  //
     const PageAllocatorRuntimeOptions& allocator_options,         //
-    const IoRingLogDriverOptions& allocator_log_options,          //
+    const LogDeviceRuntimeOptions& allocator_log_options,         //
     const IoRingFileRuntimeOptions& page_device_file_options);
 
 //=#=#==#==#===============+=+=+=+=++=++++++++++++++-++-+--+-+----+---------------
diff --git a/src/llfs/page_arena_file.cpp b/src/llfs/page_arena_file.cpp
deleted file mode 100644
index 64aa846..0000000
--- a/src/llfs/page_arena_file.cpp
+++ /dev/null
@@ -1,96 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#include <llfs/page_arena_file.hpp>
-//
-
-#include <llfs/config.hpp>
-
-#ifndef LLFS_DISABLE_IO_URING
-
-#include <llfs/crc.hpp>
-#include <llfs/filesystem.hpp>
-#include <llfs/ioring_log_device.hpp>
-#include <llfs/ioring_page_file_device.hpp>
-#include <llfs/ring_buffer.hpp>
-#include <llfs/status.hpp>
-#include <llfs/system_config.hpp>
-
-#include <batteries/checked_cast.hpp>
-#include <batteries/math.hpp>
-
-#include <boost/uuid/random_generator.hpp>
-
-#include <cstdlib>
-
-#include <unistd.h>
-
-namespace llfs {
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-auto driver_config_from_arena_config(const FileOffsetPtr<PackedPageArenaConfig>& /*config*/)
-{
-  return;
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-StatusOr<PageArena> open_page_device_file_impl(
-    batt::TaskScheduler& /*scheduler*/, IoRing& /*ioring*/, const FileSegmentRef& /*file_ref*/,
-    const PageArenaFileRuntimeOptions& /*options*/, PackedPageArenaConfig* /*config*/,
-    bool /*write_config*/, ConfirmThisWillEraseAllMyData /*confirm*/)
-{
-  //TODO [tastolfi 2023-05-22] implement me!
-  return {batt::StatusCode::kUnimplemented};
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-StatusOr<PageArena> page_arena_from_file(batt::TaskScheduler& scheduler, IoRing& ioring,
-                                         const FileSegmentRef& file_ref,
-                                         const PageArenaFileRuntimeOptions& options,
-                                         PackedPageArenaConfig* config_out)
-{
-  return open_page_device_file_impl(scheduler, ioring, file_ref, options, config_out,
-                                    /*write_config=*/
-                                    false, ConfirmThisWillEraseAllMyData::kNo);
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-StatusOr<PageArena> initialize_page_arena_file(batt::TaskScheduler& scheduler, IoRing& ioring,
-                                               const FileSegmentRef& file_ref,
-                                               const PageArenaFileRuntimeOptions& options,
-                                               const PackedPageArenaConfig& /*config*/,
-                                               ConfirmThisWillEraseAllMyData confirm)
-{
-  if (confirm != ConfirmThisWillEraseAllMyData::kYes) {
-    return Status{batt::StatusCode::kInvalidArgument};  // TODO [tastolfi 2021-10-20] "operation not
-                                                        // confirmed!"
-  }
-
-  //  auto config_copy = config;
-  return open_page_device_file_impl(scheduler, ioring, file_ref, options, /*&config_copy*/ nullptr,
-                                    /*write_config=*/true, confirm);
-}
-
-//=#=#==#==#===============+=+=+=+=++=++++++++++++++-++-+--+-+----+---------------
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-StatusOr<std::vector<std::unique_ptr<PageArenaConfigInFile>>> read_arena_configs_from_file(
-    const std::string& /*filename*/)
-{
-  //TODO [tastolfi 2023-05-22] implement me!
-  return {batt::StatusCode::kUnimplemented};
-}
-
-}  // namespace llfs
-
-#endif  // LLFS_DISABLE_IO_URING
diff --git a/src/llfs/page_arena_file.hpp b/src/llfs/page_arena_file.hpp
deleted file mode 100644
index 72cf186..0000000
--- a/src/llfs/page_arena_file.hpp
+++ /dev/null
@@ -1,68 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#pragma once
-#ifndef LLFS_PAGE_ARENA_FILE_HPP
-#define LLFS_PAGE_ARENA_FILE_HPP
-
-#include <llfs/config.hpp>
-
-#ifndef LLFS_DISABLE_IO_URING
-
-#include <llfs/confirm.hpp>
-#include <llfs/data_layout.hpp>
-#include <llfs/file_segment_ref.hpp>
-#include <llfs/ioring.hpp>
-#include <llfs/ioring_log_device.hpp>
-#include <llfs/packed_config.hpp>
-#include <llfs/page_arena.hpp>
-#include <llfs/page_arena_config.hpp>
-#include <llfs/read_only.hpp>
-
-#include <batteries/async/task_scheduler.hpp>
-
-namespace llfs {
-
-struct PageArenaConfigInFile {
-  FileSegmentRef file_ref;
-  PackedPageArenaConfig config;
-};
-
-// Open the passed file and read all PageArena configs it contains.
-//
-StatusOr<std::vector<std::unique_ptr<PageArenaConfigInFile>>> read_arena_configs_from_file(
-    const std::string& filename);
-
-// We must make this struct large enough to use with O_DIRECT.
-//
-
-struct PageArenaFileRuntimeOptions {
-  std::string name = "anonymous";
-  ReadOnly read_only = ReadOnly::kFalse;
-  usize log_queue_depth = 16;
-};
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-StatusOr<PageArena> page_arena_from_file(batt::TaskScheduler& scheduler, IoRing& ioring,
-                                         const FileSegmentRef& file_ref,
-                                         const PageArenaFileRuntimeOptions& options,
-                                         PackedPageArenaConfig* config_out = nullptr);
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-StatusOr<PageArena> initialize_page_arena_file(batt::TaskScheduler& scheduler, IoRing& ioring,
-                                               const FileSegmentRef& file_ref,
-                                               const PageArenaFileRuntimeOptions& options,
-                                               const PackedPageArenaConfig& config,
-                                               ConfirmThisWillEraseAllMyData confirm);
-
-}  // namespace llfs
-
-#endif  // LLFS_DISABLE_IO_URING
-#endif  // LLFS_PAGE_ARENA_FILE_HPP
diff --git a/src/llfs/simulated_log_device_storage.cpp b/src/llfs/simulated_log_device_storage.cpp
index b440114..8381259 100644
--- a/src/llfs/simulated_log_device_storage.cpp
+++ b/src/llfs/simulated_log_device_storage.cpp
@@ -8,23 +8,10 @@
 
 #include <llfs/simulated_log_device_storage.hpp>
 //
-#include <llfs/ioring_log_driver.hpp>
-#include <llfs/ioring_log_driver.ipp>
-#include <llfs/ioring_log_flush_op.hpp>
-#include <llfs/ioring_log_flush_op.ipp>
 #include <llfs/storage_simulation.hpp>
 
 namespace llfs {
 
-// Explicitly instantiate BasicIoRingLogDriver for the simulated LogDevice storage.
-//
-template class BasicIoRingLogDriver<BasicIoRingLogFlushOp, SimulatedLogDeviceStorage>;
-
-// BasicIoRingLogFlushOp is required by BasicIoRingLogDriver, so explicitly instantiate that too.
-//
-template class BasicIoRingLogFlushOp<
-    BasicIoRingLogDriver<BasicIoRingLogFlushOp, SimulatedLogDeviceStorage>>;
-
 //=#=#==#==#===============+=+=+=+=++=++++++++++++++-++-+--+-+----+---------------
 // class SimulatedLogDeviceStorage::DurableState
 
diff --git a/src/llfs/status_code.cpp b/src/llfs/status_code.cpp
index b0b73d7..9e9f431 100644
--- a/src/llfs/status_code.cpp
+++ b/src/llfs/status_code.cpp
@@ -136,6 +136,9 @@ bool initialize_status_codes()
       CODE_WITH_MSG_(StatusCode::kLogControlBlockBadMagic,
                      "Log device control block magic number is not correct (is this really a log "
                      "device?)"),  // 65,
+      CODE_WITH_MSG_(StatusCode::kLogDeviceV1Deprecated,
+                     "IoRingLogDevice (aka LogDevice storage object) has been deprecated; use "
+                     "IoRingLogDevice2/LogDevice2 instead"),  // 66,
   });
   return initialized;
 }
diff --git a/src/llfs/status_code.hpp b/src/llfs/status_code.hpp
index 021ddd4..05809c8 100644
--- a/src/llfs/status_code.hpp
+++ b/src/llfs/status_code.hpp
@@ -81,6 +81,7 @@ enum struct StatusCode {
   kPageCacheSlotNotInitialized = 63,
   kIoRingShutDown = 64,
   kLogControlBlockBadMagic = 65,
+  kLogDeviceV1Deprecated = 66,
 };
 
 bool initialize_status_codes();
diff --git a/src/llfs/storage_context.cpp b/src/llfs/storage_context.cpp
index fadff0a..2a412fb 100644
--- a/src/llfs/storage_context.cpp
+++ b/src/llfs/storage_context.cpp
@@ -107,12 +107,7 @@ StatusOr<std::unique_ptr<LogDeviceFactory>> StorageContext::recover_log_device(
   switch (info->p_config_slot->tag) {
       //----- --- -- -  -  -   -
     case PackedConfigSlotBase::Tag::kLogDevice:
-      return recover_storage_object(
-          batt::shared_ptr_from(this), info->storage_file->file_name(),
-          FileOffsetPtr<const PackedLogDeviceConfig&>{
-              config_slot_cast<PackedLogDeviceConfig>(info->p_config_slot.object),
-              info->p_config_slot.file_offset},
-          log_runtime_options);
+      return {::llfs::make_status(::llfs::StatusCode::kLogDeviceV1Deprecated)};
 
       //----- --- -- -  -  -   -
     case PackedConfigSlotBase::Tag::kLogDevice2:
@@ -161,7 +156,7 @@ StatusOr<batt::SharedPtr<PageCache>> StorageContext::get_page_cache()
               .name = batt::to_string(base_name, "_Allocator"),
           },
           [&] {
-            IoRingLogDriverOptions options;
+            LogDeviceRuntimeOptions options;
             options.name = batt::to_string(base_name, "_AllocatorLog");
             return options;
           }(),
diff --git a/src/llfs/storage_context.test.cpp b/src/llfs/storage_context.test.cpp
index f3836af..2918d1d 100644
--- a/src/llfs/storage_context.test.cpp
+++ b/src/llfs/storage_context.test.cpp
@@ -14,7 +14,6 @@
 #include <gtest/gtest.h>
 
 #include <llfs/constants.hpp>
-#include <llfs/ioring_log_device.hpp>
 #include <llfs/page_arena_config.hpp>
 #include <llfs/raw_block_file_impl.hpp>
 #include <llfs/uuid.hpp>
@@ -54,70 +53,72 @@ TEST(StorageContextTest, GetPageCache)
   llfs::Status file_create_status = storage_context->add_new_file(
       storage_file_name, [&](llfs::StorageFileBuilder& builder) -> llfs::Status {
         llfs::StatusOr<llfs::FileOffsetPtr<const llfs::PackedPageArenaConfig&>> config_4kb =
-            builder.add_object(llfs::PageArenaConfigOptions{
-                .uuid = arena_uuid_4kb,
-                .page_allocator =
-                    llfs::CreateNewPageAllocator{
-                        .options =
-                            llfs::PageAllocatorConfigOptions{
-                                .uuid = llfs::None,
-                                .max_attachments = 32,
-                                .page_count = llfs::PageCount{32},
-                                .log_device =
-                                    llfs::CreateNewLogDeviceWithDefaultSize{
-                                        .uuid = llfs::None,
-                                        .pages_per_block_log2 =
-                                            llfs::IoRingLogConfig::kDefaultPagesPerBlockLog2 + 1,
-                                    },
-                                .page_size_log2 = llfs::PageSizeLog2{12},
-                                .page_device = llfs::LinkToNewPageDevice{},
-                            },
-                    },
-                .page_device =
-                    llfs::CreateNewPageDevice{
-                        .options =
-                            llfs::PageDeviceConfigOptions{
-                                .uuid = llfs::None,
-                                .device_id = llfs::None,
-                                .page_count = llfs::PageCount{32},
-                                .page_size_log2 = llfs::PageSizeLog2{12},
-                            },
-                    },
-            });
+            builder.add_object(
+                llfs::PageArenaConfigOptions{
+                    .uuid = arena_uuid_4kb,
+                    .page_allocator =
+                        llfs::CreateNewPageAllocator{
+                            .options =
+                                llfs::PageAllocatorConfigOptions{
+                                    .uuid = llfs::None,
+                                    .max_attachments = 32,
+                                    .page_count = llfs::PageCount{32},
+                                    .log_device =
+                                        llfs::CreateNewLogDevice2WithDefaultSize{
+                                            .uuid = llfs::None,
+                                            .device_page_size_log2 = 9,
+                                            .data_alignment_log2 = 12,
+                                        },
+                                    .page_size_log2 = llfs::PageSizeLog2{12},
+                                    .page_device = llfs::LinkToNewPageDevice{},
+                                },
+                        },
+                    .page_device =
+                        llfs::CreateNewPageDevice{
+                            .options =
+                                llfs::PageDeviceConfigOptions{
+                                    .uuid = llfs::None,
+                                    .device_id = llfs::None,
+                                    .page_count = llfs::PageCount{32},
+                                    .page_size_log2 = llfs::PageSizeLog2{12},
+                                },
+                        },
+                });
 
         BATT_REQUIRE_OK(config_4kb);
 
         llfs::StatusOr<llfs::FileOffsetPtr<const llfs::PackedPageArenaConfig&>> config_2mb =
-            builder.add_object(llfs::PageArenaConfigOptions{
-                .uuid = arena_uuid_2mb,
-                .page_allocator =
-                    llfs::CreateNewPageAllocator{
-                        .options =
-                            llfs::PageAllocatorConfigOptions{
-                                .uuid = llfs::None,
-                                .max_attachments = 32,
-                                .page_count = llfs::PageCount{32},
-                                .log_device =
-                                    llfs::CreateNewLogDeviceWithDefaultSize{
-                                        .uuid = llfs::None,
-                                        .pages_per_block_log2 =
-                                            llfs::IoRingLogConfig::kDefaultPagesPerBlockLog2 + 1,
-                                    },
-                                .page_size_log2 = llfs::PageSizeLog2{21},
-                                .page_device = llfs::LinkToNewPageDevice{},
-                            },
-                    },
-                .page_device =
-                    llfs::CreateNewPageDevice{
-                        .options =
-                            llfs::PageDeviceConfigOptions{
-                                .uuid = llfs::None,
-                                .device_id = llfs::None,
-                                .page_count = llfs::PageCount{32},
-                                .page_size_log2 = llfs::PageSizeLog2{21},
-                            },
-                    },
-            });
+            builder.add_object(
+                llfs::PageArenaConfigOptions{
+                    .uuid = arena_uuid_2mb,
+                    .page_allocator =
+                        llfs::CreateNewPageAllocator{
+                            .options =
+                                llfs::PageAllocatorConfigOptions{
+                                    .uuid = llfs::None,
+                                    .max_attachments = 32,
+                                    .page_count = llfs::PageCount{32},
+                                    .log_device =
+                                        llfs::CreateNewLogDevice2WithDefaultSize{
+                                            .uuid = llfs::None,
+                                            .device_page_size_log2 = 9,
+                                            .data_alignment_log2 = 12,
+                                        },
+                                    .page_size_log2 = llfs::PageSizeLog2{21},
+                                    .page_device = llfs::LinkToNewPageDevice{},
+                                },
+                        },
+                    .page_device =
+                        llfs::CreateNewPageDevice{
+                            .options =
+                                llfs::PageDeviceConfigOptions{
+                                    .uuid = llfs::None,
+                                    .device_id = llfs::None,
+                                    .page_count = llfs::PageCount{32},
+                                    .page_size_log2 = llfs::PageSizeLog2{21},
+                                },
+                        },
+                });
 
         BATT_REQUIRE_OK(config_2mb);
 
diff --git a/src/llfs/storage_file_builder.cpp b/src/llfs/storage_file_builder.cpp
index 3f4f1bb..15ab2a8 100644
--- a/src/llfs/storage_file_builder.cpp
+++ b/src/llfs/storage_file_builder.cpp
@@ -10,7 +10,6 @@
 //
 
 #include <llfs/crc.hpp>
-#include <llfs/ioring_log_device.hpp>
 #include <llfs/page_allocator.hpp>
 #include <llfs/page_recycler.hpp>
 
diff --git a/src/llfs/storage_simulation.cpp b/src/llfs/storage_simulation.cpp
index 072e651..bf12038 100644
--- a/src/llfs/storage_simulation.cpp
+++ b/src/llfs/storage_simulation.cpp
@@ -11,10 +11,9 @@
 
 #include <llfs/basic_ring_buffer_log_device.hpp>
 #include <llfs/confirm.hpp>
-#include <llfs/ioring_log_driver.hpp>
-#include <llfs/ioring_log_driver_options.hpp>
-#include <llfs/ioring_log_flush_op.hpp>
-#include <llfs/ioring_log_initializer.hpp>
+#include <llfs/ioring_log_config2.hpp>
+#include <llfs/ioring_log_device2.hpp>
+#include <llfs/log_device_runtime_options.hpp>
 #include <llfs/simulated_log_device.hpp>
 #include <llfs/simulated_log_device_impl.hpp>
 #include <llfs/simulated_page_device.hpp>
@@ -80,12 +79,8 @@ void StorageSimulation::run_main_task(std::function<void()> main_fn)
 
   const bool was_running = this->is_running_.exchange(true);
 
-  const bool saved_quiet_logging =
-      default_ioring_quiet_failure_logging().exchange(this->low_level_log_devices_);
-
   auto on_scope_exit = batt::finally([&] {
     this->is_running_.store(was_running);
-    default_ioring_quiet_failure_logging().store(saved_quiet_logging);
     LLFS_LOG_SIM_EVENT() << "leaving run_main_task()";
   });
 
@@ -233,38 +228,27 @@ std::unique_ptr<LogDevice> StorageSimulation::get_log_device(const std::string&
       if (!capacity) {
         return None;
       }
-      auto config = IoRingLogConfig::from_logical_size(*capacity);
-      return Interval<i64>{
-          .lower_bound = BATT_CHECKED_CAST(i64, config.physical_offset),
-          .upper_bound = BATT_CHECKED_CAST(i64, config.physical_offset + config.physical_size),
-      };
+      auto config = IoRingLogConfig2::from_logical_size(*capacity);
+      return config.offset_range();
     }();
     SimulatedLogDeviceStorage storage = this->get_log_device_storage(name, capacity, file_offset);
 
-    auto config = IoRingLogConfig::from_logical_size(storage.log_size());
+    auto config = IoRingLogConfig2::from_logical_size(storage.log_size());
 
     if (!storage.is_initialized()) {
-      Status init_status = initialize_ioring_log_device(*storage.get_raw_block_file(), config,
-                                                        ConfirmThisWillEraseAllMyData::kYes);
+      Status init_status = initialize_log_device2(*storage.get_raw_block_file(), config,
+                                                  ConfirmThisWillEraseAllMyData::kYes);
 
       BATT_CHECK_OK(init_status);
 
       storage.set_initialized(true);
     }
 
-    auto options = IoRingLogDriverOptions::with_default_values();
+    auto options = LogDeviceRuntimeOptions::with_default_values();
     options.name = name;
-    options.limit_queue_depth(config.block_count());
-
-    using DriverT = BasicIoRingLogDriver<BasicIoRingLogFlushOp, SimulatedLogDeviceStorage>;
-    using LogDeviceT = BasicRingBufferLogDevice<DriverT>;
-
-    batt::TaskScheduler& scheduler =
-        this->is_running() ? this->task_scheduler() : batt::Runtime::instance().default_scheduler();
 
-    auto log_device =
-        std::make_unique<LogDeviceT>(RingBuffer::TempFile{.byte_size = config.logical_size},
-                                     scheduler, std::move(storage), config, options);
+    auto log_device = std::make_unique<BasicIoRingLogDevice2<SimulatedLogDeviceStorage>>(
+        config, options, std::move(storage));
 
     BATT_CHECK_OK(log_device->open());
 
diff --git a/src/llfs/volume_config.cpp b/src/llfs/volume_config.cpp
index 471872f..9226136 100644
--- a/src/llfs/volume_config.cpp
+++ b/src/llfs/volume_config.cpp
@@ -9,7 +9,6 @@
 #include <llfs/volume_config.hpp>
 //
 
-#include <llfs/ioring_log_device.hpp>
 #include <llfs/page_recycler.hpp>
 #include <llfs/uuid.hpp>
 
@@ -30,23 +29,6 @@ BATT_PRINT_OBJECT_IMPL(PackedVolumeConfig,  //
 
 namespace {
 
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-StatusOr<FileOffsetPtr<const PackedLogDeviceConfig&>> add_recycler_log(
-    StorageFileBuilder::Transaction& txn, batt::StaticType<LogDeviceConfigOptions>,
-    const VolumeConfigOptions& options)
-{
-  const LogDeviceConfigOptions recycler_log_options{
-      .uuid = random_uuid(),
-      .pages_per_block_log2 = IoRingLogConfig::kDefaultPagesPerBlockLog2 + 1,
-      .log_size = PageRecycler::calculate_log_size(
-          PageRecyclerOptions{}.set_max_refs_per_page(options.base.max_refs_per_page),
-          options.recycler_max_buffered_page_count),
-  };
-
-  return txn.add_object(recycler_log_options);
-}
-
 //==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
 //
 StatusOr<FileOffsetPtr<const PackedLogDeviceConfig2&>> add_recycler_log(
@@ -73,38 +55,36 @@ Status configure_storage_object(StorageFileBuilder::Transaction& txn,
                                 FileOffsetPtr<PackedVolumeConfig&> p_config,
                                 const VolumeConfigOptions& options)
 {
-  return batt::case_of(options.root_log, [&](const auto& root_log_options) -> Status {
-    BATT_CHECK(!root_log_options.uuid)
-        << "Creating a Volume from a pre-existing root log is not supported";
-
-    using LogDeviceOptionsType = std::decay_t<decltype(root_log_options)>;
-
-    auto p_root_log_config = txn.add_object(root_log_options);
-    BATT_REQUIRE_OK(p_root_log_config);
-
-    auto p_recycler_log_config =
-        add_recycler_log(txn, batt::StaticType<LogDeviceOptionsType>{}, options);
-    BATT_REQUIRE_OK(p_recycler_log_config);
-
-    p_config->uuid = options.base.uuid.value_or(random_uuid());
-    p_config->slot_i = 0;
-    p_config->n_slots = 2;
-    p_config->max_refs_per_page = options.base.max_refs_per_page;
-    p_config->root_log_uuid = (*p_root_log_config)->uuid;
-    p_config->recycler_log_uuid = (*p_recycler_log_config)->uuid;
-
-    p_config->slot_1.tag = PackedConfigSlotBase::Tag::kVolumeContinuation;
-    p_config->slot_1.slot_i = 1;
-    p_config->slot_1.n_slots = 2;
-    p_config->trim_lock_update_interval_bytes = options.base.trim_lock_update_interval;
-    p_config->trim_delay_byte_count = options.base.trim_delay_byte_count;
-
-    if (!txn.packer().pack_string_to(&p_config->name, options.base.name)) {
-      return ::batt::StatusCode::kResourceExhausted;
-    }
-
-    return OkStatus();
-  });
+  BATT_CHECK(!options.root_log.uuid)
+      << "Creating a Volume from a pre-existing root log is not supported";
+
+  using LogDeviceOptionsType = std::decay_t<decltype(options.root_log)>;
+
+  auto p_root_log_config = txn.add_object(options.root_log);
+  BATT_REQUIRE_OK(p_root_log_config);
+
+  auto p_recycler_log_config =
+      add_recycler_log(txn, batt::StaticType<LogDeviceOptionsType>{}, options);
+  BATT_REQUIRE_OK(p_recycler_log_config);
+
+  p_config->uuid = options.base.uuid.value_or(random_uuid());
+  p_config->slot_i = 0;
+  p_config->n_slots = 2;
+  p_config->max_refs_per_page = options.base.max_refs_per_page;
+  p_config->root_log_uuid = (*p_root_log_config)->uuid;
+  p_config->recycler_log_uuid = (*p_recycler_log_config)->uuid;
+
+  p_config->slot_1.tag = PackedConfigSlotBase::Tag::kVolumeContinuation;
+  p_config->slot_1.slot_i = 1;
+  p_config->slot_1.n_slots = 2;
+  p_config->trim_lock_update_interval_bytes = options.base.trim_lock_update_interval;
+  p_config->trim_delay_byte_count = options.base.trim_delay_byte_count;
+
+  if (!txn.packer().pack_string_to(&p_config->name, options.base.name)) {
+    return ::batt::StatusCode::kResourceExhausted;
+  }
+
+  return OkStatus();
 }
 
 //==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
diff --git a/src/llfs/volume_config.hpp b/src/llfs/volume_config.hpp
index 4cdbf5a..a26d95c 100644
--- a/src/llfs/volume_config.hpp
+++ b/src/llfs/volume_config.hpp
@@ -13,7 +13,6 @@
 #include <llfs/constants.hpp>
 #include <llfs/data_layout.hpp>
 #include <llfs/int_types.hpp>
-#include <llfs/log_device_config.hpp>
 #include <llfs/log_device_config2.hpp>
 #include <llfs/packed_config.hpp>
 #include <llfs/packed_pointer.hpp>
@@ -64,7 +63,7 @@ struct VolumeConfigOptions {
 
   // Options controlling the creation of the root log (WAL).
   //
-  std::variant<LogDeviceConfigOptions, LogDeviceConfigOptions2> root_log;
+  LogDeviceConfigOptions2 root_log;
 
   // Used to calculate the minimum recycler log size.
   //
diff --git a/src/llfs/volume_config.test.cpp b/src/llfs/volume_config.test.cpp
index 6cc01b2..5c9a126 100644
--- a/src/llfs/volume_config.test.cpp
+++ b/src/llfs/volume_config.test.cpp
@@ -85,8 +85,8 @@ class VolumeConfigTest : public ::testing::Test
   {
     return llfs::VolumeRuntimeOptions{
         .slot_visitor_fn = std::move(slot_visitor_fn),
-        .root_log_options = llfs::IoRingLogDriverOptions{},
-        .recycler_log_options = llfs::IoRingLogDriverOptions{},
+        .root_log_options = llfs::LogDeviceRuntimeOptions{},
+        .recycler_log_options = llfs::LogDeviceRuntimeOptions{},
         .trim_control = nullptr,
     };
   }
@@ -130,10 +130,13 @@ TEST_F(VolumeConfigTest, ConfigRestore)
                         .trim_delay_byte_count = llfs::TrimDelayByteCount{0},
                     },
                 .root_log =
-                    llfs::LogDeviceConfigOptions{
+                    llfs::LogDeviceConfigOptions2{
                         .uuid = llfs::None,
-                        .pages_per_block_log2 = llfs::None,
                         .log_size = 8 * kMiB,
+                        .device_page_size_log2 =
+                            llfs::LogDeviceConfigOptions2::kDefaultDevicePageSizeLog2,
+                        .data_alignment_log2 =
+                            llfs::LogDeviceConfigOptions2::kDefaultDataAlignmentLog2,
                     },
                 .recycler_max_buffered_page_count = llfs::None,
             });
diff --git a/src/llfs_cli/arena_command.cpp b/src/llfs_cli/arena_command.cpp
deleted file mode 100644
index fe4a376..0000000
--- a/src/llfs_cli/arena_command.cpp
+++ /dev/null
@@ -1,206 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#include <boost/uuid/uuid_io.hpp>
-//
-
-#include <llfs_cli/arena_command.hpp>
-//
-
-#include <llfs/filesystem.hpp>
-#include <llfs/page_arena_file.hpp>
-
-#include <batteries/assert.hpp>
-
-#include <iostream>
-
-namespace llfs_cli {
-
-using namespace llfs;
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-CLI::App* add_arena_command(CLI::App* cmd)
-{
-  CLI::App* arena_cmd = cmd->add_subcommand("arena", "Manage PageArena (.lla) files");
-
-  auto args = std::make_shared<ArenaCommandArgs>();
-
-  //==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-  {
-    CLI::App* arena_create_cmd =
-        arena_cmd->add_subcommand("create", "Create a new PageArena (.lla) file");
-
-    //+++++++++++-+-+--+----- --- -- -  -  -   -
-    arena_create_cmd
-        ->add_option("page_arena_filename,-f,--file", args->filename, "The PageArena (.lla) file")
-        ->required()
-        ->check(CLI::NonexistentPath);
-
-    add_arena_create_options(arena_create_cmd, batt::make_copy(args));
-
-    //+++++++++++-+-+--+----- --- -- -  -  -   -
-    arena_create_cmd->add_option("-i,--id", args->device_id, "Serial id number for device")
-        ->required();
-
-    //+++++++++++-+-+--+----- --- -- -  -  -   -
-    arena_create_cmd->callback([args] {
-      arena_create(*args);
-    });
-  }
-
-  //==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-  {
-    CLI::App* arena_info_cmd =
-        arena_cmd->add_subcommand("info", "Print information about PageArena (.lla) file");
-
-    //+++++++++++-+-+--+----- --- -- -  -  -   -
-    arena_info_cmd->add_option("filename,-f,--file", args->filename, "The PageArena (.lla) file")
-        ->required()
-        ->check(CLI::ExistingFile);
-
-    arena_info_cmd->callback([args] {
-      arena_info(*args);
-    });
-  }
-
-  return arena_cmd;
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-void add_arena_create_options(CLI::App* app, std::shared_ptr<ArenaCommandArgs>&& args)
-{
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-  CLI::Option* page_count_opt =
-      app->add_option("-n,--page_count", args->page_count, "The number of pages")
-          ->transform(CLI::AsSizeValue(true));
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-  app->add_option("-b,--page_size", args->page_size, "The page size in bytes")
-      ->required()
-      ->transform(CLI::AsSizeValue(false));
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-  app->add_option("-t,--total_size", args->total_size, "The total arena size")
-      ->transform(CLI::AsSizeValue(false))
-      ->excludes(page_count_opt);
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-  app->add_option("-m,--max_attachments", args->max_attachments,
-                  "The maximum number of client attachments supported");
-
-  //+++++++++++-+-+--+----- --- -- -  -  -   -
-  app->add_option("-u,--uuid", args->device_uuid, "UUID for the device");
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-void arena_create(ArenaCommandArgs& args)
-{
-  if (args.page_count == 0 && args.page_size == 0) {
-    std::cerr << "Error: at least one of {page_count, page_size} must be specified!" << std::endl;
-  }
-  if (args.page_count == 0) {
-    BATT_CHECK_NE(args.total_size, 0u);
-    args.page_count = (args.total_size + args.page_size - 1) / args.page_size;
-  } else if (args.page_size == 0) {
-    BATT_CHECK_NE(args.total_size, 0u);
-    args.page_size = 1ull << batt::log2_ceil(args.total_size / args.page_count);
-  } else {
-    BATT_CHECK_EQ(args.total_size, 0u);
-    args.total_size = args.page_count * args.page_size;
-  }
-
-  LLFS_VLOG(1) << BATT_INSPECT(args.page_count);
-  LLFS_VLOG(1) << BATT_INSPECT(args.page_size);
-  LLFS_VLOG(1) << BATT_INSPECT(args.total_size);
-
-  BATT_PANIC() << "Implement me!";
-
-#if 0
-  auto builder = PackedPageArenaConfig::Builder{}
-                     .page_count(args.page_count)
-                     .page_size(args.page_size)
-                     .max_attach_count(args.max_attachments)
-                     .device_id(args.device_id)
-                     .device_uuid(args.device_uuid);
-
-  PackedPageArenaConfig config;
-  BATT_CHECK_OK(builder.build(&config));
-
-  LLFS_VLOG(1) << BATT_INSPECT(config);
-
-  // Create an empty file of the required size.
-  //
-  BATT_CHECK_OK(truncate_file(args.filename, config.total_arena_size()));
-
-  LLFS_VLOG(1) << BATT_INSPECT(config.total_arena_size()) << BATT_INSPECT(sizeof(config));
-
-  FileSegmentRef file_ref{
-      .path_utf8 = args.filename,
-      .offset = 0,
-      .size = config.total_arena_size(),
-  };
-
-  StatusOr<IoRing> ioring = IoRing::make_new(/*entries=*/256);
-  BATT_CHECK_OK(ioring);
-
-  ioring->on_work_started();
-
-  // The IoRing requires a background thread to process events.
-  //
-  std::thread ioring_thread{[&] {
-    LLFS_VLOG(1) << "ioring_thread entered";
-    Status ioring_exit_status = ioring->run();
-    LLFS_VLOG(1) << BATT_INSPECT(ioring_exit_status);
-    LLFS_VLOG(1) << "ioring_thread finished";
-  }};
-
-  // Initialize the page arena file.
-  //
-  {
-    PageArenaFileRuntimeOptions runtime_options;
-    StatusOr<PageArena> arena =
-        initialize_page_arena_file(batt::Runtime::instance().default_scheduler(), *ioring, file_ref,
-                                   runtime_options, config, ConfirmThisWillEraseAllMyData::kYes);
-    LLFS_VLOG(1) << "arena initialize returned: " << arena.status();
-    BATT_CHECK_OK(arena);
-  }
-  ioring->on_work_finished();
-
-  // Shut down the IoRing.
-  //
-  LLFS_VLOG(1) << "stopping the ioring";
-  ioring->stop();
-
-  LLFS_VLOG(1) << "joining the ioring_thread";
-  ioring_thread.join();
-#endif
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-void arena_info(ArenaCommandArgs& args)
-{
-  StatusOr<std::vector<std::unique_ptr<PageArenaConfigInFile>>> records =
-      read_arena_configs_from_file(args.filename);
-  BATT_CHECK_OK(records);
-
-  if (records->empty()) {
-    std::cerr << "No PackedPageArenaConfig found at the end of '" << args.filename
-              << "'; is this a valid PageArena (.lla) file?" << std::endl;
-    return;
-  }
-
-  for (auto& r : *records) {
-    std::cout << r->file_ref << std::endl << r->config << std::endl;
-  }
-}
-
-}  // namespace llfs_cli
diff --git a/src/llfs_cli/arena_command.hpp b/src/llfs_cli/arena_command.hpp
deleted file mode 100644
index dc12ffe..0000000
--- a/src/llfs_cli/arena_command.hpp
+++ /dev/null
@@ -1,48 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#pragma once
-#ifndef LLFS_CLI_ARENA_COMMAND_HPP
-#define LLFS_CLI_ARENA_COMMAND_HPP
-
-#include <boost/uuid/uuid.hpp>
-#include <boost/uuid/uuid_io.hpp>
-
-#include <CLI/App.hpp>
-
-#include <llfs/int_types.hpp>
-
-#include <boost/uuid/random_generator.hpp>
-
-#include <string>
-
-namespace llfs_cli {
-
-using namespace llfs::int_types;
-
-CLI::App* add_arena_command(CLI::App* app);
-
-struct ArenaCommandArgs {
-  std::string filename;
-  u64 base_offset = 0;
-  u64 page_count = 0;
-  u64 page_size = 0;
-  u64 max_attachments = 64;
-  u64 total_size = 0;
-  boost::uuids::uuid device_uuid = boost::uuids::random_generator{}();
-  u32 device_id = 0;
-};
-
-void arena_create(ArenaCommandArgs& args);
-void arena_info(ArenaCommandArgs& args);
-
-void add_arena_create_options(CLI::App* app, std::shared_ptr<ArenaCommandArgs>&& args);
-
-}  // namespace llfs_cli
-
-#endif  // LLFS_CLI_ARENA_COMMAND_HPP
diff --git a/src/llfs_cli/cache_command.cpp b/src/llfs_cli/cache_command.cpp
deleted file mode 100644
index 5657c5f..0000000
--- a/src/llfs_cli/cache_command.cpp
+++ /dev/null
@@ -1,183 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#include <boost/uuid/uuid_io.hpp>
-//
-
-#include <llfs_cli/cache_command.hpp>
-//
-
-#include <llfs/data_packer.hpp>
-#include <llfs/filesystem.hpp>
-#include <llfs/page_arena_file.hpp>
-#include <llfs/page_cache_config_file.hpp>
-#include <llfs/page_id_factory.hpp>
-
-namespace llfs_cli {
-
-using namespace llfs;
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-CLI::App* add_cache_command(CLI::App* cmd)
-{
-  CLI::App* cache_cmd = cmd->add_subcommand("cache", "Manage PageCache config (.llc) files");
-
-  auto args = std::make_shared<CacheCommandArgs>();
-
-  //==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-  {
-    CLI::App* cache_create_cmd =
-        cache_cmd->add_subcommand("create", "Create a new PaceCache config (.llc) file");
-
-    //+++++++++++-+-+--+----- --- -- -  -  -   -
-    cache_create_cmd
-        ->add_option("page_cache_config_filename,-f,--file", args->filename,
-                     "The PageCache config (.llc) file")
-        ->required()
-        ->check(CLI::NonexistentPath);
-
-    //+++++++++++-+-+--+----- --- -- -  -  -   -
-    cache_create_cmd->callback([args] {
-      cache_create(*args);
-    });
-  }
-
-  //==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-  {
-    CLI::App* cache_info_cmd = cache_cmd->add_subcommand(
-        "info", "Read PageCache config (.llc) file and display information");
-
-    //+++++++++++-+-+--+----- --- -- -  -  -   -
-    cache_info_cmd
-        ->add_option("page_cache_config_filename,-f,--file", args->filename,
-                     "The PageCache config (.llc) file")
-        ->required()
-        ->check(CLI::ExistingFile);
-
-    //+++++++++++-+-+--+----- --- -- -  -  -   -
-    cache_info_cmd->callback([args] {
-      cache_info(*args);
-    });
-  }
-
-  //==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-  {
-    CLI::App* cache_add_arena_cmd = cache_cmd->add_subcommand(
-        "add_arena",
-        "Add an already-existing PageArena (.lla) file to a PageCache config (.llc) file");
-
-    //+++++++++++-+-+--+----- --- -- -  -  -   -
-    cache_add_arena_cmd
-        ->add_option("page_cache_config_filename,-f,--file", args->filename,
-                     "The PageCache config (.llc) file")
-        ->required()
-        ->check(CLI::ExistingFile);
-
-    //+++++++++++-+-+--+----- --- -- -  -  -   -
-    cache_add_arena_cmd
-        ->add_option("page_arena_filename,-a,--arena", args->arena_filenames_to_add,
-                     "A comma-separated list of ")
-        ->required()
-        ->check(CLI::ExistingFile);
-
-    //+++++++++++-+-+--+----- --- -- -  -  -   -
-    cache_add_arena_cmd->callback([args] {
-      cache_add_arena(*args);
-    });
-  }
-
-  //==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-
-  return cache_cmd;
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-void cache_create(CacheCommandArgs& args)
-{
-  const PageCacheConfigFile empty_cache_config;
-
-  Status status = write_page_cache_config_file(args.filename, empty_cache_config);
-  BATT_CHECK_OK(status);
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-void cache_info(CacheCommandArgs& args)
-{
-  Status status = [&]() -> Status {
-    StatusOr<PageCacheConfigFile> cache_config = read_page_cache_config_file(args.filename);
-    BATT_REQUIRE_OK(cache_config);
-
-    std::cout << batt::dump_range(cache_config->arenas, batt::Pretty::True) << std::endl;
-
-    return OkStatus();
-  }();
-  BATT_CHECK_OK(status);
-}
-
-//==#==========+==+=+=++=+++++++++++-+-+--+----- --- -- -  -  -   -
-//
-void cache_add_arena(CacheCommandArgs& args)
-{
-  (void)args;
-
-  BATT_PANIC() << "Implement me!";
-
-#if 0
-  Status status = [&]() -> Status {
-    StatusOr<PageCacheConfigFile> cache_config = read_page_cache_config_file(args.filename);
-    BATT_REQUIRE_OK(cache_config);
-
-    // Build a list of in-use device ids to detect and prevent conflicts.
-    //
-    std::set<page_device_id_int> device_ids_in_use;
-    const auto check_device_id_unique = [&](page_device_id_int device_id) {
-      if (device_ids_in_use.count(device_id)) {
-        BATT_PANIC() << "duplicate device_id found in PageCache config! "
-                     << BATT_INSPECT(device_id);
-      }
-      device_ids_in_use.emplace(device_id);
-    };
-
-    for (const PageArenaFileRef& arena_ref : cache_config->arenas) {
-      check_device_id_unique(arena_ref.page_device_id);
-    }
-
-    // Load arena configs from all the specified files and add them to the cache config.
-    //
-    for (const std::string& arena_filename : args.arena_filenames_to_add) {
-      StatusOr<std::vector<std::unique_ptr<PageArenaConfigInFile>>> arena_configs =
-          read_arena_configs_from_file(arena_filename);
-
-      BATT_REQUIRE_OK(arena_configs);
-
-      for (auto& to_add : *arena_configs) {
-        check_device_id_unique(to_add->config.page_device->device_id);
-
-        cache_config->arenas.emplace_back(PageArenaFileRef{
-            .arena_file = to_add->file_ref,
-            .page_device_id = batt::checked_cast<u32>(to_add->config.page_device.device_id.value()),
-            .page_device_uuid = to_add->config.page_device.device_uuid,
-        });
-
-        VLOG(1) << "added " << cache_config->arenas.back();
-      }
-    }
-
-    // Write the new config.
-    //
-    return write_page_cache_config_file(args.filename, *cache_config);
-  }();
-
-  BATT_CHECK_OK(status);
-#endif
-}
-
-}  // namespace llfs_cli
diff --git a/src/llfs_cli/cache_command.hpp b/src/llfs_cli/cache_command.hpp
deleted file mode 100644
index b9afa18..0000000
--- a/src/llfs_cli/cache_command.hpp
+++ /dev/null
@@ -1,37 +0,0 @@
-//#=##=##=#==#=#==#===#+==#+==========+==+=+=+=+=+=++=+++=+++++=-++++=-+++++++++++
-//
-// Part of the LLFS Project, under Apache License v2.0.
-// See https://www.apache.org/licenses/LICENSE-2.0 for license information.
-// SPDX short identifier: Apache-2.0
-//
-//+++++++++++-+-+--+----- --- -- -  -  -   -
-
-#pragma once
-#ifndef LLFS_CLI_CACHE_COMMAND_HPP
-#define LLFS_CLI_CACHE_COMMAND_HPP
-
-#include <boost/uuid/uuid_io.hpp>
-
-#include <CLI/App.hpp>
-
-#include <string>
-
-#include <llfs_cli/arena_command.hpp>
-
-namespace llfs_cli {
-
-CLI::App* add_cache_command(CLI::App* app);
-
-struct CacheCommandArgs {
-  std::string filename;
-  std::vector<std::string> arena_filenames_to_add;
-};
-
-void cache_create(CacheCommandArgs& args);
-void cache_info(CacheCommandArgs& args);
-void cache_add_arena(CacheCommandArgs& args);
-void cache_add_new_arena(CacheCommandArgs& cache_args, ArenaCommandArgs& arena_args);
-
-}  // namespace llfs_cli
-
-#endif  // LLFS_CLI_CACHE_COMMAND_HPP
diff --git a/src/llfs_cli/main.cpp b/src/llfs_cli/main.cpp
index c10f97f..b5ffb41 100644
--- a/src/llfs_cli/main.cpp
+++ b/src/llfs_cli/main.cpp
@@ -10,8 +10,6 @@
 // LLFS Command-Line Interface.
 //
 
-#include <llfs_cli/arena_command.hpp>
-#include <llfs_cli/cache_command.hpp>
 #include <llfs_cli/list_command.hpp>
 
 #include <CLI/App.hpp>
@@ -26,8 +24,6 @@ int main(int argc, char** argv)
 {
   CLI::App app{"Low-Level File System (LLFS) Command Line Utility"};
 
-  // llfs_cli::add_arena_command(&app);
-  // llfs_cli::add_cache_command(&app);
   llfs_cli::add_list_command(&app);
 
   app.require_subcommand();