// 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 <lib/syslog/cpp/macros.h>

#include <bitset>

#include "f2fs.h"

namespace f2fs::fsck {

struct Block {
  uint8_t data[kBlockSize];
};

template <typename T>
static inline void DisplayMember(uint32_t typesize, T &value, std::string name) {
  if (typesize == sizeof(char)) {
    std::cout << name << " [" << value << "]" << std::endl;
  } else {
    ZX_ASSERT(sizeof(T) <= typesize);
    std::cout << name << " [0x" << std::hex << value << " : " << std::dec << value << "]"
              << std::endl;
  }
}

static int32_t operator-(CursegType &a, CursegType &&b) {
  return (static_cast<int32_t>(a) - static_cast<int32_t>(b));
}

static bool operator<=(int32_t &a, CursegType &&b) { return (a <= static_cast<int32_t>(b)); }

CursegType operator+(CursegType a, uint32_t &&b) {
  return static_cast<CursegType>(static_cast<uint32_t>(a) + b);
}

static inline bool IsSumNodeSeg(SummaryFooter &footer) { return footer.entry_type == kSumTypeNode; }

static inline uint64_t BlkoffFromMain(SbInfo *sbi, uint64_t blk_addr) {
  ZX_ASSERT(blk_addr >= GetSmInfo(sbi)->main_blkaddr);
  return blk_addr - GetSmInfo(sbi)->main_blkaddr;
}

static inline uint32_t OffsetInSeg(SbInfo *sbi, uint64_t blk_addr) {
  return (uint32_t)(BlkoffFromMain(sbi, blk_addr) % (1 << sbi->log_blocks_per_seg));
}

static inline uint32_t AddrsPerInode(Inode *i) {
#if 0  // porting needed
	      if (i->i_inline & kInlineXattr)
					            return kAddrPerInode - kInlineXattrAddrs;
#endif
  return kAddrsPerInode;
}

zx_status_t Fsck(Bcache *bc) {
  FsckWorker fsck(bc);
  return fsck.Run();
}

zx_status_t FsckWorker::ReadBlock(void *data, uint64_t bno) { return bc_->Readblk(bno, data); }

void FsckWorker::AddIntoHardLinkList(uint32_t nid, uint32_t link_cnt) {
  FsckInfo *fsck = &fsck_;
  HardLinkNode *node = nullptr, *tmp = nullptr, *prev = nullptr;

  node = new HardLinkNode();
  ZX_ASSERT(node != nullptr);

  node->nid = nid;
  node->links = link_cnt;
  node->next = nullptr;

  if (fsck->hard_link_list_head == nullptr) {
    fsck->hard_link_list_head = node;
  } else {
    tmp = fsck->hard_link_list_head;

    // Find insertion position
    while (tmp && (nid < tmp->nid)) {
      ZX_ASSERT(tmp->nid != nid);
      prev = tmp;
      tmp = tmp->next;
    }

    if (tmp == fsck->hard_link_list_head) {
      node->next = tmp;
      fsck->hard_link_list_head = node;
    } else {
      prev->next = node;
      node->next = tmp;
    }
  }
  FX_LOGS(INFO) << "ino[0x" << std::hex << nid << "] has hard links [0x" << link_cnt << "]";
}

zx_status_t FsckWorker::FindAndDecHardLinkList(uint32_t nid) {
  FsckInfo *fsck = &fsck_;
  HardLinkNode *node = nullptr, *prev = nullptr;

  if (fsck->hard_link_list_head == nullptr) {
    ZX_ASSERT(0);
    return ZX_ERR_NOT_FOUND;
  }

  node = fsck->hard_link_list_head;

  while (node && (nid < node->nid)) {
    prev = node;
    node = node->next;
  }

  if (node == nullptr || (nid != node->nid)) {
    ZX_ASSERT(0);
    return ZX_ERR_NOT_FOUND;
  }

  // Decrease link count
  node->links = node->links - 1;

  // if link count becomes one, remove the node
  if (node->links == 1) {
    if (fsck->hard_link_list_head == node)
      fsck->hard_link_list_head = node->next;
    else
      prev->next = node->next;
    delete node;
  }

  return ZX_OK;
}

bool FsckWorker::IsValidSsaNodeBlk(uint32_t nid, uint32_t blk_addr) {
  Summary sum_entry;

  SegType ret = GetSumEntry(blk_addr, &sum_entry);
  ZX_ASSERT(static_cast<int>(ret) >= 0);

  if (ret == SegType::kSegTypeData || ret == SegType::kSegTypeCurData) {
    FX_LOGS(ERROR) << "Summary footer is not a node segment summary";
    ZX_ASSERT(0);
  } else if (ret == SegType::kSegTypeNode) {
    if (LeToCpu(sum_entry.nid) != nid) {
      FX_LOGS(ERROR) << "nid                       [0x" << std::hex << nid << "]";
      FX_LOGS(ERROR) << "target blk_addr           [0x" << std::hex << blk_addr << "]";
      FX_LOGS(ERROR) << "summary blk_addr          [0x" << std::hex
                     << GetSumBlock(&sbi_, GetSegNo(blk_addr)) << "]";
      FX_LOGS(ERROR) << "seg no / offset           [0x" << std::hex << GetSegNo(blk_addr) << "/0x"
                     << std::hex << OffsetInSeg(&sbi_, blk_addr) << "]";
      FX_LOGS(ERROR) << "summary_entry.nid         [0x" << std::hex << LeToCpu(sum_entry.nid)
                     << "]";
      FX_LOGS(ERROR) << "--> node block's nid      [0x" << std::hex << nid << "]";
      FX_LOGS(ERROR) << "Invalid node seg summary\n";
      ZX_ASSERT(0);
    }
  } else if (ret == SegType::kSegTypeCurNode) {
    // current node segment has no ssa
  } else {
    FX_LOGS(ERROR) << "Invalid return value of 'GetSumEntry'";
    ZX_ASSERT(0);
  }
  return true;
}

bool FsckWorker::IsValidSsaDataBlk(uint32_t blk_addr, uint32_t parent_nid, uint16_t idx_in_node,
                                   uint8_t version) {
  Summary sum_entry;

  SegType ret = GetSumEntry(blk_addr, &sum_entry);
  ZX_ASSERT(ret == SegType::kSegTypeData || ret == SegType::kSegTypeCurData);

  if (LeToCpu(sum_entry.nid) != parent_nid || sum_entry.version != version ||
      LeToCpu(sum_entry.ofs_in_node) != idx_in_node) {
    FX_LOGS(ERROR) << "summary_entry.nid         [0x" << std::hex << LeToCpu(sum_entry.nid) << "]";
    FX_LOGS(ERROR) << "summary_entry.version     [0x" << std::hex << sum_entry.version << "]";
    FX_LOGS(ERROR) << "summary_entry.ofs_in_node [0x" << std::hex << LeToCpu(sum_entry.ofs_in_node)
                   << "]";

    FX_LOGS(ERROR) << "parent nid                [0x" << std::hex << parent_nid << "]";
    FX_LOGS(ERROR) << "version from nat          [0x" << std::hex << version << "]";
    FX_LOGS(ERROR) << "idx in parent node        [0x" << std::hex << idx_in_node << "]";

    FX_LOGS(ERROR) << "Target data block addr    [0x" << std::hex << blk_addr << "]";
    FX_LOGS(ERROR) << "Invalid data seg summary\n";
    ZX_ASSERT(0);
  }
  return true;
}

zx_status_t FsckWorker::ChkNodeBlk(Inode *inode, uint32_t nid, FileType ftype, NodeType ntype,
                                   uint32_t *blk_cnt) {
  FsckInfo *fsck = &fsck_;
  NodeInfo ni;
  Node *node_blk = nullptr;
  zx_status_t ret = ZX_OK;
  SbInfo *sbi = &sbi_;

  IsValidNid(nid);

  if (ftype != FileType::kFtOrphan || TestValidBitmap(nid, fsck->nat_area_bitmap) != 0x0)
    ClearValidBitmap(nid, fsck->nat_area_bitmap);
  else {
    FX_LOGS(ERROR) << "nid duplicated [0x" << std::hex << nid << "]";
  }

  ret = GetNodeInfo(nid, &ni);
  ZX_ASSERT(ret == ZX_OK);

  // Is it reserved block?
  // if block addresss was kNewAddr
  // it means that block was already allocated, but not stored in disk
  if (ni.blk_addr == kNewAddr) {
    fsck->chk.valid_blk_cnt++;
    fsck->chk.valid_node_cnt++;
    if (ntype == NodeType::kTypeInode)
      fsck->chk.valid_inode_cnt++;
    return ZX_OK;
  }

  IsValidBlkAddr(ni.blk_addr);
  IsValidSsaNodeBlk(nid, ni.blk_addr);

  if (TestValidBitmap(BlkoffFromMain(sbi, ni.blk_addr), fsck->sit_area_bitmap) == 0x0) {
    FX_LOGS(INFO) << "SIT bitmap is 0x0. blk_addr[0x" << std::hex << ni.blk_addr << "]";
    ZX_ASSERT(0);
  }

  if (TestValidBitmap(BlkoffFromMain(sbi, ni.blk_addr), fsck->main_area_bitmap) == 0x0) {
    fsck->chk.valid_blk_cnt++;
    fsck->chk.valid_node_cnt++;
  }

  Block *blk = new Block;
  ZX_ASSERT(blk != nullptr);
  node_blk = reinterpret_cast<Node *>(blk->data);
  ret = ReadBlock(node_blk, ni.blk_addr);
  ZX_ASSERT(ret == ZX_OK);
  ZX_ASSERT_MSG(nid == LeToCpu(node_blk->footer.nid), "nid[0x%x] blk_addr[0x%x] footer.nid[0x%x]\n",
                nid, ni.blk_addr, LeToCpu(node_blk->footer.nid));

  if (ntype == NodeType::kTypeInode) {
    ret = ChkInodeBlk(nid, ftype, node_blk, blk_cnt, &ni);
  } else {
    // it's not inode
    ZX_ASSERT(node_blk->footer.nid != node_blk->footer.ino);

    if (TestValidBitmap(BlkoffFromMain(sbi, ni.blk_addr), fsck->main_area_bitmap) != 0) {
      FX_LOGS(INFO) << "Duplicated node block. ino[0x" << std::hex << nid << "][0x" << std::hex
                    << ni.blk_addr;
      ZX_ASSERT(0);
    }
    SetValidBitmap(BlkoffFromMain(sbi, ni.blk_addr), fsck->main_area_bitmap);

    switch (ntype) {
      case NodeType::kTypeDirectNode:
        ChkDnodeBlk(inode, nid, ftype, node_blk, blk_cnt, &ni);
        break;
      case NodeType::kTypeIndirectNode:
        ChkIdnodeBlk(inode, nid, ftype, node_blk, blk_cnt);
        break;
      case NodeType::kTypeDoubleIndirectNode:
        ChkDidnodeBlk(inode, nid, ftype, node_blk, blk_cnt);
        break;
      default:
        ZX_ASSERT(0);
    }
  }

  ZX_ASSERT(ret == ZX_OK);

  delete blk;
  return ZX_OK;
}

zx_status_t FsckWorker::ChkInodeBlk(uint32_t nid, FileType ftype, Node *node_blk, uint32_t *blk_cnt,
                                    NodeInfo *ni) {
  FsckInfo *fsck = &fsck_;
  uint32_t child_cnt = 0, child_files = 0;
  NodeType ntype;
  uint32_t i_links = LeToCpu(node_blk->i.i_links);
  uint64_t i_blocks = LeToCpu(node_blk->i.i_blocks);
  uint32_t idx = 0;

  ZX_ASSERT(node_blk->footer.nid == node_blk->footer.ino);
  ZX_ASSERT(LeToCpu(node_blk->footer.nid) == nid);

  if (TestValidBitmap(BlkoffFromMain(&sbi_, ni->blk_addr), fsck->main_area_bitmap) == 0x0)
    fsck->chk.valid_inode_cnt++;

  // Orphan node. i_links should be 0
  if (ftype == FileType::kFtOrphan) {
    ZX_ASSERT(i_links == 0);
  } else {
    ZX_ASSERT(i_links > 0);
  }

  if (ftype == FileType::kFtDir) {
    // not included '.' & '..'
    if (TestValidBitmap(BlkoffFromMain(&sbi_, ni->blk_addr), fsck->main_area_bitmap) != 0) {
      FX_LOGS(INFO) << "Duplicated inode blk. ino[0x" << std::hex << nid << "][0x" << std::hex
                    << ni->blk_addr;
      ZX_ASSERT(0);
    }
    SetValidBitmap(BlkoffFromMain(&sbi_, ni->blk_addr), fsck->main_area_bitmap);

  } else {
    if (TestValidBitmap(BlkoffFromMain(&sbi_, ni->blk_addr), fsck->main_area_bitmap) == 0x0) {
      SetValidBitmap(BlkoffFromMain(&sbi_, ni->blk_addr), fsck->main_area_bitmap);
      if (i_links > 1) {
        // First time. Create new hard link node
        AddIntoHardLinkList(nid, i_links);
        fsck->chk.multi_hard_link_files++;
      }
    } else {
      if (i_links <= 1) {
        FX_LOGS(ERROR) << "Error. Node ID [0x" << std::hex << nid << "].";
        FX_LOGS(ERROR) << " There are one more hard links. But i_links is [0x" << std::hex
                       << i_links << "].";
        ZX_ASSERT(0);
      }

      FX_LOGS(INFO) << "ino[0x" << std::hex << nid << "] has hard links [0x" << std::hex << i_links
                    << "]";
      zx_status_t status = FindAndDecHardLinkList(nid);
      ZX_ASSERT(status == ZX_OK);

      // No need to go deep into the node
      return ZX_OK;
    }
  }
#if 0  // porting needed
  fsck_chk_xattr_blk(sbi, nid, LeToCpu(node_blk->i.i_xattr_nid), blk_cnt);
#endif

  do {
    if (ftype == FileType::kFtChrdev || ftype == FileType::kFtBlkdev ||
        ftype == FileType::kFtFifo || ftype == FileType::kFtSock)
      break;
#if 0  // porting needed
  if ((node_blk->i.i_inline & F2FS_INLINE_DATA)) {
    FX_LOGS(INFO) << "ino[0x" << std::hex << nid << "] has inline data";
    break;
  }
#endif

    // check data blocks in inode
    for (idx = 0; idx < AddrsPerInode(&node_blk->i); idx++) {
      if (LeToCpu(node_blk->i.i_addr[idx]) != 0) {
        *blk_cnt = *blk_cnt + 1;
        zx_status_t ret =
            ChkDataBlk(&node_blk->i, LeToCpu(node_blk->i.i_addr[idx]), &child_cnt, &child_files,
                       (i_blocks == *blk_cnt), ftype, nid, idx, ni->version);
        ZX_ASSERT(ret == ZX_OK);
      }
    }

    // check node blocks in inode
    for (idx = 0; idx < 5; idx++) {
      if (idx == 0 || idx == 1)
        ntype = NodeType::kTypeDirectNode;
      else if (idx == 2 || idx == 3)
        ntype = NodeType::kTypeIndirectNode;
      else if (idx == 4)
        ntype = NodeType::kTypeDoubleIndirectNode;
      else
        ZX_ASSERT(0);

      if (LeToCpu(node_blk->i.i_nid[idx]) != 0) {
        *blk_cnt = *blk_cnt + 1;
        zx_status_t ret =
            ChkNodeBlk(&node_blk->i, LeToCpu(node_blk->i.i_nid[idx]), ftype, ntype, blk_cnt);
        ZX_ASSERT(ret == ZX_OK);
      }
    }
  } while (0);
#ifdef F2FS_BU_DEBUG
  if (ftype == FileType::kFtDir)  // TODO: DBG(1)
    printf("Directory Inode: ino: %x name: %s depth: %d child files: %d\n\n",
           LeToCpu(node_blk->footer.ino), node_blk->i.i_name, LeToCpu(node_blk->i.i_current_depth),
           child_files);
  if (ftype == FileType::kFtOrphan)  // TODO: DBG (1)
    printf("Orphan Inode: ino: %x name: %s i_blocks: %u\n\n", LeToCpu(node_blk->footer.ino),
           node_blk->i.i_name, (uint32_t)i_blocks);
#endif
  if ((ftype == FileType::kFtDir && i_links != child_cnt) || (i_blocks != *blk_cnt)) {
    PrintNodeInfo(node_blk);
#ifdef F2FS_BU_DEBUG
    // TODO: DBG (1)
    printf("blk   cnt [0x%x]\n", *blk_cnt);
    // TODO: DBG (1)
    printf("child cnt [0x%x]\n", child_cnt);
#endif
  }

  ZX_ASSERT(i_blocks == *blk_cnt);
  if (ftype == FileType::kFtDir)
    ZX_ASSERT(i_links == child_cnt);
  return ZX_OK;
}

void FsckWorker::ChkDnodeBlk(Inode *inode, uint32_t nid, FileType ftype, Node *node_blk,
                             uint32_t *blk_cnt, NodeInfo *ni) {
  uint32_t child_cnt = 0, child_files = 0;
  for (uint32_t idx = 0; idx < kAddrsPerBlock; idx++) {
    if (LeToCpu(node_blk->dn.addr[idx]) == 0x0)
      continue;
    *blk_cnt = *blk_cnt + 1;
    ChkDataBlk(inode, LeToCpu(node_blk->dn.addr[idx]), &child_cnt, &child_files,
               LeToCpu(inode->i_blocks) == *blk_cnt, ftype, nid, idx, ni->version);
  }
}

void FsckWorker::ChkIdnodeBlk(Inode *inode, uint32_t nid, FileType ftype, Node *node_blk,
                              uint32_t *blk_cnt) {
  for (uint32_t i = 0; i < kNidsPerBlock; i++) {
    if (LeToCpu(node_blk->in.nid[i]) == 0x0)
      continue;
    *blk_cnt = *blk_cnt + 1;
    ChkNodeBlk(inode, LeToCpu(node_blk->in.nid[i]), ftype, NodeType::kTypeDirectNode, blk_cnt);
  }
}

void FsckWorker::ChkDidnodeBlk(Inode *inode, uint32_t nid, FileType ftype, Node *node_blk,
                               uint32_t *blk_cnt) {
  int i = 0;

  for (i = 0; i < kNidsPerBlock; i++) {
    if (LeToCpu(node_blk->in.nid[i]) == 0x0)
      continue;
    *blk_cnt = *blk_cnt + 1;
    ChkNodeBlk(inode, LeToCpu(node_blk->in.nid[i]), ftype, NodeType::kTypeIndirectNode, blk_cnt);
  }
}

void FsckWorker::PrintDentry(uint32_t depth, std::string_view &name, DentryBlock *de_blk, int idx,
                             int last_blk) {
  int last_de = 0;
  int next_idx = 0;
  int name_len;
  uint32_t i;
  int bit_offset;

#if 0  // porting needed
  if (config.dbg_lv != -1)
    return;
#endif

  name_len = LeToCpu(de_blk->dentry[idx].name_len);
  next_idx = idx + (name_len + kDentrySlotLen - 1) / kDentrySlotLen;

  bit_offset = find_next_bit_le(de_blk->dentry_bitmap, kNrDentryInBlock, next_idx);
  if (bit_offset >= kNrDentryInBlock && last_blk)
    last_de = 1;

  if (tree_mark_.size() <= depth) {
    tree_mark_.resize(tree_mark_.size() * 2, 0);
  }
  if (last_de)
    tree_mark_[depth] = '`';
  else
    tree_mark_[depth] = '|';

  if (tree_mark_[depth - 1] == '`')
    tree_mark_[depth - 1] = ' ';

  for (i = 1; i < depth; i++)
    std::cout << tree_mark_[i] << "   ";
  std::cout << (last_de ? "`" : "|") << "-- " << name << std::endl;
}

void FsckWorker::ChkDentryBlk(Inode *inode, uint32_t blk_addr, uint32_t *child_cnt,
                              uint32_t *child_files, int last_blk) {
  FsckInfo *fsck = &fsck_;
  int i;
  int ret = 0;
  int dentries = 0;
  uint32_t hash_code;
  uint32_t blk_cnt;
  FileType ftype;
  DentryBlock *de_blk;

  Block *blk = new Block;
  ZX_ASSERT(blk != nullptr);
  de_blk = reinterpret_cast<DentryBlock *>(blk->data);

  ret = ReadBlock(de_blk, blk_addr);
  ZX_ASSERT(ret >= 0);

  fsck->dentry_depth++;

  for (i = 0; i < kNrDentryInBlock;) {
    if (test_bit(i, (unsigned long *)de_blk->dentry_bitmap) == 0x0) {
      i++;
      continue;
    }

    std::string_view name(reinterpret_cast<char *>(de_blk->filename[i]),
                          LeToCpu(de_blk->dentry[i].name_len));

    hash_code = DentryHash(name.data(), name.length());

    ftype = static_cast<FileType>(de_blk->dentry[i].file_type);

    // Becareful. 'dentry.file_type' is not imode
    if (ftype == FileType::kFtDir) {
      *child_cnt = *child_cnt + 1;
      if (name.compare("..") == 0 || name.compare(".") == 0) {
        i++;
        continue;
      }
    }

    // TODO: Should we check '.' and '..' entries?
    ZX_ASSERT(LeToCpu(de_blk->dentry[i].hash_code) == hash_code);
#ifdef F2FS_BU_DEBUG
    // TODO: DBG (2)
    printf("[%3u] - no[0x%x] name[%s] len[0x%x] ino[0x%x] type[0x%x]\n", fsck->dentry_depth, i,
           name.data(), LeToCpu(de_blk->dentry[i].name_len), LeToCpu(de_blk->dentry[i].ino),
           de_blk->dentry[i].file_type);
#endif
    PrintDentry(fsck->dentry_depth, name, de_blk, i, last_blk);

    blk_cnt = 1;
    ret =
        ChkNodeBlk(nullptr, LeToCpu(de_blk->dentry[i].ino), ftype, NodeType::kTypeInode, &blk_cnt);

    ZX_ASSERT(ret >= 0);

    i += (name.length() + kDentrySlotLen - 1) / kDentrySlotLen;
    dentries++;
    *child_files = *child_files + 1;
  }
#ifdef F2FS_BU_DEBUG
  // TODO: DBG (1)
  printf("[%3d] Dentry Block [0x%x] Done : dentries:%d in %d slots (len:%d)\n\n",
         fsck->dentry_depth, blk_addr, dentries, kNrDentryInBlock, kMaxNameLen);
#endif
  fsck->dentry_depth--;

  delete blk;
}

zx_status_t FsckWorker::ChkDataBlk(Inode *inode, uint32_t blk_addr, uint32_t *child_cnt,
                                   uint32_t *child_files, int last_blk, FileType ftype,
                                   uint32_t parent_nid, uint16_t idx_in_node, uint8_t ver) {
  FsckInfo *fsck = &fsck_;

  // Is it reserved block?
  if (blk_addr == kNewAddr) {
    fsck->chk.valid_blk_cnt++;
    return ZX_OK;
  }

  IsValidBlkAddr(blk_addr);

  IsValidSsaDataBlk(blk_addr, parent_nid, idx_in_node, ver);

  if (TestValidBitmap(BlkoffFromMain(&sbi_, blk_addr), fsck->sit_area_bitmap) == 0x0) {
    ZX_ASSERT_MSG(0, "SIT bitmap is 0x0. blk_addr[0x%x]\n", blk_addr);
  }

  if (TestValidBitmap(BlkoffFromMain(&sbi_, blk_addr), fsck->main_area_bitmap) != 0) {
    ZX_ASSERT_MSG(0, "Duplicated data block. pnid[0x%x] idx[0x%x] blk_addr[0x%x]\n", parent_nid,
                  idx_in_node, blk_addr);
  }
  SetValidBitmap(BlkoffFromMain(&sbi_, blk_addr), fsck->main_area_bitmap);

  fsck->chk.valid_blk_cnt++;

  if (ftype == FileType::kFtDir) {
    ChkDentryBlk(inode, blk_addr, child_cnt, child_files, last_blk);
  }

  return ZX_OK;
}

void FsckWorker::ChkOrphanNode() {
  uint32_t blk_cnt = 0;
  block_t start_blk, orphan_blkaddr, i, j;
  OrphanBlock *orphan_blk;

  if (!IsSetCkptFlags(GetCheckpoint(&sbi_), kCpOrphanPresentFlag))
    return;

  start_blk = StartCpAddr(&sbi_) + 1;
  orphan_blkaddr = StartSumAddr(&sbi_) - 1;

  orphan_blk = new OrphanBlock();

  for (i = 0; i < orphan_blkaddr; i++) {
    ReadBlock(orphan_blk, start_blk + i);

    for (j = 0; j < LeToCpu(orphan_blk->entry_count); j++) {
      nid_t ino = LeToCpu(orphan_blk->ino[j]);
#ifdef F2FS_BU_DEBUG
      // TODO: DBG (1)
      printf("[%3d] ino [0x%x]\n", i, ino);
#endif
      blk_cnt = 1;
      zx_status_t ret =
          ChkNodeBlk(nullptr, ino, FileType::kFtOrphan, NodeType::kTypeInode, &blk_cnt);
      ZX_ASSERT(ret == ZX_OK);
    }
    memset(orphan_blk, 0, kBlockSize);
  }
  delete orphan_blk;
}

#if 0  // porting needed
int FsckWorker::FsckChkXattrBlk(uint32_t ino, uint32_t x_nid, uint32_t *blk_cnt) {
  FsckInfo *fsck = &fsck_;
  NodeInfo ni;

  if (x_nid == 0x0)
    return 0;

  if (TestValidBitmap(x_nid, fsck->nat_area_bitmap) != 0x0) {
    ClearValidBitmap(x_nid, fsck->nat_area_bitmap);
  } else {
    ZX_ASSERT_MSG(0, "xattr_nid duplicated [0x%x]\n", x_nid);
  }

  *blk_cnt = *blk_cnt + 1;
  fsck->chk.valid_blk_cnt++;
  fsck->chk.valid_node_cnt++;

  ZX_ASSERT(GetNodeInfo(x_nid, &ni) >= 0);

  if (TestValidBitmap(BlkoffFromMain(sbi, ni.blk_addr), fsck->main_area_bitmap) != 0) {
    ZX_ASSERT_MSG(0,
                  "Duplicated node block for x_attr. "
                  "x_nid[0x%x] block addr[0x%x]\n",
                  x_nid, ni.blk_addr);
  }
  SetValidBitmap(BlkoffFromMain(sbi, ni.blk_addr), fsck->main_area_bitmap);
#ifdef F2FS_BU_DEBUG
  // TODO: DBG (2)
  printf("ino[0x%x] x_nid[0x%x]\n", ino, x_nid);
#endif
  return 0;
}
#endif

zx_status_t FsckWorker::Init() {
  FsckInfo *fsck = &fsck_;
  SmInfo *sm_i = GetSmInfo(&sbi_);

  fsck->nr_main_blks = sm_i->main_segments << sbi_.log_blocks_per_seg;
  fsck->main_area_bitmap_sz = (fsck->nr_main_blks + 7) / 8;
  fsck->main_area_bitmap = (char *)calloc(fsck->main_area_bitmap_sz, 1);
  ZX_ASSERT(fsck->main_area_bitmap != nullptr);

  BuildNatAreaBitmap();
  BuildSitAreaBitmap();

  return ZX_OK;
}

zx_status_t FsckWorker::Verify() {
  uint32_t i = 0;
  zx_status_t ret = ZX_OK;
  uint32_t nr_unref_nid = 0;
  FsckInfo *fsck = &fsck_;
  HardLinkNode *node = nullptr;

  printf("\n");

  for (i = 0; i < fsck->nr_nat_entries; i++) {
    if (TestValidBitmap(i, fsck->nat_area_bitmap) != 0) {
      printf("NID[0x%x] is unreachable\n", i);
      nr_unref_nid++;
    }
  }

  if (fsck->hard_link_list_head != nullptr) {
    node = fsck->hard_link_list_head;
    while (node) {
      printf("NID[0x%x] has [0x%x] more unreachable links\n", node->nid, node->links);
      node = node->next;
    }
  }

  printf("[FSCK] Unreachable nat entries                       ");
  if (nr_unref_nid == 0x0) {
    printf(" [Ok..] [0x%x]\n", nr_unref_nid);
  } else {
    printf(" [Fail] [0x%x]\n", nr_unref_nid);
    ret = ZX_ERR_BAD_STATE;
  }

  printf("[FSCK] SIT valid block bitmap checking                ");
  if (memcmp(fsck->sit_area_bitmap, fsck->main_area_bitmap, fsck->sit_area_bitmap_sz) == 0x0) {
    printf("[Ok..]\n");
  } else {
    printf("[Fail]\n");
    ret = ZX_ERR_BAD_STATE;
  }

  printf("[FSCK] Hard link checking for regular file           ");
  if (fsck->hard_link_list_head == nullptr) {
    printf(" [Ok..] [0x%x]\n", fsck->chk.multi_hard_link_files);
  } else {
    printf(" [Fail] [0x%x]\n", fsck->chk.multi_hard_link_files);
    ret = ZX_ERR_BAD_STATE;
  }

  printf("[FSCK] valid_block_count matching with CP            ");
  if (sbi_.total_valid_block_count == fsck->chk.valid_blk_cnt) {
    printf(" [Ok..] [0x%x]\n", (uint32_t)fsck->chk.valid_blk_cnt);
  } else {
    printf(" [Fail] [0x%x]\n", (uint32_t)fsck->chk.valid_blk_cnt);
    ret = ZX_ERR_BAD_STATE;
  }

  printf("[FSCK] valid_node_count matcing with CP (de lookup)  ");
  if (sbi_.total_valid_node_count == fsck->chk.valid_node_cnt) {
    printf(" [Ok..] [0x%x]\n", fsck->chk.valid_node_cnt);
  } else {
    printf(" [Fail] [0x%x]\n", fsck->chk.valid_node_cnt);
    ret = ZX_ERR_BAD_STATE;
  }

  printf("[FSCK] valid_node_count matcing with CP (nat lookup) ");
  if (sbi_.total_valid_node_count == fsck->chk.valid_nat_entry_cnt) {
    printf(" [Ok..] [0x%x]\n", fsck->chk.valid_nat_entry_cnt);
  } else {
    printf(" [Fail] [0x%x]\n", fsck->chk.valid_nat_entry_cnt);
    ret = ZX_ERR_BAD_STATE;
  }

  printf("[FSCK] valid_inode_count matched with CP             ");
  if (sbi_.total_valid_inode_count == fsck->chk.valid_inode_cnt) {
    printf(" [Ok..] [0x%x]\n", fsck->chk.valid_inode_cnt);
  } else {
    printf(" [Fail] [0x%x]\n", fsck->chk.valid_inode_cnt);
    ret = ZX_ERR_BAD_STATE;
  }

  return ret;
}

void FsckWorker::Free() {
  FsckInfo *fsck = &fsck_;
  if (fsck->main_area_bitmap != nullptr)
    free(fsck->main_area_bitmap);

  if (fsck->nat_area_bitmap != nullptr)
    delete[] fsck->nat_area_bitmap;  // free

  if (fsck->sit_area_bitmap != nullptr)
    delete[] fsck->sit_area_bitmap;
}

void FsckWorker::PrintInodeInfo(Inode *inode) {
  uint32_t i = 0;
  int namelen = LeToCpu(inode->i_namelen);

  DisplayMember(sizeof(uint32_t), inode->i_mode, "i_mode");
  DisplayMember(sizeof(uint32_t), inode->i_uid, "i_uid");
  DisplayMember(sizeof(uint32_t), inode->i_gid, "i_gid");
  DisplayMember(sizeof(uint32_t), inode->i_links, "i_links");
  DisplayMember(sizeof(uint64_t), inode->i_size, "i_size");
  DisplayMember(sizeof(uint64_t), inode->i_blocks, "i_blocks");

  DisplayMember(sizeof(uint64_t), inode->i_atime, "i_atime");
  DisplayMember(sizeof(uint32_t), inode->i_atime_nsec, "i_atime_nsec");
  DisplayMember(sizeof(uint64_t), inode->i_ctime, "i_ctime");
  DisplayMember(sizeof(uint32_t), inode->i_ctime_nsec, "i_ctime_nsec");
  DisplayMember(sizeof(uint64_t), inode->i_mtime, "i_mtime");
  DisplayMember(sizeof(uint32_t), inode->i_mtime_nsec, "i_mtime_nsec");

  DisplayMember(sizeof(uint32_t), inode->i_generation, "i_generation");
  DisplayMember(sizeof(uint32_t), inode->i_current_depth, "i_current_depth");
  DisplayMember(sizeof(uint32_t), inode->i_xattr_nid, "i_xattr_nid");
  DisplayMember(sizeof(uint32_t), inode->i_flags, "i_flags");
  DisplayMember(sizeof(uint32_t), inode->i_pino, "i_pino");

  if (namelen) {
    DisplayMember(sizeof(uint32_t), inode->i_namelen, "i_namelen");
    inode->i_name[namelen] = '\0';
    DisplayMember(sizeof(char), inode->i_name, "i_name");
  }

  printf("i_ext: fofs:%x blkaddr:%x len:%x\n", inode->i_ext.fofs, inode->i_ext.blk_addr,
         inode->i_ext.len);

  DisplayMember(sizeof(uint32_t), inode->i_addr[0], "i_addr[0]");  // Pointers to data blocks
  DisplayMember(sizeof(uint32_t), inode->i_addr[1], "i_addr[1]");  // Pointers to data blocks
  DisplayMember(sizeof(uint32_t), inode->i_addr[2], "i_addr[2]");  // Pointers to data blocks
  DisplayMember(sizeof(uint32_t), inode->i_addr[3], "i_addr[3]");  // Pointers to data blocks

  for (i = 4; i < AddrsPerInode(inode); i++) {
    if (inode->i_addr[i] != 0x0) {
      printf("i_addr[0x%x] points data block\r\t\t\t\t[0x%4x]\n", i, inode->i_addr[i]);
      break;
    }
  }

  DisplayMember(sizeof(uint32_t), inode->i_nid[0], "i_nid[0]");  // direct
  DisplayMember(sizeof(uint32_t), inode->i_nid[1], "i_nid[1]");  // direct
  DisplayMember(sizeof(uint32_t), inode->i_nid[2], "i_nid[2]");  // indirect
  DisplayMember(sizeof(uint32_t), inode->i_nid[3], "i_nid[3]");  // indirect
  DisplayMember(sizeof(uint32_t), inode->i_nid[4], "i_nid[4]");  // double indirect

  printf("\n");
}

void FsckWorker::PrintNodeInfo(Node *node_block) {
  nid_t ino = LeToCpu(node_block->footer.ino);
  nid_t nid = LeToCpu(node_block->footer.nid);
  if (ino == nid) {
    FX_LOGS(INFO) << "Node ID [0x" << std::hex << nid << ":" << nid << "] is inode";
    PrintInodeInfo(&node_block->i);
  } else {
    int i;
    uint32_t *dump_blk = (uint32_t *)node_block;
    FX_LOGS(INFO) << "Node ID [0x" << std::hex << nid << ":" << nid
                  << "] is direct node or indirect node";
    for (i = 0; i <= 10; i++)  // MSG (0)
      printf("[%d]\t\t\t[0x%8x : %d]\n", i, dump_blk[i], dump_blk[i]);
  }
}

void FsckWorker::PrintRawSbInfo() {
  const SuperBlock *sb = RawSuper(&sbi_);
#if 0  // porting needed
  if (!config.dbg_lv)
    return;
#endif

  printf("\n");
  printf("+--------------------------------------------------------+\n");
  printf("| Super block                                            |\n");
  printf("+--------------------------------------------------------+\n");

  DisplayMember(sizeof(uint32_t), sb->magic, "magic");
  DisplayMember(sizeof(uint32_t), sb->major_ver, "major_ver");
  DisplayMember(sizeof(uint32_t), sb->minor_ver, "minor_ver");
  DisplayMember(sizeof(uint32_t), sb->log_sectorsize, "log_sectorsize");
  DisplayMember(sizeof(uint32_t), sb->log_sectors_per_block, "log_sectors_per_block");

  DisplayMember(sizeof(uint32_t), sb->log_blocksize, "log_blocksize");
  DisplayMember(sizeof(uint32_t), sb->log_blocks_per_seg, "log_blocks_per_seg");
  DisplayMember(sizeof(uint32_t), sb->segs_per_sec, "segs_per_sec");
  DisplayMember(sizeof(uint32_t), sb->secs_per_zone, "secs_per_zone");
  DisplayMember(sizeof(uint32_t), sb->checksum_offset, "checksum_offset");
  DisplayMember(sizeof(uint64_t), sb->block_count, "block_count");

  DisplayMember(sizeof(uint32_t), sb->section_count, "section_count");
  DisplayMember(sizeof(uint32_t), sb->segment_count, "segment_count");
  DisplayMember(sizeof(uint32_t), sb->segment_count_ckpt, "segment_count_ckpt");
  DisplayMember(sizeof(uint32_t), sb->segment_count_sit, "segment_count_sit");
  DisplayMember(sizeof(uint32_t), sb->segment_count_nat, "segment_count_nat");

  DisplayMember(sizeof(uint32_t), sb->segment_count_ssa, "segment_count_ssa");
  DisplayMember(sizeof(uint32_t), sb->segment_count_main, "segment_count_main");
  DisplayMember(sizeof(uint32_t), sb->segment0_blkaddr, "segment0_blkaddr");

  DisplayMember(sizeof(uint32_t), sb->cp_blkaddr, "cp_blkaddr");
  DisplayMember(sizeof(uint32_t), sb->sit_blkaddr, "sit_blkaddr");
  DisplayMember(sizeof(uint32_t), sb->nat_blkaddr, "nat_blkaddr");
  DisplayMember(sizeof(uint32_t), sb->ssa_blkaddr, "ssa_blkaddr");
  DisplayMember(sizeof(uint32_t), sb->main_blkaddr, "main_blkaddr");

  DisplayMember(sizeof(uint32_t), sb->root_ino, "root_ino");
  DisplayMember(sizeof(uint32_t), sb->node_ino, "node_ino");
  DisplayMember(sizeof(uint32_t), sb->meta_ino, "meta_ino");
  printf("\n");
}

void FsckWorker::PrintCkptInfo() {
  Checkpoint *cp = GetCheckpoint(&sbi_);
  uint32_t alloc_type;
#if 0  // porting needed
  if (!config.dbg_lv)
    return;
#endif

  printf("\n");
  printf("+--------------------------------------------------------+\n");
  printf("| Checkpoint                                             |\n");
  printf("+--------------------------------------------------------+\n");

  DisplayMember(sizeof(uint64_t), cp->checkpoint_ver, "checkpoint_ver");
  DisplayMember(sizeof(uint64_t), cp->user_block_count, "user_block_count");
  DisplayMember(sizeof(uint64_t), cp->valid_block_count, "valid_block_count");
  DisplayMember(sizeof(uint32_t), cp->rsvd_segment_count, "rsvd_segment_count");
  DisplayMember(sizeof(uint32_t), cp->overprov_segment_count, "overprov_segment_count");
  DisplayMember(sizeof(uint32_t), cp->free_segment_count, "free_segment_count");

  alloc_type = cp->alloc_type[static_cast<int>(CursegType::kCursegHotNode)];
  DisplayMember(sizeof(uint32_t), alloc_type, "alloc_type[CursegType::kCursegHotNode]");
  alloc_type = cp->alloc_type[static_cast<int>(CursegType::kCursegWarmNode)];
  DisplayMember(sizeof(uint32_t), alloc_type, "alloc_type[CursegType::kCursegWarmNode]");
  alloc_type = cp->alloc_type[static_cast<int>(CursegType::kCursegColdNode)];
  DisplayMember(sizeof(uint32_t), alloc_type, "alloc_type[CursegType::kCursegColdNode]");
  alloc_type = cp->alloc_type[static_cast<int>(CursegType::kCursegHotNode)];
  DisplayMember(sizeof(uint32_t), cp->cur_node_segno[0], "cur_node_segno[0]");
  DisplayMember(sizeof(uint32_t), cp->cur_node_segno[1], "cur_node_segno[1]");
  DisplayMember(sizeof(uint32_t), cp->cur_node_segno[2], "cur_node_segno[2]");

  DisplayMember(sizeof(uint32_t), cp->cur_node_blkoff[0], "cur_node_blkoff[0]");
  DisplayMember(sizeof(uint32_t), cp->cur_node_blkoff[1], "cur_node_blkoff[1]");
  DisplayMember(sizeof(uint32_t), cp->cur_node_blkoff[2], "cur_node_blkoff[2]");

  alloc_type = cp->alloc_type[static_cast<int>(CursegType::kCursegHotData)];
  DisplayMember(sizeof(uint32_t), alloc_type, "alloc_type[CursegType::kCursegHotData]");
  alloc_type = cp->alloc_type[static_cast<int>(CursegType::kCursegWarmData)];
  DisplayMember(sizeof(uint32_t), alloc_type, "alloc_type[CursegType::kCursegWarmData]");
  alloc_type = cp->alloc_type[static_cast<int>(CursegType::kCursegColdData)];
  DisplayMember(sizeof(uint32_t), alloc_type, "alloc_type[CursegType::kCursegColdData]");
  DisplayMember(sizeof(uint32_t), cp->cur_data_segno[0], "cur_data_segno[0]");
  DisplayMember(sizeof(uint32_t), cp->cur_data_segno[1], "cur_data_segno[1]");
  DisplayMember(sizeof(uint32_t), cp->cur_data_segno[2], "cur_data_segno[2]");

  DisplayMember(sizeof(uint32_t), cp->cur_data_blkoff[0], "cur_data_blkoff[0]");
  DisplayMember(sizeof(uint32_t), cp->cur_data_blkoff[1], "cur_data_blkoff[1]");
  DisplayMember(sizeof(uint32_t), cp->cur_data_blkoff[2], "cur_data_blkoff[2]");

  DisplayMember(sizeof(uint32_t), cp->ckpt_flags, "ckpt_flags");
  DisplayMember(sizeof(uint32_t), cp->cp_pack_total_block_count, "cp_pack_total_block_count");
  DisplayMember(sizeof(uint32_t), cp->cp_pack_start_sum, "cp_pack_start_sum");
  DisplayMember(sizeof(uint32_t), cp->valid_node_count, "valid_node_count");
  DisplayMember(sizeof(uint32_t), cp->valid_inode_count, "valid_inode_count");
  DisplayMember(sizeof(uint32_t), cp->next_free_nid, "next_free_nid");
  DisplayMember(sizeof(uint32_t), cp->sit_ver_bitmap_bytesize, "sit_ver_bitmap_bytesize");
  DisplayMember(sizeof(uint32_t), cp->nat_ver_bitmap_bytesize, "nat_ver_bitmap_bytesize");
  DisplayMember(sizeof(uint32_t), cp->checksum_offset, "checksum_offset");
  DisplayMember(sizeof(uint64_t), cp->elapsed_time, "elapsed_time");

  printf("\n\n");
}

zx_status_t FsckWorker::SanityCheckRawSuper(const SuperBlock *raw_super) {
  if (kF2fsSuperMagic != LeToCpu(raw_super->magic)) {
    return ZX_ERR_BAD_STATE;
  }
  if (kBlockSize != kPageCacheSize) {
    return ZX_ERR_BAD_STATE;
  }
  block_t blocksize = 1 << LeToCpu(raw_super->log_blocksize);
  if (kBlockSize != blocksize) {
    return ZX_ERR_BAD_STATE;
  }
  if (kLogSectorSize != LeToCpu(raw_super->log_sectorsize)) {
    return ZX_ERR_BAD_STATE;
  }
  if (kLogSectorsPerBlock != LeToCpu(raw_super->log_sectors_per_block)) {
    return ZX_ERR_BAD_STATE;
  }
  return ZX_OK;
}

zx_status_t FsckWorker::ValidateSuperblock(block_t block) {
  SuperBlock *sb = new SuperBlock();
  zx_status_t ret = ZX_OK;
  if (ret = LoadSuperblock(bc_, sb); ret != ZX_OK)
    return ret;

  if (ret = SanityCheckRawSuper(sb); ret == ZX_OK) {
    sbi_.raw_super = sb;
    return ret;
  }
  FX_LOGS(WARNING) << "Can't find a valid F2FS filesystem in" << block << "superblock";
  delete sb;
  return ret;
}

void FsckWorker::InitSbInfo() {
  const SuperBlock *raw_super = sbi_.raw_super;

  sbi_.log_sectors_per_block = LeToCpu(raw_super->log_sectors_per_block);
  sbi_.log_blocksize = LeToCpu(raw_super->log_blocksize);
  sbi_.blocksize = 1 << sbi_.log_blocksize;
  sbi_.log_blocks_per_seg = LeToCpu(raw_super->log_blocks_per_seg);
  sbi_.blocks_per_seg = 1 << sbi_.log_blocks_per_seg;
  sbi_.segs_per_sec = LeToCpu(raw_super->segs_per_sec);
  sbi_.secs_per_zone = LeToCpu(raw_super->secs_per_zone);
  sbi_.total_sections = LeToCpu(raw_super->section_count);
  sbi_.total_node_count =
      (LeToCpu(raw_super->segment_count_nat) / 2) * sbi_.blocks_per_seg * kNatEntryPerBlock;
  sbi_.root_ino_num = LeToCpu(raw_super->root_ino);
  sbi_.node_ino_num = LeToCpu(raw_super->node_ino);
  sbi_.meta_ino_num = LeToCpu(raw_super->meta_ino);
#if 0  // porting needed
  sbi->cur_victim_sec = kNullSegNo;
#endif
}

void *FsckWorker::ValidateCheckpoint(block_t cp_addr, uint64_t *version) {
  void *cp_page_1, *cp_page_2;
  Checkpoint *cp_block;
  uint64_t blk_size = sbi_.blocksize;
  uint64_t cur_version = 0, pre_version = 0;
  uint32_t crc = 0;
  size_t crc_offset;

  // Read the 1st cp block in this CP pack
  cp_page_1 = reinterpret_cast<Block *>(new Block);
  if (ReadBlock(cp_page_1, cp_addr) < 0)
    return nullptr;

  cp_block = (Checkpoint *)cp_page_1;
  crc_offset = LeToCpu(cp_block->checksum_offset);
  if (crc_offset >= blk_size) {
    delete reinterpret_cast<Block *>(cp_page_1);
    return nullptr;
  }

  crc = *(unsigned int *)((unsigned char *)cp_block + crc_offset);
  if (!F2fsCrcValid(crc, cp_block, crc_offset)) {
    delete reinterpret_cast<Block *>(cp_page_1);
    return nullptr;
  }

  pre_version = LeToCpu(cp_block->checkpoint_ver);

  // Read the 2nd cp block in this CP pack
  cp_page_2 = reinterpret_cast<Block *>(new Block);
  cp_addr += LeToCpu(cp_block->cp_pack_total_block_count) - 1;
  if (ReadBlock(cp_page_2, cp_addr) < 0) {
    delete reinterpret_cast<Block *>(cp_page_1);
    delete reinterpret_cast<Block *>(cp_page_2);
    return nullptr;
  }

  cp_block = (Checkpoint *)cp_page_2;
  crc_offset = LeToCpu(cp_block->checksum_offset);
  if (crc_offset >= blk_size) {
    delete reinterpret_cast<Block *>(cp_page_1);
    delete reinterpret_cast<Block *>(cp_page_2);
    return nullptr;
  }

  crc = *(unsigned int *)((unsigned char *)cp_block + crc_offset);
  if (!F2fsCrcValid(crc, cp_block, crc_offset)) {
    delete reinterpret_cast<Block *>(cp_page_1);
    delete reinterpret_cast<Block *>(cp_page_2);
    return nullptr;
  }

  cur_version = LeToCpu(cp_block->checkpoint_ver);

  if (cur_version == pre_version) {
    *version = cur_version;
    delete reinterpret_cast<Block *>(cp_page_2);
    return cp_page_1;
  }

  delete reinterpret_cast<Block *>(cp_page_2);
  delete reinterpret_cast<Block *>(cp_page_1);
  return nullptr;
}

zx_status_t FsckWorker::GetValidCheckpoint() {
  const SuperBlock *raw_sb = RawSuper(&sbi_);
  void *cp1, *cp2, *cur_page;
  uint64_t blk_size = sbi_.blocksize;
  uint64_t cp1_version = 0, cp2_version = 0;
  uint64_t cp_start_blk_no;
  Block *blk = new Block;

  if (sbi_.ckpt = reinterpret_cast<Checkpoint *>(blk); sbi_.ckpt == nullptr)
    return ZX_ERR_NO_MEMORY;

  // Finding out valid cp block involves read both
  // sets( cp pack1 and cp pack 2)
  cp_start_blk_no = LeToCpu(raw_sb->cp_blkaddr);
  cp1 = ValidateCheckpoint(cp_start_blk_no, &cp1_version);

  // The second checkpoint pack should start at the next segment
  cp_start_blk_no += 1 << LeToCpu(raw_sb->log_blocks_per_seg);
  cp2 = ValidateCheckpoint(cp_start_blk_no, &cp2_version);

  if (cp1 != nullptr && cp2 != nullptr) {
    if (VerAfter(cp2_version, cp1_version))
      cur_page = cp2;
    else
      cur_page = cp1;
  } else if (cp1 != nullptr) {
    cur_page = cp1;
  } else if (cp2 != nullptr) {
    cur_page = cp2;
  } else {
    delete reinterpret_cast<Block *>(cp1);
    delete reinterpret_cast<Block *>(cp2);
    delete blk;
    return ZX_ERR_INVALID_ARGS;
  }

  memcpy(sbi_.ckpt, cur_page, blk_size);

  delete reinterpret_cast<Block *>(cp1);
  delete reinterpret_cast<Block *>(cp2);
  return ZX_OK;
}

zx_status_t FsckWorker::SanityCheckCkpt() {
  unsigned int total, fsmeta;
  const SuperBlock *raw_super = RawSuper(&sbi_);
  Checkpoint *ckpt = GetCheckpoint(&sbi_);

  total = LeToCpu(raw_super->segment_count);
  fsmeta = LeToCpu(raw_super->segment_count_ckpt);
  fsmeta += LeToCpu(raw_super->segment_count_sit);
  fsmeta += LeToCpu(raw_super->segment_count_nat);
  fsmeta += LeToCpu(ckpt->rsvd_segment_count);
  fsmeta += LeToCpu(raw_super->segment_count_ssa);

  if (fsmeta >= total)
    return ZX_ERR_INVALID_ARGS;

  return ZX_OK;
}

zx_status_t FsckWorker::InitNodeManager() {
  const SuperBlock *sb_raw = RawSuper(&sbi_);
  NmInfo *nm_i = GetNmInfo(&sbi_);
  unsigned char *version_bitmap;
  unsigned int nat_segs, nat_blocks;

  nm_i->nat_blkaddr = LeToCpu(sb_raw->nat_blkaddr);

  // segment_count_nat includes pair segment so divide to 2.
  nat_segs = LeToCpu(sb_raw->segment_count_nat) >> 1;
  nat_blocks = nat_segs << LeToCpu(sb_raw->log_blocks_per_seg);
  nm_i->max_nid = kNatEntryPerBlock * nat_blocks;
  nm_i->fcnt = 0;
  nm_i->nat_cnt = 0;
  nm_i->init_scan_nid = LeToCpu(sbi_.ckpt->next_free_nid);
  nm_i->next_scan_nid = LeToCpu(sbi_.ckpt->next_free_nid);

  nm_i->bitmap_size = BitmapSize(&sbi_, MetaBitmap::kNatBitmap);

  if (nm_i->nat_bitmap = new char[nm_i->bitmap_size]; nm_i->nat_bitmap == nullptr)
    return ZX_ERR_NO_MEMORY;
  if (version_bitmap = static_cast<uint8_t *>(BitmapPrt(&sbi_, MetaBitmap::kNatBitmap));
      version_bitmap == nullptr)
    return ZX_ERR_NO_MEMORY;

  // copy version bitmap
  memcpy(nm_i->nat_bitmap, version_bitmap, nm_i->bitmap_size);
  return ZX_OK;
}

zx_status_t FsckWorker::BuildNodeManager() {
  if (sbi_.nm_info = new NmInfo; sbi_.nm_info == nullptr)
    return ZX_ERR_NO_MEMORY;

  if (zx_status_t err = InitNodeManager(); err != ZX_OK)
    return err;

  return ZX_OK;
}

zx_status_t FsckWorker::BuildSitInfo() {
  const SuperBlock *raw_sb = RawSuper(&sbi_);
  Checkpoint *ckpt = GetCheckpoint(&sbi_);
  SitInfo *sit_i;
  unsigned int sit_segs, start;
  char *src_bitmap, *dst_bitmap;
  unsigned int bitmap_size;

  if (sit_i = new SitInfo; sit_i == nullptr)
    return ZX_ERR_NO_MEMORY;

  GetSmInfo(&sbi_)->SitInfo = sit_i;

  sit_i->sentries = new SegEntry[TotalSegs(&sbi_)]();

  for (start = 0; start < TotalSegs(&sbi_); start++) {
    sit_i->sentries[start].cur_valid_map = new uint8_t[kSitVBlockMapSize]();
    sit_i->sentries[start].ckpt_valid_map = new uint8_t[kSitVBlockMapSize]();
    if (sit_i->sentries[start].cur_valid_map == nullptr ||
        sit_i->sentries[start].ckpt_valid_map == nullptr)
      return ZX_ERR_NO_MEMORY;
  }

  sit_segs = LeToCpu(raw_sb->segment_count_sit) >> 1;
  bitmap_size = BitmapSize(&sbi_, MetaBitmap::kSitBitmap);
  if (src_bitmap = static_cast<char *>(BitmapPrt(&sbi_, MetaBitmap::kSitBitmap));
      src_bitmap == nullptr)
    return ZX_ERR_NO_MEMORY;

  if (dst_bitmap = new char[bitmap_size]; dst_bitmap == nullptr)
    return ZX_ERR_NO_MEMORY;

  memcpy(dst_bitmap, src_bitmap, bitmap_size);

  sit_i->sit_base_addr = LeToCpu(raw_sb->sit_blkaddr);
  sit_i->sit_blocks = sit_segs << sbi_.log_blocks_per_seg;
  sit_i->written_valid_blocks = LeToCpu(ckpt->valid_block_count);
  sit_i->sit_bitmap = dst_bitmap;
  sit_i->bitmap_size = bitmap_size;
  sit_i->dirty_sentries = 0;
  sit_i->sents_per_block = kSitEntryPerBlock;
  sit_i->elapsed_time = LeToCpu(ckpt->elapsed_time);
  return ZX_OK;
}

void FsckWorker::ResetCurseg(CursegType type, int modified) {
  CursegInfo *curseg = SegMgr::CURSEG_I(&sbi_, type);

  curseg->segno = curseg->next_segno;
  curseg->zone = GetZoneNoFromSegNo(&sbi_, curseg->segno);
  curseg->next_blkoff = 0;
  curseg->next_segno = kNullSegNo;
}

zx_status_t FsckWorker::ReadCompactedSummaries() {
  Checkpoint *ckpt = GetCheckpoint(&sbi_);
  CursegInfo *curseg;
  block_t start;
  Block *blk = new Block;
  uint32_t j, offset;

  start = StartSumBlock();

  ReadBlock(blk->data, start++);

  curseg = SegMgr::CURSEG_I(&sbi_, CursegType::kCursegHotData);
  memcpy(&curseg->sum_blk->n_nats, blk->data, kSumJournalSize);

  curseg = SegMgr::CURSEG_I(&sbi_, CursegType::kCursegColdData);
  memcpy(&curseg->sum_blk->n_sits, blk->data + kSumJournalSize, kSumJournalSize);

  offset = 2 * kSumJournalSize;
  for (int32_t i = static_cast<int32_t>(CursegType::kCursegHotData);
       i <= CursegType::kCursegColdData; i++) {
    unsigned short blk_off;
    unsigned int segno;

    curseg = SegMgr::CURSEG_I(&sbi_, static_cast<CursegType>(i));
    segno = LeToCpu(ckpt->cur_data_segno[i]);
    blk_off = LeToCpu(ckpt->cur_data_blkoff[i]);
    curseg->next_segno = segno;
    ResetCurseg(static_cast<CursegType>(i), 0);
    curseg->alloc_type = ckpt->alloc_type[i];
    curseg->next_blkoff = blk_off;

    if (curseg->alloc_type == static_cast<uint8_t>(AllocMode::kSSR))
      blk_off = sbi_.blocks_per_seg;

    for (j = 0; j < blk_off; j++) {
      Summary *s;
      s = (Summary *)(blk->data + offset);
      curseg->sum_blk->entries[j] = *s;
      offset += kSummarySize;
      if (offset + kSummarySize <= kPageCacheSize - kSumFooterSize)
        continue;
      memset(blk->data, 0, kPageSize);
      ReadBlock(blk->data, start++);
      offset = 0;
    }
  }

  delete blk;
  return ZX_OK;
}

zx_status_t FsckWorker::RestoreNodeSummary(unsigned int segno, SummaryBlock *sum_blk) {
  Node *node_blk;
  Summary *sum_entry;
  block_t addr;
  uint32_t i;
  Block *blk = new Block;

  if (blk == nullptr)
    return ZX_ERR_NO_MEMORY;

  // scan the node segment
  addr = StartBlock(&sbi_, segno);
  sum_entry = &sum_blk->entries[0];
  for (i = 0; i < sbi_.blocks_per_seg; i++, sum_entry++) {
    if (ReadBlock(blk->data, addr))
      break;
    node_blk = reinterpret_cast<Node *>(blk->data);
    sum_entry->nid = node_blk->footer.nid;
    addr++;
  }
  delete blk;
  return ZX_OK;
}

zx_status_t FsckWorker::ReadNormalSummaries(CursegType type) {
  Checkpoint *ckpt = GetCheckpoint(&sbi_);
  SummaryBlock *sum_blk;
  CursegInfo *curseg;
  unsigned short blk_off;
  unsigned int segno = 0;
  block_t blk_addr = 0;

  if (IsDataSeg(type)) {
    segno = LeToCpu(ckpt->cur_data_segno[static_cast<int>(type)]);
    blk_off = LeToCpu(ckpt->cur_data_blkoff[type - CursegType::kCursegHotData]);

    if (IsSetCkptFlags(ckpt, kCpUmountFlag))
      blk_addr = SumBlkAddr(kNrCursegType, static_cast<int>(type));
    else
      blk_addr = SumBlkAddr(kNrCursegDataType, static_cast<int>(type));
  } else {
    segno = LeToCpu(ckpt->cur_node_segno[type - CursegType::kCursegHotNode]);
    blk_off = LeToCpu(ckpt->cur_node_blkoff[type - CursegType::kCursegHotNode]);

    if (IsSetCkptFlags(ckpt, kCpUmountFlag))
      blk_addr = SumBlkAddr(kNrCursegNodeType, type - CursegType::kCursegHotNode);
    else
      blk_addr = GetSumBlock(&sbi_, segno);
  }

  sum_blk = reinterpret_cast<SummaryBlock *>(new Block);
  ReadBlock(sum_blk, blk_addr);

  if (IsNodeSeg(type)) {
    if (IsSetCkptFlags(ckpt, kCpUmountFlag)) {
#if 0  // do not change original value
      Summary *sum_entry = &sum_blk->entries[0];
      for (uint64_t i = 0; i < sbi->blocks_per_seg; i++, sum_entry++) {
				sum_entry->version = 0;
				sum_entry->ofs_in_node = 0;
      }
#endif
    } else {
      if (zx_status_t ret = RestoreNodeSummary(segno, sum_blk); ret != ZX_OK) {
        delete reinterpret_cast<Block *>(sum_blk);
        return ret;
      }
    }
  }

  curseg = SegMgr::CURSEG_I(&sbi_, type);
  memcpy(curseg->sum_blk, sum_blk, kPageCacheSize);
  curseg->next_segno = segno;
  ResetCurseg(type, 0);
  curseg->alloc_type = ckpt->alloc_type[static_cast<int>(type)];
  curseg->next_blkoff = blk_off;
  delete reinterpret_cast<Block *>(sum_blk);

  return ZX_OK;
}

zx_status_t FsckWorker::RestoreCursegSummaries() {
  int32_t type = static_cast<int32_t>(CursegType::kCursegHotData);

  if (IsSetCkptFlags(GetCheckpoint(&sbi_), kCpCompactSumFlag)) {
    if (zx_status_t ret = ReadCompactedSummaries(); ret != ZX_OK)
      return ret;
    type = static_cast<int32_t>(CursegType::kCursegHotNode);
  }

  for (; type <= CursegType::kCursegColdNode; type++) {
    if (zx_status_t ret = ReadNormalSummaries(static_cast<CursegType>(type)); ret != ZX_OK)
      return ret;
  }
  return ZX_OK;
}

zx_status_t FsckWorker::BuildCurseg() {
  CursegInfo *array;
  int i;

  if (array = new CursegInfo[kNrCursegType](); array == nullptr)
    return ZX_ERR_NO_MEMORY;

  GetSmInfo(&sbi_)->curseg_array = array;

  for (i = 0; i < kNrCursegType; i++) {
    array[i].sum_blk = reinterpret_cast<SummaryBlock *>(new Block);
    if (!array[i].sum_blk)
      return ZX_ERR_NO_MEMORY;
    array[i].segno = kNullSegNo;
    array[i].next_blkoff = 0;
  }
  return RestoreCursegSummaries();
}

inline void FsckWorker::ChkSegRange(unsigned int segno) {
  unsigned int end_segno = GetSmInfo(&sbi_)->segment_count - 1;
  ZX_ASSERT(segno <= end_segno);
}

SitBlock *FsckWorker::GetCurrentSitPage(unsigned int segno) {
  SitInfo *sit_i = GetSitInfo(&sbi_);
  unsigned int offset = SitBlockOffset(sit_i, segno);
  block_t blk_addr = sit_i->sit_base_addr + offset;
  SitBlock *sit_blk = reinterpret_cast<SitBlock *>(new Block);

  ChkSegRange(segno);

  // calculate sit block address
  if (TestValidBitmap(offset, sit_i->sit_bitmap))
    blk_addr += sit_i->sit_blocks;

  ReadBlock(sit_blk, blk_addr);

  return sit_blk;
}

void FsckWorker::CheckBlockCount(uint32_t segno, SitEntry *raw_sit) {
  SmInfo *sm_info = GetSmInfo(&sbi_);
  uint32_t end_segno = sm_info->segment_count - 1;
  int valid_blocks = 0;

  // check segment usage
  ZX_ASSERT(GetSitVblocks(raw_sit) <= sbi_.blocks_per_seg);

  // check boundary of a given segment number
  ZX_ASSERT(segno <= end_segno);

  // check bitmap with valid block count
  for (uint64_t i = 0; i < sbi_.blocks_per_seg; i++)
    if (TestValidBitmap(i, (char *)raw_sit->valid_map))
      valid_blocks++;
  ZX_ASSERT(GetSitVblocks(raw_sit) == valid_blocks);
}

void FsckWorker::SegInfoFromRawSit(SegEntry *se, SitEntry *raw_sit) {
  se->valid_blocks = GetSitVblocks(raw_sit);
  se->ckpt_valid_blocks = GetSitVblocks(raw_sit);
  memcpy(se->cur_valid_map, raw_sit->valid_map, kSitVBlockMapSize);
  memcpy(se->ckpt_valid_map, raw_sit->valid_map, kSitVBlockMapSize);
  se->type = GetSitType(raw_sit);
  se->mtime = LeToCpu(raw_sit->mtime);
}

SegEntry *FsckWorker::GetSegEntry(unsigned int segno) {
  SitInfo *sit_i = GetSitInfo(&sbi_);
  return &sit_i->sentries[segno];
}

SegType FsckWorker::GetSumBlockInfo(uint32_t segno, SummaryBlock *sum_blk) {
  Checkpoint *ckpt = GetCheckpoint(&sbi_);
  CursegInfo *curseg;
  int ret;
  uint64_t ssa_blk;

  ssa_blk = GetSumBlock(&sbi_, segno);
  for (int type = 0; type < kNrCursegNodeType; type++) {
    if (segno == ckpt->cur_node_segno[type]) {
      curseg = SegMgr::CURSEG_I(&sbi_, CursegType::kCursegHotNode + type);
      memcpy(sum_blk, curseg->sum_blk, kBlockSize);
      return SegType::kSegTypeCurNode;  // current node seg was not stored
    }
  }

  for (int type = 0; type < kNrCursegDataType; type++) {
    if (segno == ckpt->cur_data_segno[type]) {
      curseg = SegMgr::CURSEG_I(&sbi_, CursegType::kCursegHotData + type);
      memcpy(sum_blk, curseg->sum_blk, kBlockSize);
      ZX_ASSERT(!IsSumNodeSeg(sum_blk->footer));
#ifdef F2FS_BU_DEBUG
      // TODO: DBG (2)
      printf("segno [0x%x] is current data seg[0x%x]\n", segno, type);
#endif
      return SegType::kSegTypeCurData;  // current data seg was not stored
    }
  }

  ret = ReadBlock(sum_blk, ssa_blk);
  ZX_ASSERT(ret >= 0);

  if (IsSumNodeSeg(sum_blk->footer))
    return SegType::kSegTypeNode;
  else
    return SegType::kSegTypeData;
}

uint32_t FsckWorker::GetSegNo(uint32_t blk_addr) {
  return (uint32_t)(BlkoffFromMain(&sbi_, blk_addr) >> sbi_.log_blocks_per_seg);
}

SegType FsckWorker::GetSumEntry(uint32_t blk_addr, Summary *sum_entry) {
  uint32_t segno, offset;
  Block *blk = new Block;

  segno = GetSegNo(blk_addr);
  offset = OffsetInSeg(&sbi_, blk_addr);

  SummaryBlock *sum_blk = reinterpret_cast<SummaryBlock *>(blk->data);
  SegType type = GetSumBlockInfo(segno, sum_blk);
  memcpy(sum_entry, &(sum_blk->entries[offset]), sizeof(Summary));
  delete blk;
  return type;
}

zx_status_t FsckWorker::GetNatEntry(nid_t nid, RawNatEntry *raw_nat) {
  FsckInfo *fsck = &fsck_;
  NmInfo *nm_i = GetNmInfo(&sbi_);
  pgoff_t block_off;
  pgoff_t block_addr;
  int seg_off, entry_off;
  int ret;

  if ((nid / kNatEntryPerBlock) > fsck->nr_nat_entries) {
    FX_LOGS(WARNING) << "nid is over max nid";
    return ZX_ERR_INVALID_ARGS;
  }

  if (auto i_or = LookupNatInJournal(nid, raw_nat); i_or.is_ok())
    return ZX_OK;

  Block *blk = new Block;
  NatBlock *nat_block = reinterpret_cast<NatBlock *>(blk);

  block_off = nid / kNatEntryPerBlock;
  entry_off = nid % kNatEntryPerBlock;

  seg_off = block_off >> sbi_.log_blocks_per_seg;
  block_addr = (pgoff_t)(nm_i->nat_blkaddr + (seg_off << sbi_.log_blocks_per_seg << 1) +
                         (block_off & ((1 << sbi_.log_blocks_per_seg) - 1)));

  if (TestValidBitmap(block_off, nm_i->nat_bitmap))
    block_addr += sbi_.blocks_per_seg;

  ret = ReadBlock(nat_block, block_addr);
  ZX_ASSERT(ret >= 0);

  memcpy(raw_nat, &nat_block->entries[entry_off], sizeof(RawNatEntry));
  delete blk;
  return ZX_OK;
}

zx_status_t FsckWorker::GetNodeInfo(nid_t nid, NodeInfo *ni) {
  RawNatEntry raw_nat;
  zx_status_t ret = GetNatEntry(nid, &raw_nat);
  ni->nid = nid;
  NodeInfoFromRawNat(ni, &raw_nat);
  return ret;
}

void FsckWorker::BuildSitEntries() {
  SitInfo *sit_i = GetSitInfo(&sbi_);
  CursegInfo *curseg = SegMgr::CURSEG_I(&sbi_, CursegType::kCursegColdData);
  SummaryBlock *sum = curseg->sum_blk;
  unsigned int segno;

  for (segno = 0; segno < TotalSegs(&sbi_); segno++) {
    SegEntry *se = &sit_i->sentries[segno];
    SitBlock *sit_blk;
    SitEntry sit;
    bool found = false;

    for (int i = 0; i < SitsInCursum(sum); i++) {
      if (LeToCpu(SegnoInJournal(sum, i)) == segno) {
        sit = sum->sit_j.entries[i].se;
        found = true;
        break;
      }
    }
    if (found == false) {
      sit_blk = GetCurrentSitPage(segno);
      sit = sit_blk->entries[SitEntryOffset(sit_i, segno)];
      delete reinterpret_cast<Block *>(sit_blk);
    }
    CheckBlockCount(segno, &sit);
    SegInfoFromRawSit(se, &sit);
  }
}

zx_status_t FsckWorker::BuildSegmentManager() {
  const SuperBlock *raw_super = RawSuper(&sbi_);
  Checkpoint *ckpt = GetCheckpoint(&sbi_);
  SmInfo *sm_info;

  if (sm_info = new SmInfo(); sm_info == nullptr)
    return ZX_ERR_NO_MEMORY;

  // init sm info
  sbi_.sm_info = sm_info;
  sm_info->seg0_blkaddr = LeToCpu(raw_super->segment0_blkaddr);
  sm_info->main_blkaddr = LeToCpu(raw_super->main_blkaddr);
  sm_info->segment_count = LeToCpu(raw_super->segment_count);
  sm_info->reserved_segments = LeToCpu(ckpt->rsvd_segment_count);
  sm_info->ovp_segments = LeToCpu(ckpt->overprov_segment_count);
  sm_info->main_segments = LeToCpu(raw_super->segment_count_main);
  sm_info->ssa_blkaddr = LeToCpu(raw_super->ssa_blkaddr);

  if (zx_status_t ret = BuildSitInfo(); ret != ZX_OK)
    return ret;
  if (zx_status_t ret = BuildCurseg(); ret != ZX_OK)
    return ret;
  BuildSitEntries();
  return ZX_OK;
}

void FsckWorker::BuildSitAreaBitmap() {
  FsckInfo *fsck = &fsck_;
  SmInfo *sm_i = GetSmInfo(&sbi_);
  uint32_t sum_vblocks = 0;
  uint32_t free_segs = 0;
  uint32_t vblocks = 0;

  fsck->sit_area_bitmap_sz = sm_i->main_segments * kSitVBlockMapSize;
  fsck->sit_area_bitmap = new char[fsck->sit_area_bitmap_sz];
  ZX_ASSERT(fsck->sit_area_bitmap_sz == fsck->main_area_bitmap_sz);
  char *ptr = fsck->sit_area_bitmap;

  for (uint64_t segno = 0; segno < sm_i->main_segments; segno++) {
    SegEntry *se = GetSegEntry(segno);

    memcpy(ptr, se->cur_valid_map, kSitVBlockMapSize);
    ptr += kSitVBlockMapSize;
    vblocks = 0;
    for (uint64_t j = 0; j < kSitVBlockMapSize; j++) {
      vblocks += std::bitset<8>(se->cur_valid_map[j]).count();
    }
    ZX_ASSERT(vblocks == se->valid_blocks);

    if (se->valid_blocks == 0x0) {
      if (sbi_.ckpt->cur_node_segno[0] == segno || sbi_.ckpt->cur_data_segno[0] == segno ||
          sbi_.ckpt->cur_node_segno[1] == segno || sbi_.ckpt->cur_data_segno[1] == segno ||
          sbi_.ckpt->cur_node_segno[2] == segno || sbi_.ckpt->cur_data_segno[2] == segno) {
        continue;
      } else {
        free_segs++;
      }
    } else {
      ZX_ASSERT(se->valid_blocks <= 512);
      sum_vblocks += se->valid_blocks;
    }
  }

  fsck->chk.sit_valid_blocks = sum_vblocks;
  fsck->chk.sit_free_segs = free_segs;
#ifdef F2FS_BU_DEBUG
  // TODO: DBG (1)
  printf("Blocks [0x%x : %d] Free Segs [0x%x : %d]\n\n", sum_vblocks, sum_vblocks, free_segs,
         free_segs);
#endif
}

zx::status<int> FsckWorker::LookupNatInJournal(uint32_t nid, RawNatEntry *raw_nat) {
  CursegInfo *curseg = SegMgr::CURSEG_I(&sbi_, CursegType::kCursegHotData);
  SummaryBlock *sum = curseg->sum_blk;
  int i = 0;

  for (i = 0; i < NatsInCursum(sum); i++) {
    if (LeToCpu(NidInJournal(sum, i)) == nid) {
      RawNatEntry ret = NatInJournal(sum, i);
      memcpy(raw_nat, &ret, sizeof(RawNatEntry));
#ifdef F2FS_BU_DEBUG
      // TODO: DBG (3)
      printf("==> Found nid [0x%x] in nat cache\n", nid);
#endif
      return zx::ok(i);
    }
  }
  return zx::error(ZX_ERR_NOT_FOUND);
}

void FsckWorker::BuildNatAreaBitmap() {
  FsckInfo *fsck = &fsck_;
  const SuperBlock *raw_sb = RawSuper(&sbi_);
  NmInfo *nm_i = GetNmInfo(&sbi_);
  NatBlock *nat_block;
  uint32_t nid, nr_nat_blks;

  pgoff_t block_off;
  pgoff_t block_addr;
  int seg_off;
  int ret;

  Block *blk = new Block;
  nat_block = reinterpret_cast<NatBlock *>(blk);

  // Alloc & build nat entry bitmap
  nr_nat_blks = (LeToCpu(raw_sb->segment_count_nat) / 2) << sbi_.log_blocks_per_seg;

  fsck->nr_nat_entries = nr_nat_blks * kNatEntryPerBlock;
  fsck->nat_area_bitmap_sz = (fsck->nr_nat_entries + 7) / 8;
  fsck->nat_area_bitmap = new char[fsck->nat_area_bitmap_sz];
  ZX_ASSERT(fsck->nat_area_bitmap != nullptr);

  for (block_off = 0; block_off < nr_nat_blks; block_off++) {
    seg_off = block_off >> sbi_.log_blocks_per_seg;
    block_addr = (pgoff_t)(nm_i->nat_blkaddr + (seg_off << sbi_.log_blocks_per_seg << 1) +
                           (block_off & ((1 << sbi_.log_blocks_per_seg) - 1)));

    if (TestValidBitmap(block_off, nm_i->nat_bitmap))
      block_addr += sbi_.blocks_per_seg;

    ret = ReadBlock(nat_block, block_addr);
    ZX_ASSERT(ret >= 0);

    nid = block_off * kNatEntryPerBlock;
    for (uint32_t i = 0; i < kNatEntryPerBlock; i++) {
      RawNatEntry raw_nat;
      NodeInfo ni;
      ni.nid = nid + i;

      if ((nid + i) == NodeIno(&sbi_) || (nid + i) == MetaIno(&sbi_)) {
        ZX_ASSERT(nat_block->entries[i].block_addr != 0x0);
        continue;
      }

      if (auto i_or = LookupNatInJournal(nid + i, &raw_nat); i_or.is_ok()) {
        NodeInfoFromRawNat(&ni, &raw_nat);
        if (ni.blk_addr != kNullAddr) {
          SetValidBitmap(nid + i, fsck->nat_area_bitmap);
          fsck->chk.valid_nat_entry_cnt++;
#ifdef F2FS_BU_DEBUG
          // TODO: DBG (3)
          printf("nid[0x%x] in nat cache\n", nid + i);
#endif
        }
      } else {
        NodeInfoFromRawNat(&ni, &nat_block->entries[i]);
        if (ni.blk_addr != kNullAddr) {
          ZX_ASSERT(nid + i != 0x0);
#ifdef F2FS_BU_DEBUG
          // TODO: DBG (3)
          printf("nid[0x%8x] in nat entry [0x%16x] [0x%8x]\n", nid + i, ni.blk_addr, ni.ino);
#endif
          SetValidBitmap(nid + i, fsck->nat_area_bitmap);
          fsck->chk.valid_nat_entry_cnt++;
        }
      }
    }
  }
  delete blk;
#ifdef F2FS_BU_DEBUG
  // TODO: DBG (1)
  printf("valid nat entries (block_addr != 0x0) [0x%8x : %u]\n", fsck->chk.valid_nat_entry_cnt,
         fsck->chk.valid_nat_entry_cnt);
#endif
}

zx_status_t FsckWorker::DoMount() {
  zx_status_t ret;
  sbi_.active_logs = kNrCursegType;

  if (ret = ValidateSuperblock(0); ret != ZX_OK) {
    if (ret = ValidateSuperblock(1); ret != ZX_OK) {
      return ret;
    }
  }

  PrintRawSbInfo();
  InitSbInfo();

  if (ret = GetValidCheckpoint(); ret != ZX_OK) {
    FX_LOGS(ERROR) << "Can't find valid checkpoint" << ret;
    return ret;
  }
  if (ret = SanityCheckCkpt(); ret != ZX_OK) {
    FX_LOGS(ERROR) << "Checkpoint is polluted" << ret;
    return ret;
  }

  PrintCkptInfo();
  sbi_.total_valid_node_count = LeToCpu(sbi_.ckpt->valid_node_count);
  sbi_.total_valid_inode_count = LeToCpu(sbi_.ckpt->valid_inode_count);
  sbi_.user_block_count = LeToCpu(sbi_.ckpt->user_block_count);
  sbi_.total_valid_block_count = LeToCpu(sbi_.ckpt->valid_block_count);
  sbi_.last_valid_block_count = sbi_.total_valid_block_count;
  sbi_.alloc_valid_block_count = 0;

  if (ret = BuildSegmentManager(); ret != ZX_OK) {
    FX_LOGS(ERROR) << "build_segment_manager failed: " << ret;
    return ret;
  }
  if (ret = BuildNodeManager(); ret != ZX_OK) {
    FX_LOGS(ERROR) << "build_segment_manager failed: " << ret;
    return ret;
  }
  return ret;
}

void FsckWorker::DoUmount() {
  SitInfo *sit_i = GetSitInfo(&sbi_);
  SmInfo *sm_i = GetSmInfo(&sbi_);
  NmInfo *nm_i = GetNmInfo(&sbi_);

  // free nm_info
  delete[] nm_i->nat_bitmap;
  delete sbi_.nm_info;

  // free sit_info
  for (uint32_t i = 0; i < TotalSegs(&sbi_); i++) {
    delete[] sit_i->sentries[i].cur_valid_map;
    delete[] sit_i->sentries[i].ckpt_valid_map;
  }
  delete[] sit_i->sentries;

  delete sit_i->sit_bitmap;
  delete sm_i->SitInfo;

  // free sm_info
  for (uint32_t i = 0; i < kNrCursegType; i++)
    delete reinterpret_cast<Block *>(sm_i->curseg_array[i].sum_blk);

  delete[] sm_i->curseg_array;
  delete sbi_.sm_info;

  delete reinterpret_cast<Block *>(sbi_.ckpt);
  delete sbi_.raw_super;
}

zx_status_t FsckWorker::DoFsck() {
  uint32_t blk_cnt;
  int ret = ZX_OK;
  if (ret = Init(); ret != ZX_OK)
    return ret;

  ChkOrphanNode();
  FX_LOGS(INFO) << "checking orphan node.. done";

  // Travses all block recursively from root inode
  blk_cnt = 1;
  ret = ChkNodeBlk(nullptr, sbi_.root_ino_num, FileType::kFtDir, NodeType::kTypeInode, &blk_cnt);
  FX_LOGS(INFO) << "checking node blocks.. done: " << ret;
  if (ret != ZX_OK) {
    Free();
    return ret;
  }

  ret = Verify();
  FX_LOGS(INFO) << "verifying.. done: " << ret;
  Free();
  return ret;
}

zx_status_t FsckWorker::Run() {
  zx_status_t ret = ZX_OK;
  if (ret = DoMount(); ret != ZX_OK)
    return ret;

  ret = DoFsck();
#if 0  // porting needed
  // ret = DoDump(sbi);
#endif
  DoUmount();
  FX_LOGS(INFO) << "Fsck.. done: " << ret;
  return ret;
}

}  // namespace f2fs::fsck