/*
 * Copyright 2001-2009, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */
#ifndef USERLAND_FS_VOLUME_H
#define USERLAND_FS_VOLUME_H

#include <fs_interface.h>
#include <SupportDefs.h>

#include <util/DoublyLinkedList.h>

#include "FSCapabilities.h"


namespace UserlandFS {

class FileSystem;
class IORequestInfo;

using UserlandFSUtil::FSVolumeCapabilities;

class Volume : public DoublyLinkedListLinkImpl<Volume> {
public:
                                                                Volume(FileSystem* fileSystem, dev_t id);
        virtual                                         ~Volume();

                        FileSystem*                     GetFileSystem() const;
                        dev_t                           GetID() const;

                        void                            GetCapabilities(
                                                                        FSVolumeCapabilities& capabilities) const
                                                                        { capabilities = fCapabilities; }

        // FS
        virtual status_t                        Mount(const char* device, uint32 flags,
                                                                        const char* parameters, ino_t* rootID);
        virtual status_t                        Unmount();
        virtual status_t                        Sync();
        virtual status_t                        ReadFSInfo(fs_info* info);
        virtual status_t                        WriteFSInfo(const struct fs_info* info,
                                                                        uint32 mask);

        // vnodes
        virtual status_t                        Lookup(void* dir, const char* entryName,
                                                                        ino_t* vnid);
        virtual status_t                        GetVNodeType(void* node, int* type);
                                                                        // Only needs to be implemented when
                                                                        // the three parameters publish_vnode() is
                                                                        // used.
        virtual status_t                        GetVNodeName(void* node, char* buffer,
                                                                        size_t bufferSize);
        virtual status_t                        ReadVNode(ino_t vnid, bool reenter,
                                                                        void** node, int* type, uint32* flags,
                                                                        FSVNodeCapabilities* _capabilities);
        virtual status_t                        WriteVNode(void* node, bool reenter);
        virtual status_t                        RemoveVNode(void* node, bool reenter);

        // asynchronous I/O
        virtual status_t                        DoIO(void* node, void* cookie,
                                                                        const IORequestInfo& requestInfo);
        virtual status_t                        CancelIO(void* node, void* cookie,
                                                                        int32 ioRequestID);
        virtual status_t                        IterativeIOGetVecs(void* cookie,
                                                                        int32 requestID, off_t offset, size_t size,
                                                                        struct file_io_vec* vecs, size_t* _count);
        virtual status_t                        IterativeIOFinished(void* cookie,
                                                                        int32 requestID, status_t status,
                                                                        bool partialTransfer,
                                                                        size_t bytesTransferred);

        // nodes
        virtual status_t                        IOCtl(void* node, void* cookie,
                                                                        uint32 command, void* buffer, size_t size);
        virtual status_t                        SetFlags(void* node, void* cookie,
                                                                        int flags);
        virtual status_t                        Select(void* node, void* cookie,
                                                                        uint8 event, selectsync* sync);
        virtual status_t                        Deselect(void* node, void* cookie,
                                                                        uint8 event, selectsync* sync);

        virtual status_t                        FSync(void* node);

        virtual status_t                        ReadSymlink(void* node, char* buffer,
                                                                        size_t bufferSize, size_t* bytesRead);
        virtual status_t                        CreateSymlink(void* dir, const char* name,
                                                                        const char* target, int mode);

        virtual status_t                        Link(void* dir, const char* name,
                                                                        void* node);
        virtual status_t                        Unlink(void* dir, const char* name);
        virtual status_t                        Rename(void* oldDir, const char* oldName,
                                                                        void* newDir, const char* newName);

        virtual status_t                        Access(void* node, int mode);
        virtual status_t                        ReadStat(void* node, struct stat* st);
        virtual status_t                        WriteStat(void* node, const struct stat *st,
                                                                        uint32 mask);

        // files
        virtual status_t                        Create(void* dir, const char* name,
                                                                        int openMode, int mode, void** cookie,
                                                                        ino_t* vnid);
        virtual status_t                        Open(void* node, int openMode,
                                                                        void** cookie);
        virtual status_t                        Close(void* node, void* cookie);
        virtual status_t                        FreeCookie(void* node, void* cookie);
        virtual status_t                        Read(void* node, void* cookie, off_t pos,
                                                                        void* buffer, size_t bufferSize,
                                                                        size_t* bytesRead);
        virtual status_t                        Write(void* node, void* cookie,
                                                                        off_t pos, const void* buffer,
                                                                        size_t bufferSize, size_t* bytesWritten);

        // directories
        virtual status_t                        CreateDir(void* dir, const char* name,
                                                                        int mode);
        virtual status_t                        RemoveDir(void* dir, const char* name);
        virtual status_t                        OpenDir(void* node, void** cookie);
        virtual status_t                        CloseDir(void* node, void* cookie);
        virtual status_t                        FreeDirCookie(void* node, void* cookie);
        virtual status_t                        ReadDir(void* node, void* cookie,
                                                                        void* buffer, size_t bufferSize,
                                                                        uint32 count, uint32* countRead);
        virtual status_t                        RewindDir(void* node, void* cookie);

        // attribute directories
        virtual status_t                        OpenAttrDir(void* node, void** cookie);
        virtual status_t                        CloseAttrDir(void* node, void* cookie);
        virtual status_t                        FreeAttrDirCookie(void* node,
                                                                        void* cookie);
        virtual status_t                        ReadAttrDir(void* node, void* cookie,
                                                                        void* buffer, size_t bufferSize,
                                                                        uint32 count, uint32* countRead);
        virtual status_t                        RewindAttrDir(void* node, void* cookie);

        // attributes
        virtual status_t                        CreateAttr(void* node, const char* name,
                                                                        uint32 type, int openMode,
                                                                        void** cookie);
        virtual status_t                        OpenAttr(void* node, const char* name,
                                                                        int openMode, void** cookie);
        virtual status_t                        CloseAttr(void* node, void* cookie);
        virtual status_t                        FreeAttrCookie(void* node, void* cookie);
        virtual status_t                        ReadAttr(void* node, void* cookie,
                                                                        off_t pos, void* buffer, size_t bufferSize,
                                                                        size_t* bytesRead);
        virtual status_t                        WriteAttr(void* node, void* cookie,
                                                                        off_t pos, const void* buffer,
                                                                        size_t bufferSize, size_t* bytesWritten);
        virtual status_t                        ReadAttrStat(void* node, void* cookie,
                                                                        struct stat* st);
        virtual status_t                        WriteAttrStat(void* node, void* cookie,
                                                                        const struct stat* st, int statMask);
        virtual status_t                        RenameAttr(void* oldNode,
                                                                        const char* oldName, void* newNode,
                                                                        const char* newName);
        virtual status_t                        RemoveAttr(void* node, const char* name);

        // indices
        virtual status_t                        OpenIndexDir(void** cookie);
        virtual status_t                        CloseIndexDir(void* cookie);
        virtual status_t                        FreeIndexDirCookie(void* cookie);
        virtual status_t                        ReadIndexDir(void* cookie, void* buffer,
                                                                        size_t bufferSize, uint32 count,
                                                                        uint32* countRead);
        virtual status_t                        RewindIndexDir(void* cookie);
        virtual status_t                        CreateIndex(const char* name, uint32 type,
                                                                        uint32 flags);
        virtual status_t                        RemoveIndex(const char* name);
        virtual status_t                        ReadIndexStat(const char *name,
                                                                        struct stat *st);

        // queries
        virtual status_t                        OpenQuery(const char* queryString,
                                                                        uint32 flags, port_id port, uint32 token,
                                                                        void** cookie);
        virtual status_t                        CloseQuery(void* cookie);
        virtual status_t                        FreeQueryCookie(void* cookie);
        virtual status_t                        ReadQuery(void* cookie, void* buffer,
                                                                        size_t bufferSize, uint32 count,
                                                                        uint32* countRead);
        virtual status_t                        RewindQuery(void* cookie);

protected:
                        FileSystem*                     fFileSystem;
                        dev_t                           fID;
                        FSVolumeCapabilities fCapabilities;
};

}       // namespace UserlandFS

using UserlandFS::Volume;

#endif  // USERLAND_FS_VOLUME_H