/*
 * Copyright 2010, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include "Volume.h"

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>

#include <new>

#include <fs_cache.h>

#include <AutoDeleter.h>
#include <util/AutoLock.h>

#include "Block.h"
#include "BlockAllocator.h"
#include "checksumfs.h"
#include "checksumfs_private.h"
#include "DebugSupport.h"
#include "Directory.h"
#include "File.h"
#include "SuperBlock.h"
#include "SymLink.h"
#include "Transaction.h"


Volume::Volume(uint32 flags)
        :
        fFSVolume(NULL),
        fFD(-1),
        fFlags(B_FS_IS_PERSISTENT | B_FS_HAS_ATTR | B_FS_HAS_MIME
                | ((flags & B_FS_IS_READONLY) != 0 ? B_FS_IS_READONLY : 0)),
        fBlockCache(NULL),
        fTotalBlocks(0),
        fName(NULL),
        fBlockAllocator(NULL),
        fRootDirectory(NULL)
{
        mutex_init(&fLock, "checksumfs volume");
        mutex_init(&fTransactionLock, "checksumfs transaction");
}


Volume::~Volume()
{
        delete fRootDirectory;
        delete fBlockAllocator;

        if (fBlockCache != NULL)
                block_cache_delete(fBlockCache, false);

        if (fFD >= 0)
                close(fFD);

        free(fName);

        mutex_destroy(&fTransactionLock);
        mutex_destroy(&fLock);
}


status_t
Volume::Init(const char* device)
{
        // open the device
        if (!IsReadOnly()) {
                fFD = open(device, O_RDWR);

                // If opening read-write fails, we retry read-only.
                if (fFD < 0)
                        fFlags |= B_FS_IS_READONLY;
        }

        if (IsReadOnly())
                fFD = open(device, O_RDONLY);

        if (fFD < 0)
                return errno;

        // get the size
        struct stat st;
        if (fstat(fFD, &st) < 0)
                return errno;

        off_t size;
        switch (st.st_mode & S_IFMT) {
                case S_IFREG:
                        size = st.st_size;
                        break;
                case S_IFCHR:
                case S_IFBLK:
                {
                        device_geometry geometry;
                        if (ioctl(fFD, B_GET_GEOMETRY, &geometry, sizeof(geometry)) < 0)
                                return errno;

                        size = (off_t)geometry.bytes_per_sector * geometry.sectors_per_track
                                * geometry.cylinder_count * geometry.head_count;
                        break;
                }
                default:
                        return B_BAD_VALUE;
        }

        return _Init(size / B_PAGE_SIZE);
}


status_t
Volume::Init(int fd, uint64 totalBlocks)
{
        fFD = dup(fd);
        if (fFD < 0)
                RETURN_ERROR(errno);

        return _Init(totalBlocks);
}


status_t
Volume::Mount(fs_volume* fsVolume)
{
        fFSVolume = fsVolume;

        // load the superblock
        Block block;
        if (!block.GetReadable(this, kCheckSumFSSuperBlockOffset / B_PAGE_SIZE))
                RETURN_ERROR(B_ERROR);

        SuperBlock* superBlock = (SuperBlock*)block.Data();
        if (!superBlock->Check(fTotalBlocks))
                RETURN_ERROR(B_BAD_DATA);

        // copy the volume name
        fName = strdup(superBlock->Name());
        if (fName == NULL)
                RETURN_ERROR(B_NO_MEMORY);

        // init the block allocator
        status_t error = fBlockAllocator->Init(superBlock->BlockBitmap(),
                superBlock->FreeBlocks());
        if (error != B_OK)
                RETURN_ERROR(error);

        // load the root directory
        Node* rootNode;
        error = ReadNode(superBlock->RootDirectory(), rootNode);
        if (error != B_OK)
                RETURN_ERROR(error);

        fRootDirectory = dynamic_cast<Directory*>(rootNode);
        if (fRootDirectory == NULL) {
                delete rootNode;
                RETURN_ERROR(B_BAD_DATA);
        }

        error = PublishNode(fRootDirectory, 0);
        if (error != B_OK) {
                delete fRootDirectory;
                fRootDirectory = NULL;
                return error;
        }

        return B_OK;
}


void
Volume::Unmount()
{
        status_t error = block_cache_sync(fBlockCache);
        if (error != B_OK) {
                dprintf("checksumfs: Error: Failed to sync block cache when "
                        "unmounting!\n");
        }
}


status_t
Volume::Initialize(const char* name)
{
        fName = strdup(name);
        if (fName == NULL)
                RETURN_ERROR(B_NO_MEMORY);

        Transaction transaction(this);
        status_t error = transaction.Start();
        if (error != B_OK)
                RETURN_ERROR(error);

        error = fBlockAllocator->Initialize(transaction);
        if (error != B_OK)
                RETURN_ERROR(error);

        // create the root directory
        error = CreateDirectory(S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH,
                transaction, fRootDirectory);
        if (error != B_OK)
                RETURN_ERROR(error);

        transaction.KeepNode(fRootDirectory);
        fRootDirectory->SetHardLinks(1);

        // write the superblock
        Block block;
        if (!block.GetZero(this, kCheckSumFSSuperBlockOffset / B_PAGE_SIZE,
                        transaction)) {
                RETURN_ERROR(B_ERROR);
        }

        SuperBlock* superBlock = (SuperBlock*)block.Data();
        superBlock->Initialize(this);

        block.Put();

        // commit the transaction and flush the block cache
        error = transaction.Commit();
        if (error != B_OK)
                RETURN_ERROR(error);

        return block_cache_sync(fBlockCache);
}


void
Volume::GetInfo(fs_info& info)
{
        MutexLocker locker(fLock);

        info.flags = fFlags;
        info.block_size = B_PAGE_SIZE;
        info.io_size = B_PAGE_SIZE * 16;        // random value
        info.total_blocks = fTotalBlocks;
        info.free_blocks = fBlockAllocator->FreeBlocks();
        info.total_nodes = 1;   // phew, who cares?
        info.free_nodes = info.free_blocks;
        strlcpy(info.volume_name, fName, sizeof(info.volume_name));
}


status_t
Volume::NewNode(Node* node)
{
        return new_vnode(fFSVolume, node->BlockIndex(), node, &gCheckSumFSVnodeOps);
}


status_t
Volume::PublishNode(Node* node, uint32 flags)
{
        return publish_vnode(fFSVolume, node->BlockIndex(), node,
                &gCheckSumFSVnodeOps, node->Mode(), flags);
}


status_t
Volume::GetNode(uint64 blockIndex, Node*& _node)
{
        return get_vnode(fFSVolume, blockIndex, (void**)&_node);
}


status_t
Volume::PutNode(Node* node)
{
        return put_vnode(fFSVolume, node->BlockIndex());
}


status_t
Volume::RemoveNode(Node* node)
{
        return remove_vnode(fFSVolume, node->BlockIndex());
}


status_t
Volume::UnremoveNode(Node* node)
{
        return unremove_vnode(fFSVolume, node->BlockIndex());
}


status_t
Volume::ReadNode(uint64 blockIndex, Node*& _node)
{
        if (blockIndex == 0 || blockIndex >= fTotalBlocks)
                return B_BAD_VALUE;

        // load the node's block
        Block block;
        if (!block.GetReadable(this, blockIndex))
                return B_ERROR;

        checksumfs_node* nodeData = (checksumfs_node*)block.Data();

        // create the Node object
        Node* node;
        switch (nodeData->mode & S_IFMT) {
                        // TODO: Don't directly access mode!
                case S_IFDIR:
                        node = new(std::nothrow) Directory(this, blockIndex, *nodeData);
                        break;
                case S_IFREG:
                        node = new(std::nothrow) File(this, blockIndex, *nodeData);
                        break;
                case S_IFLNK:
                        node = new(std::nothrow) SymLink(this, blockIndex, *nodeData);
                        break;
                default:
                        node = new(std::nothrow) Node(this, blockIndex, *nodeData);
                        break;
        }

        if (node == NULL)
                return B_NO_MEMORY;

        // TODO: Sanity check the node!

        _node = node;
        return B_OK;
}


status_t
Volume::CreateDirectory(mode_t mode, Transaction& transaction,
        Directory*& _directory)
{
        Directory* directory = new(std::nothrow) Directory(this,
                (mode & S_IUMSK) | S_IFDIR);

        status_t error = _CreateNode(directory, transaction);
        if (error != B_OK)
                return error;

        _directory = directory;
        return B_OK;
}


status_t
Volume::CreateFile(mode_t mode, Transaction& transaction, File*& _file)
{
        File* file = new(std::nothrow) File(this, (mode & S_IUMSK) | S_IFREG);

        status_t error = _CreateNode(file, transaction);
        if (error != B_OK)
                return error;

        _file = file;
        return B_OK;
}


status_t
Volume::CreateSymLink(mode_t mode, Transaction& transaction, SymLink*& _symLink)
{
        SymLink* symLink = new(std::nothrow) SymLink(this,
                (mode & S_IUMSK) | S_IFLNK);

        status_t error = _CreateNode(symLink, transaction);
        if (error != B_OK)
                return error;

        _symLink = symLink;
        return B_OK;
}


status_t
Volume::DeleteNode(Node* node)
{
        // let the node delete data associated with it
        node->DeletingNode();

        uint64 blockIndex = node->BlockIndex();

        // delete the node itself
        Transaction transaction(this);
        status_t error = transaction.Start();
        if (error == B_OK) {
                error = fBlockAllocator->Free(node->BlockIndex(), 1, transaction);
                if (error == B_OK) {
                        error = transaction.Commit();
                        if (error != B_OK) {
                                ERROR("Failed to commit transaction for deleting node at %"
                                        B_PRIu64 "\n", blockIndex);
                        }
                } else {
                        ERROR("Failed to free block for node at %" B_PRIu64 "\n",
                                blockIndex);
                }
        } else {
                ERROR("Failed to start transaction for deleting node at %" B_PRIu64
                        "\n", blockIndex);
        }

        transaction.Abort();

        delete node;

        return error;
}


status_t
Volume::SetName(const char* name)
{
        if (name == NULL || strlen(name) > kCheckSumFSNameLength)
                return B_BAD_VALUE;

        // clone the name
        char* newName = strdup(name);
        if (newName == NULL)
                return B_NO_MEMORY;
        MemoryDeleter newNameDeleter(newName);

        // start a transaction
        Transaction transaction(this);
        status_t error = transaction.Start();
        if (error != B_OK)
                return error;

        // we lock the volume now, to keep the locking order (transaction -> volume)
        MutexLocker locker(fLock);

        // update the superblock
        Block block;
        if (!block.GetWritable(this, kCheckSumFSSuperBlockOffset / B_PAGE_SIZE,
                        transaction)) {
                return B_ERROR;
        }

        SuperBlock* superBlock = (SuperBlock*)block.Data();
        superBlock->SetName(newName);

        block.Put();

        // commit the transaction
        error = transaction.Commit();
        if (error != B_OK)
                return error;

        // Everything went fine. We can replace the name. Since we still have the
        // volume lock, there's no race condition.
        free(fName);
        fName = (char*)newNameDeleter.Detach();

        return B_OK;
}


status_t
Volume::_Init(uint64 totalBlocks)
{
        fTotalBlocks = totalBlocks;
        if (fTotalBlocks * B_PAGE_SIZE < kCheckSumFSMinSize)
                RETURN_ERROR(B_BAD_VALUE);

        // create a block cache
        fBlockCache = block_cache_create(fFD, fTotalBlocks, B_PAGE_SIZE,
                IsReadOnly());
        if (fBlockCache == NULL)
                RETURN_ERROR(B_NO_MEMORY);

        // create the block allocator
        fBlockAllocator = new(std::nothrow) BlockAllocator(this);
        if (fBlockAllocator == NULL)
                RETURN_ERROR(B_NO_MEMORY);

        return B_OK;
}


status_t
Volume::_CreateNode(Node* node, Transaction& transaction)
{
        if (node == NULL)
                return B_NO_MEMORY;

        ObjectDeleter<Node> nodeDeleter(node);

        // allocate a free block
        AllocatedBlock allocatedBlock(fBlockAllocator, transaction);
        status_t error = allocatedBlock.Allocate();
        if (error != B_OK)
                return error;

        // clear the block
        {
                Block block;
                if (!block.GetZero(this, allocatedBlock.Index(), transaction))
                        return B_ERROR;
        }

        node->SetBlockIndex(allocatedBlock.Index());

        // attach the node to the transaction
        error = transaction.AddNode(node, TRANSACTION_DELETE_NODE);
        if (error != B_OK)
                return error;

        allocatedBlock.Detach();
        nodeDeleter.Detach();

        return B_OK;
}