src/storage/minfs/test/unit/superblock_test.cc - fuchsia - Git at Google

 // Copyright 2019 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.

 // Tests minfs backup superblock behavior.

 #include <lib/cksum.h>
 #include <unistd.h>

 #include <memory>

 #include <gmock/gmock.h>
 #include <gtest/gtest.h>

 #include "src/storage/lib/block_client/cpp/fake_block_device.h"
 #include "src/storage/lib/block_client/cpp/reader.h"
 #include "src/storage/minfs/format.h"
 #include "src/storage/minfs/fsck.h"

 namespace minfs {
 namespace {

 using ::block_client::FakeBlockDevice;
 using ::testing::_;

 constexpr size_t abm_block = 5;
 constexpr size_t ibm_block = 6;
 constexpr size_t data_block = 7;
 constexpr size_t integrity_block = 8;

 // Mock TransactionHandler class to be used in superblock tests.
 class MockTransactionHandler : public fs::DeviceTransactionHandler {
  public:
   explicit MockTransactionHandler(block_client::BlockDevice* device) { device_ = device; }

   MockTransactionHandler(const MockTransactionHandler&) = delete;
   MockTransactionHandler(MockTransactionHandler&&) = delete;
   MockTransactionHandler& operator=(const MockTransactionHandler&) = delete;
   MockTransactionHandler& operator=(MockTransactionHandler&&) = delete;

   // fs::TransactionHandler Interface.
   uint64_t BlockNumberToDevice(uint64_t block_num) const final { return block_num; }

   block_client::BlockDevice* GetDevice() final { return device_; }

  private:
   block_client::BlockDevice* device_;
 };

 void CreateAndRegisterVmo(block_client::BlockDevice* device, size_t blocks, zx::vmo* vmo,
                           storage::OwnedVmoid* vmoid) {
   fuchsia_hardware_block::wire::BlockInfo info = {};
   ASSERT_EQ(device->BlockGetInfo(&info), ZX_OK);
   ASSERT_EQ(zx::vmo::create(blocks * info.block_size, 0, vmo), ZX_OK);
   ASSERT_EQ(device->BlockAttachVmo(*vmo, &vmoid->GetReference(device)), ZX_OK);
 }

 void FillSuperblockFields(Superblock* info) {
   info->magic0 = kMinfsMagic0;
   info->magic1 = kMinfsMagic1;
   info->major_version = kMinfsCurrentMajorVersion;
   info->flags = kMinfsFlagClean;
   info->block_size = kMinfsBlockSize;
   info->inode_size = kMinfsInodeSize;
   info->dat_block = data_block;
   info->integrity_start_block = integrity_block;
   info->ibm_block = ibm_block;
   info->abm_block = abm_block;
   info->ino_block = abm_block;
   info->block_count = 4;
   info->inode_count = 4;
   info->alloc_block_count = 2;
   info->alloc_inode_count = 2;
   info->generation_count = 0;
   info->oldest_minor_version = kMinfsCurrentMinorVersion;
   minfs::UpdateChecksum(info);
 }

 // Fills write request for the respective block locations.
 void FillWriteRequest(MockTransactionHandler* transaction_handler, uint32_t first_block_location,
                       uint32_t second_block_location, vmoid_t vmoid,
                       block_fifo_request_t* out_requests) {
   out_requests[0].command = {.opcode = BLOCK_OPCODE_WRITE, .flags = 0};
   out_requests[0].vmoid = vmoid;
   out_requests[0].length = 1;
   out_requests[0].vmo_offset = 0;
   out_requests[0].dev_offset = first_block_location;
   out_requests[1].command = {.opcode = BLOCK_OPCODE_WRITE, .flags = 0};
   out_requests[1].vmoid = vmoid;
   out_requests[1].length = 1;
   out_requests[1].vmo_offset = 1;
   out_requests[1].dev_offset = second_block_location;
 }

 // Tests the alloc_*_counts bitmap reconstruction.
 TEST(SuperblockTest, TestBitmapReconstruction) {
   Superblock info = {};
   FillSuperblockFields(&info);

   FakeBlockDevice device = FakeBlockDevice(100, kMinfsBlockSize);
   auto transaction_handler = std::make_unique<MockTransactionHandler>(&device);

   uint8_t block[minfs::kMinfsBlockSize];
   memset(block, 0, sizeof(block));

   // Fill up the entire bitmap sparsely with random 1 and 0.
   // 0xFF = 8 bits set.
   block[0] = 0xFF;
   block[30] = 0xFF;
   block[100] = 0xFF;
   block[5000] = 0xFF;

   zx::vmo vmo;
   block_fifo_request_t request[2];
   storage::OwnedVmoid vmoid;
   ASSERT_NO_FATAL_FAILURE(CreateAndRegisterVmo(&device, 2, &vmo, &vmoid));
   ASSERT_EQ(vmo.write(block, 0, kMinfsBlockSize), ZX_OK);
   ASSERT_EQ(vmo.write(block, kMinfsBlockSize, kMinfsBlockSize), ZX_OK);

   // Write abm_block and ibm_block to disk.
   FillWriteRequest(transaction_handler.get(), abm_block, ibm_block, vmoid.get(), request);

   ASSERT_EQ(device.FifoTransaction(request, 2), ZX_OK);

   // Reconstruct alloc_*_counts from respective bitmaps.
   ASSERT_TRUE(ReconstructAllocCounts(transaction_handler.get(), &device, &info).is_ok());

   // Confirm that alloc_*_counts are updated correctly.
   ASSERT_EQ(info.alloc_block_count, 32u);
   ASSERT_EQ(info.alloc_inode_count, 32u);

   // Write all bits unset for abm_block and ibm_block.
   memset(block, 0, sizeof(block));

   // Write the bitmaps to disk.
   ASSERT_EQ(vmo.write(block, 0, sizeof(block)), ZX_OK);
   ASSERT_EQ(vmo.write(block, sizeof(block), sizeof(block)), ZX_OK);
   ASSERT_EQ(device.FifoTransaction(request, 2), ZX_OK);

   // Reconstruct alloc_*_counts from respective bitmaps.
   ASSERT_TRUE(ReconstructAllocCounts(transaction_handler.get(), &device, &info).is_ok());

   // Confirm the alloc_*_counts are updated correctly.
   ASSERT_EQ(info.alloc_block_count, 0u);
   ASSERT_EQ(info.alloc_inode_count, 0u);

   memset(block, 0, sizeof(block));

   // Fill up the entire bitmap sparsely with random 1 and 0.
   block[0] = 0x88;
   block[30] = 0xAA;
   block[100] = 0x44;
   block[5000] = 0x2C;

   // Write the bitmaps on disk.
   ASSERT_EQ(vmo.write(block, 0, sizeof(block)), ZX_OK);
   ASSERT_EQ(vmo.write(block, sizeof(block), sizeof(block)), ZX_OK);
   ASSERT_EQ(device.FifoTransaction(request, 2), ZX_OK);

   // Reconstruct alloc_*_counts from respective bitmaps.
   ASSERT_TRUE(ReconstructAllocCounts(transaction_handler.get(), &device, &info).is_ok());

   // Confirm the alloc_*_counts are updated correctly.
   ASSERT_EQ(info.alloc_block_count, 11u);
   ASSERT_EQ(info.alloc_inode_count, 11u);
 }

 // Tests corrupt superblock and corrupt backup superblock.
 TEST(SuperblockTest, TestCorruptSuperblockWithoutCorrection) {
   Superblock info = {};
   FillSuperblockFields(&info);

   FakeBlockDevice device = FakeBlockDevice(100, kMinfsBlockSize);
   auto transaction_handler = std::make_unique<MockTransactionHandler>(&device);

   Superblock backup;
   memcpy(&backup, &info, sizeof(backup));

   // Corrupt original Superblock.
   info.major_version = 0xdeadbeef;

   // Corrupt backup Superblock.
   backup.major_version = 0x55;

   // Write superblock and backup to disk.
   block_fifo_request_t request[2];
   zx::vmo vmo;
   storage::OwnedVmoid vmoid;
   ASSERT_NO_FATAL_FAILURE(CreateAndRegisterVmo(&device, 2, &vmo, &vmoid));
   ASSERT_EQ(vmo.write(&info, 0, kMinfsBlockSize), ZX_OK);
   ASSERT_EQ(vmo.write(&backup, kMinfsBlockSize, kMinfsBlockSize), ZX_OK);

   FillWriteRequest(transaction_handler.get(), kSuperblockStart, kNonFvmSuperblockBackup,
                    vmoid.get(), request);
   ASSERT_EQ(device.FifoTransaction(request, 2), ZX_OK);

   // Try to correct the corrupted superblock.
   auto info_or =
       RepairSuperblock(transaction_handler.get(), &device, info.dat_block + info.block_count);
   ASSERT_TRUE(info_or.is_error());

   // Read back the superblock and backup superblock.
   block_client::Reader reader(device);
   ASSERT_EQ(reader.Read(kSuperblockStart * kMinfsBlockSize, kMinfsBlockSize, &info), ZX_OK);
   ASSERT_EQ(reader.Read(kNonFvmSuperblockBackup * kMinfsBlockSize, kMinfsBlockSize, &backup),
             ZX_OK);

   // Confirm that the superblock is not updated by backup.
   ASSERT_NE(memcmp(&info, &backup, sizeof(backup)), 0);
   ASSERT_EQ(0xdeadbeef, info.major_version);
   ASSERT_EQ(backup.major_version, 0x55u);
 }

 // Tests corrupt superblock and non-corrupt backup superblock.
 TEST(SuperblockTest, TestCorruptSuperblockWithCorrection) {
   Superblock info = {};
   FillSuperblockFields(&info);

   FakeBlockDevice device = FakeBlockDevice(100, kMinfsBlockSize);
   auto transaction_handler = std::make_unique<MockTransactionHandler>(&device);

   Superblock backup;
   memcpy(&backup, &info, sizeof(backup));

   // Corrupt original Superblock.
   info.major_version = 0xdeadbeef;

   // Write superblock and backup to disk.
   block_fifo_request_t request[2];
   zx::vmo vmo;
   storage::OwnedVmoid vmoid;
   ASSERT_NO_FATAL_FAILURE(CreateAndRegisterVmo(&device, 2, &vmo, &vmoid));
   ASSERT_EQ(vmo.write(&info, 0, kMinfsBlockSize), ZX_OK);
   ASSERT_EQ(vmo.write(&backup, kMinfsBlockSize, kMinfsBlockSize), ZX_OK);
   FillWriteRequest(transaction_handler.get(), kSuperblockStart, kNonFvmSuperblockBackup,
                    vmoid.get(), request);
   ASSERT_EQ(device.FifoTransaction(request, 2), ZX_OK);

   // Try to correct the corrupted superblock.
   auto info_or =
       RepairSuperblock(transaction_handler.get(), &device, info.dat_block + info.block_count);
   ASSERT_TRUE(info_or.is_ok());
   info = info_or.value();

   // Read back the superblock and backup superblock.
   block_client::Reader reader(device);
   ASSERT_EQ(reader.Read(kSuperblockStart * kMinfsBlockSize, kMinfsBlockSize, &info), ZX_OK);
   ASSERT_EQ(reader.Read(kNonFvmSuperblockBackup * kMinfsBlockSize, kMinfsBlockSize, &backup),
             ZX_OK);

   // Confirm that the superblock is updated by backup.
   ASSERT_EQ(memcmp(&info, &backup, sizeof(backup)), 0);
 }

 // Tests if Repair of corrupted superblock reconstructs the bitmaps correctly.
 TEST(SuperblockTest, TestRepairSuperblockWithBitmapReconstruction) {
   FakeBlockDevice device = FakeBlockDevice(100, kMinfsBlockSize);
   auto transaction_handler = std::make_unique<MockTransactionHandler>(&device);

   Superblock backup;
   FillSuperblockFields(&backup);
   backup.alloc_block_count = 0;
   backup.alloc_inode_count = 0;
   minfs::UpdateChecksum(&backup);

   Superblock info = {};
   // Write corrupted superblock and backup to disk.
   block_fifo_request_t request[2];
   zx::vmo vmo;
   storage::OwnedVmoid vmoid;
   ASSERT_NO_FATAL_FAILURE(CreateAndRegisterVmo(&device, 2, &vmo, &vmoid));
   ASSERT_EQ(vmo.write(&info, 0, kMinfsBlockSize), ZX_OK);
   ASSERT_EQ(vmo.write(&backup, kMinfsBlockSize, kMinfsBlockSize), ZX_OK);
   FillWriteRequest(transaction_handler.get(), kSuperblockStart, kNonFvmSuperblockBackup,
                    vmoid.get(), request);
   ASSERT_EQ(device.FifoTransaction(request, 2), ZX_OK);

   uint8_t block[minfs::kMinfsBlockSize];
   memset(block, 0, sizeof(block));

   // Fill up the entire bitmap sparsely with random 1 and 0.
   block[0] = 0xFF;
   block[30] = 0xFF;
   block[100] = 0xFF;
   block[5000] = 0xFF;

   // Write abm_block and ibm_block to disk.
   ASSERT_EQ(vmo.write(block, 0, kMinfsBlockSize), ZX_OK);
   ASSERT_EQ(vmo.write(block, kMinfsBlockSize, kMinfsBlockSize), ZX_OK);
   FillWriteRequest(transaction_handler.get(), abm_block, ibm_block, vmoid.get(), request);
   ASSERT_EQ(device.FifoTransaction(request, 2), ZX_OK);

   // Try to correct the corrupted superblock.
   auto info_or =
       RepairSuperblock(transaction_handler.get(), &device, backup.dat_block + backup.block_count);
   ASSERT_TRUE(info_or.is_ok());
   info = info_or.value();

   // Read back the superblock and backup superblock.
   block_client::Reader reader(device);
   ASSERT_EQ(reader.Read(kSuperblockStart * kMinfsBlockSize, kMinfsBlockSize, &info), ZX_OK);
   ASSERT_EQ(reader.Read(kNonFvmSuperblockBackup * kMinfsBlockSize, kMinfsBlockSize, &backup),
             ZX_OK);

   // Confirm that alloc_*_counts are updated correctly in superblock and backup from bitmaps.
   ASSERT_GT(info.alloc_block_count, 0u);
   ASSERT_GT(info.alloc_inode_count, 0u);
   ASSERT_GT(backup.alloc_block_count, 0u);
   ASSERT_GT(backup.alloc_inode_count, 0u);
 }

 TEST(SuperblockTest, UnsupportedBlockSize) {
   ASSERT_DEATH(
       {
         Superblock info = {};
         info.block_size = kMinfsBlockSize - 1;
         info.BlockSize();
       },
       _);
 }

 TEST(SuperblockTest, SupportedBlockSize) {
   Superblock info = {};
   info.block_size = kMinfsBlockSize;
   info.BlockSize();
 }

 TEST(SuperblockTest, GetFvmFlag) {
   Superblock info;
   FillSuperblockFields(&info);
   ASSERT_FALSE(info.GetFlagFvm());

   SetMinfsFlagFvm(info);
   ASSERT_TRUE(info.GetFlagFvm());
 }

 TEST(SuperblockTest, InodeBitmapStartBlock) {
   Superblock info;
   FillSuperblockFields(&info);
   ASSERT_EQ(info.InodeBitmapStartBlock(), info.ibm_block);

   SetMinfsFlagFvm(info);
   ASSERT_EQ(info.InodeBitmapStartBlock(), kFVMBlockInodeBmStart);
 }

 TEST(SuperblockTest, DataBitmapStartBlock) {
   Superblock info;
   FillSuperblockFields(&info);
   ASSERT_EQ(info.DataBitmapStartBlock(), info.abm_block);

   SetMinfsFlagFvm(info);
   ASSERT_EQ(info.DataBitmapStartBlock(), kFVMBlockDataBmStart);
 }

 TEST(SuperblockTest, InodeTableStartBlock) {
   Superblock info;
   FillSuperblockFields(&info);
   ASSERT_EQ(info.InodeTableStartBlock(), info.ino_block);

   SetMinfsFlagFvm(info);
   ASSERT_EQ(info.InodeTableStartBlock(), kFVMBlockInodeStart);
 }

 TEST(SuperblockTest, DataStartBlock) {
   Superblock info;
   FillSuperblockFields(&info);
   ASSERT_EQ(info.DataStartBlock(), info.dat_block);

   SetMinfsFlagFvm(info);
   ASSERT_EQ(info.DataStartBlock(), kFVMBlockDataStart);
 }

 TEST(SuperblockTest, BackupSuperblock) {
   Superblock info;
   FillSuperblockFields(&info);
   ASSERT_EQ(info.BackupSuperblockStart(), kNonFvmSuperblockBackup);

   SetMinfsFlagFvm(info);
   ASSERT_EQ(info.BackupSuperblockStart(), kFvmSuperblockBackup);
 }

 }  // namespace
 }  // namespace minfs
	// Copyright 2019 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.

	// Tests minfs backup superblock behavior.

	#include <lib/cksum.h>
	#include <unistd.h>

	#include <memory>

	#include <gmock/gmock.h>
	#include <gtest/gtest.h>

	#include "src/storage/lib/block_client/cpp/fake_block_device.h"
	#include "src/storage/lib/block_client/cpp/reader.h"
	#include "src/storage/minfs/format.h"
	#include "src/storage/minfs/fsck.h"

	namespace minfs {
	namespace {

	using ::block_client::FakeBlockDevice;
	using ::testing::_;

	constexpr size_t abm_block = 5;
	constexpr size_t ibm_block = 6;
	constexpr size_t data_block = 7;
	constexpr size_t integrity_block = 8;

	// Mock TransactionHandler class to be used in superblock tests.
	class MockTransactionHandler : public fs::DeviceTransactionHandler {
	public:
	explicit MockTransactionHandler(block_client::BlockDevice* device) { device_ = device; }

	MockTransactionHandler(const MockTransactionHandler&) = delete;
	MockTransactionHandler(MockTransactionHandler&&) = delete;
	MockTransactionHandler& operator=(const MockTransactionHandler&) = delete;
	MockTransactionHandler& operator=(MockTransactionHandler&&) = delete;

	// fs::TransactionHandler Interface.
	uint64_t BlockNumberToDevice(uint64_t block_num) const final { return block_num; }

	block_client::BlockDevice* GetDevice() final { return device_; }

	private:
	block_client::BlockDevice* device_;
	};

	void CreateAndRegisterVmo(block_client::BlockDevice* device, size_t blocks, zx::vmo* vmo,
	storage::OwnedVmoid* vmoid) {
	fuchsia_hardware_block::wire::BlockInfo info = {};
	ASSERT_EQ(device->BlockGetInfo(&info), ZX_OK);
	ASSERT_EQ(zx::vmo::create(blocks * info.block_size, 0, vmo), ZX_OK);
	ASSERT_EQ(device->BlockAttachVmo(*vmo, &vmoid->GetReference(device)), ZX_OK);
	}

	void FillSuperblockFields(Superblock* info) {
	info->magic0 = kMinfsMagic0;
	info->magic1 = kMinfsMagic1;
	info->major_version = kMinfsCurrentMajorVersion;
	info->flags = kMinfsFlagClean;
	info->block_size = kMinfsBlockSize;
	info->inode_size = kMinfsInodeSize;
	info->dat_block = data_block;
	info->integrity_start_block = integrity_block;
	info->ibm_block = ibm_block;
	info->abm_block = abm_block;
	info->ino_block = abm_block;
	info->block_count = 4;
	info->inode_count = 4;
	info->alloc_block_count = 2;
	info->alloc_inode_count = 2;
	info->generation_count = 0;
	info->oldest_minor_version = kMinfsCurrentMinorVersion;
	minfs::UpdateChecksum(info);
	}

	// Fills write request for the respective block locations.
	void FillWriteRequest(MockTransactionHandler* transaction_handler, uint32_t first_block_location,
	uint32_t second_block_location, vmoid_t vmoid,
	block_fifo_request_t* out_requests) {
	out_requests[0].command = {.opcode = BLOCK_OPCODE_WRITE, .flags = 0};
	out_requests[0].vmoid = vmoid;
	out_requests[0].length = 1;
	out_requests[0].vmo_offset = 0;
	out_requests[0].dev_offset = first_block_location;
	out_requests[1].command = {.opcode = BLOCK_OPCODE_WRITE, .flags = 0};
	out_requests[1].vmoid = vmoid;
	out_requests[1].length = 1;
	out_requests[1].vmo_offset = 1;
	out_requests[1].dev_offset = second_block_location;
	}

	// Tests the alloc_*_counts bitmap reconstruction.
	TEST(SuperblockTest, TestBitmapReconstruction) {
	Superblock info = {};
	FillSuperblockFields(&info);

	FakeBlockDevice device = FakeBlockDevice(100, kMinfsBlockSize);
	auto transaction_handler = std::make_unique<MockTransactionHandler>(&device);

	uint8_t block[minfs::kMinfsBlockSize];
	memset(block, 0, sizeof(block));

	// Fill up the entire bitmap sparsely with random 1 and 0.
	// 0xFF = 8 bits set.
	block[0] = 0xFF;
	block[30] = 0xFF;
	block[100] = 0xFF;
	block[5000] = 0xFF;

	zx::vmo vmo;
	block_fifo_request_t request[2];
	storage::OwnedVmoid vmoid;
	ASSERT_NO_FATAL_FAILURE(CreateAndRegisterVmo(&device, 2, &vmo, &vmoid));
	ASSERT_EQ(vmo.write(block, 0, kMinfsBlockSize), ZX_OK);
	ASSERT_EQ(vmo.write(block, kMinfsBlockSize, kMinfsBlockSize), ZX_OK);

	// Write abm_block and ibm_block to disk.
	FillWriteRequest(transaction_handler.get(), abm_block, ibm_block, vmoid.get(), request);

	ASSERT_EQ(device.FifoTransaction(request, 2), ZX_OK);

	// Reconstruct alloc_*_counts from respective bitmaps.
	ASSERT_TRUE(ReconstructAllocCounts(transaction_handler.get(), &device, &info).is_ok());

	// Confirm that alloc_*_counts are updated correctly.
	ASSERT_EQ(info.alloc_block_count, 32u);
	ASSERT_EQ(info.alloc_inode_count, 32u);

	// Write all bits unset for abm_block and ibm_block.
	memset(block, 0, sizeof(block));

	// Write the bitmaps to disk.
	ASSERT_EQ(vmo.write(block, 0, sizeof(block)), ZX_OK);
	ASSERT_EQ(vmo.write(block, sizeof(block), sizeof(block)), ZX_OK);
	ASSERT_EQ(device.FifoTransaction(request, 2), ZX_OK);

	// Reconstruct alloc_*_counts from respective bitmaps.
	ASSERT_TRUE(ReconstructAllocCounts(transaction_handler.get(), &device, &info).is_ok());

	// Confirm the alloc_*_counts are updated correctly.
	ASSERT_EQ(info.alloc_block_count, 0u);
	ASSERT_EQ(info.alloc_inode_count, 0u);

	memset(block, 0, sizeof(block));

	// Fill up the entire bitmap sparsely with random 1 and 0.
	block[0] = 0x88;
	block[30] = 0xAA;
	block[100] = 0x44;
	block[5000] = 0x2C;

	// Write the bitmaps on disk.
	ASSERT_EQ(vmo.write(block, 0, sizeof(block)), ZX_OK);
	ASSERT_EQ(vmo.write(block, sizeof(block), sizeof(block)), ZX_OK);
	ASSERT_EQ(device.FifoTransaction(request, 2), ZX_OK);

	// Reconstruct alloc_*_counts from respective bitmaps.
	ASSERT_TRUE(ReconstructAllocCounts(transaction_handler.get(), &device, &info).is_ok());

	// Confirm the alloc_*_counts are updated correctly.
	ASSERT_EQ(info.alloc_block_count, 11u);
	ASSERT_EQ(info.alloc_inode_count, 11u);
	}

	// Tests corrupt superblock and corrupt backup superblock.
	TEST(SuperblockTest, TestCorruptSuperblockWithoutCorrection) {
	Superblock info = {};
	FillSuperblockFields(&info);

	FakeBlockDevice device = FakeBlockDevice(100, kMinfsBlockSize);
	auto transaction_handler = std::make_unique<MockTransactionHandler>(&device);

	Superblock backup;
	memcpy(&backup, &info, sizeof(backup));

	// Corrupt original Superblock.
	info.major_version = 0xdeadbeef;

	// Corrupt backup Superblock.
	backup.major_version = 0x55;

	// Write superblock and backup to disk.
	block_fifo_request_t request[2];
	zx::vmo vmo;
	storage::OwnedVmoid vmoid;
	ASSERT_NO_FATAL_FAILURE(CreateAndRegisterVmo(&device, 2, &vmo, &vmoid));
	ASSERT_EQ(vmo.write(&info, 0, kMinfsBlockSize), ZX_OK);
	ASSERT_EQ(vmo.write(&backup, kMinfsBlockSize, kMinfsBlockSize), ZX_OK);

	FillWriteRequest(transaction_handler.get(), kSuperblockStart, kNonFvmSuperblockBackup,
	vmoid.get(), request);
	ASSERT_EQ(device.FifoTransaction(request, 2), ZX_OK);

	// Try to correct the corrupted superblock.
	auto info_or =
	RepairSuperblock(transaction_handler.get(), &device, info.dat_block + info.block_count);
	ASSERT_TRUE(info_or.is_error());

	// Read back the superblock and backup superblock.
	block_client::Reader reader(device);
	ASSERT_EQ(reader.Read(kSuperblockStart * kMinfsBlockSize, kMinfsBlockSize, &info), ZX_OK);
	ASSERT_EQ(reader.Read(kNonFvmSuperblockBackup * kMinfsBlockSize, kMinfsBlockSize, &backup),
	ZX_OK);

	// Confirm that the superblock is not updated by backup.
	ASSERT_NE(memcmp(&info, &backup, sizeof(backup)), 0);
	ASSERT_EQ(0xdeadbeef, info.major_version);
	ASSERT_EQ(backup.major_version, 0x55u);
	}

	// Tests corrupt superblock and non-corrupt backup superblock.
	TEST(SuperblockTest, TestCorruptSuperblockWithCorrection) {
	Superblock info = {};
	FillSuperblockFields(&info);

	FakeBlockDevice device = FakeBlockDevice(100, kMinfsBlockSize);
	auto transaction_handler = std::make_unique<MockTransactionHandler>(&device);

	Superblock backup;
	memcpy(&backup, &info, sizeof(backup));

	// Corrupt original Superblock.
	info.major_version = 0xdeadbeef;

	// Write superblock and backup to disk.
	block_fifo_request_t request[2];
	zx::vmo vmo;
	storage::OwnedVmoid vmoid;
	ASSERT_NO_FATAL_FAILURE(CreateAndRegisterVmo(&device, 2, &vmo, &vmoid));
	ASSERT_EQ(vmo.write(&info, 0, kMinfsBlockSize), ZX_OK);
	ASSERT_EQ(vmo.write(&backup, kMinfsBlockSize, kMinfsBlockSize), ZX_OK);
	FillWriteRequest(transaction_handler.get(), kSuperblockStart, kNonFvmSuperblockBackup,
	vmoid.get(), request);
	ASSERT_EQ(device.FifoTransaction(request, 2), ZX_OK);

	// Try to correct the corrupted superblock.
	auto info_or =
	RepairSuperblock(transaction_handler.get(), &device, info.dat_block + info.block_count);
	ASSERT_TRUE(info_or.is_ok());
	info = info_or.value();

	// Read back the superblock and backup superblock.
	block_client::Reader reader(device);
	ASSERT_EQ(reader.Read(kSuperblockStart * kMinfsBlockSize, kMinfsBlockSize, &info), ZX_OK);
	ASSERT_EQ(reader.Read(kNonFvmSuperblockBackup * kMinfsBlockSize, kMinfsBlockSize, &backup),
	ZX_OK);

	// Confirm that the superblock is updated by backup.
	ASSERT_EQ(memcmp(&info, &backup, sizeof(backup)), 0);
	}

	// Tests if Repair of corrupted superblock reconstructs the bitmaps correctly.
	TEST(SuperblockTest, TestRepairSuperblockWithBitmapReconstruction) {
	FakeBlockDevice device = FakeBlockDevice(100, kMinfsBlockSize);
	auto transaction_handler = std::make_unique<MockTransactionHandler>(&device);

	Superblock backup;
	FillSuperblockFields(&backup);
	backup.alloc_block_count = 0;
	backup.alloc_inode_count = 0;
	minfs::UpdateChecksum(&backup);

	Superblock info = {};
	// Write corrupted superblock and backup to disk.
	block_fifo_request_t request[2];
	zx::vmo vmo;
	storage::OwnedVmoid vmoid;
	ASSERT_NO_FATAL_FAILURE(CreateAndRegisterVmo(&device, 2, &vmo, &vmoid));
	ASSERT_EQ(vmo.write(&info, 0, kMinfsBlockSize), ZX_OK);
	ASSERT_EQ(vmo.write(&backup, kMinfsBlockSize, kMinfsBlockSize), ZX_OK);
	FillWriteRequest(transaction_handler.get(), kSuperblockStart, kNonFvmSuperblockBackup,
	vmoid.get(), request);
	ASSERT_EQ(device.FifoTransaction(request, 2), ZX_OK);

	uint8_t block[minfs::kMinfsBlockSize];
	memset(block, 0, sizeof(block));

	// Fill up the entire bitmap sparsely with random 1 and 0.
	block[0] = 0xFF;
	block[30] = 0xFF;
	block[100] = 0xFF;
	block[5000] = 0xFF;

	// Write abm_block and ibm_block to disk.
	ASSERT_EQ(vmo.write(block, 0, kMinfsBlockSize), ZX_OK);
	ASSERT_EQ(vmo.write(block, kMinfsBlockSize, kMinfsBlockSize), ZX_OK);
	FillWriteRequest(transaction_handler.get(), abm_block, ibm_block, vmoid.get(), request);
	ASSERT_EQ(device.FifoTransaction(request, 2), ZX_OK);

	// Try to correct the corrupted superblock.
	auto info_or =
	RepairSuperblock(transaction_handler.get(), &device, backup.dat_block + backup.block_count);
	ASSERT_TRUE(info_or.is_ok());
	info = info_or.value();

	// Read back the superblock and backup superblock.
	block_client::Reader reader(device);
	ASSERT_EQ(reader.Read(kSuperblockStart * kMinfsBlockSize, kMinfsBlockSize, &info), ZX_OK);
	ASSERT_EQ(reader.Read(kNonFvmSuperblockBackup * kMinfsBlockSize, kMinfsBlockSize, &backup),
	ZX_OK);

	// Confirm that alloc_*_counts are updated correctly in superblock and backup from bitmaps.
	ASSERT_GT(info.alloc_block_count, 0u);
	ASSERT_GT(info.alloc_inode_count, 0u);
	ASSERT_GT(backup.alloc_block_count, 0u);
	ASSERT_GT(backup.alloc_inode_count, 0u);
	}

	TEST(SuperblockTest, UnsupportedBlockSize) {
	ASSERT_DEATH(
	{
	Superblock info = {};
	info.block_size = kMinfsBlockSize - 1;
	info.BlockSize();
	},
	_);
	}

	TEST(SuperblockTest, SupportedBlockSize) {
	Superblock info = {};
	info.block_size = kMinfsBlockSize;
	info.BlockSize();
	}

	TEST(SuperblockTest, GetFvmFlag) {
	Superblock info;
	FillSuperblockFields(&info);
	ASSERT_FALSE(info.GetFlagFvm());

	SetMinfsFlagFvm(info);
	ASSERT_TRUE(info.GetFlagFvm());
	}

	TEST(SuperblockTest, InodeBitmapStartBlock) {
	Superblock info;
	FillSuperblockFields(&info);
	ASSERT_EQ(info.InodeBitmapStartBlock(), info.ibm_block);

	SetMinfsFlagFvm(info);
	ASSERT_EQ(info.InodeBitmapStartBlock(), kFVMBlockInodeBmStart);
	}

	TEST(SuperblockTest, DataBitmapStartBlock) {
	Superblock info;
	FillSuperblockFields(&info);
	ASSERT_EQ(info.DataBitmapStartBlock(), info.abm_block);

	SetMinfsFlagFvm(info);
	ASSERT_EQ(info.DataBitmapStartBlock(), kFVMBlockDataBmStart);
	}

	TEST(SuperblockTest, InodeTableStartBlock) {
	Superblock info;
	FillSuperblockFields(&info);
	ASSERT_EQ(info.InodeTableStartBlock(), info.ino_block);

	SetMinfsFlagFvm(info);
	ASSERT_EQ(info.InodeTableStartBlock(), kFVMBlockInodeStart);
	}

	TEST(SuperblockTest, DataStartBlock) {
	Superblock info;
	FillSuperblockFields(&info);
	ASSERT_EQ(info.DataStartBlock(), info.dat_block);

	SetMinfsFlagFvm(info);
	ASSERT_EQ(info.DataStartBlock(), kFVMBlockDataStart);
	}

	TEST(SuperblockTest, BackupSuperblock) {
	Superblock info;
	FillSuperblockFields(&info);
	ASSERT_EQ(info.BackupSuperblockStart(), kNonFvmSuperblockBackup);

	SetMinfsFlagFvm(info);
	ASSERT_EQ(info.BackupSuperblockStart(), kFvmSuperblockBackup);
	}

	} // namespace
	} // namespace minfs