// Copyright 2016 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 <assert.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include <fbl/alloc_checker.h>
#include <fbl/ref_ptr.h>
#include <fbl/unique_ptr.h>
#include <fs/trace.h>

#ifdef __Fuchsia__
#include <fuchsia/device/c/fidl.h>
#include <lib/fdio/directory.h>
#endif

#include <minfs/format.h>

#include "minfs-private.h"
#include <utility>

namespace minfs {

zx_status_t Bcache::Readblk(blk_t bno, void* data) {
    off_t off = static_cast<off_t>(bno) * kMinfsBlockSize;
    assert(off / kMinfsBlockSize == bno); // Overflow
#ifndef __Fuchsia__
    off += offset_;
#endif
    if (lseek(fd_.get(), off, SEEK_SET) < 0) {
        FS_TRACE_ERROR("minfs: cannot seek to block %u\n", bno);
        return ZX_ERR_IO;
    }
    if (read(fd_.get(), data, kMinfsBlockSize) != kMinfsBlockSize) {
        FS_TRACE_ERROR("minfs: cannot read block %u\n", bno);
        return ZX_ERR_IO;
    }
    return ZX_OK;
}

zx_status_t Bcache::Writeblk(blk_t bno, const void* data) {
    off_t off = static_cast<off_t>(bno) * kMinfsBlockSize;
    assert(off / kMinfsBlockSize == bno); // Overflow
#ifndef __Fuchsia__
    off += offset_;
#endif
    if (lseek(fd_.get(), off, SEEK_SET) < 0) {
        FS_TRACE_ERROR("minfs: cannot seek to block %u. %d\n", bno, errno);
        return ZX_ERR_IO;
    }
    ssize_t ret = write(fd_.get(), data, kMinfsBlockSize);
    if (ret != kMinfsBlockSize) {
        FS_TRACE_ERROR("minfs: cannot write block %u (%zd)\n", bno, ret);
        return ZX_ERR_IO;
    }
    return ZX_OK;
}

int Bcache::Sync() {
    fs::WriteTxn sync_txn(this);
    sync_txn.EnqueueFlush();
    return sync_txn.Transact();
}

zx_status_t Bcache::Create(fbl::unique_ptr<Bcache>* out, fbl::unique_fd fd, uint32_t blockmax) {
    fbl::AllocChecker ac;
    fbl::unique_ptr<Bcache> bc(new (&ac) Bcache(std::move(fd), blockmax));
    if (!ac.check()) {
        return ZX_ERR_NO_MEMORY;
    }
#ifdef __Fuchsia__
    zx::fifo fifo;

    zx_status_t io_status, status;
    io_status = fuchsia_hardware_block_BlockGetInfo(bc->caller_.borrow_channel(), &status,
                                                    &bc->info_);
    if (io_status != ZX_OK) {
        status = io_status;
    }
    if (status != ZX_OK) {
        FS_TRACE_ERROR("minfs: Cannot acquire block device information: %d\n", status);
        return status;
    }
    if (kMinfsBlockSize % bc->info_.block_size != 0) {
        FS_TRACE_ERROR("minfs: minfs Block size not multiple of underlying block size\n");
        return ZX_ERR_BAD_STATE;
    }

    io_status = fuchsia_hardware_block_BlockGetFifo(bc->caller_.borrow_channel(), &status,
                                                    fifo.reset_and_get_address());
    if (io_status != ZX_OK) {
        status = io_status;
    }
    if (status != ZX_OK) {
        FS_TRACE_ERROR("minfs: Cannot acquire block device fifo: %d\n", status);
        return status;
    }
    if ((status = block_client::Client::Create(std::move(fifo), &bc->fifo_client_)) != ZX_OK) {
        return status;
    }
#endif

    *out = std::move(bc);
    return ZX_OK;
}

#ifdef __Fuchsia__

groupid_t Bcache::BlockGroupID() {
    thread_local groupid_t group = next_group_.fetch_add(1);
    ZX_ASSERT_MSG(group < MAX_TXN_GROUP_COUNT, "Too many threads accessing block device");
    return group;
}

uint32_t Bcache::DeviceBlockSize() const {
    return info_.block_size;
}

zx_status_t Bcache::GetDevicePath(size_t buffer_len, char* out_name, size_t* out_len) {
    if (buffer_len == 0) {
        return ZX_ERR_BUFFER_TOO_SMALL;
    }
    zx_status_t call_status;
    zx_status_t status = fuchsia_device_ControllerGetTopologicalPath(caller_.borrow_channel(),
                                                                     &call_status, out_name,
                                                                     buffer_len - 1, out_len);
    if (status == ZX_OK) {
        status = call_status;
    }
    if (status != ZX_OK) {
        return status;
    }
    // Ensure null-terminated
    out_name[*out_len] = 0;
    // Account for the null byte in the length, since callers expect it.
    (*out_len)++;
    return ZX_OK;
}

zx_status_t Bcache::AttachVmo(const zx::vmo& vmo, fuchsia_hardware_block_VmoID* out) const {
    zx::vmo xfer_vmo;
    zx_status_t status = vmo.duplicate(ZX_RIGHT_SAME_RIGHTS, &xfer_vmo);
    if (status != ZX_OK) {
        return status;
    }
    zx_status_t io_status = fuchsia_hardware_block_BlockAttachVmo(caller_.borrow_channel(),
                                                                  xfer_vmo.release(), &status,
                                                                  out);
    if (io_status != ZX_OK) {
        status = io_status;
    }
    return status;
}

zx_status_t Bcache::FVMQuery(fuchsia_hardware_block_volume_VolumeInfo* info) const {
    // Querying may be used to confirm if the underlying connection is capable of
    // communicating the FVM protocol. Clone the connection, since if the block
    // device does NOT speak the Volume protocol, the connection is terminated.
    zx::channel connection(fdio_service_clone(caller_.borrow_channel()));

    zx_status_t io_status, status;
    io_status = fuchsia_hardware_block_volume_VolumeQuery(connection.get(), &status, info);
    if (io_status != ZX_OK) {
        status = io_status;
    }
    return status;
}

zx_status_t Bcache::FVMVsliceQuery(
        const query_request_t* request,
        fuchsia_hardware_block_volume_VsliceRange out_response[16],
        size_t* out_count) const {
    zx_status_t io_status, status;
    io_status = fuchsia_hardware_block_volume_VolumeQuerySlices(caller_.borrow_channel(),
                                                                request->vslice_start,
                                                                request->count, &status,
                                                                out_response, out_count);
    if (io_status != ZX_OK) {
        return io_status;
    }
    return status;
}

zx_status_t Bcache::FVMExtend(const extend_request_t* request) {
    zx_status_t io_status, status;
    io_status = fuchsia_hardware_block_volume_VolumeExtend(caller_.borrow_channel(),
                                                           request->offset, request->length,
                                                           &status);
    if (io_status != ZX_OK) {
        return io_status;
    }
    return status;
}

zx_status_t Bcache::FVMShrink(const extend_request_t* request) {
    zx_status_t io_status, status;
    io_status = fuchsia_hardware_block_volume_VolumeShrink(caller_.borrow_channel(),
                                                           request->offset, request->length,
                                                           &status);
    if (io_status != ZX_OK) {
        return io_status;
    }
    return status;
}

#endif

Bcache::Bcache(fbl::unique_fd fd, uint32_t blockmax) :
    fd_(std::move(fd)), blockmax_(blockmax)
#ifdef __Fuchsia__
    , caller_(fd_.get())
#endif
    {}

Bcache::~Bcache() {
#ifdef __Fuchsia__
    if (caller_) {
        zx_status_t status;
        fuchsia_hardware_block_BlockCloseFifo(caller_.borrow_channel(), &status);
    }
#endif
}

#ifndef __Fuchsia__
zx_status_t Bcache::SetOffset(off_t offset) {
    if (offset_ || extent_lengths_.size() > 0) {
        return ZX_ERR_ALREADY_BOUND;
    }
    offset_ = offset;
    return ZX_OK;
}

zx_status_t Bcache::SetSparse(off_t offset, const fbl::Vector<size_t>& extent_lengths) {
    if (offset_ || extent_lengths_.size() > 0) {
        return ZX_ERR_ALREADY_BOUND;
    }

    ZX_ASSERT(extent_lengths.size() == kExtentCount);

    fbl::AllocChecker ac;
    extent_lengths_.reset(new (&ac) size_t[kExtentCount], kExtentCount);

    if (!ac.check()) {
        return ZX_ERR_NO_MEMORY;
    }

    for (size_t i = 0; i < extent_lengths.size(); i++) {
        extent_lengths_[i] = extent_lengths[i];
    }

    offset_ = offset;
    return ZX_OK;
}

#endif

} // namespace minfs