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

#include "HaikuKernelFileSystem.h"

#include <string.h>

#include <new>

#include <fs_interface.h>

#include <AutoLocker.h>

#include <block_cache.h>
#include <condition_variable.h>
#include <file_cache.h>

#include "HaikuKernelIORequest.h"
#include "HaikuKernelVolume.h"


// IORequestHashDefinition
struct HaikuKernelFileSystem::IORequestHashDefinition {
        typedef int32                                   KeyType;
        typedef HaikuKernelIORequest    ValueType;

        size_t HashKey(int32 key) const
                { return key; }
        size_t Hash(const HaikuKernelIORequest* value) const
                { return value->id; }
        bool Compare(int32 key, const HaikuKernelIORequest* value) const
                { return value->id == key; }
        HaikuKernelIORequest*& GetLink(HaikuKernelIORequest* value) const
                        { return value->hashLink; }
};


// IORequestTable
struct HaikuKernelFileSystem::IORequestTable
        : public BOpenHashTable<IORequestHashDefinition> {
        typedef int32                                   KeyType;
        typedef HaikuKernelIORequest    ValueType;

        size_t HashKey(int32 key) const
                { return key; }
        size_t Hash(const HaikuKernelIORequest* value) const
                { return value->id; }
        bool Compare(int32 key, const HaikuKernelIORequest* value) const
                { return value->id == key; }
        HaikuKernelIORequest*& GetLink(HaikuKernelIORequest* value) const
                        { return value->hashLink; }
};


// NodeCapabilitiesHashDefinition
struct HaikuKernelFileSystem::NodeCapabilitiesHashDefinition {
        typedef fs_vnode_ops*                                   KeyType;
        typedef HaikuKernelNode::Capabilities   ValueType;

        size_t HashKey(fs_vnode_ops* key) const
                { return (size_t)(addr_t)key; }
        size_t Hash(const ValueType* value) const
                { return HashKey(value->ops); }
        bool Compare(fs_vnode_ops* key, const ValueType* value) const
                { return value->ops == key; }
        ValueType*& GetLink(ValueType* value) const
                { return value->hashLink; }
};


// NodeCapabilitiesTable
struct HaikuKernelFileSystem::NodeCapabilitiesTable
        : public BOpenHashTable<NodeCapabilitiesHashDefinition> {
};


// constructor
HaikuKernelFileSystem::HaikuKernelFileSystem(const char* fsName,
        file_system_module_info* fsModule)
        :
        FileSystem(fsName),
        fFSModule(fsModule),
        fIORequests(NULL),
        fNodeCapabilities(NULL),
        fLock("HaikuKernelFileSystem")
{
        _InitCapabilities();
}


// destructor
HaikuKernelFileSystem::~HaikuKernelFileSystem()
{
        // call the kernel module uninitialization
        if (fFSModule->info.std_ops)
                fFSModule->info.std_ops(B_MODULE_UNINIT);

        delete fIORequests;
        delete fNodeCapabilities;

// TODO: Call the cleanup methods (condition vars, block cache)!
}


// Init
status_t
HaikuKernelFileSystem::Init()
{
        status_t error = fLock.InitCheck();
        if (error != B_OK)
                RETURN_ERROR(error);

        // init condition variables
        condition_variable_init();
// TODO: Call the cleanup methods, if something goes wrong!

        // init block cache
        error = block_cache_init();
        if (error != B_OK)
                RETURN_ERROR(error);

        // init file map
        error = file_map_init();
        if (error != B_OK)
                RETURN_ERROR(error);

        // create I/O request map
        fIORequests = new(std::nothrow) IORequestTable;
        if (fIORequests == NULL)
                RETURN_ERROR(B_NO_MEMORY);

        error = fIORequests->Init();
        if (error != B_OK)
                RETURN_ERROR(error);

        // create the node capabilites map
        fNodeCapabilities = new(std::nothrow) NodeCapabilitiesTable;
        if (fNodeCapabilities == NULL)
                RETURN_ERROR(B_NO_MEMORY);

        error = fNodeCapabilities->Init();
        if (error != B_OK)
                RETURN_ERROR(error);

        // call the kernel module initialization (if any)
        if (!fFSModule->info.std_ops)
                return B_OK;

        error = fFSModule->info.std_ops(B_MODULE_INIT);
        if (error != B_OK)
                RETURN_ERROR(error);

        return B_OK;
}


// CreateVolume
status_t
HaikuKernelFileSystem::CreateVolume(Volume** _volume, dev_t id)
{
        // check initialization and parameters
        if (!fFSModule || !_volume)
                return B_BAD_VALUE;

        // create and init the volume
        HaikuKernelVolume* volume
                = new(std::nothrow) HaikuKernelVolume(this, id, fFSModule);
        if (!volume)
                return B_NO_MEMORY;

        status_t error = volume->Init();
        if (error != B_OK) {
                delete volume;
                return error;
        }

        *_volume = volume;
        return B_OK;
}


// DeleteVolume
status_t
HaikuKernelFileSystem::DeleteVolume(Volume* volume)
{
        if (!volume || !dynamic_cast<HaikuKernelVolume*>(volume))
                return B_BAD_VALUE;
        delete volume;
        return B_OK;
}


// AddIORequest
status_t
HaikuKernelFileSystem::AddIORequest(HaikuKernelIORequest* request)
{
        AutoLocker<Locker> _(fLock);

        // check, if a request with that ID is already in the map
        if (fIORequests->Lookup(request->id) != NULL)
                RETURN_ERROR(B_BAD_VALUE);

        fIORequests->Insert(request);
        return B_OK;
}


// GetIORequest
HaikuKernelIORequest*
HaikuKernelFileSystem::GetIORequest(int32 requestID)
{
        AutoLocker<Locker> _(fLock);

        HaikuKernelIORequest* request = fIORequests->Lookup(requestID);
        if (request != NULL)
                request->refCount++;

        return request;
}


// PutIORequest
void
HaikuKernelFileSystem::PutIORequest(HaikuKernelIORequest* request,
        int32 refCount)
{
        AutoLocker<Locker> locker(fLock);

        if ((request->refCount -= refCount) <= 0) {
                fIORequests->Remove(request);
                locker.Unlock();
                delete request;
        }
}


// GetVNodeCapabilities
HaikuKernelNode::Capabilities*
HaikuKernelFileSystem::GetNodeCapabilities(fs_vnode_ops* ops)
{
        AutoLocker<Locker> locker(fLock);

        // check whether the ops are already known
        HaikuKernelNode::Capabilities* capabilities
                = fNodeCapabilities->Lookup(ops);
        if (capabilities != NULL) {
                capabilities->refCount++;
                return capabilities;
        }

        // get the capabilities implied by the ops vector
        FSVNodeCapabilities nodeCapabilities;
        _InitNodeCapabilities(ops, nodeCapabilities);

        // create a new object
        capabilities = new(std::nothrow) HaikuKernelNode::Capabilities(ops,
                nodeCapabilities);
        if (capabilities == NULL)
                return NULL;

        fNodeCapabilities->Insert(capabilities);

        return capabilities;
}


// PutVNodeCapabilities
void
HaikuKernelFileSystem::PutNodeCapabilities(
        HaikuKernelNode::Capabilities* capabilities)
{
        AutoLocker<Locker> locker(fLock);

        if (--capabilities->refCount == 0) {
                fNodeCapabilities->Remove(capabilities);
                delete capabilities;
        }
}


// _InitCapabilities
void
HaikuKernelFileSystem::_InitCapabilities()
{
        fCapabilities.ClearAll();

        // FS interface type
        fClientFSType = CLIENT_FS_HAIKU_KERNEL;

        // FS operations
        fCapabilities.Set(FS_CAPABILITY_MOUNT, fFSModule->mount);
}


/*static*/ void
HaikuKernelFileSystem::_InitNodeCapabilities(fs_vnode_ops* ops,
        FSVNodeCapabilities& capabilities)
{
        capabilities.ClearAll();

        // vnode operations
        capabilities.Set(FS_VNODE_CAPABILITY_LOOKUP, ops->lookup);
        capabilities.Set(FS_VNODE_CAPABILITY_GET_VNODE_NAME, ops->get_vnode_name);
        capabilities.Set(FS_VNODE_CAPABILITY_PUT_VNODE, ops->put_vnode);
        capabilities.Set(FS_VNODE_CAPABILITY_REMOVE_VNODE, ops->remove_vnode);

        // asynchronous I/O
        capabilities.Set(FS_VNODE_CAPABILITY_IO, ops->io);
        capabilities.Set(FS_VNODE_CAPABILITY_CANCEL_IO, ops->cancel_io);

        // cache file access
        capabilities.Set(FS_VNODE_CAPABILITY_GET_FILE_MAP, ops->get_file_map);

        // common operations
        capabilities.Set(FS_VNODE_CAPABILITY_IOCTL, ops->ioctl);
        capabilities.Set(FS_VNODE_CAPABILITY_SET_FLAGS, ops->set_flags);
        capabilities.Set(FS_VNODE_CAPABILITY_SELECT, ops->select);
        capabilities.Set(FS_VNODE_CAPABILITY_DESELECT, ops->deselect);
        capabilities.Set(FS_VNODE_CAPABILITY_FSYNC, ops->fsync);

        capabilities.Set(FS_VNODE_CAPABILITY_READ_SYMLINK, ops->read_symlink);
        capabilities.Set(FS_VNODE_CAPABILITY_CREATE_SYMLINK, ops->create_symlink);

        capabilities.Set(FS_VNODE_CAPABILITY_LINK, ops->link);
        capabilities.Set(FS_VNODE_CAPABILITY_UNLINK, ops->unlink);
        capabilities.Set(FS_VNODE_CAPABILITY_RENAME, ops->rename);

        capabilities.Set(FS_VNODE_CAPABILITY_ACCESS, ops->access);
        capabilities.Set(FS_VNODE_CAPABILITY_READ_STAT, ops->read_stat);
        capabilities.Set(FS_VNODE_CAPABILITY_WRITE_STAT, ops->write_stat);

        // file operations
        capabilities.Set(FS_VNODE_CAPABILITY_CREATE, ops->create);
        capabilities.Set(FS_VNODE_CAPABILITY_OPEN, ops->open);
        capabilities.Set(FS_VNODE_CAPABILITY_CLOSE, ops->close);
        capabilities.Set(FS_VNODE_CAPABILITY_FREE_COOKIE, ops->free_cookie);
        capabilities.Set(FS_VNODE_CAPABILITY_READ, ops->read);
        capabilities.Set(FS_VNODE_CAPABILITY_WRITE, ops->write);

        // directory operations
        capabilities.Set(FS_VNODE_CAPABILITY_CREATE_DIR, ops->create_dir);
        capabilities.Set(FS_VNODE_CAPABILITY_REMOVE_DIR, ops->remove_dir);
        capabilities.Set(FS_VNODE_CAPABILITY_OPEN_DIR, ops->open_dir);
        capabilities.Set(FS_VNODE_CAPABILITY_CLOSE_DIR, ops->close_dir);
        capabilities.Set(FS_VNODE_CAPABILITY_FREE_DIR_COOKIE, ops->free_dir_cookie);
        capabilities.Set(FS_VNODE_CAPABILITY_READ_DIR, ops->read_dir);
        capabilities.Set(FS_VNODE_CAPABILITY_REWIND_DIR, ops->rewind_dir);

        // attribute directory operations
        capabilities.Set(FS_VNODE_CAPABILITY_OPEN_ATTR_DIR, ops->open_attr_dir);
        capabilities.Set(FS_VNODE_CAPABILITY_CLOSE_ATTR_DIR, ops->close_attr_dir);
        capabilities.Set(FS_VNODE_CAPABILITY_FREE_ATTR_DIR_COOKIE,
                ops->free_attr_dir_cookie);
        capabilities.Set(FS_VNODE_CAPABILITY_READ_ATTR_DIR, ops->read_attr_dir);
        capabilities.Set(FS_VNODE_CAPABILITY_REWIND_ATTR_DIR, ops->rewind_attr_dir);

        // attribute operations
        capabilities.Set(FS_VNODE_CAPABILITY_CREATE_ATTR, ops->create_attr);
        capabilities.Set(FS_VNODE_CAPABILITY_OPEN_ATTR, ops->open_attr);
        capabilities.Set(FS_VNODE_CAPABILITY_CLOSE_ATTR, ops->close_attr);
        capabilities.Set(FS_VNODE_CAPABILITY_FREE_ATTR_COOKIE,
                ops->free_attr_cookie);
        capabilities.Set(FS_VNODE_CAPABILITY_READ_ATTR, ops->read_attr);
        capabilities.Set(FS_VNODE_CAPABILITY_WRITE_ATTR, ops->write_attr);

        capabilities.Set(FS_VNODE_CAPABILITY_READ_ATTR_STAT, ops->read_attr_stat);
        capabilities.Set(FS_VNODE_CAPABILITY_WRITE_ATTR_STAT,
                ops->write_attr_stat);
        capabilities.Set(FS_VNODE_CAPABILITY_RENAME_ATTR, ops->rename_attr);
        capabilities.Set(FS_VNODE_CAPABILITY_REMOVE_ATTR, ops->remove_attr);

        // support for node and FS layers
        capabilities.Set(FS_VNODE_CAPABILITY_CREATE_SPECIAL_NODE,
                ops->create_special_node);
        capabilities.Set(FS_VNODE_CAPABILITY_GET_SUPER_VNODE, ops->get_super_vnode);
}


// #pragma mark - bootstrapping


status_t
userlandfs_create_file_system(const char* fsName, image_id image,
        FileSystem** _fileSystem)
{
        // get the modules
        module_info** modules;
        status_t error = get_image_symbol(image, "modules", B_SYMBOL_TYPE_DATA,
                (void**)&modules);
        if (error != B_OK)
                RETURN_ERROR(error);

        // module name must match "file_systems/<name>/v1"
        char moduleName[B_PATH_NAME_LENGTH];
        snprintf(moduleName, sizeof(moduleName), "file_systems/%s/v1", fsName);

        // find the module
        file_system_module_info* module = NULL;
        for (int32 i = 0; modules[i] && modules[i]->name; i++) {
                if (strcmp(modules[i]->name, moduleName) == 0) {
                        module = (file_system_module_info*)modules[i];
                        break;
                }
        }
        if (!module)
                RETURN_ERROR(B_ERROR);

        // create the file system
        HaikuKernelFileSystem* fileSystem
                = new(std::nothrow) HaikuKernelFileSystem(fsName, module);
        if (!fileSystem)
                RETURN_ERROR(B_NO_MEMORY);

        error = fileSystem->Init();
        if (error != B_OK) {
                delete fileSystem;
                return error;
        }

        *_fileSystem = fileSystem;
        return B_OK;
}