diff --git a/sdk/fidl/fuchsia.hardware.nand/ram-nand.fidl b/sdk/fidl/fuchsia.hardware.nand/ram-nand.fidl
index 40ae8ab..fb8f667 100644
--- a/sdk/fidl/fuchsia.hardware.nand/ram-nand.fidl
+++ b/sdk/fidl/fuchsia.hardware.nand/ram-nand.fidl
@@ -64,6 +64,9 @@
     bool export_nand_config;
     /// if true, export a boot partition map as metadata.
     bool export_partition_map;
+
+    /// If non-zero, fail after `fail_after` writes.
+    uint32 fail_after;
 };
 
 [ForDeprecatedCBindings]
diff --git a/src/devices/block/drivers/ftl/nand_driver.cc b/src/devices/block/drivers/ftl/nand_driver.cc
index 084e731..f18296a 100644
--- a/src/devices/block/drivers/ftl/nand_driver.cc
+++ b/src/devices/block/drivers/ftl/nand_driver.cc
@@ -70,7 +70,16 @@
  public:
   NandDriverImpl(const nand_protocol_t* parent, const bad_block_protocol_t* bad_block,
                  ftl::OperationCounters* counters)
-      : parent_(parent), bad_block_protocol_(bad_block), counters_(counters) {}
+      : NandDriver(FtlLogger{
+            .trace = &LogTrace,
+            .debug = &LogDebug,
+            .info = &LogInfo,
+            .warn = &LogWarning,
+            .error = &LogError,
+        }),
+        parent_(parent),
+        bad_block_protocol_(bad_block),
+        counters_(counters) {}
   ~NandDriverImpl() final {}
 
   // NdmDriver interface:
@@ -84,6 +93,8 @@
   int IsBadBlock(uint32_t page_num) final;
   bool IsEmptyPage(uint32_t page_num, const uint8_t* data, const uint8_t* spare) final;
   void TryEraseRange(uint32_t start_block, uint32_t end_block) final;
+  uint32_t PageSize() final { return info_.page_size; }
+  uint8_t SpareSize() final { return info_.oob_size; }
   const nand_info_t& info() const final { return info_; }
 
  private:
@@ -137,14 +148,7 @@
   } else if (BadBbtReservation()) {
     return "Unable to use bad block reservation";
   }
-  ftl::LoggerProxy logger = {
-      .trace = &LogTrace,
-      .debug = &LogDebug,
-      .info = &LogInfo,
-      .warn = &LogWarning,
-      .error = &LogError,
-  };
-  const char* error = CreateNdmVolumeWithLogger(ftl_volume, options, true, logger);
+  const char* error = CreateNdmVolume(ftl_volume, options, true);
   if (error) {
     // Retry allowing the volume to be fixed as needed.
     zxlogf(INFO, "FTL: About to retry volume creation");
diff --git a/src/devices/block/drivers/ftl/nand_driver.h b/src/devices/block/drivers/ftl/nand_driver.h
index 322df16..71fa1c4 100644
--- a/src/devices/block/drivers/ftl/nand_driver.h
+++ b/src/devices/block/drivers/ftl/nand_driver.h
@@ -42,6 +42,9 @@
   // Cleans all non bad blocks in a given block range. Erase failures are logged amd deemed non
   // fatal.
   virtual void TryEraseRange(uint32_t start_block, uint32_t end_block) = 0;
+
+ protected:
+  NandDriver(FtlLogger logger) : NdmBaseDriver(logger) {}
 };
 
 }  // namespace ftl.
diff --git a/src/devices/block/drivers/ftl/tests/ndm-ram-driver.cc b/src/devices/block/drivers/ftl/tests/ndm-ram-driver.cc
index 90cd103..6a680af 100644
--- a/src/devices/block/drivers/ftl/tests/ndm-ram-driver.cc
+++ b/src/devices/block/drivers/ftl/tests/ndm-ram-driver.cc
@@ -248,6 +248,10 @@
   return ftl::kNdmOk;
 }
 
+uint32_t NdmRamDriver::PageSize() { return options_.page_size; }
+
+uint8_t NdmRamDriver::SpareSize() { return options_.eb_size; }
+
 bool NdmRamDriver::SimulateBadBlock(uint32_t page_num) {
   if (num_bad_blocks_ < options_.max_bad_blocks) {
     bad_block_interval_++;
diff --git a/src/devices/block/drivers/ftl/tests/ndm-ram-driver.h b/src/devices/block/drivers/ftl/tests/ndm-ram-driver.h
index 4d8b083..cb5dd14 100644
--- a/src/devices/block/drivers/ftl/tests/ndm-ram-driver.h
+++ b/src/devices/block/drivers/ftl/tests/ndm-ram-driver.h
@@ -47,7 +47,7 @@
  public:
   explicit NdmRamDriver(const ftl::VolumeOptions& options) : NdmRamDriver(options, {}) {}
   NdmRamDriver(const ftl::VolumeOptions& options, const TestOptions& test_options)
-      : options_(options), test_options_(test_options) {}
+      : NdmBaseDriver(ftl::DefaultLogger()), options_(options), test_options_(test_options) {}
   ~NdmRamDriver() final = default;
 
   // Extends the visible volume to the whole size of the storage.
@@ -75,6 +75,8 @@
   int NandErase(uint32_t page_num) final;
   int IsBadBlock(uint32_t page_num) final;
   bool IsEmptyPage(uint32_t page_num, const uint8_t* data, const uint8_t* spare) final;
+  uint32_t PageSize() final;
+  uint8_t SpareSize() final;
 
  private:
   // Reads or Writes a single page.
diff --git a/src/devices/nand/drivers/ram-nand/ram-nand.cc b/src/devices/nand/drivers/ram-nand/ram-nand.cc
index 53e610f..c27e6fe 100644
--- a/src/devices/nand/drivers/ram-nand/ram-nand.cc
+++ b/src/devices/nand/drivers/ram-nand/ram-nand.cc
@@ -5,6 +5,8 @@
 #include "ram-nand.h"
 
 #include <lib/ddk/binding.h>
+#include <lib/ddk/debug.h>
+#include <lib/ddk/metadata.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ -15,7 +17,6 @@
 #include <algorithm>
 #include <utility>
 
-#include <lib/ddk/metadata.h>
 #include <ddk/metadata/bad-block.h>
 #include <ddk/metadata/nand.h>
 #include <fbl/algorithm.h>
@@ -141,6 +142,11 @@
       {BIND_NAND_CLASS, 0, params_.nand_class},
   };
 
+  fail_after_ = info.fail_after;
+  if (fail_after_ > 0) {
+    zxlogf(INFO, "fail-after: %u", fail_after_);
+  }
+
   return DdkAdd(ddk::DeviceAddArgs(name).set_props(props));
 }
 
@@ -323,12 +329,36 @@
     zx_status_t status = ZX_OK;
 
     switch (operation->command) {
-      case NAND_OP_READ:
       case NAND_OP_WRITE:
+        if (fail_after_ > 0) {
+          if (write_count_ >= fail_after_) {
+            status = ZX_ERR_IO;
+            break;
+          }
+          if (write_count_ + operation->rw.length > fail_after_) {
+            const uint32_t old_length = operation->rw.length;
+            operation->rw.length = fail_after_ - write_count_;
+            status = ReadWriteData(operation);
+            if (status == ZX_OK) {
+              status = ReadWriteOob(operation);
+            }
+            if (status == ZX_OK) {
+              write_count_ = fail_after_;
+              status = ZX_ERR_IO;
+            }
+            operation->rw.length = old_length;
+            break;
+          }
+        }
+        __FALLTHROUGH;
+      case NAND_OP_READ:
         status = ReadWriteData(operation);
         if (status == ZX_OK) {
           status = ReadWriteOob(operation);
         }
+        if (status == ZX_OK && operation->command == NAND_OP_WRITE) {
+          write_count_ += operation->rw.length;
+        }
         break;
 
       case NAND_OP_ERASE: {
diff --git a/src/devices/nand/drivers/ram-nand/ram-nand.h b/src/devices/nand/drivers/ram-nand/ram-nand.h
index 4f73814..57d05e2 100644
--- a/src/devices/nand/drivers/ram-nand/ram-nand.h
+++ b/src/devices/nand/drivers/ram-nand/ram-nand.h
@@ -112,6 +112,12 @@
   std::optional<nand_config_t> export_nand_config_;
   fbl::Array<char> export_partition_map_;
 
+  // If non-zero, the driver will fail writes once the write-count reaches this value.
+  uint32_t fail_after_ = 0;
+
+  // The number of pages written.
+  uint32_t write_count_ = 0;
+
   DISALLOW_COPY_ASSIGN_AND_MOVE(NandDevice);
 };
 
diff --git a/src/storage/blobfs/test/integration/sync_test.cc b/src/storage/blobfs/test/integration/sync_test.cc
index 7bdde1b..be30974 100644
--- a/src/storage/blobfs/test/integration/sync_test.cc
+++ b/src/storage/blobfs/test/integration/sync_test.cc
@@ -76,7 +76,7 @@
   ASSERT_EQ(vmo.CreateAndMap(kVmoSize, "vmo"), ZX_OK);
   memset(vmo.start(), 0xff, kVmoSize);
 
-  auto options = BlobfsDefaultTestParam();
+  auto options = BlobfsWithFvmTestParam();
   options.use_ram_nand = true;
   options.ram_nand_vmo = vmo.vmo().borrow();
   options.device_block_count = 0;  // Uses VMO size.
diff --git a/src/storage/fs_test/corrupt.cc b/src/storage/fs_test/corrupt.cc
index db14855..fcab3ac 100644
--- a/src/storage/fs_test/corrupt.cc
+++ b/src/storage/fs_test/corrupt.cc
@@ -5,6 +5,7 @@
 #include <fuchsia/device/llcpp/fidl.h>
 #include <lib/fdio/directory.h>
 #include <lib/fzl/owned-vmo-mapper.h>
+#include <lib/syslog/cpp/macros.h>
 #include <lib/zx/channel.h>
 
 #include <random>
@@ -24,27 +25,47 @@
   // 768 blocks containing 64 pages of 4 KiB with 8 bytes OOB
   constexpr int kSize = 768 * 64 * (4096 + 8);
 
-  fzl::OwnedVmoMapper vmo;
-  ASSERT_EQ(vmo.CreateAndMap(kSize, "corrupt-test-vmo"), ZX_OK);
-  memset(vmo.start(), 0xff, kSize);
+  for (int pass = 0; pass < 2; ++pass) {
+    fzl::OwnedVmoMapper vmo;
+    ASSERT_EQ(vmo.CreateAndMap(kSize, "corrupt-test-vmo"), ZX_OK);
+    memset(vmo.start(), 0xff, kSize);
 
-  TestFilesystemOptions options = TestFilesystemOptions::DefaultMinfs();
-  options.device_block_size = 8192;
-  options.device_block_count = 0;  // Use VMO size.
-  options.use_ram_nand = true;
-  options.ram_nand_vmo = zx::unowned_vmo(vmo.vmo());
+    TestFilesystemOptions options = TestFilesystemOptions::DefaultMinfs();
+    options.device_block_size = 8192;
+    options.device_block_count = 0;  // Use VMO size.
+    options.use_ram_nand = true;
+    options.ram_nand_vmo = zx::unowned_vmo(vmo.vmo());
+    std::random_device random;
 
-  // In one thread, repeatedly create a file, write to it, sync and then delete two files.  Then,
-  // some random amount of time later, tear down the Ram Nand driver, then rebind and fsck.  The
-  // journal should ensure the file system remains consistent.
-  {
-    auto fs_or = TestFilesystem::Create(options);
-    ASSERT_TRUE(fs_or.is_ok()) << fs_or.status_string();
-    TestFilesystem fs = std::move(fs_or).value();
+    if (pass == 0) {
+      // In this first pass, a write failure is closely targeted such that the failure is more
+      // likely to occur just as the FTL is writing the first page of a new map block.  If things
+      // change with the write pattern for minfs, then this range might not be right, so on the
+      // second pass, we target a much wider range.
+      std::uniform_int_distribution distribution(1325, 1400);
 
-    const std::string file1 = fs.mount_path() + "/file1";
-    const std::string file2 = fs.mount_path() + "/file2";
-    std::thread thread([&]() {
+      // Deliberately fail after an odd number so that we always fail half-way through an 8 KiB
+      // write.
+      options.fail_after = distribution(random) | 1;
+    } else {
+      // On the second pass, we use a wider random range in case a change in the system means that
+      // the first pass no longer targets weak spots.
+      std::uniform_int_distribution distribution(1300, 2300);
+      options.fail_after = distribution(random);
+    }
+
+    // Create a dummy FVM partition that shifts the location of the minfs partition such that the
+    // offsets being used will hit the second half of the FTL's 8 KiB map pages.
+    options.dummy_fvm_partition_size = 8'388'608;
+
+    {
+      auto fs_or = TestFilesystem::Create(options);
+      ASSERT_TRUE(fs_or.is_ok()) << fs_or.status_string();
+      TestFilesystem fs = std::move(fs_or).value();
+
+      // Loop until we encounter write failures.
+      const std::string file1 = fs.mount_path() + "/file1";
+      const std::string file2 = fs.mount_path() + "/file2";
       for (;;) {
         {
           fbl::unique_fd fd(open(file1.c_str(), O_RDWR | O_CREAT, 0644));
@@ -61,30 +82,16 @@
           }
         }
       }
-    });
+    }
 
-    std::random_device random;
-    std::uniform_int_distribution distribution(0, 20000);
-    const int usec = distribution(random);
-    std::cout << "sleeping for " << usec << "us" << std::endl;
-    zx_nanosleep(zx_deadline_after(zx::usec(usec).get()));
-
-    // Unbind the NAND driver.
-    zx::channel local, remote;
-    ASSERT_EQ(zx::channel::create(0, &local, &remote), ZX_OK);
-    ASSERT_EQ(fdio_service_connect(fs.GetRamNand()->path(), remote.release()), ZX_OK);
-    auto resp = fidl::WireCall<device::Controller>(local.borrow()).ScheduleUnbind();
-    ASSERT_EQ(resp.status(), ZX_OK);
-    ASSERT_FALSE(resp->result.is_err());
-
-    thread.join();
+    std::cout << "Remounting" << std::endl;
+    options.fail_after = 0;
+    auto fs_or = TestFilesystem::Open(options);
+    ASSERT_TRUE(fs_or.is_ok()) << fs_or.status_string();
+    TestFilesystem fs = std::move(fs_or).value();
+    EXPECT_EQ(fs.Unmount().status_value(), ZX_OK);
+    EXPECT_EQ(fs.Fsck().status_value(), ZX_OK);
   }
-
-  auto fs_or = TestFilesystem::Open(options);
-  ASSERT_TRUE(fs_or.is_ok()) << fs_or.status_string();
-  TestFilesystem fs = std::move(fs_or).value();
-  EXPECT_EQ(fs.Unmount().status_value(), ZX_OK);
-  EXPECT_EQ(fs.Fsck().status_value(), ZX_OK);
 }
 
 }  // namespace
diff --git a/src/storage/fs_test/fs_test.cc b/src/storage/fs_test/fs_test.cc
index 1ce866c..0a47c6f 100644
--- a/src/storage/fs_test/fs_test.cc
+++ b/src/storage/fs_test/fs_test.cc
@@ -29,6 +29,7 @@
 #include <fbl/unique_fd.h>
 #include <fs-management/admin.h>
 #include <fs-management/format.h>
+#include <fs-management/fvm.h>
 #include <fs-management/launch.h>
 #include <fs-management/mount.h>
 
@@ -79,20 +80,8 @@
     return ram_disk_or.take_error();
   }
 
-  // Create an FVM partition if requested.
-  std::string device_path;
-  if (options.use_fvm) {
-    auto fvm_partition_or =
-        storage::CreateFvmPartition(ram_disk_or.value().path(), options.fvm_slice_size);
-    if (fvm_partition_or.is_error()) {
-      return fvm_partition_or.take_error();
-    }
-    device_path = fvm_partition_or.value();
-  } else {
-    device_path = ram_disk_or.value().path();
-  }
-
-  return zx::ok(std::make_pair(std::move(ram_disk_or).value(), device_path));
+  std::string device_path = ram_disk_or.value().path();
+  return zx::ok(std::make_pair(std::move(ram_disk_or).value(), std::move(device_path)));
 }
 
 // Creates a ram-nand device.  It does not create an FVM partition; that is left to the caller.
@@ -152,7 +141,8 @@
       .nand_info.num_blocks = block_count,
       .nand_info.ecc_bits = 8,
       .nand_info.oob_size = kOobSize,
-      .nand_info.nand_class = fuchsia_hardware_nand_Class_FTL};
+      .nand_info.nand_class = fuchsia_hardware_nand_Class_FTL,
+      .fail_after = options.fail_after};
   status = zx::make_status(ramdevice_client::RamNand::Create(&config, &ram_nand));
   if (status.is_error()) {
     std::cout << "RamNand::Create failed: " << status.status_string() << std::endl;
@@ -208,28 +198,59 @@
 // Returns device and device path.
 zx::status<std::pair<RamDevice, std::string>> CreateRamDevice(
     const TestFilesystemOptions& options) {
+  RamDevice ram_device;
+  std::string device_path;
+
   if (options.use_ram_nand) {
     auto ram_nand_or = CreateRamNand(options);
     if (ram_nand_or.is_error()) {
       return ram_nand_or.take_error();
     }
     auto [ram_nand, nand_device_path] = std::move(ram_nand_or).value();
-
-    auto fvm_partition_or = storage::CreateFvmPartition(nand_device_path, options.fvm_slice_size);
-    if (fvm_partition_or.is_error()) {
-      std::cout << "Failed to create FVM partition: " << fvm_partition_or.status_string()
-                << std::endl;
-      return fvm_partition_or.take_error();
-    }
-
-    return zx::ok(std::make_pair(std::move(ram_nand), std::move(fvm_partition_or).value()));
+    ram_device = RamDevice(std::move(ram_nand));
+    device_path = std::move(nand_device_path);
   } else {
     auto ram_disk_or = CreateRamDisk(options);
     if (ram_disk_or.is_error()) {
       return ram_disk_or.take_error();
     }
-    auto [device, device_path] = std::move(ram_disk_or).value();
-    return zx::ok(std::make_pair(std::move(device), std::move(device_path)));
+    auto [device, ram_disk_path] = std::move(ram_disk_or).value();
+    ram_device = RamDevice(std::move(device));
+    device_path = std::move(ram_disk_path);
+  }
+
+  // Create an FVM partition if requested.
+  if (options.use_fvm) {
+    auto fvm_partition_or = storage::CreateFvmPartition(device_path, options.fvm_slice_size);
+    if (fvm_partition_or.is_error()) {
+      return fvm_partition_or.take_error();
+    }
+
+    if (options.dummy_fvm_partition_size > 0) {
+      auto fvm_fd = fbl::unique_fd(open((device_path + "/fvm").c_str(), O_RDWR));
+      if (!fvm_fd) {
+        std::cout << "Could not open FVM driver: " << strerror(errno) << std::endl;
+        return zx::error(ZX_ERR_BAD_STATE);
+      }
+
+      alloc_req_t request = {
+          .slice_count = options.dummy_fvm_partition_size / options.fvm_slice_size,
+          .type = {0x01, 0x02, 0x03, 0x04, 0x01, 0x02, 0x03, 0x04, 0x01, 0x02, 0x03, 0x04, 0x01,
+                   0x02, 0x03, 0x04},
+          .guid = {0x01, 0x02, 0x03, 0x04, 0x01, 0x02, 0x03, 0x04, 0x01, 0x02, 0x03, 0x04, 0x01,
+                   0x02, 0x03, 0x04},
+          .name = "dummy",
+      };
+      fbl::unique_fd fd(fvm_allocate_partition(fvm_fd.get(), &request));
+      if (!fd) {
+        std::cout << "Could not allocate dummy FVM partition" << std::endl;
+        return zx::error(ZX_ERR_BAD_STATE);
+      }
+    }
+
+    return zx::ok(std::make_pair(std::move(ram_device), std::move(fvm_partition_or).value()));
+  } else {
+    return zx::ok(std::make_pair(std::move(ram_device), std::move(device_path)));
   }
 }
 
diff --git a/src/storage/fs_test/fs_test.h b/src/storage/fs_test/fs_test.h
index 62bfd066b..03166eb 100644
--- a/src/storage/fs_test/fs_test.h
+++ b/src/storage/fs_test/fs_test.h
@@ -51,6 +51,11 @@
   // for OOB.
   zx::unowned_vmo ram_nand_vmo;
   bool use_fvm = false;
+
+  // If non-zero, create a dummy FVM partition which has the effect of moving the location of the
+  // partition under test to be at a different offset on the underlying device.
+  uint64_t dummy_fvm_partition_size = 0;
+
   uint64_t device_block_size = 0;
   uint64_t device_block_count = 0;
   uint64_t fvm_slice_size = 0;
@@ -62,6 +67,9 @@
 
   // The format blobfs should store blobs in.
   std::optional<blobfs::BlobLayoutFormat> blob_layout_format;
+
+  // If using ram_nand, the number of writes after which writes should fail.
+  uint32_t fail_after;
 };
 
 std::ostream& operator<<(std::ostream& out, const TestFilesystemOptions& options);
diff --git a/src/storage/testing/fvm.cc b/src/storage/testing/fvm.cc
index ba8307c..cb30a2c 100644
--- a/src/storage/testing/fvm.cc
+++ b/src/storage/testing/fvm.cc
@@ -79,20 +79,18 @@
     return zx::error(ZX_ERR_BAD_STATE);
   }
 
-  alloc_req_t request;
-  memset(&request, 0, sizeof(request));
-  request.slice_count = 1;
+  alloc_req_t request = {.slice_count = 1};
   memcpy(request.name, options.name.data(), options.name.size());
   request.name[options.name.size()] = 0;
   memcpy(request.type, options.type ? options.type->data() : kTestPartGUID, sizeof(request.type));
   memcpy(request.guid, kTestUniqueGUID, sizeof(request.guid));
 
-  fbl::unique_fd fd(fvm_allocate_partition(fvm_fd.get(), &request));
+  auto fd = fbl::unique_fd(fvm_allocate_partition(fvm_fd.get(), &request));
   if (!fd) {
     FX_LOGS(ERROR) << "Could not allocate FVM partition";
     return zx::error(ZX_ERR_BAD_STATE);
   }
-  close(fvm_fd.release());
+  fvm_fd.reset();
 
   char partition_path[PATH_MAX];
   fd.reset(open_partition(kTestUniqueGUID, request.type, 0, partition_path));
diff --git a/src/storage/volume_image/ftl/ftl_test_helper.h b/src/storage/volume_image/ftl/ftl_test_helper.h
index 56818e2..f725485 100644
--- a/src/storage/volume_image/ftl/ftl_test_helper.h
+++ b/src/storage/volume_image/ftl/ftl_test_helper.h
@@ -26,7 +26,10 @@
 class InMemoryNdm final : public ftl::NdmBaseDriver {
  public:
   explicit InMemoryNdm(InMemoryRawNand* raw_nand, uint64_t page_size, uint64_t oob_size)
-      : raw_nand_(raw_nand), page_size_(page_size), oob_size_(oob_size) {}
+      : NdmBaseDriver(ftl::DefaultLogger()),
+        raw_nand_(raw_nand),
+        page_size_(page_size),
+        oob_size_(oob_size) {}
 
   // Performs driver initialization. Returns an error string, or nullptr on
   // success.
@@ -65,6 +68,9 @@
   // the contents of the page.
   bool IsEmptyPage(uint32_t page_num, const uint8_t* data, const uint8_t* spare) final;
 
+  uint32_t PageSize() final { return static_cast<uint32_t>(page_size_); }
+  uint8_t SpareSize() final { return static_cast<uint8_t>(oob_size_); }
+
  private:
   InMemoryRawNand* raw_nand_ = nullptr;
   uint64_t page_size_ = 0;
diff --git a/zircon/system/ulib/ftl-mtd/include/lib/ftl-mtd/nand-volume-driver.h b/zircon/system/ulib/ftl-mtd/include/lib/ftl-mtd/nand-volume-driver.h
index d40fff3..850af0f 100644
--- a/zircon/system/ulib/ftl-mtd/include/lib/ftl-mtd/nand-volume-driver.h
+++ b/zircon/system/ulib/ftl-mtd/include/lib/ftl-mtd/nand-volume-driver.h
@@ -39,6 +39,8 @@
   int NandErase(uint32_t page_num);
   int IsBadBlock(uint32_t page_num);
   bool IsEmptyPage(uint32_t page_num, const uint8_t* page_buffer, const uint8_t* oob_buffer);
+  uint32_t PageSize() final;
+  uint8_t SpareSize() final;
 
   DISALLOW_COPY_ASSIGN_AND_MOVE(NandVolumeDriver);
 
@@ -54,8 +56,6 @@
   uint32_t GetByteOffsetForPage(uint32_t real_page);
 
   uint32_t ByteOffset();
-  uint32_t MappedPageSize();
-  uint32_t MappedOobSize();
 
   uint32_t block_offset_;
   uint32_t page_multiplier_;
diff --git a/zircon/system/ulib/ftl-mtd/nand-volume-driver.cc b/zircon/system/ulib/ftl-mtd/nand-volume-driver.cc
index f9caf6e..b1cfb4a 100644
--- a/zircon/system/ulib/ftl-mtd/nand-volume-driver.cc
+++ b/zircon/system/ulib/ftl-mtd/nand-volume-driver.cc
@@ -41,7 +41,8 @@
 NandVolumeDriver::NandVolumeDriver(uint32_t block_offset, uint32_t max_bad_blocks,
                                    uint32_t page_multiplier,
                                    std::unique_ptr<mtd::NandInterface> interface)
-    : block_offset_(block_offset),
+    : NdmBaseDriver(ftl::DefaultLogger()),
+      block_offset_(block_offset),
       page_multiplier_(page_multiplier),
       max_bad_blocks_(max_bad_blocks),
       interface_(std::move(interface)) {}
@@ -54,8 +55,8 @@
       // This should be 2%, but that is of the whole device, not just this partition.
       .max_bad_blocks = max_bad_blocks_,
       .block_size = interface_->BlockSize(),
-      .page_size = MappedPageSize(),
-      .eb_size = MappedOobSize(),
+      .page_size = PageSize(),
+      .eb_size = SpareSize(),
       .flags = 0  // Same as FSF_DRVR_PAGES (current default).
   };
 
@@ -155,7 +156,7 @@
 
 bool NandVolumeDriver::IsEmptyPage(uint32_t page_num, const uint8_t* page_buffer,
                                    const uint8_t* oob_buffer) {
-  return IsEmptyPageImpl(page_buffer, MappedPageSize(), oob_buffer, MappedOobSize());
+  return IsEmptyPageImpl(page_buffer, PageSize(), oob_buffer, SpareSize());
 }
 
 zx_status_t NandVolumeDriver::ReadPageAndOob(uint32_t byte_offset, void* page_buffer,
@@ -208,8 +209,8 @@
 
 uint32_t NandVolumeDriver::ByteOffset() { return block_offset_ * interface_->BlockSize(); }
 
-uint32_t NandVolumeDriver::MappedPageSize() { return page_multiplier_ * interface_->PageSize(); }
+uint32_t NandVolumeDriver::PageSize() { return page_multiplier_ * interface_->PageSize(); }
 
-uint32_t NandVolumeDriver::MappedOobSize() { return page_multiplier_ * interface_->OobSize(); }
+uint8_t NandVolumeDriver::SpareSize() { return page_multiplier_ * interface_->OobSize(); }
 
 }  // namespace ftl_mtd
diff --git a/zircon/system/ulib/ftl-mtd/test/ftl-volume-wrapper-tests.cc b/zircon/system/ulib/ftl-mtd/test/ftl-volume-wrapper-tests.cc
index 26cf298..779a7393 100644
--- a/zircon/system/ulib/ftl-mtd/test/ftl-volume-wrapper-tests.cc
+++ b/zircon/system/ulib/ftl-mtd/test/ftl-volume-wrapper-tests.cc
@@ -99,7 +99,8 @@
 
     ftl_volume_wrapper_ = std::make_unique<FtlVolumeWrapper>(std::move(volume));
     volume_->set_ftl_instance(ftl_volume_wrapper_.get());
-    ASSERT_OK(ftl_volume_wrapper_->Init(std::unique_ptr<ftl::NdmBaseDriver>()));
+    ASSERT_OK(
+        ftl_volume_wrapper_->Init(std::unique_ptr<ftl::NdmBaseDriver>(ftl::DefaultLogger())));
     ASSERT_TRUE(volume_->initialized());
   }
 
diff --git a/zircon/system/ulib/ftl/BUILD.gn b/zircon/system/ulib/ftl/BUILD.gn
index 2886026..60e88424b 100644
--- a/zircon/system/ulib/ftl/BUILD.gn
+++ b/zircon/system/ulib/ftl/BUILD.gn
@@ -37,6 +37,7 @@
     "ftln/ftln_intrnl.c",
     "ftln/ftln_rd.c",
     "ftln/ftln_util.c",
+    "ftln/stats.c",
     "ftln/ndm-driver.cc",
     "ftln/volume.cc",
     "ndm/ndm_init.c",
diff --git a/zircon/system/ulib/ftl/ftl.h b/zircon/system/ulib/ftl/ftl.h
index 7741d27..132f03b 100644
--- a/zircon/system/ulib/ftl/ftl.h
+++ b/zircon/system/ulib/ftl/ftl.h
@@ -5,6 +5,7 @@
 #ifndef ZIRCON_SYSTEM_ULIB_FTL_FTL_H_
 #define ZIRCON_SYSTEM_ULIB_FTL_FTL_H_
 
+#include <lib/ftl/logger.h>
 #include <stdint.h>
 #include <zircon/compiler.h>
 
@@ -189,18 +190,6 @@
 typedef struct ndm* NDM;
 typedef const struct ndm* CNDM;
 
-typedef void (*LogFunction)(const char*, int, const char*, ...) __PRINTFLIKE(3, 4);
-
-typedef struct {
-  // Logger interface for different log levels.
-  LogFunction trace;
-  LogFunction debug;
-  LogFunction info;
-  LogFunction warning;
-  LogFunction error;
-  LogFunction fatal;
-} Logger;
-
 // FTL NDM structure holding all driver information.
 typedef struct {
   uint32_t block_size;        // Size of a block in bytes.
@@ -213,7 +202,7 @@
   uint32_t read_wear_limit;   // Device read-wear limit.
   void* ndm;                  // Driver's NDM pointer.
   uint32_t flags;             // Option flags.
-  Logger logger;
+  FtlLogger logger;
 } FtlNdmVol;
 
 // TargetNDM Configuration Structure.
@@ -252,7 +241,7 @@
   int (*rd_raw_spare)(uint32_t p, uint8_t* spare, void* dev);
   int (*rd_raw_page)(uint32_t p, void* data, void* dev);
 #endif
-  Logger logger;
+  FtlLogger logger;
 } NDMDrvr;
 
 // Driver count statistics for TargetFTL-NDM volumes.
diff --git a/zircon/system/ulib/ftl/ftln/ftln_init.c b/zircon/system/ulib/ftl/ftln/ftln_init.c
index 650c58f..680ccb9 100644
--- a/zircon/system/ulib/ftl/ftln/ftln_init.c
+++ b/zircon/system/ulib/ftl/ftln/ftln_init.c
@@ -203,8 +203,8 @@
 
             // If page is erased or invalid, return its status.
             if (status != NDM_PAGE_VALID) {
-              ftl->logger.warning(__FILE__, __LINE__,
-                                  "Erased or Invalid page found in erase block list.");
+              ftl->logger.warn(__FILE__, __LINE__,
+                               "Erased or Invalid page found in erase block list.");
               return status;
             }
 
@@ -345,10 +345,10 @@
       if (po == 0) {
         bc = GET_SA_BC(ftl->spare_buf);
       } else if (bc != GET_SA_BC(ftl->spare_buf)) {
-#if FTLN_DEBUG > 1
-        ftl->logger.debug(__FILE__, __LINE__, "build_map: b = %u, po = %u, i_bc = %u vs 0_bc = %u",
-                          b, po, GET_SA_BC(ftl->spare_buf), bc);
-#endif
+        if (ftln_debug() > 1) {
+          ftl->logger.debug(__FILE__, __LINE__, "build_map: b = %u, po = %u, i_bc = %u vs 0_bc = %u",
+                            b, po, GET_SA_BC(ftl->spare_buf), bc);
+        }
 
         // Should not be, but page is invalid. Break to skip block.
         break;
@@ -364,10 +364,10 @@
       // Retrieve MPN and check that it is valid.
       mpn = GET_SA_VPN(ftl->spare_buf);
       if (mpn > ftl->num_map_pgs) {
-#if FTLN_DEBUG > 1
-        ftl->logger.debug(__FILE__, __LINE__, "build_map: b = %u, po = %u, mpn = %u, max = %u", b,
-                          po, mpn, ftl->num_map_pgs);
-#endif
+        if (ftln_debug() > 1) {
+          ftl->logger.debug(__FILE__, __LINE__, "build_map: b = %u, po = %u, mpn = %u, max = %u", b,
+                            po, mpn, ftl->num_map_pgs);
+        }
 
         // Should not be, but page is invalid. Break to skip block.
         break;
@@ -392,10 +392,10 @@
           PfAssert(IS_MAP_BLK(ftl->bdata[b]));
           INC_USED(ftl->bdata[b]);
         }
-#if FTLN_DEBUG > 1
-        ftl->logger.debug(__FILE__, __LINE__, "build_map: mpn = %u, old_pn = %d, new_pn = %u", mpn,
-                          ftl->mpns[mpn], b * ftl->pgs_per_blk + po);
-#endif
+        if (ftln_debug() > 1) {
+          ftl->logger.debug(__FILE__, __LINE__, "build_map: mpn = %u, old_pn = %d, new_pn = %u", mpn,
+                            ftl->mpns[mpn], b * ftl->pgs_per_blk + po);
+        }
 
         // Save the map page number and (temporarily) the block count.
         ftl->mpns[mpn] = b * ftl->pgs_per_blk + po;
@@ -424,9 +424,9 @@
     if (pn == (ui32)-1)
       continue;
 
-#if FTLN_DEBUG > 1
-    ftl->logger.debug(__FILE__, __LINE__, "  -> MPN[%2u] = %u", mpn, pn);
-#endif
+    if (ftln_debug() > 1) {
+      ftl->logger.debug(__FILE__, __LINE__, "  -> MPN[%2u] = %u", mpn, pn);
+    }
 
     // Read map page. Return -1 if error.
     if (FtlnRdPage(ftl, pn, ftl->main_buf))
@@ -490,10 +490,10 @@
       }
     }
   }
-#if FTLN_DEBUG > 1
-  ftl->logger.debug(__FILE__, __LINE__, "volume block %d has lowest used page offset (%d)\n",
-                    ftl->resume_vblk, ftl->resume_po);
-#endif
+  if (ftln_debug() > 1) {
+    ftl->logger.debug(__FILE__, __LINE__, "volume block %d has lowest used page offset (%d)\n",
+                      ftl->resume_vblk, ftl->resume_po);
+  }
 
   // Clean temporary use of vol block read-wear field for page offset.
   for (b = 0; b < ftl->num_blks; ++b)
@@ -844,7 +844,7 @@
     uint32_t column = i % 8;
     sprintf(line_buffer + 5 * column, "%5u", wear_lag_histogram[255 - i]);
     if (column == 7) {
-      ftl->logger.info(__FILE__, __LINE__, line_buffer);
+      ftl->logger.info(__FILE__, __LINE__, "%s", line_buffer);
     }
   }
 
@@ -1203,12 +1203,12 @@
     }
   }
 
-#if FTLN_DEBUG > 1
-  ftl->logger.debug(
-      __FILE__, __LINE__,
-      "FTL formatted successfully. [Current Generation Number = %u  Highest Wear Count = %u",
-      ftl->high_bc, ftl->high_wc);
-#endif
+  if (ftln_debug() > 1) {
+    ftl->logger.debug(
+        __FILE__, __LINE__,
+        "FTL formatted successfully. [Current Generation Number = %u  Highest Wear Count = %u",
+        ftl->high_bc, ftl->high_wc);
+  }
 
   // Do recycles if needed and return status.
   return FtlnRecCheck(ftl, 0);
@@ -1221,10 +1221,10 @@
 static void free_ftl(void* vol) {
   FTLN ftl = vol;
 
-#if FTLN_DEBUG > 1
-  // Display FTL statistics.
-  FtlnStats(ftl);
-#endif
+  if (ftln_debug() > 1) {
+    // Display FTL statistics.
+    FtlnStats(ftl);
+  }
 
   // Free FTL memory allocations.
   if (ftl->bdata)
@@ -1452,10 +1452,10 @@
   ftl->num_map_pgs = 1 + (ftl->num_vpages + ftl->mappings_per_mpg - 1) / ftl->mappings_per_mpg;
   PfAssert(ftl->num_vpages / ftl->mappings_per_mpg < ftl->num_map_pgs);
 
-#if FTLN_DEBUG > 1
-  ftl->logger.debug(__FILE__, __LINE__, "Volume Pages = %u. FTL pages = %u. %u%% usage",
-                    ftl->num_vpages, ftl->num_pages, (ftl->num_vpages * 100) / ftl->num_pages);
-#endif
+  if (ftln_debug() > 1) {
+    ftl->logger.debug(__FILE__, __LINE__, "Volume Pages = %u. FTL pages = %u. %u%% usage",
+                      ftl->num_vpages, ftl->num_pages, (ftl->num_vpages * 100) / ftl->num_pages);
+  }
 
   // Allocate one or two main data pages and spare buffers. Max spare
   // use is one block worth of spare areas for multi-page writes.
@@ -1554,10 +1554,10 @@
   ftl->wear_data.lft_max_lag = ftl->wear_data.cur_max_lag;
   ftl->wear_data.avg_wc_lag = ftl->wc_lag_sum / ftl->num_blks;
 
-#if FTLN_DEBUG > 1
-  // Display FTL statistics.
-  FtlnStats(ftl);
-#endif
+  if (ftln_debug() > 1) {
+    // Display FTL statistics.
+    FtlnStats(ftl);
+  }
 
   // Initialize FTL interface structure.
   xfs->num_pages = ftl->num_vpages;
@@ -1567,9 +1567,9 @@
   xfs->report = FtlnReport;
   xfs->vol = ftl;
 
-#if FTLN_DEBUG > 1
-  ftl->logger.debug(__FILE__, __LINE__, "[XFS] num_pages       = %u\n\n", xfs->num_pages);
-#endif
+  if (ftln_debug() > 1) {
+    ftl->logger.debug(__FILE__, __LINE__, "[XFS] num_pages       = %u\n\n", xfs->num_pages);
+  }
 
   // Register FTL volume with user.
   if (XfsAddVol(xfs))
diff --git a/zircon/system/ulib/ftl/ftln/ftln_intrnl.c b/zircon/system/ulib/ftl/ftln/ftln_intrnl.c
index 8d6646d..c636cc9 100644
--- a/zircon/system/ulib/ftl/ftln/ftln_intrnl.c
+++ b/zircon/system/ulib/ftl/ftln/ftln_intrnl.c
@@ -583,10 +583,9 @@
 static int recycle_vblk(FTLN ftl, ui32 recycle_b) {
   ui32 pn, past_end;
 
-#if FTLN_DEBUG > 1
-  if (ftl->flags & FTLN_VERBOSE)
+  if (ftln_debug() > 1 && ftl->flags & FTLN_VERBOSE) {
     printf("recycle_vblk: block# %u\n", recycle_b);
-#endif
+  }
 
   // Transfer all used pages from recycle block to free block.
   pn = recycle_b * ftl->pgs_per_blk;
@@ -924,10 +923,9 @@
 int FtlnRecycleMapBlk(FTLN ftl, ui32 recycle_b) {
   ui32 i, pn;
 
-#if FTLN_DEBUG > 1
-  if (ftl->flags & FTLN_VERBOSE)
+  if (ftln_debug() > 1 && ftl->flags & FTLN_VERBOSE) {
     printf("FtlnRecycleMapBlk: block# %u\n", recycle_b);
-#endif
+  }
 
   // Transfer all used pages from recycle block to free block.
   pn = recycle_b * ftl->pgs_per_blk;
@@ -984,6 +982,104 @@
   return 0;
 }
 
+//  FtlnCalculateSpareValidity: Returns a validity byte for the spare using
+//                              a bitwise check where each bit covers 2
+//                              bytes of the spare and 1/8th of the page data.
+//                              1 if all bytes are 0xffff and 0 otherwise.
+//                              When performing this, we ensure that the byte
+//                              this will write out to is read as 0, ensuring a
+//                              non-0xff result.
+//
+//              Inputs: spare_buf = The pointer to the spare data to be read and
+//                                  validated.
+//
+//                       data_buf = The pointer to the page data to be
+//                                  validated.
+//
+//                      page_size = The size of the data page in bytes.
+//
+//              Returns: The calculated validity byte.
+ui8 FtlnCalculateSpareValidity(const ui8* spare_buf, const ui8* data_buf, ui32 page_size) {
+  ui16* oob_to_check = (ui16*)spare_buf;
+  ui8 result = 0;
+  const ui32 page_chunk = page_size / 8;
+
+  // Only check 7/8 byte pairs and shift at the end. Since we interpret
+  // where this check byte goes as zero, so it will always be a zero.
+  for (ui32 i = 0; i < 7; i++) {
+    if (oob_to_check[i] == 0xffff) {
+      // Breaking 32 bit constraint here, because fuchsia expects at least 64
+      // bit support anyways. Allows us to move at 8 byte strides.
+      uint64_t* data_to_check = (uint64_t*)&data_buf[page_chunk * i];
+      for (ui32 j = 0; j < page_chunk / 8; j++) {
+        if (data_to_check[j] != 0xffffffffffffffff) {
+          break;
+        }
+      }
+      result |= 1;
+    }
+    result <<= 1;
+  }
+  return result;
+}
+
+//  FtlnSetSpareValidity: Sets the last validity byte of the spare to the
+//                        result of FtlnCalculateSpareValidity.
+//
+//              Inputs: spare_buf = The pointer to the spare data to be read and
+//                                  updated.
+//
+//                       data_buf = The pointer to the page data to be
+//                                  validated.
+//
+//                      page_size = The size of the data page in bytes.
+//
+void FtlnSetSpareValidity(ui8* spare_buf, const ui8* data_buf, ui32 page_size) {
+  spare_buf[14] = FtlnCalculateSpareValidity(spare_buf, data_buf, page_size);
+}
+
+//  FtlnSetSpareValidity: Verifies that the last validity byte of the spare is
+//                        the result of FtlnCalculateSpareValidity.
+//
+//              Inputs: spare_buf = The pointer to the spare data to be read and
+//                                  validated.
+//
+//                       data_buf = The pointer to the page data to be
+//                                  validated.
+//
+//                      page_size = The size of the data page in bytes.
+//
+//              Returns: 1 if true, and 0 if false.
+//
+int FtlnCheckSpareValidity(const ui8* spare_buf, const ui8* data_buf, ui32 page_size) {
+  return spare_buf[14] == FtlnCalculateSpareValidity(spare_buf, data_buf, page_size);
+}
+
+//  FtlnIncompleteWrite: Verifies a complete write by checking the validity
+//                       byte if populated, otherwise checks that wear count
+//                       isn't maxed out. The wear count is used as a less
+//                       reliable, but reverse-compatible check for
+//                       incomplete oob data for before the validity byte was
+//                       used.
+//
+//              Inputs: spare_buf = The pointer to the spare data to be read and
+//                                  validated.
+//
+//                       data_buf = The pointer to the page data to be
+//                                  validated.
+//
+//                      page_size = The size of the data page in bytes.
+//
+//              Returns: 1 if incomplete write detected, and 0 if otherwise.
+//
+int FtlnIncompleteWrite(const ui8* spare_buf, const ui8* data_buf, ui32 page_size) {
+  if (spare_buf[14] != 0xff) {
+    return !FtlnCheckSpareValidity(spare_buf, data_buf, page_size);
+  } else {
+    return GET_SA_WC(spare_buf) == 0xfffffff ? 1 : 0;
+  }
+}
+
 //  FtlnMetaWr: Write FTL meta information page
 //
 //      Inputs: ftl = pointer to FTL control block
@@ -1032,14 +1128,13 @@
     // Count number of times any recycle is done in FtlnRecCheck().
     ++ftl->recycle_needed;
 
-#if FTLN_DEBUG > 1
-    if (ftl->flags & FTLN_VERBOSE)
+    if (ftln_debug() > 1 && ftl->flags & FTLN_VERBOSE) {
       printf(
           "\n0 rec begin: free vpn = %5u (%3u), free mpn = %5u (%3u)"
           " free blocks = %2u\n",
           ftl->free_vpn, free_vol_list_pgs(ftl), ftl->free_mpn, free_map_list_pgs(ftl),
           ftl->num_free_blks);
-#endif
+    }
 
     // Loop until enough pages are free.
     for (count = 1;; ++count) {
@@ -1055,20 +1150,19 @@
       // Record the highest number of consecutive recycles.
       if (ftl->wear_data.max_consec_rec < count) {
         ftl->wear_data.max_consec_rec = count;
-#if FTLN_DEBUG > 2
-        printf("max_consec_rec=%u, avg_wc_lag=%u\n", ftl->wear_data.max_consec_rec,
-               ftl->wear_data.avg_wc_lag);
-#endif
+        if (ftln_debug() > 2) {
+          printf("max_consec_rec=%u, avg_wc_lag=%u\n", ftl->wear_data.max_consec_rec,
+                 ftl->wear_data.avg_wc_lag);
+        }
       }
 
-#if FTLN_DEBUG > 1
-      if (ftl->flags & FTLN_VERBOSE)
+      if (ftln_debug() > 1 && ftl->flags & FTLN_VERBOSE) {
         printf(
             "%u rec begin: free vpn = %5u (%3u), free mpn = %5u (%3u)"
             " free blocks = %2u\n",
             count, ftl->free_vpn, free_vol_list_pgs(ftl), ftl->free_mpn, free_map_list_pgs(ftl),
             ftl->num_free_blks);
-#endif
+      }
 
       // Break if enough pages have been freed.
       if (FtlnRecNeeded(ftl, wr_cnt) == FALSE)
@@ -1085,10 +1179,10 @@
       // Ensure we haven't recycled too many times.
       PfAssert(count <= 2 * ftl->num_blks);
       if (count > 2 * ftl->num_blks) {
-#if FTLN_DEBUG
-        printf("FTL NDM too many consec recycles = %u\n", count);
-        FtlnBlkStats(ftl);
-#endif
+        if (ftln_debug() > 0) {
+          printf("FTL NDM too many consec recycles = %u\n", count);
+          FtlnBlkStats(ftl);
+        }
         return FsError2(FTL_RECYCLE_CNT, ENOSPC);
       }
     }
diff --git a/zircon/system/ulib/ftl/ftln/ftln_rd.c b/zircon/system/ulib/ftl/ftln/ftln_rd.c
index a2434f9..61fbc8e 100644
--- a/zircon/system/ulib/ftl/ftln/ftln_rd.c
+++ b/zircon/system/ulib/ftl/ftln/ftln_rd.c
@@ -73,7 +73,8 @@
 
   // Ensure request is within volume's range of provided pages.
   if (vpn + count > ftl->num_vpages) {
-    ftl->logger.error(__FILE__, __LINE__, "FTL Read failed. Attempting to read page %u is out of range(max %u).",
+    ftl->logger.error(__FILE__, __LINE__,
+                      "FTL Read failed. Attempting to read page %u is out of range(max %u).",
                       vpn + count - 1, ftl->num_pages - 1);
     return FsError2(FTL_ASSERT, ENOSPC);
   }
@@ -85,7 +86,7 @@
   // If there's at least a block with a maximum read count, recycle.
   if (ftl->max_rc_blk != (ui32)-1)
     if (FtlnRecCheck(ftl, 0)) {
-      ftl->logger.error(__FILE__, __LINE__, "FTL read recycle failed for page %u.");
+      ftl->logger.error(__FILE__, __LINE__, "FTL read recycle failed");
       return -1;
     }
 
diff --git a/zircon/system/ulib/ftl/ftln/ftln_util.c b/zircon/system/ulib/ftl/ftln/ftln_util.c
index 53324b4..f5cc8af 100644
--- a/zircon/system/ulib/ftl/ftln/ftln_util.c
+++ b/zircon/system/ulib/ftl/ftln/ftln_util.c
@@ -263,11 +263,11 @@
       }
 #endif  // INC_ELIST
 
-#if FTLN_DEBUG > 1
-      // Display FTL statistics.
-      FtlnStats(ftl);
-      FtlnBlkStats(ftl);
-#endif
+      if (ftln_debug() > 1) {
+        // Display FTL statistics.
+        FtlnStats(ftl);
+        FtlnBlkStats(ftl);
+      }
 
       // Return success.
       return 0;
@@ -372,14 +372,14 @@
       ftl->stats.ram_used = sizeof(struct ftln) + ftl->num_map_pgs * sizeof(ui32) + ftl->page_size +
                             ftl->eb_size * ftl->pgs_per_blk + ftlmcRAM(ftl->map_cache) +
                             ftl->num_blks * (sizeof(ui32) + sizeof(ui8));
-#if FTLN_DEBUG > 1
-      printf("TargetFTL-NDM RAM usage:\n");
-      printf(" - sizeof(Ftln) : %u\n", (int)sizeof(FTLN));
-      printf(" - tmp buffers  : %u\n", ftl->page_size + ftl->eb_size * ftl->pgs_per_blk);
-      printf(" - map pages    : %u\n", ftl->num_map_pgs * 4);
-      printf(" - map cache    : %u\n", ftlmcRAM(ftl->map_cache));
-      printf(" - bdata[]      : %u\n", ftl->num_blks * (int)(sizeof(ui32) + sizeof(ui8)));
-#endif
+      if (ftln_debug() > 1) {
+        printf("TargetFTL-NDM RAM usage:\n");
+        printf(" - sizeof(Ftln) : %u\n", (int)sizeof(FTLN));
+        printf(" - tmp buffers  : %u\n", ftl->page_size + ftl->eb_size * ftl->pgs_per_blk);
+        printf(" - map pages    : %u\n", ftl->num_map_pgs * 4);
+        printf(" - map cache    : %u\n", ftlmcRAM(ftl->map_cache));
+        printf(" - bdata[]      : %u\n", ftl->num_blks * (int)(sizeof(ui32) + sizeof(ui8)));
+      }
 
       const int kNumBuckets = sizeof(buf->wear_histogram) / sizeof(ui32);
       PfAssert(kNumBuckets == 20);
@@ -412,13 +412,13 @@
         return FsError2(FTL_MOUNTED, EEXIST);
       ftl->flags |= FTLN_MOUNTED;
 
-#if FTLN_DEBUG > 1
-      // Display FTL statistics.
-      FtlnStats(ftl);
-      FtlnBlkStats(ftl);
-#elif FTLN_DEBUG
-      printf("FTL: total blocks: %u, free blocks: %u\n", ftl->num_blks, ftl->num_free_blks);
-#endif
+      if (ftln_debug() > 1) {
+        // Display FTL statistics.
+        FtlnStats(ftl);
+        FtlnBlkStats(ftl);
+      } else {
+        printf("FTL: total blocks: %u, free blocks: %u\n", ftl->num_blks, ftl->num_free_blks);
+      }
 
       // Return success.
       return 0;
@@ -440,9 +440,9 @@
   if (ftl->free_vpn != (ui32)-1) {
     ui32 pn = ndmPastPrevPair(ftl->ndm, ftl->free_vpn);
 
-#if FTLN_DEBUG
-    printf("FtlnMlcSafeFreeVpn: old free = %u, new free = %u\n", ftl->free_vpn, pn);
-#endif
+    if (ftln_debug() > 0) {
+      printf("FtlnMlcSafeFreeVpn: old free = %u, new free = %u\n", ftl->free_vpn, pn);
+    }
     ftl->free_vpn = pn;
   }
 }
@@ -654,10 +654,10 @@
   FtlnStateRst(ftl);
   ftl->high_bc = 1;  // initial block count of unformatted volumes
 
-#if FTLN_DEBUG
-  // Display FTL statistics.
-  FtlnBlkStats(ftl);
-#endif
+  if (ftln_debug() > 0) {
+    // Display FTL statistics.
+    FtlnBlkStats(ftl);
+  }
 
   // Return success.
   return 0;
@@ -703,14 +703,14 @@
   PfAssert(!IS_FREE(ftl->bdata[b]));
   DEC_USED(ftl->bdata[b]);
 
-#if FTLN_DEBUG
-  // Read page spare area and assert VPNs match.
-  ++ftl->stats.read_spare;
-  // Ignore errors here.
-  if (ndmReadSpare(ftl->start_pn + pn, ftl->spare_buf, ftl->ndm) >= 0) {
-    PfAssert(GET_SA_VPN(ftl->spare_buf) == vpn);
+  if (ftln_debug() > 0) {
+    // Read page spare area and assert VPNs match.
+    ++ftl->stats.read_spare;
+    // Ignore errors here.
+    if (ndmReadSpare(ftl->start_pn + pn, ftl->spare_buf, ftl->ndm) >= 0) {
+      PfAssert(GET_SA_VPN(ftl->spare_buf) == vpn);
+    }
   }
-#endif
 }  // lint !e818
 
 //  FtlnFatErr: Process FTL-NDM fatal error
@@ -805,107 +805,6 @@
   return wear_data;
 }
 
-#if FTLN_DEBUG
-// flush_bstat: Flush buffered statistics counts
-//
-//      Inputs: ftl = pointer to FTL control block
-//              b = block number of current block
-//              type = "FREE", "MAP", or "VOLUME"
-//  In/Outputs: *blk0 = first consecutive block number or -1
-//              *blke = end consecutive block number
-//
-static void flush_bstat(CFTLN ftl, int* blk0, int* blke, int b, const char* type) {
-  if (*blk0 == -1)
-    *blk0 = *blke = b;
-  else if (*blke + 1 == b)
-    *blke = b;
-  else {
-    printf("B = %4u", *blk0);
-    if (*blk0 == *blke) {
-      printf(" - used = %2u, wc lag = %3d, rc = %8u", NUM_USED(ftl->bdata[*blk0]),
-             ftl->blk_wc_lag[*blk0], GET_RC(ftl->bdata[*blk0]));
-      printf(" - %s BLOCK\n", type);
-    } else {
-      printf("-%-4u", *blke);
-      printf("%*s", 37, " ");
-      printf("- %s BLOCKS\n", type);
-    }
-    *blk0 = *blke = b;
-  }
-}
-
-// FtlnBlkStats: Debug function to display blocks statistics
-//
-//       Input: ftl = pointer to FTL control block
-//
-void FtlnBlkStats(CFTLN ftl) {
-  int free0 = -1, freee, vol0 = -1, vole;
-  ui32 b;
-
-  printf(
-      "\nBLOCK STATS: %u blocks, %u pages per block, curr free "
-      "blocks = %u\n",
-      ftl->num_blks, ftl->pgs_per_blk, ftl->num_free_blks);
-
-  // Loop over FTL blocks.
-  for (b = 0; b < ftl->num_blks; ++b) {
-    // Check if block is free.
-    if (IS_FREE(ftl->bdata[b])) {
-      flush_bstat(ftl, &vol0, &vole, -1, "VOLUME");
-      flush_bstat(ftl, &free0, &freee, b, "FREE");
-    }
-
-    // Else check if map block.
-    else if (IS_MAP_BLK(ftl->bdata[b])) {
-      flush_bstat(ftl, &free0, &freee, -1, "FREE");
-      flush_bstat(ftl, &vol0, &vole, -1, "VOLUME");
-      printf("B = %4u - used = %2u, wc lag = %3d, rc = %8u - ", b, NUM_USED(ftl->bdata[b]),
-             ftl->blk_wc_lag[b], GET_RC(ftl->bdata[b]));
-      printf("MAP BLOCK\n");
-    }
-
-    // Else is volume block.
-    else {
-      flush_bstat(ftl, &free0, &freee, -1, "FREE");
-#if FTLN_DEBUG <= 1
-      flush_bstat(ftl, &vol0, &vole, b, "VOLUME");
-#else
-      printf("B = %4u - used = %2u, wc lag = %3d, rc = %8u - ", b, NUM_USED(ftl->bdata[b]),
-             ftl->blk_wc_lag[b], GET_RC(ftl->bdata[b]));
-      printf("VOLUME BLOCK\n");
-#endif
-    }
-  }
-  flush_bstat(ftl, &free0, &freee, -1, "FREE");
-  flush_bstat(ftl, &vol0, &vole, -1, "VOLUME");
-}
-#endif  // FTLN_DEBUG
-
-#if FTLN_DEBUG > 1
-//   FtlnStats: Display FTL statistics
-//
-//       Input: ftl = pointer to FTL control block
-//
-void FtlnStats(FTLN ftl) {
-  ui32 b, n;
-
-  printf("\nFTL STATS:\n");
-  printf("  - # vol pages    = %d\n", ftl->num_vpages);
-  printf("  - # map pages    = %d\n", ftl->num_map_pgs);
-  printf("  - # free blocks  = %d\n", ftl->num_free_blks);
-  for (n = b = 0; b < ftl->num_blks; ++b)
-    if (IS_ERASED(ftl->bdata[b]))
-      ++n;
-  printf("  - # erased blks  = %d\n", n);
-  printf("  - flags =");
-  if (ftl->flags & FTLN_FATAL_ERR)
-    printf(" FTLN_FATAL_ERR");
-  if (ftl->flags & FTLN_MOUNTED)
-    printf(" FTLN_MOUNTED");
-  putchar('\n');
-}
-#endif  // FTLN_DEBUG
-
 #if DEBUG_ELIST
 // FtlnCheckBlank: Ensure the specified block is blank
 //
diff --git a/zircon/system/ulib/ftl/ftln/ftlnp.h b/zircon/system/ulib/ftl/ftln/ftlnp.h
index b759c6a..7ad5554 100644
--- a/zircon/system/ulib/ftl/ftln/ftlnp.h
+++ b/zircon/system/ulib/ftl/ftln/ftlnp.h
@@ -28,6 +28,13 @@
 #define FTLN_3B_PN TRUE  // If true, use 3B page numbers.
 #endif
 
+// Prefer to use this function rather than #if FTLN_DEBUG directly because this will
+// ensure what's within will actually build whilst any reasonable compiler will ensure
+// the code is not actually included.
+static inline int ftln_debug() {
+  return FTLN_DEBUG;
+}
+
 //
 // Symbol Definitions.
 //
@@ -215,8 +222,7 @@
 #endif
   char vol_name[FTL_NAME_MAX];  // Volume name.
 
-  // Logger used by the FTL.
-  Logger logger;
+  FtlLogger logger;
 };
 
 __BEGIN_CDECLS
@@ -245,6 +251,10 @@
 int FtlnRecNeeded(CFTLN ftl, int wr_cnt);
 int FtlnRdPage(FTLN ftl, ui32 pn, void* buf);
 
+ui8 FtlnCalculateSpareValidity(const ui8* spare_buf, const ui8* data_buf, ui32 page_size);
+void FtlnSetSpareValidity(ui8* spare_buf, const ui8* data_buf, ui32 page_size);
+int FtlnCheckSpareValidity(const ui8* spare_bu, const ui8* data_buf, ui32 page_size);
+int FtlnIncompleteWrite(const ui8* spare_buf, const ui8* data_buf, ui32 page_size);
 int FtlnMapWr(void* vol, ui32 mpn, void* buf);
 int FtlnMetaWr(FTLN ftl, ui32 type);
 
diff --git a/zircon/system/ulib/ftl/ftln/ndm-driver.cc b/zircon/system/ulib/ftl/ftln/ndm-driver.cc
index ddc1609..2f42106 100644
--- a/zircon/system/ulib/ftl/ftln/ndm-driver.cc
+++ b/zircon/system/ulib/ftl/ftln/ndm-driver.cc
@@ -11,6 +11,7 @@
 
 #include "ftl.h"
 #include "ftl_private.h"
+#include "ftlnp.h"
 #include "ndm/ndmp.h"
 
 namespace ftl {
@@ -93,6 +94,10 @@
 int WritePages(uint32_t page, uint32_t count, const uint8_t* data, uint8_t* spare, int action,
                void* dev) {
   NdmDriver* device = reinterpret_cast<NdmDriver*>(dev);
+  for (uint32_t i = 0; i < count; i++) {
+    FtlnSetSpareValidity(&spare[i * device->SpareSize()], &data[i * device->PageSize()],
+                         device->PageSize());
+  }
   return device->NandWrite(page, count, data, spare);
 }
 
@@ -129,13 +134,14 @@
 // Returns kNdmOk or kNdmError, but kNdmError implies aborting initialization.
 int CheckPage(uint32_t page, uint8_t* data, uint8_t* spare, int* status, void* dev) {
   int result = ReadPagesImpl(page, 1, data, spare, dev);
+  NdmDriver* device = reinterpret_cast<NdmDriver*>(dev);
 
-  if (result == kNdmUncorrectableEcc || result == kNdmFatalError) {
+  if (result == kNdmUncorrectableEcc || result == kNdmFatalError ||
+      device->IncompletePageWrite(spare, data)) {
     *status = NDM_PAGE_INVALID;
     return kNdmOk;
   }
 
-  NdmDriver* device = reinterpret_cast<NdmDriver*>(dev);
   bool empty = device->IsEmptyPage(page, data, spare) ? kTrue : kFalse;
 
   *status = empty ? NDM_PAGE_ERASED : NDM_PAGE_VALID;
@@ -187,20 +193,18 @@
   fprintf(stderr, "\n");
 }
 
-Logger GetDefaultLogger() {
-  Logger logger = {
+}  // namespace
+
+FtlLogger DefaultLogger() {
+  return FtlLogger{
       .trace = &LogTrace,
       .debug = &LogDebug,
       .info = &LogInfo,
-      .warning = &LogWarning,
+      .warn = &LogWarning,
       .error = &LogError,
   };
-
-  return logger;
 }
 
-}  // namespace
-
 NdmBaseDriver::~NdmBaseDriver() { RemoveNdmVolume(); }
 
 bool NdmBaseDriver::IsNdmDataPresent(const VolumeOptions& options, bool use_format_v2) {
@@ -229,14 +233,6 @@
 
 const char* NdmBaseDriver::CreateNdmVolume(const Volume* ftl_volume, const VolumeOptions& options,
                                            bool save_volume_data) {
-  return CreateNdmVolumeWithLogger(ftl_volume, options, save_volume_data, std::nullopt);
-}
-
-const char* NdmBaseDriver::CreateNdmVolumeWithLogger(const Volume* ftl_volume,
-                                                     const VolumeOptions& options,
-                                                     bool save_volume_data,
-                                                     std::optional<LoggerProxy> logger) {
-  logger_ = logger;
   if (!ndm_) {
     IsNdmDataPresent(options, save_volume_data);
   }
@@ -254,7 +250,7 @@
   ftl.cached_map_pages = options.num_blocks * (options.block_size / options.page_size);
   ftl.extra_free = 6;  // Over-provision 6% of the device.
   xfs.ftl_volume = const_cast<Volume*>(ftl_volume);
-  ftl.logger = ndm_->logger;
+  ftl.logger = logger_;
 
   partition.exploded.basic_data.num_blocks = ndmGetNumVBlocks(ndm_);
   strncpy(partition.exploded.basic_data.name, "ftl", sizeof(partition.exploded.basic_data.name));
@@ -375,29 +371,15 @@
   driver->data_and_spare_check = CheckPage;
   driver->erase_block = EraseBlock;
   driver->is_block_bad = IsBadBlockImpl;
-  driver->logger = GetDefaultLogger();
+  driver->logger = logger_;
+}
 
-  if (logger_.has_value()) {
-    if (logger_->trace != nullptr) {
-      driver->logger.trace = logger_->trace;
-    }
+uint32_t NdmBaseDriver::PageSize() { return ndm_->page_size; }
 
-    if (logger_->debug != nullptr) {
-      driver->logger.debug = logger_->debug;
-    }
+uint8_t NdmBaseDriver::SpareSize() { return ndm_->eb_size; }
 
-    if (logger_->info != nullptr) {
-      driver->logger.info = logger_->info;
-    }
-
-    if (logger_->warn != nullptr) {
-      driver->logger.warning = logger_->warn;
-    }
-
-    if (logger_->error != nullptr) {
-      driver->logger.error = logger_->error;
-    }
-  }
+bool NdmBaseDriver::IncompletePageWrite(uint8_t* spare, uint8_t* data) {
+  return FtlnIncompleteWrite(spare, data, PageSize());
 }
 
 __EXPORT
diff --git a/zircon/system/ulib/ftl/ftln/stats.c b/zircon/system/ulib/ftl/ftln/stats.c
new file mode 100644
index 0000000..54c9e894
--- /dev/null
+++ b/zircon/system/ulib/ftl/ftln/stats.c
@@ -0,0 +1,103 @@
+// Copyright 2021 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ftl.h"
+#include "ftlnp.h"
+
+// flush_bstat: Flush buffered statistics counts
+//
+//      Inputs: ftl = pointer to FTL control block
+//              b = block number of current block
+//              type = "FREE", "MAP", or "VOLUME"
+//  In/Outputs: *blk0 = first consecutive block number or -1
+//              *blke = end consecutive block number
+//
+static void flush_bstat(CFTLN ftl, int* blk0, int* blke, int b, const char* type) {
+  if (*blk0 == -1)
+    *blk0 = *blke = b;
+  else if (*blke + 1 == b)
+    *blke = b;
+  else {
+    printf("B = %4u", *blk0);
+    if (*blk0 == *blke) {
+      printf(" - used = %2u, wc lag = %3d, rc = %8u", NUM_USED(ftl->bdata[*blk0]),
+             ftl->blk_wc_lag[*blk0], GET_RC(ftl->bdata[*blk0]));
+      printf(" - %s BLOCK\n", type);
+    } else {
+      printf("-%-4u", *blke);
+      printf("%*s", 37, " ");
+      printf("- %s BLOCKS\n", type);
+    }
+    *blk0 = *blke = b;
+  }
+}
+
+// FtlnBlkStats: Debug function to display blocks statistics
+//
+//       Input: ftl = pointer to FTL control block
+//
+void FtlnBlkStats(CFTLN ftl) {
+  int free0 = -1, freee, vol0 = -1, vole;
+  ui32 b;
+
+  printf(
+      "\nBLOCK STATS: %u blocks, %u pages per block, curr free "
+      "blocks = %u\n",
+      ftl->num_blks, ftl->pgs_per_blk, ftl->num_free_blks);
+
+  // Loop over FTL blocks.
+  for (b = 0; b < ftl->num_blks; ++b) {
+    // Check if block is free.
+    if (IS_FREE(ftl->bdata[b])) {
+      flush_bstat(ftl, &vol0, &vole, -1, "VOLUME");
+      flush_bstat(ftl, &free0, &freee, b, "FREE");
+    }
+
+    // Else check if map block.
+    else if (IS_MAP_BLK(ftl->bdata[b])) {
+      flush_bstat(ftl, &free0, &freee, -1, "FREE");
+      flush_bstat(ftl, &vol0, &vole, -1, "VOLUME");
+      printf("B = %4u - used = %2u, wc lag = %3d, rc = %8u - ", b, NUM_USED(ftl->bdata[b]),
+             ftl->blk_wc_lag[b], GET_RC(ftl->bdata[b]));
+      printf("MAP BLOCK\n");
+    }
+
+    // Else is volume block.
+    else {
+      flush_bstat(ftl, &free0, &freee, -1, "FREE");
+      if (ftln_debug() <= 1) {
+        flush_bstat(ftl, &vol0, &vole, b, "VOLUME");
+      } else {
+        printf("B = %4u - used = %2u, wc lag = %3d, rc = %8u - ", b, NUM_USED(ftl->bdata[b]),
+               ftl->blk_wc_lag[b], GET_RC(ftl->bdata[b]));
+        printf("VOLUME BLOCK\n");
+      }
+    }
+  }
+  flush_bstat(ftl, &free0, &freee, -1, "FREE");
+  flush_bstat(ftl, &vol0, &vole, -1, "VOLUME");
+}
+
+//   FtlnStats: Display FTL statistics
+//
+//       Input: ftl = pointer to FTL control block
+//
+void FtlnStats(FTLN ftl) {
+  ui32 b, n;
+
+  printf("\nFTL STATS:\n");
+  printf("  - # vol pages    = %d\n", ftl->num_vpages);
+  printf("  - # map pages    = %d\n", ftl->num_map_pgs);
+  printf("  - # free blocks  = %d\n", ftl->num_free_blks);
+  for (n = b = 0; b < ftl->num_blks; ++b)
+    if (IS_ERASED(ftl->bdata[b]))
+      ++n;
+  printf("  - # erased blks  = %d\n", n);
+  printf("  - flags =");
+  if (ftl->flags & FTLN_FATAL_ERR)
+    printf(" FTLN_FATAL_ERR");
+  if (ftl->flags & FTLN_MOUNTED)
+    printf(" FTLN_MOUNTED");
+  putchar('\n');
+}
diff --git a/zircon/system/ulib/ftl/include/lib/ftl/logger.h b/zircon/system/ulib/ftl/include/lib/ftl/logger.h
new file mode 100644
index 0000000..e4cca5f
--- /dev/null
+++ b/zircon/system/ulib/ftl/include/lib/ftl/logger.h
@@ -0,0 +1,23 @@
+// Copyright 2021 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef LIB_FTL_LOGGER_H_
+#define LIB_FTL_LOGGER_H_
+
+#include <zircon/compiler.h>
+
+__BEGIN_CDECLS
+
+// Helper for overriding default logging routines.
+typedef struct FtlLogger {
+  __PRINTFLIKE(3, 4) void (*trace)(const char*, int, const char*, ...);
+  __PRINTFLIKE(3, 4) void (*debug)(const char*, int, const char*, ...);
+  __PRINTFLIKE(3, 4) void (*info)(const char*, int, const char*, ...);
+  __PRINTFLIKE(3, 4) void (*warn)(const char*, int, const char*, ...);
+  __PRINTFLIKE(3, 4) void (*error)(const char*, int, const char*, ...);
+} FtlLogger;
+
+__END_CDECLS
+
+#endif  // LIB_FTL_LOGGER_H_
diff --git a/zircon/system/ulib/ftl/include/lib/ftl/ndm-driver.h b/zircon/system/ulib/ftl/include/lib/ftl/ndm-driver.h
index 1d0d12a..35cd643 100644
--- a/zircon/system/ulib/ftl/include/lib/ftl/ndm-driver.h
+++ b/zircon/system/ulib/ftl/include/lib/ftl/ndm-driver.h
@@ -5,6 +5,7 @@
 #ifndef LIB_FTL_NDM_DRIVER_H_
 #define LIB_FTL_NDM_DRIVER_H_
 
+#include <lib/ftl/logger.h>
 #include <zircon/compiler.h>
 
 #include <cstdint>
@@ -40,14 +41,7 @@
   uint32_t flags;
 };
 
-// Helper for overriding default logging routines.
-struct LoggerProxy {
-  __PRINTFLIKE(3, 4) void (*trace)(const char*, int, const char*, ...) = nullptr;
-  __PRINTFLIKE(3, 4) void (*debug)(const char*, int, const char*, ...) = nullptr;
-  __PRINTFLIKE(3, 4) void (*info)(const char*, int, const char*, ...) = nullptr;
-  __PRINTFLIKE(3, 4) void (*warn)(const char*, int, const char*, ...) = nullptr;
-  __PRINTFLIKE(3, 4) void (*error)(const char*, int, const char*, ...) = nullptr;
-};
+FtlLogger DefaultLogger();
 
 // Encapsulates the lower layer TargetFtl-Ndm driver.
 class __EXPORT NdmDriver {
@@ -91,12 +85,22 @@
   // Returns whether a given page is empty or not. |data| and |spare| store
   // the contents of the page.
   virtual bool IsEmptyPage(uint32_t page_num, const uint8_t* data, const uint8_t* spare) = 0;
+
+  // Returns the number of bytes in a page.
+  virtual uint32_t PageSize() = 0;
+
+  // Returns the number of bytes available for spare data storage.
+  virtual uint8_t SpareSize() = 0;
+
+  // Looks at the spare  and data buffer to try to determine if the write may
+  // have been incomplete. Return true if it appears to have been incomplete.
+  virtual bool IncompletePageWrite(uint8_t* spare, uint8_t* data) = 0;
 };
 
 // Base functionality for a driver implementation.
 class __EXPORT NdmBaseDriver : public NdmDriver {
  public:
-  NdmBaseDriver() {}
+  NdmBaseDriver(FtlLogger logger) : logger_(logger) {}
   virtual ~NdmBaseDriver();
 
   // Returns true if known data appears to be present on the device. This does
@@ -126,10 +130,6 @@
   const char* CreateNdmVolume(const Volume* ftl_volume, const VolumeOptions& options,
                               bool save_volume_data = true);
 
-  // Just like |CreateNdmVolume| but provides an override for default logging routines.
-  const char* CreateNdmVolumeWithLogger(const Volume* ftl_volume, const VolumeOptions& options,
-                                        bool save_volume_data, std::optional<LoggerProxy> logger);
-
   // Deletes the underlying NDM volume.
   bool RemoveNdmVolume();
 
@@ -155,6 +155,11 @@
   // save_volume_data set to true.
   bool WriteVolumeData();
 
+  bool IncompletePageWrite(uint8_t* spare, uint8_t* data) override;
+
+  uint32_t PageSize() override;
+  uint8_t SpareSize() override;
+
  protected:
   // This is exposed for unit tests only.
   ndm* GetNdmForTest() const { return ndm_; }
@@ -165,7 +170,7 @@
  private:
   ndm* ndm_ = nullptr;
   bool volume_data_saved_ = false;
-  std::optional<LoggerProxy> logger_ = std::nullopt;
+  const FtlLogger logger_;
 };
 
 // Performs global module initialization. This is exposed to support unit tests,
diff --git a/zircon/system/ulib/ftl/ndm/ndm_init.c b/zircon/system/ulib/ftl/ndm/ndm_init.c
index 8d03b61..2fd173d 100644
--- a/zircon/system/ulib/ftl/ndm/ndm_init.c
+++ b/zircon/system/ulib/ftl/ndm/ndm_init.c
@@ -984,7 +984,7 @@
 
   // Else device is NDM formatted. Find latest control information.
   if (find_last_ctrl_info(ndm)) {
-    ndm->logger.warning(__FILE__, __LINE__, "Failed to obtain valid NDM Control Block.");
+    ndm->logger.warn(__FILE__, __LINE__, "Failed to obtain valid NDM Control Block.");
     return -1;
   }
 
@@ -1096,7 +1096,7 @@
       FsError2(NDM_RD_ECC_FAIL, EIO);
       return 1;
     }
-    ndm->logger.error(__FILE__, __LINE__, "Failed to read page %d. IO Error.");
+    ndm->logger.error(__FILE__, __LINE__, "Failed to read page %d. IO Error.", old_pn);
     FsError2(NDM_EIO, EIO);
     return -2;
   }
diff --git a/zircon/system/ulib/ftl/ndm/ndmp.h b/zircon/system/ulib/ftl/ndm/ndmp.h
index 4a6782d..24385b5 100644
--- a/zircon/system/ulib/ftl/ndm/ndmp.h
+++ b/zircon/system/ulib/ftl/ndm/ndmp.h
@@ -155,7 +155,7 @@
   int (*erase_block)(ui32 pn, void* dev);
   int (*is_block_bad)(ui32 pn, void* dev);
 
-  Logger logger;
+  FtlLogger logger;
 
   // Device Dependent Variables
   void* dev;          // optional value set by driver
diff --git a/zircon/system/ulib/ftl/test/BUILD.gn b/zircon/system/ulib/ftl/test/BUILD.gn
index 322fd2f..236a66f 100644
--- a/zircon/system/ulib/ftl/test/BUILD.gn
+++ b/zircon/system/ulib/ftl/test/BUILD.gn
@@ -22,11 +22,13 @@
     }
   }
   sources = [
+    "ftl_test.cc",
     "ndm_driver_test.cc",
     "ndm_test.cc",
   ]
   deps = [
-    "//zircon/public/lib/zxtest",
+    "//src/lib/fxl/test:gtest_main",
+    "//third_party/googletest:gtest",
     "//zircon/system/ulib/ftl",
     "//zircon/system/ulib/ftl:private_headers",
   ]
diff --git a/zircon/system/ulib/ftl/test/ftl_test.cc b/zircon/system/ulib/ftl/test/ftl_test.cc
new file mode 100644
index 0000000..ad9ac69
--- /dev/null
+++ b/zircon/system/ulib/ftl/test/ftl_test.cc
@@ -0,0 +1,52 @@
+// Copyright 2021 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <string.h>
+
+#include <gtest/gtest.h>
+
+#include "zircon/system/ulib/ftl/ftln/ftlnp.h"
+
+namespace {
+
+constexpr uint32_t kPageSize = 4096;
+constexpr uint8_t kOobSize = 16;
+
+TEST(FtlTest, IncompleteWriteWithValidity) {
+  uint8_t spare[kOobSize];
+  auto data = std::make_unique<uint8_t[]>(kPageSize);
+  memset(spare, 0xff, kOobSize);
+  memset(data.get(), 0xff, kPageSize);
+  data.get()[0] = 0;
+  FtlnSetSpareValidity(spare, data.get(), kPageSize);
+  ASSERT_FALSE(FtlnIncompleteWrite(spare, data.get(), kPageSize));
+}
+
+TEST(FtlTest, IncompleteWriteWithBadValidity) {
+  uint8_t spare[kOobSize];
+  auto data = std::make_unique<uint8_t[]>(kPageSize);
+  memset(spare, 0xff, kOobSize);
+  memset(data.get(), 0xff, kPageSize);
+  spare[14] = 0;
+  ASSERT_TRUE(FtlnIncompleteWrite(spare, data.get(), kPageSize));
+}
+
+TEST(FtlTest, IncompleteWriteNoValidityBadWearCount) {
+  uint8_t spare[kOobSize];
+  auto data = std::make_unique<uint8_t[]>(kPageSize);
+  memset(spare, 0xff, kOobSize);
+  memset(data.get(), 0xff, kPageSize);
+  ASSERT_TRUE(FtlnIncompleteWrite(spare, data.get(), kPageSize));
+}
+
+TEST(FtlTest, IncompleteWriteNoValidityGoodWearCount) {
+  uint8_t spare[kOobSize];
+  auto data = std::make_unique<uint8_t[]>(kPageSize);
+  memset(spare, 0xff, kOobSize);
+  memset(data.get(), 0xff, kPageSize);
+  spare[10] = 0;
+  ASSERT_FALSE(FtlnIncompleteWrite(spare, data.get(), kPageSize));
+}
+
+}  // namespace
diff --git a/zircon/system/ulib/ftl/test/ndm_driver_test.cc b/zircon/system/ulib/ftl/test/ndm_driver_test.cc
index 2573d9d..cd7e095 100644
--- a/zircon/system/ulib/ftl/test/ndm_driver_test.cc
+++ b/zircon/system/ulib/ftl/test/ndm_driver_test.cc
@@ -2,19 +2,19 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "lib/ftl/ndm-driver.h"
-
-#include <zxtest/zxtest.h>
+#include <gtest/gtest.h>
 
 #include "ftl_private.h"
+#include "lib/ftl/ndm-driver.h"
 
 namespace {
 
 class MockDriver final : public ftl::NdmBaseDriver {
  public:
-  MockDriver() {}
+  MockDriver() : NdmBaseDriver(ftl::DefaultLogger()) {}
   ~MockDriver() final {}
 
+  void set_incomplete(bool value) { incomplete_ = value; }
   void set_result(int result) { result_ = result; }
   void set_empty(bool value) { empty_ = value; }
 
@@ -30,25 +30,27 @@
   int NandErase(uint32_t page_num) final;
   int IsBadBlock(uint32_t page_num) final { return ftl::kFalse; }
   bool IsEmptyPage(uint32_t page_num, const uint8_t* data, const uint8_t* spare) final;
+  bool IncompletePageWrite(uint8_t* spare, uint8_t* data) final { return incomplete_; }
+  uint32_t PageSize() final { return 4096; }
+  uint8_t SpareSize() final { return 16; }
 
  private:
   int result_ = ftl::kNdmOk;
   bool empty_ = true;
+  bool incomplete_ = false;
 };
 
 int MockDriver::NandRead(uint32_t start_page, uint32_t page_count, void* page_buffer,
-                           void* oob_buffer) {
+                         void* oob_buffer) {
   return result_;
 }
 
 int MockDriver::NandWrite(uint32_t start_page, uint32_t page_count, const void* page_buffer,
-                            const void* oob_buffer) {
+                          const void* oob_buffer) {
   return result_;
 }
 
-int MockDriver::NandErase(uint32_t page_num) {
-  return result_;
-}
+int MockDriver::NandErase(uint32_t page_num) { return result_; }
 
 bool MockDriver::IsEmptyPage(uint32_t page_num, const uint8_t* data, const uint8_t* spare) {
   return empty_;
@@ -59,7 +61,7 @@
 
   NDMDrvr ndm;
   driver.GetNdmDriver(&ndm);
-  ASSERT_NOT_NULL(ndm.data_and_spare_check);
+  ASSERT_NE(nullptr, ndm.data_and_spare_check);
 
   driver.set_result(ftl::kNdmUncorrectableEcc);
 
@@ -73,7 +75,7 @@
 
   NDMDrvr ndm;
   driver.GetNdmDriver(&ndm);
-  ASSERT_NOT_NULL(ndm.data_and_spare_check);
+  ASSERT_NE(nullptr, ndm.data_and_spare_check);
 
   driver.set_result(ftl::kNdmFatalError);
 
@@ -87,7 +89,7 @@
 
   NDMDrvr ndm;
   driver.GetNdmDriver(&ndm);
-  ASSERT_NOT_NULL(ndm.data_and_spare_check);
+  ASSERT_NE(nullptr, ndm.data_and_spare_check);
 
   int status;
   EXPECT_EQ(ftl::kNdmOk, ndm.data_and_spare_check(0, nullptr, nullptr, &status, &driver));
@@ -99,7 +101,7 @@
 
   NDMDrvr ndm;
   driver.GetNdmDriver(&ndm);
-  ASSERT_NOT_NULL(ndm.data_and_spare_check);
+  ASSERT_NE(nullptr, ndm.data_and_spare_check);
 
   driver.set_result(ftl::kNdmUnsafeEcc);
   driver.set_empty(false);
@@ -109,4 +111,19 @@
   EXPECT_EQ(NDM_PAGE_VALID, status);
 }
 
+TEST(NdmDriverTest, CheckPageValidIncompleteWrite) {
+  MockDriver driver;
+
+  NDMDrvr ndm;
+  driver.GetNdmDriver(&ndm);
+  ASSERT_NE(nullptr, ndm.data_and_spare_check);
+
+  driver.set_result(ftl::kNdmUnsafeEcc);
+  driver.set_incomplete(true);
+
+  int status;
+  EXPECT_EQ(ftl::kNdmOk, ndm.data_and_spare_check(0, nullptr, nullptr, &status, &driver));
+  EXPECT_EQ(NDM_PAGE_INVALID, status);
+}
+
 }  // namespace
diff --git a/zircon/system/ulib/ftl/test/ndm_test.cc b/zircon/system/ulib/ftl/test/ndm_test.cc
index 9967155c..2d98c92 100644
--- a/zircon/system/ulib/ftl/test/ndm_test.cc
+++ b/zircon/system/ulib/ftl/test/ndm_test.cc
@@ -3,11 +3,12 @@
 // found in the LICENSE file.
 
 #include <lib/ftl/ndm-driver.h>
+#include <string.h>
 
 #include <optional>
 #include <vector>
 
-#include <zxtest/zxtest.h>
+#include <gtest/gtest.h>
 
 #include "ftl.h"
 #include "ndm/ndmp.h"
@@ -27,17 +28,16 @@
 
 class NdmRamDriver final : public ftl::NdmBaseDriver {
  public:
-  NdmRamDriver(const ftl::VolumeOptions options = kDefaultOptions) : options_(options) {}
-  ~NdmRamDriver() final {}
+  NdmRamDriver(const ftl::VolumeOptions options = kDefaultOptions,
+               FtlLogger logger = ftl::DefaultLogger())
+      : NdmBaseDriver(logger), options_(options) {}
 
   const uint8_t* data(uint32_t page_num) const { return &volume_[page_num * kPageSize]; }
   NDM ndm() { return GetNdmForTest(); }
   void format_using_v2(bool value) { format_using_v2_ = value; }
 
   // Goes through the normal logic to create a volume with user data info.
-  const char* CreateVolume(std::optional<ftl::LoggerProxy> logger = std::nullopt) {
-    return CreateNdmVolumeWithLogger(nullptr, options_, true, logger);
-  }
+  const char* CreateVolume() { return CreateNdmVolume(nullptr, options_, true); }
 
   // NdmDriver interface:
   const char* Init() final;
@@ -51,6 +51,8 @@
   bool IsEmptyPage(uint32_t page_num, const uint8_t* data, const uint8_t* spare) final {
     return IsEmptyPageImpl(data, kPageSize, spare, kOobSize);
   }
+  uint32_t PageSize() final { return kPageSize; }
+  uint8_t SpareSize() final { return kOobSize; }
 
  private:
   std::vector<uint8_t> volume_;
@@ -113,12 +115,12 @@
   return ftl::kNdmOk;
 }
 
-class NdmTest : public zxtest::Test {
+class NdmTest : public ::testing::Test {
  public:
   void SetUp() override {
     ASSERT_TRUE(ftl::InitModules());
-    ASSERT_NULL(ndm_driver_.Init());
-    ASSERT_NULL(ndm_driver_.Attach(nullptr));
+    ASSERT_EQ(nullptr, ndm_driver_.Init());
+    ASSERT_EQ(nullptr, ndm_driver_.Attach(nullptr));
   }
 
  protected:
@@ -149,9 +151,9 @@
  public:
   void SetUp() override {
     ASSERT_TRUE(ftl::InitModules());
-    ASSERT_NULL(ndm_driver_.Init());
+    ASSERT_EQ(nullptr, ndm_driver_.Init());
     ndm_driver_.format_using_v2(false);
-    ASSERT_NULL(ndm_driver_.Attach(nullptr));
+    ASSERT_EQ(nullptr, ndm_driver_.Attach(nullptr));
   }
 };
 
@@ -160,12 +162,12 @@
   EXPECT_EQ(1, header->current_location);
   EXPECT_EQ(1, header->last_location);
   EXPECT_EQ(0, header->sequence_num);
-  EXPECT_EQ(kNumBlocks, header->num_blocks);
-  EXPECT_EQ(kPageSize * kPagesPerBlock, header->block_size);
-  EXPECT_EQ(kNumBlocks - 1, header->control_block0);
-  EXPECT_EQ(kNumBlocks - 2, header->control_block1);
-  EXPECT_EQ(kNumBlocks - 4, header->free_virt_block);
-  EXPECT_EQ(kNumBlocks - 3, header->free_control_block);
+  EXPECT_EQ(kNumBlocks, static_cast<uint32_t>(header->num_blocks));
+  EXPECT_EQ(kPageSize * kPagesPerBlock, static_cast<uint32_t>(header->block_size));
+  EXPECT_EQ(kNumBlocks - 1, static_cast<uint32_t>(header->control_block0));
+  EXPECT_EQ(kNumBlocks - 2, static_cast<uint32_t>(header->control_block1));
+  EXPECT_EQ(kNumBlocks - 4, static_cast<uint32_t>(header->free_virt_block));
+  EXPECT_EQ(kNumBlocks - 3, static_cast<uint32_t>(header->free_control_block));
   EXPECT_EQ(-1, header->transfer_to_block);
 }
 
@@ -176,12 +178,12 @@
   EXPECT_EQ(1, header->v1.current_location);
   EXPECT_EQ(1, header->v1.last_location);
   EXPECT_EQ(0, header->v1.sequence_num);
-  EXPECT_EQ(kNumBlocks, header->v1.num_blocks);
-  EXPECT_EQ(kPageSize * kPagesPerBlock, header->v1.block_size);
-  EXPECT_EQ(kNumBlocks - 1, header->v1.control_block0);
-  EXPECT_EQ(kNumBlocks - 2, header->v1.control_block1);
-  EXPECT_EQ(kNumBlocks - 4, header->v1.free_virt_block);
-  EXPECT_EQ(kNumBlocks - 3, header->v1.free_control_block);
+  EXPECT_EQ(kNumBlocks, static_cast<uint32_t>(header->v1.num_blocks));
+  EXPECT_EQ(kPageSize * kPagesPerBlock, static_cast<uint32_t>(header->v1.block_size));
+  EXPECT_EQ(kNumBlocks - 1, static_cast<uint32_t>(header->v1.control_block0));
+  EXPECT_EQ(kNumBlocks - 2, static_cast<uint32_t>(header->v1.control_block1));
+  EXPECT_EQ(kNumBlocks - 4, static_cast<uint32_t>(header->v1.free_virt_block));
+  EXPECT_EQ(kNumBlocks - 3, static_cast<uint32_t>(header->v1.free_control_block));
   EXPECT_EQ(-1, header->v1.transfer_to_block);
 }
 
@@ -198,8 +200,8 @@
   partition.num_blocks = ndmGetNumVBlocks(ndm_driver_.ndm());
   ASSERT_EQ(0, ndmWritePartition(ndm_driver_.ndm(), &partition, 0, "foo"));
 
-  EXPECT_NOT_NULL(ndmGetPartition(ndm_driver_.ndm(), 0));
-  EXPECT_NULL(ndmGetPartitionInfo(ndm_driver_.ndm()));
+  EXPECT_NE(nullptr, ndmGetPartition(ndm_driver_.ndm(), 0));
+  EXPECT_EQ(nullptr, ndmGetPartitionInfo(ndm_driver_.ndm()));
 }
 
 TEST_F(NdmTest, UsesVersion2) {
@@ -209,14 +211,14 @@
   strcpy(partition.basic_data.name, "foo");
   ASSERT_EQ(0, ndmWritePartitionInfo(ndm_driver_.ndm(), &partition));
 
-  EXPECT_NOT_NULL(ndmGetPartition(ndm_driver_.ndm(), 0));
+  EXPECT_NE(nullptr, ndmGetPartition(ndm_driver_.ndm(), 0));
 
   const NDMPartitionInfo* info = ndmGetPartitionInfo(ndm_driver_.ndm());
-  ASSERT_NOT_NULL(info);
-  EXPECT_EQ(0, info->basic_data.first_block);
+  ASSERT_NE(nullptr, info);
+  EXPECT_EQ(0u, info->basic_data.first_block);
   EXPECT_EQ(partition_size, info->basic_data.num_blocks);
-  EXPECT_EQ(0, info->user_data.data_size);
-  EXPECT_STR_EQ("foo", info->basic_data.name);
+  EXPECT_EQ(0u, info->user_data.data_size);
+  EXPECT_STREQ("foo", info->basic_data.name);
 }
 
 TEST_F(NdmTest, SavesVersion2) {
@@ -231,12 +233,12 @@
   EXPECT_EQ(1, header->v1.current_location);
   EXPECT_EQ(1, header->v1.last_location);
   EXPECT_EQ(1, header->v1.sequence_num);
-  EXPECT_EQ(kNumBlocks, header->v1.num_blocks);
-  EXPECT_EQ(kPageSize * kPagesPerBlock, header->v1.block_size);
-  EXPECT_EQ(kNumBlocks - 1, header->v1.control_block0);
-  EXPECT_EQ(kNumBlocks - 2, header->v1.control_block1);
-  EXPECT_EQ(kNumBlocks - 4, header->v1.free_virt_block);
-  EXPECT_EQ(kNumBlocks - 3, header->v1.free_control_block);
+  EXPECT_EQ(kNumBlocks, static_cast<uint32_t>(header->v1.num_blocks));
+  EXPECT_EQ(kPageSize * kPagesPerBlock, static_cast<uint32_t>(header->v1.block_size));
+  EXPECT_EQ(kNumBlocks - 1, static_cast<uint32_t>(header->v1.control_block0));
+  EXPECT_EQ(kNumBlocks - 2, static_cast<uint32_t>(header->v1.control_block1));
+  EXPECT_EQ(kNumBlocks - 4, static_cast<uint32_t>(header->v1.free_virt_block));
+  EXPECT_EQ(kNumBlocks - 3, static_cast<uint32_t>(header->v1.free_control_block));
   EXPECT_EQ(-1, header->v1.transfer_to_block);
 }
 
@@ -302,7 +304,7 @@
 
   // Reinitialize NDM.
   EXPECT_TRUE(ndm_driver_.Detach());
-  ASSERT_NULL(ndm_driver_.Attach(nullptr));
+  ASSERT_EQ(nullptr, ndm_driver_.Attach(nullptr));
 
   // Redefine the partition.
   PartitionInfo new_info = {};
@@ -314,14 +316,14 @@
 
   // Read the latest version from disk.
   EXPECT_TRUE(ndm_driver_.Detach());
-  ASSERT_NULL(ndm_driver_.Attach(nullptr));
+  ASSERT_EQ(nullptr, ndm_driver_.Attach(nullptr));
 
   const NDMPartitionInfo* info = ndmGetPartitionInfo(ndm_driver_.ndm());
-  ASSERT_NOT_NULL(info);
+  ASSERT_NE(nullptr, info);
   ASSERT_EQ(sizeof(new_info.exploded.data), info->user_data.data_size);
 
   auto actual_info = reinterpret_cast<const PartitionInfo*>(info);
-  EXPECT_EQ(42, actual_info->exploded.data);
+  EXPECT_EQ(42u, actual_info->exploded.data);
 
   // Verify the expected disk layout.
   auto header = reinterpret_cast<const HeaderV2*>(ndm_driver_.data(kControlPage0 + 1));
@@ -340,25 +342,25 @@
 }
 
 TEST_F(NdmTest, BaseDriverSavesConfig) {
-  ASSERT_NULL(ndm_driver_.CreateVolume());
+  ASSERT_EQ(nullptr, ndm_driver_.CreateVolume());
 
   const NDMPartitionInfo* info = ndmGetPartitionInfo(ndm_driver_.ndm());
-  ASSERT_NOT_NULL(info);
-  ASSERT_GE(info->user_data.data_size, 96);  // Size of the first version of the data.
+  ASSERT_NE(nullptr, info);
+  ASSERT_GE(info->user_data.data_size, 96u);  // Size of the first version of the data.
 
   const ftl::VolumeOptions* options = ndm_driver_.GetSavedOptions();
-  ASSERT_NOT_NULL(options);
-  ASSERT_BYTES_EQ(&kDefaultOptions, options, sizeof(*options));
+  ASSERT_NE(nullptr, options);
+  ASSERT_EQ(memcmp(&kDefaultOptions, options, sizeof(*options)), 0);
 }
 
-class NdmReadOnlyTest : public zxtest::Test {
+class NdmReadOnlyTest : public ::testing::Test {
  public:
   void SetUp() override {
     ASSERT_TRUE(ftl::InitModules());
     ftl::VolumeOptions options = kDefaultOptions;
     options.flags |= ftl::kReadOnlyInit;
     ndm_driver_.reset(new NdmRamDriver(options));
-    ASSERT_NULL(ndm_driver_->Init());
+    ASSERT_EQ(nullptr, ndm_driver_->Init());
     buffer_ = std::vector<uint8_t>(kPageSize, 0xff);
   }
 
@@ -378,7 +380,7 @@
   memcpy(buffer_.data(), kControl29V1, sizeof(kControl29V1));
   ASSERT_EQ(ftl::kNdmOk, ndm_driver_->NandWrite(kControlPage0, 1, buffer_.data(), kControlOob));
 
-  ASSERT_NULL(ndm_driver_->CreateVolume());
+  ASSERT_EQ(nullptr, ndm_driver_->CreateVolume());
 }
 
 // An NDM control block version 2.0, stored on page 29.
@@ -390,7 +392,7 @@
   memcpy(buffer_.data(), kControl29V2, sizeof(kControl29V2));
   ASSERT_EQ(ftl::kNdmOk, ndm_driver_->NandWrite(kControlPage0, 1, buffer_.data(), kControlOob));
 
-  ASSERT_NULL(ndm_driver_->CreateVolume());
+  ASSERT_EQ(nullptr, ndm_driver_->CreateVolume());
 }
 
 // An NDM control block version 2.0, stored on page 28, with partition data.
@@ -408,7 +410,7 @@
 
   memcpy(buffer_.data(), kControl28V2, sizeof(kControl28V2));
   ASSERT_EQ(ftl::kNdmOk, ndm_driver_->NandWrite(kControlPage1, 1, buffer_.data(), kControlOob));
-  ASSERT_NULL(ndm_driver_->CreateVolume());
+  ASSERT_EQ(nullptr, ndm_driver_->CreateVolume());
 }
 
 // An NDM control block version 1, stored on page 29, with one factory bad block and
@@ -423,7 +425,7 @@
   memcpy(buffer_.data(), kControlBlockTransferV1, sizeof(kControlBlockTransferV1));
   ASSERT_EQ(ftl::kNdmOk, ndm_driver_->NandWrite(kControlPage0, 1, buffer_.data(), kControlOob));
 
-  ASSERT_NOT_NULL(ndm_driver_->CreateVolume());
+  ASSERT_NE(nullptr, ndm_driver_->CreateVolume());
   ASSERT_EQ(NDM_BAD_BLK_RECOV, GetFsErrCode());
 }
 
@@ -438,8 +440,8 @@
   memcpy(buffer_.data(), kControlBlockBadBlocksV1, sizeof(kControlBlockBadBlocksV1));
   ASSERT_EQ(ftl::kNdmOk, ndm_driver_->NandWrite(kControlPage0, 1, buffer_.data(), kControlOob));
 
-  ASSERT_NULL(ndm_driver_->CreateVolume());
-  EXPECT_EQ(2, ndm_driver_->ndm()->num_bad_blks);
+  ASSERT_EQ(nullptr, ndm_driver_->CreateVolume());
+  EXPECT_EQ(2u, ndm_driver_->ndm()->num_bad_blks);
 }
 
 // An NDM control block version 2.0, stored on page 29, with one factory bad block and
@@ -454,7 +456,7 @@
   memcpy(buffer_.data(), kControlBlockTransferV2, sizeof(kControlBlockTransferV2));
   ASSERT_EQ(ftl::kNdmOk, ndm_driver_->NandWrite(kControlPage0, 1, buffer_.data(), kControlOob));
 
-  ASSERT_NOT_NULL(ndm_driver_->CreateVolume());
+  ASSERT_NE(nullptr, ndm_driver_->CreateVolume());
   ASSERT_EQ(NDM_BAD_BLK_RECOV, GetFsErrCode());
 }
 
@@ -466,7 +468,7 @@
     0x00000003, 0x0000001b, 0xffffffff, 0xffffffff, 0x00000000, 0x0000001a, 0x006c7466, 0x00000000,
     0x00000000, 0x00000000, 0x00000000, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff};
 
-TEST_F(NdmReadOnlyTest, BadBlocksV2) {
+TEST(NdmReadOnlyTestWithLogger, BadBlocksV2) {
   static bool logger_called = false;
   logger_called = false;
 
@@ -477,18 +479,25 @@
     }
   };
 
-  ftl::LoggerProxy logger;
+  FtlLogger logger;
   logger.trace = &LoggerHelper::Log;
   logger.debug = &LoggerHelper::Log;
   logger.info = &LoggerHelper::Log;
   logger.warn = &LoggerHelper::Log;
   logger.error = &LoggerHelper::Log;
 
-  memcpy(buffer_.data(), kControlBlockBadBlocksV2, sizeof(kControlBlockBadBlocksV2));
-  ASSERT_EQ(ftl::kNdmOk, ndm_driver_->NandWrite(kControlPage0, 1, buffer_.data(), kControlOob));
+  ASSERT_TRUE(ftl::InitModules());
+  ftl::VolumeOptions options = kDefaultOptions;
+  options.flags |= ftl::kReadOnlyInit;
+  auto ndm_driver = std::make_unique<NdmRamDriver>(options, logger);
+  ASSERT_EQ(nullptr, ndm_driver->Init());
+  std::vector<uint8_t> buffer(kPageSize, 0xff);
 
-  ASSERT_NULL(ndm_driver_->CreateVolume(logger));
-  EXPECT_EQ(2, ndm_driver_->ndm()->num_bad_blks);
+  memcpy(buffer.data(), kControlBlockBadBlocksV2, sizeof(kControlBlockBadBlocksV2));
+  ASSERT_EQ(ftl::kNdmOk, ndm_driver->NandWrite(kControlPage0, 1, buffer.data(), kControlOob));
+
+  ASSERT_EQ(nullptr, ndm_driver->CreateVolume());
+  EXPECT_EQ(2u, ndm_driver->ndm()->num_bad_blks);
   EXPECT_TRUE(logger_called);
 }