// Copyright 2017 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include <fvm/fvm-sparse.h>
#include <minfs/transaction-limits.h>
#include <safemath/checked_math.h>

#include <utility>

#include "fvm-host/format.h"

MinfsFormat::MinfsFormat(fbl::unique_fd fd, const char* type)
    : Format() {
    if (!strcmp(type, kDataTypeName)) {
        memcpy(type_, kDataType, sizeof(kDataType));
        flags_ |= fvm::kSparseFlagZxcrypt;

    } else if (!strcmp(type, kDataUnsafeTypeName)) {
        memcpy(type_, kDataType, sizeof(kDataType));

    } else if (!strcmp(type, kSystemTypeName)) {
        memcpy(type_, kSystemType, sizeof(kSystemType));

    } else if (!strcmp(type, kDefaultTypeName)) {
        memcpy(type_, kDefaultType, sizeof(kDefaultType));

    } else {
        fprintf(stderr, "Unrecognized type for minfs: %s\n", type);
        exit(-1);
    }

    struct stat s;

    if (fstat(fd.get(), &s) < 0) {
        fprintf(stderr, "error: minfs could not find end of file/device\n");
        exit(-1);
    } else if (s.st_size == 0) {
        fprintf(stderr, "minfs: failed to access block device\n");
        exit(-1);
    }

    off_t size = s.st_size / minfs::kMinfsBlockSize;

    if (minfs::Bcache::Create(&bc_, std::move(fd), (uint32_t)size) < 0) {
        fprintf(stderr, "error: cannot create block cache\n");
        exit(-1);
    }

    if (bc_->Readblk(0, &blk_) != ZX_OK) {
        fprintf(stderr, "minfs: could not read info block\n");
        exit(-1);
    }

    if (CheckSuperblock(&info_, bc_.get()) != ZX_OK) {
        fprintf(stderr, "Check info failed\n");
        exit(-1);
    }
}

zx_status_t MinfsFormat::MakeFvmReady(size_t slice_size, uint32_t vpart_index,
                                      FvmReservation* reserve) {
    memcpy(&fvm_blk_, &blk_, minfs::kMinfsBlockSize);
    fvm_info_.slice_size = slice_size;
    fvm_info_.flags |= minfs::kMinfsFlagFVM;

    if (fvm_info_.slice_size % minfs::kMinfsBlockSize) {
        fprintf(stderr, "minfs mkfs: Slice size not multiple of minfs block\n");
        return ZX_ERR_INVALID_ARGS;
    }

    size_t kBlocksPerSlice = fvm_info_.slice_size / minfs::kMinfsBlockSize;

    uint64_t minimum_inodes = reserve->inodes().request.value_or(0);
    uint32_t ibm_blocks = fvm_info_.abm_block - fvm_info_.ibm_block;
    uint32_t ino_blocks = fvm_info_.journal_start_block - fvm_info_.ino_block;

    if (minimum_inodes > fvm_info_.inode_count) {
        // If requested, reserve more inodes than originally allocated.
        ino_blocks = minfs::BlocksRequiredForInode(minimum_inodes);
        ibm_blocks = minfs::BlocksRequiredForBits(minimum_inodes);
    }

    uint32_t minimum_data_blocks = safemath::checked_cast<uint32_t>(
        fbl::round_up(reserve->data().request.value_or(0), minfs::kMinfsBlockSize) /
        minfs::kMinfsBlockSize);
    uint32_t abm_blocks = fvm_info_.ino_block - fvm_info_.abm_block;
    uint32_t dat_blocks = fvm_info_.block_count;

    if (minimum_data_blocks > fvm_info_.block_count) {
        abm_blocks = minfs::BlocksRequiredForBits(minimum_data_blocks);
        dat_blocks = minimum_data_blocks;
    }

    uint32_t journal_blocks = fvm_info_.dat_block - fvm_info_.journal_start_block;

    //TODO(planders): Once blobfs journaling patch is landed, use fvm::BlocksToSlices() here.
    fvm_info_.ibm_slices =
        safemath::checked_cast<uint32_t>((ibm_blocks + kBlocksPerSlice - 1) / kBlocksPerSlice);
    fvm_info_.abm_slices =
        safemath::checked_cast<uint32_t>((abm_blocks + kBlocksPerSlice - 1) / kBlocksPerSlice);
    fvm_info_.ino_slices =
        safemath::checked_cast<uint32_t>((ino_blocks + kBlocksPerSlice - 1) / kBlocksPerSlice);

    // TODO(planders): Weird things may happen if we grow the journal here while it contains valid
    //                 entries. Make sure to account for this case (or verify that the journal is
    //                 resolved prior to extension).
    minfs::TransactionLimits limits(fvm_info_);
    journal_blocks = fbl::max(journal_blocks, limits.GetRecommendedJournalBlocks());
    fvm_info_.journal_slices =
        safemath::checked_cast<uint32_t>((journal_blocks + kBlocksPerSlice - 1) / kBlocksPerSlice);
    fvm_info_.dat_slices =
        safemath::checked_cast<uint32_t>((dat_blocks + kBlocksPerSlice - 1) / kBlocksPerSlice);
    fvm_info_.vslice_count = 1 + fvm_info_.ibm_slices + fvm_info_.abm_slices +
                             fvm_info_.ino_slices + fvm_info_.journal_slices + fvm_info_.dat_slices;

    xprintf("Minfs: slice_size is %" PRIu64 "u, kBlocksPerSlice is %zu\n", fvm_info_.slice_size,
            kBlocksPerSlice);
    xprintf("Minfs: ibm_blocks: %u, ibm_slices: %u\n", ibm_blocks, fvm_info_.ibm_slices);
    xprintf("Minfs: abm_blocks: %u, abm_slices: %u\n", abm_blocks, fvm_info_.abm_slices);
    xprintf("Minfs: ino_blocks: %u, ino_slices: %u\n", ino_blocks, fvm_info_.ino_slices);
    xprintf("Minfs: jnl_blocks: %u, jnl_slices: %u\n", journal_blocks,
            fvm_info_.journal_slices);
    xprintf("Minfs: dat_blocks: %u, dat_slices: %u\n", dat_blocks, fvm_info_.dat_slices);

    fvm_info_.inode_count = safemath::checked_cast<uint32_t>(
        fvm_info_.ino_slices * fvm_info_.slice_size / minfs::kMinfsInodeSize);
    fvm_info_.block_count = safemath::checked_cast<uint32_t>(
        fvm_info_.dat_slices * fvm_info_.slice_size / minfs::kMinfsBlockSize);

    fvm_info_.ibm_block = minfs::kFVMBlockInodeBmStart;
    fvm_info_.abm_block = minfs::kFVMBlockDataBmStart;
    fvm_info_.ino_block = minfs::kFVMBlockInodeStart;
    fvm_info_.journal_start_block = minfs::kFVMBlockJournalStart;
    fvm_info_.dat_block = minfs::kFVMBlockDataStart;

    reserve->set_data_reserved(fvm_info_.dat_slices * fvm_info_.slice_size);
    reserve->set_inodes_reserved(fvm_info_.inode_count);
    reserve->set_total_bytes_reserved(fvm_info_.vslice_count * kBlocksPerSlice *
                                      minfs::kMinfsBlockSize);
    if (!reserve->Approved()) {
        return ZX_ERR_BUFFER_TOO_SMALL;
    }

    zx_status_t status;
    // Check if bitmaps are the wrong size, slice extents run on too long, etc.
    if ((status = CheckSuperblock(&fvm_info_, bc_.get())) != ZX_OK) {
        fprintf(stderr, "Check info failed\n");
        return status;
    }

    fvm_ready_ = true;
    vpart_index_ = vpart_index;
    return ZX_OK;
}

zx_status_t MinfsFormat::GetVsliceRange(unsigned extent_index, vslice_info_t* vslice_info) const {
    CheckFvmReady();
    switch (extent_index) {
    case 0: {
        vslice_info->vslice_start = 0;
        vslice_info->slice_count = 1;
        vslice_info->block_offset = 0;
        vslice_info->block_count = 1;
        vslice_info->zero_fill = true;
        return ZX_OK;
    }
    case 1: {
        vslice_info->vslice_start = minfs::kFVMBlockInodeBmStart;
        vslice_info->slice_count = fvm_info_.ibm_slices;
        vslice_info->block_offset = info_.ibm_block;
        vslice_info->block_count = info_.abm_block - info_.ibm_block;
        vslice_info->zero_fill = true;
        return ZX_OK;
    }
    case 2: {
        vslice_info->vslice_start = minfs::kFVMBlockDataBmStart;
        vslice_info->slice_count = fvm_info_.abm_slices;
        vslice_info->block_offset = info_.abm_block;
        vslice_info->block_count = info_.ino_block - info_.abm_block;
        vslice_info->zero_fill = true;
        return ZX_OK;
    }
    case 3: {
        vslice_info->vslice_start = minfs::kFVMBlockInodeStart;
        vslice_info->slice_count = fvm_info_.ino_slices;
        vslice_info->block_offset = info_.ino_block;
        vslice_info->block_count = info_.journal_start_block - info_.ino_block;
        vslice_info->zero_fill = true;
        return ZX_OK;
    }
    case 4: {
        vslice_info->vslice_start = minfs::kFVMBlockJournalStart;
        vslice_info->slice_count = fvm_info_.journal_slices;
        vslice_info->block_offset = info_.journal_start_block;
        vslice_info->block_count = info_.dat_block - info_.journal_start_block;
        vslice_info->zero_fill = false;
        return ZX_OK;
    }
    case 5: {
        vslice_info->vslice_start = minfs::kFVMBlockDataStart;
        vslice_info->slice_count = fvm_info_.dat_slices;
        vslice_info->block_offset = info_.dat_block;
        vslice_info->block_count = info_.block_count;
        vslice_info->zero_fill = false;
        return ZX_OK;
    }
    }

    return ZX_ERR_OUT_OF_RANGE;
}

zx_status_t MinfsFormat::GetSliceCount(uint32_t* slices_out) const {
    CheckFvmReady();
    *slices_out = safemath::checked_cast<uint32_t>(fvm_info_.vslice_count);
    return ZX_OK;
}

zx_status_t MinfsFormat::FillBlock(size_t block_offset) {
    CheckFvmReady();
    if (block_offset == 0) {
        memcpy(datablk, fvm_blk_, minfs::kMinfsBlockSize);
    } else if (bc_->Readblk(safemath::checked_cast<uint32_t>(block_offset), datablk) != ZX_OK) {
        fprintf(stderr, "minfs: could not read block\n");
        exit(-1);
    }
    return ZX_OK;
}

zx_status_t MinfsFormat::EmptyBlock() {
    CheckFvmReady();
    memset(datablk, 0, BlockSize());
    return ZX_OK;
}

void* MinfsFormat::Data() {
    return datablk;
}

const char* MinfsFormat::Name() const {
    return kMinfsName;
}

uint32_t MinfsFormat::BlockSize() const {
    return minfs::kMinfsBlockSize;
}

uint32_t MinfsFormat::BlocksPerSlice() const {
    CheckFvmReady();
    return safemath::checked_cast<uint32_t>(fvm_info_.slice_size / BlockSize());
}