// 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 "f2fs.h"

#include <fcntl.h>
#include <inttypes.h>
#include <lib/syslog/cpp/macros.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
#include <unistd.h>

#include "src/lib/uuid/uuid.h"
#include "zircon/errors.h"
#include "zircon/types.h"

#include <memory>

#include <lib/zx/event.h>
#include <zircon/assert.h>

#include <lib/trace-provider/provider.h>


namespace f2fs {

const char *media_ext_lists[] = {"jpg", "gif", "png",  "avi", "divx", "mp4", "mp3", "3gp",
                                 "wmv", "wma", "mpeg", "mkv", "mov",  "asx", "asf", "wmx",
                                 "svi", "wvx", "wm",   "mpg", "mpe",  "rm",  "ogg", nullptr};

F2fsMkfs::F2fsMkfs(std::unique_ptr<f2fs::Bcache> bc, const MkfsOptions &mkfs_options)
    : bc_(std::move(bc)), mkfs_options_(mkfs_options) {}

zx_status_t F2fsMkfs::Mkfs() {
  char extension_list[] = "";

#ifdef F2FS_BU_DEBUG
  // TODO: lable, extention list
  std::cout << "f2fs mkfs heap-based allocation = " << mkfs_options_.heap_based_allocation
            << std::endl;
  std::cout << "f2fs mkfs overprovision ratio = " << mkfs_options_.overprovision_ratio << std::endl;
  std::cout << "f2fs mkfs # of segments per section = " << mkfs_options_.num_of_seg_per_sec
            << std::endl;
  std::cout << "f2fs mkfs overprovision ratio = " << mkfs_options_.num_of_sec_per_zone << std::endl;
#endif

  // TODO: parse mkfs options
  f2fs_params.extension_list = extension_list;

  F2fsInitGlobalParameters();

  if (F2fsGetDeviceInfo() < 0)
    return -1;

  if (F2fsFormatDevice() < 0)
    return -1;

  printf("Info: format successful\n");

  return ZX_OK;
}

void F2fsMkfs::ASCIIToUNICODE(uint16_t *out_buf, uint8_t *in_buf) {
  uint8_t *pchTempPtr = in_buf;
  uint16_t *pwTempPtr = out_buf;

  while (*pchTempPtr != '\0') {
    /* Copy the string elements character by character
     * to the output string with typecasting the source.
     */
    *pwTempPtr = static_cast<uint16_t>(*pchTempPtr);
    pchTempPtr++;
    pwTempPtr++;
  }
  *pwTempPtr = '\0';
}

void F2fsMkfs::F2fsInitGlobalParameters() {
  static_assert(__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__);

  f2fs_params.sector_size = DEFAULT_SECTOR_SIZE;
  f2fs_params.sectors_per_blk = DEFAULT_SECTORS_PER_BLOCK;
  f2fs_params.blks_per_seg = DEFAULT_BLOCKS_PER_SEGMENT;
  f2fs_params.reserved_segments = 20; /* calculated by overprovision ratio */
  f2fs_params.overprovision = 5;
  f2fs_params.segs_per_sec = 1;
  f2fs_params.secs_per_zone = 1;
  f2fs_params.heap = 1;
  memset(f2fs_params.vol_label, 0, sizeof(f2fs_params.vol_label));

  f2fs_params.vol_label[0] = 'F';
  f2fs_params.vol_label[1] = '2';
  f2fs_params.vol_label[2] = 'F';
  f2fs_params.vol_label[3] = 'S';
  f2fs_params.vol_label[4] = '\0';
  f2fs_params.device_name = nullptr;
}

inline int F2fsMkfs::F2fsSetBit(unsigned int nr, unsigned char *addr) {
  int mask;
  int ret;

  addr += (nr >> 3);
  mask = 1 << (7 - (nr & 0x07));
  ret = mask & *addr;
  *addr |= mask;
  return ret;
}

int8_t F2fsMkfs::LogBase2(uint32_t num) {
  int8_t ret = 0;

  if (num <= 0 || (num & (num - 1)) != 0) {
    return -1;
  }

  while (num >>= 1) {
    ret++;
  }

  return ret;
}

#if 0  // porting needed
void F2fsMkfs::f2fs_usage(void)
{
        fprintf(stderr, "Usage: f2fs_format [options] device\n");
        fprintf(stderr, "[options]\n");
        fprintf(stderr, "-l label\n");
        fprintf(stderr, "-a heap-based allocation [default:1]\n");
        fprintf(stderr, "-o overprovision ratio [default:5]\n");
        fprintf(stderr, "-s # of segments per section [default:1]\n");
        fprintf(stderr, "-z # of sections per zone [default:1]\n");
        fprintf(stderr, "-e [extension list] e.g. \"mp3,gif,mov\"\n");
        exit(1);
}
#endif

zx_status_t F2fsMkfs::F2fsGetDeviceInfo() {
  fuchsia_hardware_block_BlockInfo info;

  bc_->device()->BlockGetInfo(&info);

  ZX_ASSERT(info.block_size == DEFAULT_SECTOR_SIZE);

  f2fs_params.sector_size = DEFAULT_SECTOR_SIZE;
  f2fs_params.sectors_per_blk = kF2fsBlockSize / DEFAULT_SECTOR_SIZE;
  f2fs_params.total_sectors = info.block_count;
  f2fs_params.start_sector = kSuperblockStart;

  if (f2fs_params.total_sectors < (F2FS_MIN_VOLUME_SIZE / DEFAULT_SECTOR_SIZE)) {
    printf("Error: Min volume size supported is %d\n", F2FS_MIN_VOLUME_SIZE);
    return ZX_ERR_NO_RESOURCES;
  }

  return ZX_OK;
}

void F2fsMkfs::ConfigureExtensionList() {
  const char **extlist = media_ext_lists;
  char *ext_str = f2fs_params.extension_list;
  char *ue;
  int name_len;
  int i = 0;

  super_block.extension_count = 0;
  memset(super_block.extension_list, 0, sizeof(super_block.extension_list));

  while (*extlist) {
    name_len = static_cast<int>(strlen(*extlist));
    memcpy(super_block.extension_list[i++], *extlist, name_len);
    extlist++;
  }
  super_block.extension_count = i - 1;

  if (!ext_str)
    return;

  /* add user ext list */
  ue = strtok(ext_str, ",");
  while (ue != nullptr) {
    name_len = static_cast<int>(strlen(ue));
    memcpy(super_block.extension_list[i++], ue, name_len);
    ue = strtok(nullptr, ",");
    if (i > F2FS_MAX_EXTENSION)
      break;
  }

  super_block.extension_count = i - 1;
#if 0  // porting needed
  // TODO: strdup in f2fs_parse_options
  // free(f2fs_params.extension_list);
#endif
}

zx_status_t F2fsMkfs::WriteToDisk(void *buf, uint64_t offset, size_t length) {
  zx_status_t status = 0;
  uint64_t curr_offset = offset;

#ifdef F2FS_BU_DEBUG
  std::cout << std::hex << "writetodeisk: offset= 0x" << offset << " length= 0x" << length
            << std::endl;
#endif

  if (offset % kF2fsBlockSize) {
    std::cout << std::hex << "block is not aligned: offset =  " << offset << " length = " << length
              << std::endl;
    return ZX_ERR_INVALID_ARGS;
  }

  if (length % kF2fsBlockSize) {
    std::cout << std::hex << "block size is not aligned: offset =  " << offset
              << " length = " << length << std::endl;
    return ZX_ERR_INVALID_ARGS;
  }

  for (uint64_t i = 0; i < length / kF2fsBlockSize; i++) {
    if ((status = bc_->Writeblk((offset / kF2fsBlockSize) + i, buf)) != ZX_OK) {
      std::cout << "mkfs: Failed to write root directory: " << status << std::endl;
    }

    curr_offset += kF2fsBlockSize;
  }

  ZX_ASSERT(curr_offset == offset + length);

  return status;
}

zx_status_t F2fsMkfs::F2fsPrepareSuperBlock() {
  uint32_t blk_size_bytes;
  uint32_t log_sectorsize, log_sectors_per_block;
  uint32_t log_blocksize, log_blks_per_seg;
  uint32_t segment_size_bytes, zone_size_bytes;
  uint32_t sit_segments;
  uint32_t blocks_for_sit, blocks_for_nat, blocks_for_ssa;
  uint32_t total_valid_blks_available;
  uint64_t zone_align_start_offset, diff, total_meta_segments;
  uint32_t sit_bitmap_size, max_nat_bitmap_size, max_nat_segments;
  uint32_t total_zones;

  super_block.magic = CpuToLe(uint32_t{kF2fsSuperMagic});
  super_block.major_ver = CpuToLe(uint16_t{F2FS_MAJOR_VERSION});
  super_block.minor_ver = CpuToLe(uint16_t{F2FS_MINOR_VERSION});

  log_sectorsize = LogBase2(f2fs_params.sector_size);
  log_sectors_per_block = LogBase2(f2fs_params.sectors_per_blk);
  log_blocksize = log_sectorsize + log_sectors_per_block;
  log_blks_per_seg = LogBase2(f2fs_params.blks_per_seg);

  super_block.log_sectorsize = CpuToLe(log_sectorsize);

  if (log_sectorsize < 0) {
    printf("\n\tError: Failed to get the sector size: %u!\n", f2fs_params.sector_size);
    return ZX_ERR_INVALID_ARGS;
  }

  super_block.log_sectors_per_block = CpuToLe(log_sectors_per_block);

  if (log_sectors_per_block < 0) {
    printf("\n\tError: Failed to get sectors per block: %u!\n", f2fs_params.sectors_per_blk);
    return ZX_ERR_INVALID_ARGS;
  }

  super_block.log_blocksize = CpuToLe(log_blocksize);
  super_block.log_blocks_per_seg = CpuToLe(log_blks_per_seg);

  if (log_blks_per_seg < 0) {
    printf("\n\tError: Failed to get block per segment: %u!\n", f2fs_params.blks_per_seg);
    return ZX_ERR_INVALID_ARGS;
  }

  super_block.segs_per_sec = CpuToLe(f2fs_params.segs_per_sec);
  super_block.secs_per_zone = CpuToLe(f2fs_params.secs_per_zone);
  blk_size_bytes = 1 << log_blocksize;
  segment_size_bytes = blk_size_bytes * f2fs_params.blks_per_seg;
  zone_size_bytes = blk_size_bytes * f2fs_params.secs_per_zone * f2fs_params.segs_per_sec *
                    f2fs_params.blks_per_seg;

  super_block.checksum_offset = 0;

  super_block.block_count =
      CpuToLe((f2fs_params.total_sectors * DEFAULT_SECTOR_SIZE) / blk_size_bytes);

  zone_align_start_offset =
      (f2fs_params.start_sector * DEFAULT_SECTOR_SIZE + 2 * F2FS_BLKSIZE + zone_size_bytes - 1) /
          zone_size_bytes * zone_size_bytes -
      f2fs_params.start_sector * DEFAULT_SECTOR_SIZE;

  if (f2fs_params.start_sector % DEFAULT_SECTORS_PER_BLOCK) {
    printf("WARN: Align start sector number in a unit of pages\n");
    printf("\ti.e., start sector: %d, ofs:%d (sectors per page: %d)\n", f2fs_params.start_sector,
           f2fs_params.start_sector % DEFAULT_SECTORS_PER_BLOCK, DEFAULT_SECTORS_PER_BLOCK);
  }

  super_block.segment_count =
      CpuToLe(((f2fs_params.total_sectors * DEFAULT_SECTOR_SIZE) - zone_align_start_offset) /
                  segment_size_bytes);

  super_block.segment0_blkaddr = CpuToLe(zone_align_start_offset / blk_size_bytes);
  super_block.cp_blkaddr = super_block.segment0_blkaddr;

  super_block.segment_count_ckpt = CpuToLe(uint32_t{F2FS_NUMBER_OF_CHECKPOINT_PACK});

  super_block.sit_blkaddr =
      CpuToLe(LeToCpu(super_block.segment0_blkaddr) +
                  (LeToCpu(super_block.segment_count_ckpt) * (1 << log_blks_per_seg)));

  blocks_for_sit =
      (LeToCpu(super_block.segment_count) + SIT_ENTRY_PER_BLOCK - 1) / SIT_ENTRY_PER_BLOCK;

  sit_segments = (blocks_for_sit + f2fs_params.blks_per_seg - 1) / f2fs_params.blks_per_seg;

  super_block.segment_count_sit = CpuToLe(sit_segments * 2);

  super_block.nat_blkaddr =
      CpuToLe(LeToCpu(super_block.sit_blkaddr) +
                  (LeToCpu(super_block.segment_count_sit) * f2fs_params.blks_per_seg));

  total_valid_blks_available =
      (LeToCpu(super_block.segment_count) -
       (LeToCpu(super_block.segment_count_ckpt) + LeToCpu(super_block.segment_count_sit))) *
      f2fs_params.blks_per_seg;

  blocks_for_nat = (total_valid_blks_available + NAT_ENTRY_PER_BLOCK - 1) / NAT_ENTRY_PER_BLOCK;

  super_block.segment_count_nat =
      CpuToLe((blocks_for_nat + f2fs_params.blks_per_seg - 1) / f2fs_params.blks_per_seg);
  /*
   * The number of node segments should not be exceeded a "Threshold".
   * This number resizes NAT bitmap area in a CP page.
   * So the threshold is determined not to overflow one CP page
   */
  sit_bitmap_size = ((LeToCpu(super_block.segment_count_sit) / 2) << log_blks_per_seg) / 8;
  max_nat_bitmap_size = 4096 - sizeof(struct f2fs_checkpoint) + 1 - sit_bitmap_size;
  max_nat_segments = (max_nat_bitmap_size * 8) >> log_blks_per_seg;

  if (LeToCpu(super_block.segment_count_nat) > max_nat_segments)
    super_block.segment_count_nat = CpuToLe(max_nat_segments);

  super_block.segment_count_nat = CpuToLe(LeToCpu(super_block.segment_count_nat) * 2);

  super_block.ssa_blkaddr =
      CpuToLe(LeToCpu(super_block.nat_blkaddr) +
                  LeToCpu(super_block.segment_count_nat) * f2fs_params.blks_per_seg);

  total_valid_blks_available =
      (LeToCpu(super_block.segment_count) -
       (LeToCpu(super_block.segment_count_ckpt) + LeToCpu(super_block.segment_count_sit) +
        LeToCpu(super_block.segment_count_nat))) *
      f2fs_params.blks_per_seg;

  blocks_for_ssa = total_valid_blks_available / f2fs_params.blks_per_seg + 1;

  super_block.segment_count_ssa =
      CpuToLe((blocks_for_ssa + f2fs_params.blks_per_seg - 1) / f2fs_params.blks_per_seg);

  total_meta_segments =
      LeToCpu(super_block.segment_count_ckpt) + LeToCpu(super_block.segment_count_sit) +
      LeToCpu(super_block.segment_count_nat) + LeToCpu(super_block.segment_count_ssa);
  diff = total_meta_segments % (f2fs_params.segs_per_sec * f2fs_params.secs_per_zone);
  if (diff)
    super_block.segment_count_ssa =
        CpuToLe(LeToCpu(super_block.segment_count_ssa) +
                    (f2fs_params.segs_per_sec * f2fs_params.secs_per_zone - diff));

  super_block.main_blkaddr =
      CpuToLe(LeToCpu(super_block.ssa_blkaddr) +
                  (LeToCpu(super_block.segment_count_ssa) * f2fs_params.blks_per_seg));

  super_block.segment_count_main = CpuToLe(
      LeToCpu(super_block.segment_count) -
      (LeToCpu(super_block.segment_count_ckpt) + LeToCpu(super_block.segment_count_sit) +
       LeToCpu(super_block.segment_count_nat) + LeToCpu(super_block.segment_count_ssa)));

  super_block.section_count =
      CpuToLe(LeToCpu(super_block.segment_count_main) / f2fs_params.segs_per_sec);

  super_block.segment_count_main =
      CpuToLe(LeToCpu(super_block.section_count) * f2fs_params.segs_per_sec);

  if ((LeToCpu(super_block.segment_count_main) - 2) < f2fs_params.reserved_segments) {
    printf(
        "Error: Device size is not sufficient for F2FS volume, \
			more segment needed =%u",
        f2fs_params.reserved_segments - (LeToCpu(super_block.segment_count_main) - 2));
    return ZX_ERR_NO_SPACE;
  }

  memcpy(super_block.uuid, uuid::Uuid::Generate().bytes(), 16);

  ASCIIToUNICODE(super_block.volume_name, f2fs_params.vol_label);

  super_block.node_ino = CpuToLe(uint32_t{1});
  super_block.meta_ino = CpuToLe(uint32_t{2});
  super_block.root_ino = CpuToLe(uint32_t{3});

  total_zones = ((LeToCpu(super_block.segment_count_main) - 1) / f2fs_params.segs_per_sec) /
                f2fs_params.secs_per_zone;
  if (total_zones <= 6) {
    printf(
        "\n\tError: %d zones: Need more zones \
			by shrinking zone size\n",
        total_zones);
    return ZX_ERR_NO_SPACE;
  }

  if (f2fs_params.heap) {
    f2fs_params.cur_seg[CURSEG_HOT_NODE] =
        (total_zones - 1) * f2fs_params.segs_per_sec * f2fs_params.secs_per_zone +
        ((f2fs_params.secs_per_zone - 1) * f2fs_params.segs_per_sec);
    f2fs_params.cur_seg[CURSEG_WARM_NODE] =
        f2fs_params.cur_seg[CURSEG_HOT_NODE] - f2fs_params.segs_per_sec * f2fs_params.secs_per_zone;
    f2fs_params.cur_seg[CURSEG_COLD_NODE] = f2fs_params.cur_seg[CURSEG_WARM_NODE] -
                                            f2fs_params.segs_per_sec * f2fs_params.secs_per_zone;
    f2fs_params.cur_seg[CURSEG_HOT_DATA] = f2fs_params.cur_seg[CURSEG_COLD_NODE] -
                                           f2fs_params.segs_per_sec * f2fs_params.secs_per_zone;
    f2fs_params.cur_seg[CURSEG_COLD_DATA] = 0;
    f2fs_params.cur_seg[CURSEG_WARM_DATA] = f2fs_params.cur_seg[CURSEG_COLD_DATA] +
                                            f2fs_params.segs_per_sec * f2fs_params.secs_per_zone;
  } else {
    f2fs_params.cur_seg[CURSEG_HOT_NODE] = 0;
    f2fs_params.cur_seg[CURSEG_WARM_NODE] =
        f2fs_params.cur_seg[CURSEG_HOT_NODE] + f2fs_params.segs_per_sec * f2fs_params.secs_per_zone;
    f2fs_params.cur_seg[CURSEG_COLD_NODE] = f2fs_params.cur_seg[CURSEG_WARM_NODE] +
                                            f2fs_params.segs_per_sec * f2fs_params.secs_per_zone;
    f2fs_params.cur_seg[CURSEG_HOT_DATA] = f2fs_params.cur_seg[CURSEG_COLD_NODE] +
                                           f2fs_params.segs_per_sec * f2fs_params.secs_per_zone;
    f2fs_params.cur_seg[CURSEG_COLD_DATA] =
        f2fs_params.cur_seg[CURSEG_HOT_DATA] + f2fs_params.segs_per_sec * f2fs_params.secs_per_zone;
    f2fs_params.cur_seg[CURSEG_WARM_DATA] = f2fs_params.cur_seg[CURSEG_COLD_DATA] +
                                            f2fs_params.segs_per_sec * f2fs_params.secs_per_zone;
  }

  ConfigureExtensionList();

  return 0;
}

zx_status_t F2fsMkfs::F2fsInitSitArea() {
  uint32_t blk_size_bytes;
  uint32_t seg_size_bytes;
  uint32_t index = 0;
  uint64_t sit_seg_blk_offset = 0;
  uint8_t *zero_buf = nullptr;
  zx_status_t ret;

  blk_size_bytes = 1 << LeToCpu(super_block.log_blocksize);
  seg_size_bytes = (1 << LeToCpu(super_block.log_blocks_per_seg)) * blk_size_bytes;

  zero_buf = static_cast<uint8_t *>(calloc(sizeof(uint8_t), seg_size_bytes));
  if (zero_buf == nullptr) {
    printf("\n\tError: Calloc Failed for sit_zero_buf!!!\n");
    return ZX_ERR_NO_MEMORY;
  }

  sit_seg_blk_offset = LeToCpu(super_block.sit_blkaddr) * blk_size_bytes;

  for (index = 0; index < (LeToCpu(super_block.segment_count_sit) / 2); index++) {
    ret = WriteToDisk(zero_buf, sit_seg_blk_offset, seg_size_bytes);
    if (ret < 0) {
      printf(
          "\n\tError: While zeroing out the sit area \
					on disk!!!\n");
      return ret;
    }
    sit_seg_blk_offset = sit_seg_blk_offset + seg_size_bytes;
  }

  free(zero_buf);
  return ZX_OK;
}

zx_status_t F2fsMkfs::F2fsInitNatArea() {
  uint32_t blk_size_bytes;
  uint32_t seg_size_bytes;
  uint32_t index = 0;
  uint64_t nat_seg_blk_offset = 0;
  uint8_t *nat_buf = nullptr;
  zx_status_t ret;

  blk_size_bytes = 1 << LeToCpu(super_block.log_blocksize);
  seg_size_bytes = (1 << LeToCpu(super_block.log_blocks_per_seg)) * blk_size_bytes;

  nat_buf = static_cast<uint8_t *>(calloc(sizeof(uint8_t), seg_size_bytes));
  if (nat_buf == nullptr) {
    printf("\n\tError: Calloc Failed for nat_zero_blk!!!\n");
    return ZX_ERR_NO_MEMORY;
  }

  nat_seg_blk_offset = LeToCpu(super_block.nat_blkaddr) * blk_size_bytes;

  for (index = 0; index < (LeToCpu(super_block.segment_count_nat) / 2); index++) {
    ret = WriteToDisk(nat_buf, nat_seg_blk_offset, seg_size_bytes);
    if (ret < 0) {
      printf(
          "\n\tError: While zeroing out the nat area \
					on disk!!!\n");
      return ret;
    }
    nat_seg_blk_offset = nat_seg_blk_offset + (2 * seg_size_bytes);
  }

  free(nat_buf);
  return ZX_OK;
}

zx_status_t F2fsMkfs::F2fsWriteCheckPointPack() {
  struct f2fs_checkpoint *ckp = nullptr;
  struct f2fs_summary_block *sum = nullptr;
  uint32_t blk_size_bytes;
  uint64_t cp_seg_blk_offset = 0;
  uint32_t crc = 0;
  zx_status_t ret;
  int i;

  ckp = static_cast<struct f2fs_checkpoint *>(calloc(F2FS_BLKSIZE, 1));
  if (ckp == nullptr) {
    printf("\n\tError: Calloc Failed for f2fs_checkpoint!!!\n");
    return ZX_ERR_NO_MEMORY;
  }

  sum = static_cast<struct f2fs_summary_block *>(calloc(F2FS_BLKSIZE, 1));
  if (sum == nullptr) {
    printf("\n\tError: Calloc Failed for summay_node!!!\n");
    return ZX_ERR_NO_MEMORY;
  }

  /* 1. cp page 1 of checkpoint pack 1 */
  ckp->checkpoint_ver = 1;
  ckp->cur_node_segno[0] = CpuToLe(f2fs_params.cur_seg[CURSEG_HOT_NODE]);
  ckp->cur_node_segno[1] = CpuToLe(f2fs_params.cur_seg[CURSEG_WARM_NODE]);
  ckp->cur_node_segno[2] = CpuToLe(f2fs_params.cur_seg[CURSEG_COLD_NODE]);
  ckp->cur_data_segno[0] = CpuToLe(f2fs_params.cur_seg[CURSEG_HOT_DATA]);
  ckp->cur_data_segno[1] = CpuToLe(f2fs_params.cur_seg[CURSEG_WARM_DATA]);
  ckp->cur_data_segno[2] = CpuToLe(f2fs_params.cur_seg[CURSEG_COLD_DATA]);
  for (i = 3; i < MAX_ACTIVE_NODE_LOGS; i++) {
    ckp->cur_node_segno[i] = 0xffffffff;
    ckp->cur_data_segno[i] = 0xffffffff;
  }

  ckp->cur_node_blkoff[0] = CpuToLe(uint16_t{1});
  ckp->cur_data_blkoff[0] = CpuToLe(uint16_t{1});
  ckp->valid_block_count = CpuToLe(uint64_t{2});
  ckp->rsvd_segment_count = CpuToLe(f2fs_params.reserved_segments);
  ckp->overprov_segment_count = CpuToLe(
      (LeToCpu(super_block.segment_count_main) - LeToCpu(ckp->rsvd_segment_count)) *
      f2fs_params.overprovision / 100);
  ckp->overprov_segment_count =
      CpuToLe(LeToCpu(ckp->overprov_segment_count) + LeToCpu(ckp->rsvd_segment_count));

  /* main segments - reserved segments - (node + data segments) */
  ckp->free_segment_count = CpuToLe(LeToCpu(super_block.segment_count_main) - 6);

  ckp->user_block_count = CpuToLe(
      ((LeToCpu(ckp->free_segment_count) + 6 - LeToCpu(ckp->overprov_segment_count)) *
       f2fs_params.blks_per_seg));

  ckp->cp_pack_total_block_count = CpuToLe(uint32_t{8});
  ckp->ckpt_flags |= CP_UMOUNT_FLAG;
  ckp->cp_pack_start_sum = CpuToLe(uint32_t{1});
  ckp->valid_node_count = CpuToLe(uint32_t{1});
  ckp->valid_inode_count = CpuToLe(uint32_t{1});
  ckp->next_free_nid = CpuToLe(LeToCpu(super_block.root_ino) + 1);

  ckp->sit_ver_bitmap_bytesize = CpuToLe(((LeToCpu(super_block.segment_count_sit) / 2)
                                              << LeToCpu(super_block.log_blocks_per_seg)) /
                                             8);

  ckp->nat_ver_bitmap_bytesize = CpuToLe(((LeToCpu(super_block.segment_count_nat) / 2)
                                              << LeToCpu(super_block.log_blocks_per_seg)) /
                                             8);

  ckp->checksum_offset = CpuToLe(uint32_t{4092}); //TODO use constexpr

  crc = F2fsCalCrc32(kF2fsSuperMagic, ckp, LeToCpu(ckp->checksum_offset));
  *(reinterpret_cast<uint32_t *>(reinterpret_cast<unsigned char *>(ckp) +
                                 LeToCpu(ckp->checksum_offset))) = crc;

  blk_size_bytes = 1 << LeToCpu(super_block.log_blocksize);
  cp_seg_blk_offset = LeToCpu(super_block.segment0_blkaddr) * blk_size_bytes;

  ret = WriteToDisk(ckp, cp_seg_blk_offset, F2FS_BLKSIZE);
  if (ret < 0) {
    printf("\n\tError: While writing the ckp to disk!!!\n");
    return ret;
  }

  /* 2. Prepare and write Segment summary for data blocks */
  memset(sum, 0, sizeof(struct f2fs_summary_block));
  SET_SUM_TYPE((&sum->footer), SUM_TYPE_DATA);

  sum->entries[0].nid = super_block.root_ino;
  sum->entries[0].ofs_in_node = 0;

  cp_seg_blk_offset += blk_size_bytes;
  ret = WriteToDisk(sum, cp_seg_blk_offset, F2FS_BLKSIZE);
  if (ret < 0) {
    printf("\n\tError: While writing the sum_blk to disk!!!\n");
    return ret;
  }

  /* 3. Fill segment summary for data block to zero. */
  memset(sum, 0, sizeof(struct f2fs_summary_block));
  SET_SUM_TYPE((&sum->footer), SUM_TYPE_DATA);

  cp_seg_blk_offset += blk_size_bytes;
   ret = WriteToDisk(sum, cp_seg_blk_offset, F2FS_BLKSIZE);
  if (ret < 0) {
    printf("\n\tError: While writing the sum_blk to disk!!!\n");
    return ret;
  }

  /* 4. Fill segment summary for data block to zero. */
  memset(sum, 0, sizeof(struct f2fs_summary_block));
  SET_SUM_TYPE((&sum->footer), SUM_TYPE_DATA);

  /* inode sit for root */
  sum->n_sits = CpuToLe(uint16_t{6});
  sum->sit_j.entries[0].segno = ckp->cur_node_segno[0];
  sum->sit_j.entries[0].se.vblocks = CpuToLe(uint16_t{(CURSEG_HOT_NODE << 10) | 1});
  F2fsSetBit(0, sum->sit_j.entries[0].se.valid_map);
  sum->sit_j.entries[1].segno = ckp->cur_node_segno[1];
  sum->sit_j.entries[1].se.vblocks = CpuToLe(uint16_t{(CURSEG_WARM_NODE << 10)});
  sum->sit_j.entries[2].segno = ckp->cur_node_segno[2];
  sum->sit_j.entries[2].se.vblocks = CpuToLe(uint16_t{(CURSEG_COLD_NODE << 10)});

  /* data sit for root */
  sum->sit_j.entries[3].segno = ckp->cur_data_segno[0];
  sum->sit_j.entries[3].se.vblocks = CpuToLe(uint16_t{(CURSEG_HOT_DATA << 10) | 1});
  F2fsSetBit(0, sum->sit_j.entries[3].se.valid_map);
  sum->sit_j.entries[4].segno = ckp->cur_data_segno[1];
  sum->sit_j.entries[4].se.vblocks = CpuToLe(uint16_t{(CURSEG_WARM_DATA << 10)});
  sum->sit_j.entries[5].segno = ckp->cur_data_segno[2];
  sum->sit_j.entries[5].se.vblocks = CpuToLe(uint16_t{(CURSEG_COLD_DATA << 10)});

  cp_seg_blk_offset += blk_size_bytes;
  ret = WriteToDisk(sum, cp_seg_blk_offset, F2FS_BLKSIZE);
  if (ret < 0) {
    printf("\n\tError: While writing the sum_blk to disk!!!\n");
    return ret;
  }

  /* 5. Prepare and write Segment summary for node blocks */
  memset(sum, 0, sizeof(struct f2fs_summary_block));
  SET_SUM_TYPE((&sum->footer), SUM_TYPE_NODE);

  sum->entries[0].nid = super_block.root_ino;
  sum->entries[0].ofs_in_node = 0;

  cp_seg_blk_offset += blk_size_bytes;
  ret = WriteToDisk(sum, cp_seg_blk_offset, F2FS_BLKSIZE);
  if (ret < 0) {
    printf("\n\tError: While writing the sum_blk to disk!!!\n");
    return ret;
  }

  /* 6. Fill segment summary for data block to zero. */
  memset(sum, 0, sizeof(struct f2fs_summary_block));
  SET_SUM_TYPE((&sum->footer), SUM_TYPE_NODE);

  cp_seg_blk_offset += blk_size_bytes;
  ret = WriteToDisk(sum, cp_seg_blk_offset, F2FS_BLKSIZE);
  if (ret < 0) {
    printf("\n\tError: While writing the sum_blk to disk!!!\n");
    return ret;
  }

  /* 7. Fill segment summary for data block to zero. */
  memset(sum, 0, sizeof(struct f2fs_summary_block));
  SET_SUM_TYPE((&sum->footer), SUM_TYPE_NODE);
  cp_seg_blk_offset += blk_size_bytes;
  ret = WriteToDisk(sum, cp_seg_blk_offset, F2FS_BLKSIZE);
  if (ret < 0) {
    printf("\n\tError: While writing the sum_blk to disk!!!\n");
    return ret;
  }

  /* 8. cp page2 */
  cp_seg_blk_offset += blk_size_bytes;
  ret = WriteToDisk(ckp, cp_seg_blk_offset, F2FS_BLKSIZE);
  if (ret < 0) {
    printf("\n\tError: While writing the ckp to disk!!!\n");
    return ret;
  }

  /* 9. cp page 1 of check point pack 2
   * Initiatialize other checkpoint pack with version zero
   */
  ckp->checkpoint_ver = 0;

  crc = F2fsCalCrc32(kF2fsSuperMagic, ckp, LeToCpu(ckp->checksum_offset));
  *(reinterpret_cast<uint32_t *>(reinterpret_cast<unsigned char *>(ckp) +
                                 LeToCpu(ckp->checksum_offset))) = crc;

  cp_seg_blk_offset =
      (LeToCpu(super_block.segment0_blkaddr) + f2fs_params.blks_per_seg) * blk_size_bytes;
  ret = WriteToDisk(ckp, cp_seg_blk_offset, F2FS_BLKSIZE);
  if (ret < 0) {
    printf("\n\tError: While writing the ckp to disk!!!\n");
    return ret;
  }

  free(sum);
  free(ckp);
  return ZX_OK;
}

zx_status_t F2fsMkfs::F2fsWriteSuperBlock() {
  uint32_t index = 0;
  uint8_t *zero_buff;
  zx_status_t ret;

  zero_buff = static_cast<uint8_t *>(calloc(F2FS_BLKSIZE, 1));

  memcpy(zero_buff + F2FS_SUPER_OFFSET, &super_block, sizeof(super_block));

  for (index = 0; index < 2; index++) {
    ret = WriteToDisk(zero_buff, index * F2FS_BLKSIZE, F2FS_BLKSIZE);
    if (ret < 0) {
      printf(
          "\n\tError: While while writing supe_blk \
					on disk!!! index : %d\n",
          index);
      return ret;
    }
  }

  free(zero_buff);
  return ZX_OK;
}

zx_status_t F2fsMkfs::F2fsWriteRootInode() {
  struct f2fs_node *raw_node = nullptr;
  uint32_t blk_size_bytes;
  uint64_t data_blk_nor;
  uint64_t main_area_node_seg_blk_offset = 0;
  zx_status_t ret;

  raw_node = static_cast<struct f2fs_node *>(calloc(F2FS_BLKSIZE, 1));
  if (raw_node == nullptr) {
    printf("\n\tError: Calloc Failed for raw_node!!!\n");
    return ZX_ERR_NO_MEMORY;
  }

  raw_node->footer.nid = super_block.root_ino;
  raw_node->footer.ino = super_block.root_ino;
  raw_node->footer.cp_ver = CpuToLe(uint64_t{1});
  raw_node->footer.next_blkaddr =
      CpuToLe(LeToCpu(super_block.main_blkaddr) +
                  f2fs_params.cur_seg[CURSEG_HOT_NODE] * f2fs_params.blks_per_seg + 1);

  raw_node->i.i_mode = CpuToLe(uint16_t{0x41ed});
  raw_node->i.i_links = CpuToLe(uint32_t{2});
  raw_node->i.i_uid = CpuToLe(getuid());
  raw_node->i.i_gid = CpuToLe(getgid());

  blk_size_bytes = 1 << LeToCpu(super_block.log_blocksize);
  raw_node->i.i_size = CpuToLe(1 * blk_size_bytes); /* dentry */
  raw_node->i.i_blocks = CpuToLe(uint64_t{2});

  raw_node->i.i_atime = CpuToLe(static_cast<uint64_t>(time(nullptr)));
  raw_node->i.i_atime_nsec = 0;
  raw_node->i.i_ctime = CpuToLe(static_cast<uint64_t>(time(nullptr)));
  raw_node->i.i_ctime_nsec = 0;
  raw_node->i.i_mtime = CpuToLe(static_cast<uint64_t>(time(nullptr)));
  raw_node->i.i_mtime_nsec = 0;
  raw_node->i.i_generation = 0;
  raw_node->i.i_xattr_nid = 0;
  raw_node->i.i_flags = 0;
  raw_node->i.i_current_depth = CpuToLe(uint32_t{1});

  data_blk_nor = LeToCpu(super_block.main_blkaddr) +
                 f2fs_params.cur_seg[CURSEG_HOT_DATA] * f2fs_params.blks_per_seg;
  raw_node->i.i_addr[0] = CpuToLe(data_blk_nor);

  raw_node->i.i_ext.fofs = 0;
  raw_node->i.i_ext.blk_addr = CpuToLe(data_blk_nor);
  raw_node->i.i_ext.len = CpuToLe(uint32_t{1});

  main_area_node_seg_blk_offset = LeToCpu(super_block.main_blkaddr);
  main_area_node_seg_blk_offset += f2fs_params.cur_seg[CURSEG_HOT_NODE] * f2fs_params.blks_per_seg;
  main_area_node_seg_blk_offset *= blk_size_bytes;

  ret = WriteToDisk(raw_node, main_area_node_seg_blk_offset, F2FS_BLKSIZE);
  if (ret < 0) {
    printf("\n\tError: While writing the raw_node to disk!!!, size = %lu\n",
           sizeof(struct f2fs_node));
    return ret;
  }

  memset(raw_node, 0xff, sizeof(struct f2fs_node));

  ret = WriteToDisk(raw_node, main_area_node_seg_blk_offset + 4096, F2FS_BLKSIZE);
  if (ret < 0) {
    printf("\n\tError: While writing the raw_node to disk!!!\n");
    return ret;
  }
  free(raw_node);
  return ZX_OK;
}

zx_status_t F2fsMkfs::F2fsUpdateNatRoot() {
  struct f2fs_nat_block *nat_blk = nullptr;
  uint32_t blk_size_bytes;
  uint64_t nat_seg_blk_offset = 0;
  zx_status_t ret;

  nat_blk = static_cast<struct f2fs_nat_block *>(calloc(F2FS_BLKSIZE, 1));
  if (nat_blk == nullptr) {
    printf("\n\tError: Calloc Failed for nat_blk!!!\n");
    return ZX_ERR_NO_MEMORY;
  }

  /* update root */
  nat_blk->entries[super_block.root_ino].block_addr =
      CpuToLe(LeToCpu(super_block.main_blkaddr) +
                  f2fs_params.cur_seg[CURSEG_HOT_NODE] * f2fs_params.blks_per_seg);
  nat_blk->entries[super_block.root_ino].ino = super_block.root_ino;

  /* update node nat */
  nat_blk->entries[super_block.node_ino].block_addr = CpuToLe(uint32_t{1});
  nat_blk->entries[super_block.node_ino].ino = super_block.node_ino;

  /* update meta nat */
  nat_blk->entries[super_block.meta_ino].block_addr = CpuToLe(uint32_t{1});
  nat_blk->entries[super_block.meta_ino].ino = super_block.meta_ino;

  blk_size_bytes = 1 << LeToCpu(super_block.log_blocksize);

  nat_seg_blk_offset = LeToCpu(super_block.nat_blkaddr) * blk_size_bytes;

  ret = WriteToDisk(nat_blk, nat_seg_blk_offset, F2FS_BLKSIZE);
  if (ret < 0) {
    printf("\n\tError: While writing the nat_blk set0 to disk!!!\n");
    return ret;
  }

  free(nat_blk);
  return ZX_OK;
}

zx_status_t F2fsMkfs::F2fsAddDefaultDentryRoot() {
  struct f2fs_dentry_block *dent_blk = nullptr;
  uint32_t blk_size_bytes;
  uint64_t data_blk_offset = 0;
  zx_status_t ret;

  dent_blk = static_cast<struct f2fs_dentry_block *>(calloc(F2FS_BLKSIZE, 1));
  if (dent_blk == nullptr) {
    printf("\n\tError: Calloc Failed for dent_blk!!!\n");
    return ZX_ERR_NO_MEMORY;
  }

  dent_blk->dentry[0].hash_code = 0;
  dent_blk->dentry[0].ino = super_block.root_ino;
  dent_blk->dentry[0].name_len = CpuToLe(uint16_t{1});
  dent_blk->dentry[0].file_type = F2FS_FT_DIR;
  memcpy(dent_blk->filename[0], ".", 1);

  dent_blk->dentry[1].hash_code = 0;
  dent_blk->dentry[1].ino = super_block.root_ino;
  dent_blk->dentry[1].name_len = CpuToLe(uint16_t{2});
  dent_blk->dentry[1].file_type = F2FS_FT_DIR;
  memcpy(dent_blk->filename[1], "..", 2);

  /* bitmap for . and .. */
  dent_blk->dentry_bitmap[0] = (1 << 1) | (1 << 0);
  blk_size_bytes = 1 << LeToCpu(super_block.log_blocksize);
  data_blk_offset = (LeToCpu(super_block.main_blkaddr) +
                     f2fs_params.cur_seg[CURSEG_HOT_DATA] * f2fs_params.blks_per_seg) *
                    blk_size_bytes;

  ret = WriteToDisk(dent_blk, data_blk_offset, F2FS_BLKSIZE);
  if (ret < 0) {
    printf("\n\tError: While writing the dentry_blk to disk!!!\n");
    return ret;
  }

  free(dent_blk);
  return ZX_OK;
}

zx_status_t F2fsMkfs::F2fsCreateRootDir() {
  int8_t err = 0;

  err = F2fsWriteRootInode();
  if (err < 0) {
    printf("\n\tError: Failed to write root inode!!!\n");
    goto exit;
  }

  err = F2fsUpdateNatRoot();
  if (err < 0) {
    printf("\n\tError: Failed to update NAT for root!!!\n");
    goto exit;
  }

  err = F2fsAddDefaultDentryRoot();
  if (err < 0) {
    printf("\n\tError: Failed to add default dentries for root!!!\n");
    goto exit;
  }
exit:
  if (err)
    printf("\n\tError: Could not create the root directory!!!\n");

  return err;
}

#if 0  // porting needed
// int F2fsMkfs::F2fsTrimDevice()
// {
//         unsigned long long range[2];
//         struct stat stat_buf;

//         range[0] = 0;
//         range[1] = f2fs_params.total_sectors * DEFAULT_SECTOR_SIZE;

//         if (fstat(f2fs_params.fd, &stat_buf) < 0 ) {
//                 printf("\n\tError: Failed to get the device stat!!!\n");
//                 return -1;
//         }

//         if (S_ISREG(stat_buf.st_mode))
//                 return 0;
//         else if (S_ISBLK(stat_buf.st_mode)) {
// //		if (ioctl(f2fs_params.fd, BLKDISCARD, &range) < 0)
//                         printf("Info: This device doesn't support TRIM\n");
//         } else
//                 return -1;
//         return 0;
// }
#endif

int8_t F2fsMkfs::F2fsFormatDevice() {
  int8_t err = 0;

  err = static_cast<int8_t>(F2fsPrepareSuperBlock());
  if (err < 0)
    goto exit;

#if 0  // porting needed
  // TRIM is not supported
  // err = f2fs_trim_device();
  // if (err < 0) {
  //   printf("\n\tError: Failed to trim whole device!!!\n");
  //   goto exit;
  // }
#endif
  err = F2fsInitSitArea();
  if (err < 0) {
    printf("\n\tError: Failed to Initialise the SIT AREA!!!\n");
    goto exit;
  }

  err = F2fsInitNatArea();
  if (err < 0) {
    printf("\n\tError: Failed to Initialise the NAT AREA!!!\n");
    goto exit;
  }

  err = F2fsCreateRootDir();
  if (err < 0) {
    printf("\n\tError: Failed to create the root directory!!!\n");
    goto exit;
  }

  err = F2fsWriteCheckPointPack();
  if (err < 0) {
    printf("\n\tError: Failed to write the check point pack!!!\n");
    goto exit;
  }

  err = F2fsWriteSuperBlock();
  if (err < 0) {
    printf("\n\tError: Failed to write the Super Block!!!\n");
    goto exit;
  }
exit:
  if (err)
    printf("\n\tError: Could not format the device!!!\n");

  /*
   * We should call fsync() to flush out all the dirty pages
   * in the block device page cache.
   */
  bc_->Sync();

  return err;
}

}  // namespace f2fs