/*
 * Copyright 2012 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Paweł Dziepak, pdziepak@quarnos.org
 */
#ifndef FILESYSTEM_H
#define FILESYSTEM_H


#include <fs_interface.h>

#include "Debug.h"
#include "Delegation.h"
#include "InodeIdMap.h"
#include "NFS4Defs.h"
#include "NFS4Server.h"


class Inode;
class RootInode;

struct MountConfiguration {
        bool            fReadOnly;

        bool            fHard;
        int                     fRetryLimit;
        bigtime_t       fRequestTimeout;

        bool            fEmulateNamedAttrs;
        bool            fCacheMetadata;

        bigtime_t       fDirectoryCacheTime;
};

class FileSystem : public DoublyLinkedListLinkImpl<FileSystem> {
public:
        static  status_t                        Mount(FileSystem** pfs, RPC::Server* serv,
                                                                        const char* serverName, const char* path,
                                                                        fs_volume* volume,
                                                                        const MountConfiguration& configuration);
                                                                ~FileSystem();

                        status_t                        GetInode(ino_t id, Inode** inode);
        inline  RootInode*                      Root();

                        status_t                        Migrate(const RPC::Server* serv);

                        DoublyLinkedList<OpenState>&    OpenFilesLock();
                        void                            OpenFilesUnlock();
        inline  uint32                          OpenFilesCount();
                        void                            AddOpenFile(OpenState* state);
                        void                            RemoveOpenFile(OpenState* state);

                        DoublyLinkedList<Delegation>&   DelegationsLock();
                        void                            DelegationsUnlock();
                        void                            AddDelegation(Delegation* delegation);
                        void                            RemoveDelegation(Delegation* delegation);
                        Delegation*                     GetDelegation(const FileHandle& handle);

        inline  bool                            IsAttrSupported(Attribute attr) const;
        inline  uint32                          ExpireType() const;

        inline  RPC::Server*            Server();
        inline  NFS4Server*                     NFSServer();

        inline  const char**            Path() const;
        inline  const FileSystemId&     FsId() const;

        inline  uint64                          AllocFileId();

        inline  dev_t                           DevId() const;
        inline  InodeIdMap*                     InoIdMap();

        inline  uint64                          OpenOwner() const;
        inline  uint32                          OpenOwnerSequenceLock();
        inline  void                            OpenOwnerSequenceUnlock(uint32 sequence);

        inline  bool                            NamedAttrs();
        inline  void                            SetNamedAttrs(bool attrs);

        inline  const MountConfiguration&       GetConfiguration();

        inline  mutex&                          CreateFileLock();

                        status_t                        TrashStaleNode(Inode* inode);
                        status_t                        TrashIfStale(Inode* inode);
                        void                            EnsureNoCollision(ino_t newId, const FileHandle& handle);
                        void                            ServerUnlinkCleanup(ino_t id, Inode* parent,
                                                                        const char* missingName);

                        void                            Dump(void (*xprintf)(const char*, ...) = dprintf);

private:
                                                                FileSystem(const MountConfiguration& config);

        static  status_t                        _ParsePath(RequestBuilder& req, uint32& count,
                                                                        const char* _path);

                        void                            _DumpLocked(void (*xprintf)(const char*, ...),
                                                                        bool dumpDelegations, bool dumpOpenFiles) const;

                        mutex                           fCreateFileLock;

                        mutex                           fDelegationLock;
                        DoublyLinkedList<Delegation>    fDelegationList;
                        AVLTreeMap<FileHandle, Delegation*> fHandleToDelegation;

                        DoublyLinkedList<OpenState>             fOpenFiles;
                        uint32                          fOpenCount;
                        mutex                           fOpenLock;

                        uint64                          fOpenOwner;
                        uint32                          fOpenOwnerSequence;
                        mutex                           fOpenOwnerLock;

                        uint32                          fExpireType;
                        uint32                          fSupAttrs[2];
                        bool                            fNamedAttrs;

                        FileSystemId            fFsId;
                        const char**            fPath;

                        RootInode*                      fRoot;

                        RPC::Server*            fServer;

                        int64                           fId;
                        dev_t                           fDevId;

                        InodeIdMap                      fInoIdMap;

                        MountConfiguration      fConfiguration;

                        fs_volume*                      fFsVolume;
};


inline RootInode*
FileSystem::Root()
{
        return fRoot;
}


inline uint32
FileSystem::OpenFilesCount()
{
        return fOpenCount;
}


inline bool
FileSystem::IsAttrSupported(Attribute attr) const
{
        return sIsAttrSet(attr, fSupAttrs, 2);
}


inline uint32
FileSystem::ExpireType() const
{
        return fExpireType;
}


inline RPC::Server*
FileSystem::Server()
{
        ASSERT(fServer != NULL);
        return fServer;
}


inline NFS4Server*
FileSystem::NFSServer()
{
        ASSERT(fServer->PrivateData() != NULL);
        return reinterpret_cast<NFS4Server*>(fServer->PrivateData());
}


inline const char**
FileSystem::Path() const
{
        ASSERT(fPath != NULL);
        return fPath;
}


inline const FileSystemId&
FileSystem::FsId() const
{
        return fFsId;
}


inline uint64
FileSystem::AllocFileId()
{
        return atomic_add64(&fId, 1);
}


inline dev_t
FileSystem::DevId() const
{
        return fDevId;
}


inline InodeIdMap*
FileSystem::InoIdMap()
{
        return &fInoIdMap;
}


inline uint64
FileSystem::OpenOwner() const
{
        return fOpenOwner;
}


inline uint32
FileSystem::OpenOwnerSequenceLock()
{
        mutex_lock(&fOpenOwnerLock);
        return fOpenOwnerSequence;
}


inline void
FileSystem::OpenOwnerSequenceUnlock(uint32 sequence)
{
        fOpenOwnerSequence = sequence;
        mutex_unlock(&fOpenOwnerLock);
}


inline bool
FileSystem::NamedAttrs()
{
        return fNamedAttrs;
}


inline void
FileSystem::SetNamedAttrs(bool attrs)
{
        fNamedAttrs = attrs;
}


inline const MountConfiguration&
FileSystem::GetConfiguration()
{
        return fConfiguration;
}


inline mutex&
FileSystem::CreateFileLock()
{
        return fCreateFileLock;
}


#endif  // FILESYSTEM_H