// Copyright 2017 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 "src/storage/blobfs/blobfs_checker.h"

#include <inttypes.h>
#include <lib/syslog/cpp/macros.h>

#include <iterator>
#include <utility>

#ifdef __Fuchsia__

#include <fidl/fuchsia.hardware.block.volume/cpp/wire.h>
#include <zircon/status.h>

#else

#include "src/storage/blobfs/host.h"

#endif

#include "src/storage/blobfs/iterator/allocated_extent_iterator.h"

namespace blobfs {

bool BlobfsChecker::CheckBackupSuperblock() {
  if ((blobfs_->Info().flags & kBlobFlagFVM) == 0 ||
      blobfs_->Info().oldest_minor_version < kBlobfsMinorVersionBackupSuperblock)
    return true;
  auto superblock_or = blobfs_->ReadBackupSuperblock();
  if (superblock_or.is_error()) {
    FX_LOGS(ERROR) << "could not read backup superblock: " << superblock_or.status_value();
    return false;
  }
  if (zx_status_t status =
          CheckSuperblock(superblock_or.value().get(), TotalBlocks(*superblock_or.value()));
      status != ZX_OK) {
    FX_LOGS(ERROR) << "bad backup superblock: " << status;
    return false;
  }
  return true;
}

bool BlobfsChecker::TraverseInodeBitmap() {
  bool valid = true;
  for (unsigned n = 0; n < blobfs_->info_.inode_count; n++) {
    auto inode = blobfs_->GetNode(n);
    ZX_ASSERT_MSG(inode.is_ok(), "Failed to get node %u: status=%d", n, inode.status_value());
    if (inode->header.IsAllocated()) {
      alloc_inodes_++;

      if (options_.strict) {
        if (inode->reserved != 0) {
          FX_LOGS(ERROR) << "check: reserved field non-zero: 0x" << std::hex << inode->reserved;
          valid = false;
        }

        if ((inode->header.flags & ~kBlobFlagMaskValid)) {
          FX_LOGS(ERROR) << "check: unexpected flags set: 0x" << std::hex << inode->header.flags;
          valid = false;
        }

        if (inode->header.version != kBlobNodeVersion) {
          FX_LOGS(ERROR) << "check: unexpected node version: " << inode->header.version;
          valid = false;
        }
      }

      if (inode->header.IsExtentContainer()) {
        if (options_.strict &&
            (inode->header.flags & ~(kBlobFlagAllocated | kBlobFlagExtentContainer))) {
          FX_LOGS(ERROR) << "check: unexpected flags set on extent container: 0x" << std::hex
                         << inode->header.flags;
          valid = false;
        }

        // Extent containers are further validated as we traverse all the extents of a blob below.
        continue;
      }

      bool blob_valid = true;

      auto extents = AllocatedExtentIterator::Create(blobfs_->GetNodeFinder(), n);
      ZX_ASSERT_MSG(extents.is_ok(), "Failed to create extent iterator for inode %u: status=%d", n,
                    extents.status_value());

      while (!extents->Done()) {
        auto extent_or = extents->Next();
        if (extent_or.is_error()) {
          FX_LOGS(ERROR) << "check: Failed to acquire extent " << extents->ExtentIndex()
                         << " within inode " << n << ": " << *inode.value();
          blob_valid = false;
          break;
        }
        const Extent* extent = extent_or.value();
        if (extent->Length() == 0) {
          FX_LOGS(ERROR) << "check: Found zero-length extent at idx " << extents->ExtentIndex()
                         << " within inode " << n << ": " << *inode.value();
          blob_valid = false;
          break;
        }

        uint64_t start_block = extent->Start();
        uint64_t end_block = extent->Start() + extent->Length();
        uint64_t first_unset = 0;
        if (!blobfs_->CheckBlocksAllocated(start_block, end_block, &first_unset)) {
          FX_LOGS(ERROR) << "check: ino " << n << " using blocks [" << start_block << ", "
                         << end_block
                         << "). "
                            "Not fully allocated in block bitmap; first unset @"
                         << first_unset;
          blob_valid = false;
        }
        inode_blocks_ += extent->Length();
      }

      if (options_.strict && extents->node_prelude().next_node != kMaxNodeId) {
        FX_LOGS(ERROR) << "check: unexpected next_node: " << std::hex
                       << extents->node_prelude().next_node << " != " << kMaxNodeId;
        valid = false;
      }

      if (blob_valid) {
        if (zx_status_t status = blobfs_->LoadAndVerifyBlob(n); status != ZX_OK) {
          FX_LOGS(ERROR) << "check: detected inode " << n << " with bad state: " << status;
          blob_valid = false;
        }
      }
      if (!blob_valid) {
        valid = false;
      }
    } else {  // not allocated...
      if (options_.strict && inode->header.flags != 0) {
        FX_LOGS(ERROR) << "check: unallocated node with non-zero flags: " << inode->header.flags;
        valid = false;
      }
    }
  }  // for ...
  return valid;
}

bool BlobfsChecker::TraverseBlockBitmap() {
  for (uint64_t n = 0; n < blobfs_->info_.data_block_count; n++) {
    if (blobfs_->CheckBlocksAllocated(n, n + 1)) {
      alloc_blocks_++;
    }
  }
  return true;
}

bool BlobfsChecker::CheckAllocatedCounts() const {
  bool valid = true;
  if (alloc_blocks_ != blobfs_->info_.alloc_block_count) {
    FX_LOGS(ERROR) << "check: incorrect allocated block count " << blobfs_->info_.alloc_block_count
                   << " (should be " << alloc_blocks_ << ")";
    valid = false;
  }

  if (alloc_blocks_ < kStartBlockMinimum) {
    FX_LOGS(ERROR) << "check: allocated blocks (" << alloc_blocks_ << ") are less than minimum ("
                   << kStartBlockMinimum << ")";
    valid = false;
  }

  if (inode_blocks_ + kStartBlockMinimum != alloc_blocks_) {
    FX_LOGS(ERROR) << "check: bitmap allocated blocks (" << alloc_blocks_
                   << ") do not match inode allocated blocks "
                      "("
                   << inode_blocks_ + kStartBlockMinimum << ")";
    valid = false;
  }

  if (alloc_inodes_ != blobfs_->info_.alloc_inode_count) {
    FX_LOGS(ERROR) << "check: incorrect allocated inode count " << blobfs_->info_.alloc_inode_count
                   << " (should be " << alloc_inodes_ << ")";
    valid = false;
  }
  return valid;
}

bool BlobfsChecker::Check() {
  bool valid = true;
  FX_LOGS(INFO) << "Checking backup superblock...";
  valid &= CheckBackupSuperblock();
  FX_LOGS(INFO) << "Verifying inodes and blob data...";
  valid &= TraverseInodeBitmap();
  FX_LOGS(INFO) << "Checking allocation counts...";
  valid &= TraverseBlockBitmap();
  valid &= CheckAllocatedCounts();
  return valid;
}

BlobfsChecker::BlobfsChecker(Blobfs* blobfs, Options options)
    : blobfs_(blobfs), options_(options) {}

#ifdef __Fuchsia__
zx_status_t CheckFvmConsistency(const Superblock* info, BlockDevice* device, bool repair) {
  if ((info->flags & kBlobFlagFVM) == 0) {
    return ZX_OK;
  }

  fuchsia_hardware_block_volume::wire::VolumeManagerInfo manager_info;
  fuchsia_hardware_block_volume::wire::VolumeInfo volume_info;
  zx_status_t status = device->VolumeGetInfo(&manager_info, &volume_info);
  if (status != ZX_OK) {
    FX_LOGS(ERROR) << "Unable to query FVM, status: " << zx_status_get_string(status);
    return status;
  }

  if (info->slice_size != manager_info.slice_size) {
    FX_LOGS(ERROR) << "Slice size did not match expected";
    return ZX_ERR_BAD_STATE;
  }
  const size_t kBlocksPerSlice = info->slice_size / kBlobfsBlockSize;

  size_t expected_count[4];
  expected_count[0] = info->abm_slices;
  expected_count[1] = info->ino_slices;
  expected_count[2] = info->journal_slices;
  expected_count[3] = info->dat_slices;

  uint64_t start_slices[4];
  start_slices[0] = kFVMBlockMapStart / kBlocksPerSlice;
  start_slices[1] = kFVMNodeMapStart / kBlocksPerSlice;
  start_slices[2] = kFVMJournalStart / kBlocksPerSlice;
  start_slices[3] = kFVMDataStart / kBlocksPerSlice;

  fuchsia_hardware_block_volume::wire::VsliceRange
      ranges[fuchsia_hardware_block_volume::wire::kMaxSliceRequests];
  size_t actual_ranges_count;
  status = device->VolumeQuerySlices(start_slices, std::size(start_slices), ranges,
                                     &actual_ranges_count);
  if (status != ZX_OK) {
    FX_LOGS(ERROR) << "Cannot query slices, status: " << zx_status_get_string(status);
    return status;
  }

  if (actual_ranges_count != std::size(start_slices)) {
    FX_LOGS(ERROR) << "Missing slice";
    return ZX_ERR_BAD_STATE;
  }

  for (size_t i = 0; i < std::size(start_slices); i++) {
    size_t blobfs_count = expected_count[i];
    size_t fvm_count = ranges[i].count;

    if (!ranges[i].allocated || fvm_count < blobfs_count) {
      // Currently, since Blobfs can only grow new slices, it should not be possible for the FVM to
      // report a slice size smaller than what is reported by Blobfs. In this case, automatically
      // fail without trying to resolve the situation, as it is possible that Blobfs structures are
      // allocated in the slices that have been lost.
      FX_LOGS(ERROR) << "Mismatched slice count (superblock reports " << blobfs_count
                     << ", fvm has " << fvm_count << "). " << *info;
      return ZX_ERR_IO_DATA_INTEGRITY;
    }

    if (fvm_count > blobfs_count && repair) {
      // If FVM reports more slices than we expect, try to free remainder.
      uint64_t offset = start_slices[i] + blobfs_count;
      uint64_t length = fvm_count - blobfs_count;
      zx_status_t status = device->VolumeShrink(offset, length);
      if (status != ZX_OK) {
        FX_LOGS(ERROR) << "Unable to shrink to expected size: " << zx_status_get_string(status);
        return status;
      }
    }
  }

  return ZX_OK;
}
#endif  // ifdef __Fuchsia__

}  // namespace blobfs