// 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 <blobfs/fsck.h>
#include <blobfs/iterator/extent-iterator.h>
#include <fs/trace.h>
#include <inttypes.h>

#ifdef __Fuchsia__
#include <blobfs/blobfs.h>

#include <utility>
#else
#include <blobfs/host.h>
#endif

// TODO(planders): Add more checks for fsck.
// TODO(planders): Potentially check the state of the journal.
namespace blobfs {

void BlobfsChecker::TraverseInodeBitmap() {
    for (unsigned n = 0; n < blobfs_->info_.inode_count; n++) {
        Inode* inode = blobfs_->GetNode(n);
        if (inode->header.IsAllocated()) {
            alloc_inodes_++;
            if (inode->header.IsExtentContainer()) {
                // TODO(smklein): sanity check these containers.
                continue;
            }

            bool valid = true;

            AllocatedExtentIterator extents = blobfs_->GetExtents(n);
            while (!extents.Done()) {
                const Extent* extent;
                zx_status_t status = extents.Next(&extent);
                if (status != ZX_OK) {
                    FS_TRACE_ERROR("check: Failed to acquire extent %u within inode %u.\n",
                                   extents.ExtentIndex(), n);
                    valid = false;
                    break;
                }

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

            if (blobfs_->VerifyBlob(n) != ZX_OK) {
                FS_TRACE_ERROR("check: detected inode %u with bad state\n", n);
                valid = false;
            }
            if (!valid) {
                error_blobs_++;
            }
        }
    }
}

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

zx_status_t BlobfsChecker::CheckAllocatedCounts() const {
    zx_status_t status = ZX_OK;
    if (alloc_blocks_ != blobfs_->info_.alloc_block_count) {
        FS_TRACE_ERROR("check: incorrect allocated block count %" PRIu64
                       " (should be %u)\n",
                       blobfs_->info_.alloc_block_count, alloc_blocks_);
        status = ZX_ERR_BAD_STATE;
    }

    if (alloc_blocks_ < kStartBlockMinimum) {
        FS_TRACE_ERROR("check: allocated blocks (%u) are less than minimum%" PRIu64 "\n",
                       alloc_blocks_, kStartBlockMinimum);
        status = ZX_ERR_BAD_STATE;
    }

    if (inode_blocks_ + kStartBlockMinimum != alloc_blocks_) {
        FS_TRACE_ERROR("check: bitmap allocated blocks (%u) do not match inode allocated blocks "
                       "(%" PRIu64 ")\n", alloc_blocks_, inode_blocks_ + kStartBlockMinimum);
        status = ZX_ERR_BAD_STATE;
    }

    if (alloc_inodes_ != blobfs_->info_.alloc_inode_count) {
        FS_TRACE_ERROR("check: incorrect allocated inode count %" PRIu64
                       " (should be %u)\n",
                       blobfs_->info_.alloc_inode_count, alloc_inodes_);
        status = ZX_ERR_BAD_STATE;
    }

    if (error_blobs_) {
        status = ZX_ERR_BAD_STATE;
    }

    return status;
}

BlobfsChecker::BlobfsChecker()
    : blobfs_(nullptr), alloc_inodes_(0), alloc_blocks_(0), error_blobs_(0), inode_blocks_(0) {};

void BlobfsChecker::Init(fbl::unique_ptr<Blobfs> blob) {
    blobfs_ = std::move(blob);
}

zx_status_t Fsck(fbl::unique_ptr<Blobfs> blob) {
    BlobfsChecker chk;
    chk.Init(std::move(blob));
    chk.TraverseInodeBitmap();
    chk.TraverseBlockBitmap();
    return chk.CheckAllocatedCounts();
}

} // namespace blobfs