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

#include <fs_attr.h>
#include <fs_index.h>
#include <fs_info.h>
#include <fs_interface.h>

#include "Compatibility.h"
#include "FSCapabilities.h"
#include "Request.h"


enum {
        MAX_REQUEST_ADDRESS_COUNT       = 4,
};

// request types
enum {
        // kernel -> userland requests

        // administrative
        UFS_DISCONNECT_REQUEST = 0,
        FS_CONNECT_REQUEST,
        FS_CONNECT_REPLY,

        // FS
        MOUNT_VOLUME_REQUEST,
        MOUNT_VOLUME_REPLY,
        UNMOUNT_VOLUME_REQUEST,
        UNMOUNT_VOLUME_REPLY,
//      INITIALIZE_VOLUME_REQUEST,
//      INITIALIZE_VOLUME_REPLY,
        SYNC_VOLUME_REQUEST,
        SYNC_VOLUME_REPLY,
        READ_FS_INFO_REQUEST,
        READ_FS_INFO_REPLY, // 10
        WRITE_FS_INFO_REQUEST,
        WRITE_FS_INFO_REPLY,

        // vnodes
        LOOKUP_REQUEST,
        LOOKUP_REPLY,
        GET_VNODE_NAME_REQUEST,
        GET_VNODE_NAME_REPLY,
        READ_VNODE_REQUEST,
        READ_VNODE_REPLY,
        WRITE_VNODE_REQUEST,
        WRITE_VNODE_REPLY, // 20
        FS_REMOVE_VNODE_REQUEST,
        FS_REMOVE_VNODE_REPLY,

        // asynchronous I/O
        DO_IO_REQUEST,
        DO_IO_REPLY,
        CANCEL_IO_REQUEST,
        CANCEL_IO_REPLY,
        ITERATIVE_IO_GET_VECS_REQUEST,
        ITERATIVE_IO_GET_VECS_REPLY,
        ITERATIVE_IO_FINISHED_REQUEST,
        ITERATIVE_IO_FINISHED_REPLY, // 30

        // nodes
        IOCTL_REQUEST,
        IOCTL_REPLY,
        SET_FLAGS_REQUEST,
        SET_FLAGS_REPLY,
        SELECT_REQUEST,
        SELECT_REPLY,
        DESELECT_REQUEST,
        DESELECT_REPLY,
        FSYNC_REQUEST,
        FSYNC_REPLY, // 40

        READ_SYMLINK_REQUEST,
        READ_SYMLINK_REPLY,
        CREATE_SYMLINK_REQUEST,
        CREATE_SYMLINK_REPLY,
        LINK_REQUEST,
        LINK_REPLY,
        UNLINK_REQUEST,
        UNLINK_REPLY,
        RENAME_REQUEST,
        RENAME_REPLY, // 50

        ACCESS_REQUEST,
        ACCESS_REPLY,
        READ_STAT_REQUEST,
        READ_STAT_REPLY,
        WRITE_STAT_REQUEST,
        WRITE_STAT_REPLY,

        // files
        CREATE_REQUEST,
        CREATE_REPLY,
        OPEN_REQUEST,
        OPEN_REPLY, // 60
        CLOSE_REQUEST,
        CLOSE_REPLY,
        FREE_COOKIE_REQUEST,
        FREE_COOKIE_REPLY,
        READ_REQUEST,
        READ_REPLY,
        WRITE_REQUEST,
        WRITE_REPLY,

        // directories
        CREATE_DIR_REQUEST,
        CREATE_DIR_REPLY, // 70
        REMOVE_DIR_REQUEST,
        REMOVE_DIR_REPLY,
        OPEN_DIR_REQUEST,
        OPEN_DIR_REPLY,
        CLOSE_DIR_REQUEST,
        CLOSE_DIR_REPLY,
        FREE_DIR_COOKIE_REQUEST,
        FREE_DIR_COOKIE_REPLY,
        READ_DIR_REQUEST,
        READ_DIR_REPLY, // 80
        REWIND_DIR_REQUEST,
        REWIND_DIR_REPLY,

        // attribute directories
        OPEN_ATTR_DIR_REQUEST,
        OPEN_ATTR_DIR_REPLY,
        CLOSE_ATTR_DIR_REQUEST,
        CLOSE_ATTR_DIR_REPLY,
        FREE_ATTR_DIR_COOKIE_REQUEST,
        FREE_ATTR_DIR_COOKIE_REPLY,
        READ_ATTR_DIR_REQUEST,
        READ_ATTR_DIR_REPLY, // 90
        REWIND_ATTR_DIR_REQUEST,
        REWIND_ATTR_DIR_REPLY,

        // attributes
        CREATE_ATTR_REQUEST,
        CREATE_ATTR_REPLY,
        OPEN_ATTR_REQUEST,
        OPEN_ATTR_REPLY,
        CLOSE_ATTR_REQUEST,
        CLOSE_ATTR_REPLY,
        FREE_ATTR_COOKIE_REQUEST,
        FREE_ATTR_COOKIE_REPLY, // 100
        READ_ATTR_REQUEST,
        READ_ATTR_REPLY,
        WRITE_ATTR_REQUEST,
        WRITE_ATTR_REPLY,
        READ_ATTR_STAT_REQUEST,
        READ_ATTR_STAT_REPLY,
        WRITE_ATTR_STAT_REQUEST,
        WRITE_ATTR_STAT_REPLY,
        RENAME_ATTR_REQUEST,
        RENAME_ATTR_REPLY, // 110
        REMOVE_ATTR_REQUEST,
        REMOVE_ATTR_REPLY,

        // indices
        OPEN_INDEX_DIR_REQUEST,
        OPEN_INDEX_DIR_REPLY,
        CLOSE_INDEX_DIR_REQUEST,
        CLOSE_INDEX_DIR_REPLY,
        FREE_INDEX_DIR_COOKIE_REQUEST,
        FREE_INDEX_DIR_COOKIE_REPLY,
        READ_INDEX_DIR_REQUEST,
        READ_INDEX_DIR_REPLY, // 120
        REWIND_INDEX_DIR_REQUEST,
        REWIND_INDEX_DIR_REPLY,
        CREATE_INDEX_REQUEST,
        CREATE_INDEX_REPLY,
        REMOVE_INDEX_REQUEST,
        REMOVE_INDEX_REPLY,
        READ_INDEX_STAT_REQUEST,
        READ_INDEX_STAT_REPLY,

        // queries
        OPEN_QUERY_REQUEST,
        OPEN_QUERY_REPLY, // 130
        CLOSE_QUERY_REQUEST,
        CLOSE_QUERY_REPLY,
        FREE_QUERY_COOKIE_REQUEST,
        FREE_QUERY_COOKIE_REPLY,
        READ_QUERY_REQUEST,
        READ_QUERY_REPLY,
        REWIND_QUERY_REQUEST,
        REWIND_QUERY_REPLY,

        // node monitoring
        NODE_MONITORING_EVENT_REQUEST,
        NODE_MONITORING_EVENT_REPLY, // 140

        // userland -> kernel requests
        // notifications
        NOTIFY_LISTENER_REQUEST,
        NOTIFY_LISTENER_REPLY,
        NOTIFY_SELECT_EVENT_REQUEST,
        NOTIFY_SELECT_EVENT_REPLY,
        NOTIFY_QUERY_REQUEST,
        NOTIFY_QUERY_REPLY,

        // vnodes
        GET_VNODE_REQUEST,
        GET_VNODE_REPLY,
        PUT_VNODE_REQUEST,
        PUT_VNODE_REPLY, // 150
        ACQUIRE_VNODE_REQUEST,
        ACQUIRE_VNODE_REPLY,
        NEW_VNODE_REQUEST,
        NEW_VNODE_REPLY,
        PUBLISH_VNODE_REQUEST,
        PUBLISH_VNODE_REPLY,
        REMOVE_VNODE_REQUEST,
        REMOVE_VNODE_REPLY,
        UNREMOVE_VNODE_REQUEST,
        UNREMOVE_VNODE_REPLY, // 160
        GET_VNODE_REMOVED_REQUEST,
        GET_VNODE_REMOVED_REPLY,

        // file cache
        FILE_CACHE_CREATE_REQUEST,
        FILE_CACHE_CREATE_REPLY,
        FILE_CACHE_DELETE_REQUEST,
        FILE_CACHE_DELETE_REPLY,
        FILE_CACHE_SET_ENABLED_REQUEST,
        FILE_CACHE_SET_ENABLED_REPLY,
        FILE_CACHE_SET_SIZE_REQUEST,
        FILE_CACHE_SET_SIZE_REPLY, // 170
        FILE_CACHE_SYNC_REQUEST,
        FILE_CACHE_SYNC_REPLY,
        FILE_CACHE_READ_REQUEST,
        FILE_CACHE_READ_REPLY,
        FILE_CACHE_WRITE_REQUEST,
        FILE_CACHE_WRITE_REPLY,

        // I/O
        DO_ITERATIVE_FD_IO_REQUEST,
        DO_ITERATIVE_FD_IO_REPLY,
        READ_FROM_IO_REQUEST_REQUEST,
        READ_FROM_IO_REQUEST_REPLY, // 180
        WRITE_TO_IO_REQUEST_REQUEST,
        WRITE_TO_IO_REQUEST_REPLY,
        NOTIFY_IO_REQUEST_REQUEST,
        NOTIFY_IO_REQUEST_REPLY,

        // node monitoring
        ADD_NODE_LISTENER_REQUEST,
        ADD_NODE_LISTENER_REPLY,
        REMOVE_NODE_LISTENER_REQUEST,
        REMOVE_NODE_LISTENER_REPLY,

        // general reply
        RECEIPT_ACK_REPLY,

        // invalid request ID (e.g. for request handlers)
        NO_REQUEST, // 190
};

namespace UserlandFSUtil {

// ReplyRequest
class ReplyRequest : public Request {
public:
        ReplyRequest(uint32 type) : Request(type) {}

        status_t        error;
};


// #pragma mark - kernel requests


// KernelRequest
class KernelRequest : public Request {
public:
        KernelRequest(uint32 type) : Request(type) {}

        team_id         team;
        thread_id       thread;
        uid_t           user;
        gid_t           group;
};

// VolumeRequest
class VolumeRequest : public KernelRequest {
public:
        VolumeRequest(uint32 type) : KernelRequest(type) {}

        void*           volume;
};

// NodeRequest
class NodeRequest : public VolumeRequest {
public:
        NodeRequest(uint32 type) : VolumeRequest(type) {}

        void*           node;
};

// FileRequest
class FileRequest : public NodeRequest {
public:
        FileRequest(uint32 type) : NodeRequest(type) {}

        void*           fileCookie;
};

// DirRequest
class DirRequest : public NodeRequest {
public:
        DirRequest(uint32 type) : NodeRequest(type) {}

        void*           dirCookie;
};

// AttrDirRequest
class AttrDirRequest : public NodeRequest {
public:
        AttrDirRequest(uint32 type) : NodeRequest(type) {}

        void*           attrDirCookie;
};

// AttributeRequest
class AttributeRequest : public NodeRequest {
public:
        AttributeRequest(uint32 type) : NodeRequest(type) {}

        void*           attrCookie;
};

// IndexDirRequest
class IndexDirRequest : public VolumeRequest {
public:
        IndexDirRequest(uint32 type) : VolumeRequest(type) {}

        void*           indexDirCookie;
};

// QueryRequest
class QueryRequest : public VolumeRequest {
public:
        QueryRequest(uint32 type) : VolumeRequest(type) {}

        void*           queryCookie;
};

// FileCacheRequest
class FileCacheRequest : public Request {
public:
        FileCacheRequest(uint32 type) : Request(type) {}

        dev_t           nsid;
        ino_t           vnid;
};

class IORequestRequest : public Request {
public:
        IORequestRequest(uint32 type) : Request(type) {}

        dev_t           nsid;
        int32           request;
};


// #pragma mark - administrative


// UFSDisconnectRequest
class UFSDisconnectRequest : public Request {
public:
        UFSDisconnectRequest() : Request(UFS_DISCONNECT_REQUEST) {}
};

// FSConnectRequest
class FSConnectRequest : public Request {
public:
        FSConnectRequest() : Request(FS_CONNECT_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         fsName;
};

// FSConnectReply
class FSConnectReply : public ReplyRequest {
public:
        FSConnectReply() : ReplyRequest(FS_CONNECT_REPLY) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address                 portInfos;
        int32                   portInfoCount;
        FSCapabilities  capabilities;
        client_fs_type  clientFSType;
};


// #pragma mark - FS


// MountVolumeRequest
class MountVolumeRequest : public KernelRequest {
public:
        MountVolumeRequest() : KernelRequest(MOUNT_VOLUME_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        dev_t           nsid;
        Address         cwd;                    // current working dir of the mount() caller
        Address         device;
        uint32          flags;
        Address         parameters;
};

// MountVolumeReply
class MountVolumeReply : public ReplyRequest {
public:
        MountVolumeReply() : ReplyRequest(MOUNT_VOLUME_REPLY) {}

        ino_t                                   rootID;
        void*                                   volume;
        FSVolumeCapabilities    capabilities;
};

// UnmountVolumeRequest
class UnmountVolumeRequest : public VolumeRequest {
public:
        UnmountVolumeRequest() : VolumeRequest(UNMOUNT_VOLUME_REQUEST) {}
};

// UnmountVolumeReply
class UnmountVolumeReply : public ReplyRequest {
public:
        UnmountVolumeReply() : ReplyRequest(UNMOUNT_VOLUME_REPLY) {}
};

/*// InitializeVolumeRequest
class InitializeVolumeRequest : public Request {
public:
        InitializeVolumeRequest() : Request(INITIALIZE_VOLUME_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         device;
        Address         parameters;
};

// InitializeVolumeReply
class InitializeVolumeReply : public ReplyRequest {
public:
        InitializeVolumeReply() : ReplyRequest(INITIALIZE_VOLUME_REPLY) {}
};*/

// SyncVolumeRequest
class SyncVolumeRequest : public VolumeRequest {
public:
        SyncVolumeRequest() : VolumeRequest(SYNC_VOLUME_REQUEST) {}
};

// SyncVolumeReply
class SyncVolumeReply : public ReplyRequest {
public:
        SyncVolumeReply() : ReplyRequest(SYNC_VOLUME_REPLY) {}
};

// ReadFSInfoRequest
class ReadFSInfoRequest : public VolumeRequest {
public:
        ReadFSInfoRequest() : VolumeRequest(READ_FS_INFO_REQUEST) {}
};

// ReadFSInfoReply
class ReadFSInfoReply : public ReplyRequest {
public:
        ReadFSInfoReply() : ReplyRequest(READ_FS_INFO_REPLY) {}

        fs_info         info;
};

// WriteFSInfoRequest
class WriteFSInfoRequest : public VolumeRequest {
public:
        WriteFSInfoRequest() : VolumeRequest(WRITE_FS_INFO_REQUEST) {}

        fs_info         info;
        uint32          mask;
};

// WriteFSInfoReply
class WriteFSInfoReply : public ReplyRequest {
public:
        WriteFSInfoReply() : ReplyRequest(WRITE_FS_INFO_REPLY) {}
};


// #pragma mark - vnodes


// LookupRequest
class LookupRequest : public NodeRequest {
public:
        LookupRequest() : NodeRequest(LOOKUP_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         entryName;
        bool            traverseLink;
};

// LookupReply
class LookupReply : public ReplyRequest {
public:
        LookupReply() : ReplyRequest(LOOKUP_REPLY) {}

        ino_t           vnid;
};

// GetVNodeNameRequest
class GetVNodeNameRequest : public NodeRequest {
public:
        GetVNodeNameRequest() : NodeRequest(GET_VNODE_NAME_REQUEST) {}

        size_t          size;
};

// GetVNodeNameReply
class GetVNodeNameReply : public ReplyRequest {
public:
        GetVNodeNameReply() : ReplyRequest(GET_VNODE_NAME_REPLY) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         buffer;
};

// ReadVNodeRequest
class ReadVNodeRequest : public VolumeRequest {
public:
        ReadVNodeRequest() : VolumeRequest(READ_VNODE_REQUEST) {}

        ino_t           vnid;
        bool            reenter;
};

// ReadVNodeReply
class ReadVNodeReply : public ReplyRequest {
public:
        ReadVNodeReply() : ReplyRequest(READ_VNODE_REPLY) {}

        void*                           node;
        int                                     type;
        uint32                          flags;
        FSVNodeCapabilities     capabilities;
};

// WriteVNodeRequest
class WriteVNodeRequest : public NodeRequest {
public:
        WriteVNodeRequest() : NodeRequest(WRITE_VNODE_REQUEST) {}

        bool            reenter;
};

// WriteVNodeReply
class WriteVNodeReply : public ReplyRequest {
public:
        WriteVNodeReply() : ReplyRequest(WRITE_VNODE_REPLY) {}
};

// FSRemoveVNodeRequest
class FSRemoveVNodeRequest : public NodeRequest {
public:
        FSRemoveVNodeRequest() : NodeRequest(FS_REMOVE_VNODE_REQUEST) {}

        bool            reenter;
};

// FSRemoveVNodeReply
class FSRemoveVNodeReply : public ReplyRequest {
public:
        FSRemoveVNodeReply() : ReplyRequest(FS_REMOVE_VNODE_REPLY) {}
};


// #pragma mark - asynchronous I/O


// DoIORequest
class DoIORequest : public FileRequest {
public:
        DoIORequest() : FileRequest(DO_IO_REQUEST) {}

        off_t           offset;
        size_t          length;
        int32           request;
        bool            isWrite;
        bool            isVIP;
};

// DoIOReply
class DoIOReply : public ReplyRequest {
public:
        DoIOReply() : ReplyRequest(DO_IO_REPLY) {}
};

// CancelIORequest
class CancelIORequest : public FileRequest {
public:
        CancelIORequest() : FileRequest(CANCEL_IO_REQUEST) {}

        int32           request;
};

// CancelIOReply
class CancelIOReply : public ReplyRequest {
public:
        CancelIOReply() : ReplyRequest(CANCEL_IO_REPLY) {}
};

// IterativeIOGetVecsRequest
class IterativeIOGetVecsRequest : public VolumeRequest {
public:
        IterativeIOGetVecsRequest()
                : VolumeRequest(ITERATIVE_IO_GET_VECS_REQUEST) {}

        void*           cookie;
        off_t           offset;
        int32           request;
        size_t          size;
        uint32          vecCount;
};

// IterativeIOGetVecsReply
class IterativeIOGetVecsReply : public ReplyRequest {
public:
        IterativeIOGetVecsReply() : ReplyRequest(ITERATIVE_IO_GET_VECS_REPLY) {}

        enum { MAX_VECS = 8 };

        file_io_vec     vecs[MAX_VECS];
        uint32          vecCount;
};

// IterativeIOFinishedRequest
class IterativeIOFinishedRequest : public VolumeRequest {
public:
        IterativeIOFinishedRequest()
                : VolumeRequest(ITERATIVE_IO_FINISHED_REQUEST) {}

        void*           cookie;
        int32           request;
        status_t        status;
        bool            partialTransfer;
        size_t          bytesTransferred;
};

// IterativeIOFinishedReply
class IterativeIOFinishedReply : public ReplyRequest {
public:
        IterativeIOFinishedReply() : ReplyRequest(ITERATIVE_IO_FINISHED_REPLY) {}
};


// #pragma mark - nodes


// IOCtlRequest
class IOCtlRequest : public FileRequest {
public:
        IOCtlRequest() : FileRequest(IOCTL_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        uint32          command;
        void*           bufferParameter;
        size_t          lenParameter;
        bool            isBuffer;       // if false, just pass bufferParameter
                                                        // otherwise use buffer
        Address         buffer;
        int32           writeSize;      // ignored unless isBuffer -- then
                                                        // it indicates the size of the buffer to allocate
};

// IOCtlReply
class IOCtlReply : public ReplyRequest {
public:
        IOCtlReply() : ReplyRequest(IOCTL_REPLY) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        status_t        ioctlError;             // we need a special handling since error
                                                                // may be a part of the client FS protocol
        Address         buffer;
};

// SetFlagsRequest
class SetFlagsRequest : public FileRequest {
public:
        SetFlagsRequest() : FileRequest(SET_FLAGS_REQUEST) {}

        int                     flags;
};

// SetFlagsReply
class SetFlagsReply : public ReplyRequest {
public:
        SetFlagsReply() : ReplyRequest(SET_FLAGS_REPLY) {}
};

// SelectRequest
class SelectRequest : public FileRequest {
public:
        SelectRequest() : FileRequest(SELECT_REQUEST) {}

        uint8           event;
        selectsync*     sync;
};

// SelectReply
class SelectReply : public ReplyRequest {
public:
        SelectReply() : ReplyRequest(SELECT_REPLY) {}
};

// DeselectRequest
class DeselectRequest : public FileRequest {
public:
        DeselectRequest() : FileRequest(DESELECT_REQUEST) {}

        uint8           event;
        selectsync*     sync;
};

// DeselectReply
class DeselectReply : public ReplyRequest {
public:
        DeselectReply() : ReplyRequest(DESELECT_REPLY) {}
};

// FSyncRequest
class FSyncRequest : public NodeRequest {
public:
        FSyncRequest() : NodeRequest(FSYNC_REQUEST) {}
};

// FSyncReply
class FSyncReply : public ReplyRequest {
public:
        FSyncReply() : ReplyRequest(FSYNC_REPLY) {}
};

// ReadSymlinkRequest
class ReadSymlinkRequest : public NodeRequest {
public:
        ReadSymlinkRequest() : NodeRequest(READ_SYMLINK_REQUEST) {}

        size_t          size;
};

// ReadSymlinkReply
class ReadSymlinkReply : public ReplyRequest {
public:
        ReadSymlinkReply() : ReplyRequest(READ_SYMLINK_REPLY) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         buffer;
        size_t          bytesRead;
};

// CreateSymlinkRequest
class CreateSymlinkRequest : public NodeRequest {
public:
        CreateSymlinkRequest() : NodeRequest(CREATE_SYMLINK_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         name;
        Address         target;
        int                     mode;
};

// CreateSymlinkReply
class CreateSymlinkReply : public ReplyRequest {
public:
        CreateSymlinkReply() : ReplyRequest(CREATE_SYMLINK_REPLY) {}
};

// LinkRequest
class LinkRequest : public NodeRequest {
public:
        LinkRequest() : NodeRequest(LINK_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         name;
        void*           target;
};

// LinkReply
class LinkReply : public ReplyRequest {
public:
        LinkReply() : ReplyRequest(LINK_REPLY) {}
};

// UnlinkRequest
class UnlinkRequest : public NodeRequest {
public:
        UnlinkRequest() : NodeRequest(UNLINK_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         name;
};

// UnlinkReply
class UnlinkReply : public ReplyRequest {
public:
        UnlinkReply() : ReplyRequest(UNLINK_REPLY) {}
};

// RenameRequest
class RenameRequest : public VolumeRequest {
public:
        RenameRequest() : VolumeRequest(RENAME_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        void*           oldDir;
        Address         oldName;
        void*           newDir;
        Address         newName;
};

// RenameReply
class RenameReply : public ReplyRequest {
public:
        RenameReply() : ReplyRequest(RENAME_REPLY) {}
};

// AccessRequest
class AccessRequest : public NodeRequest {
public:
        AccessRequest() : NodeRequest(ACCESS_REQUEST) {}

        int                     mode;
};

// AccessReply
class AccessReply : public ReplyRequest {
public:
        AccessReply() : ReplyRequest(ACCESS_REPLY) {}
};

// ReadStatRequest
class ReadStatRequest : public NodeRequest {
public:
        ReadStatRequest() : NodeRequest(READ_STAT_REQUEST) {}
};

// ReadStatReply
class ReadStatReply : public ReplyRequest {
public:
        ReadStatReply() : ReplyRequest(READ_STAT_REPLY) {}

        struct stat     st;
};

// WriteStatRequest
class WriteStatRequest : public NodeRequest {
public:
        WriteStatRequest() : NodeRequest(WRITE_STAT_REQUEST) {}

        struct stat     st;
        uint32          mask;
};

// WriteStatReply
class WriteStatReply : public ReplyRequest {
public:
        WriteStatReply() : ReplyRequest(WRITE_STAT_REPLY) {}
};


// #pragma mark - files


// CreateRequest
class CreateRequest : public NodeRequest {
public:
        CreateRequest() : NodeRequest(CREATE_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         name;
        int                     openMode;
        int                     mode;
};

// CreateReply
class CreateReply : public ReplyRequest {
public:
        CreateReply() : ReplyRequest(CREATE_REPLY) {}

        ino_t           vnid;
        void*           fileCookie;
};

// OpenRequest
class OpenRequest : public NodeRequest {
public:
        OpenRequest() : NodeRequest(OPEN_REQUEST) {}

        int                     openMode;
};

// OpenReply
class OpenReply : public ReplyRequest {
public:
        OpenReply() : ReplyRequest(OPEN_REPLY) {}

        void*           fileCookie;
};

// CloseRequest
class CloseRequest : public FileRequest {
public:
        CloseRequest() : FileRequest(CLOSE_REQUEST) {}
};

// CloseReply
class CloseReply : public ReplyRequest {
public:
        CloseReply() : ReplyRequest(CLOSE_REPLY) {}
};

// FreeCookieRequest
class FreeCookieRequest : public FileRequest {
public:
        FreeCookieRequest() : FileRequest(FREE_COOKIE_REQUEST) {}
};

// FreeCookieReply
class FreeCookieReply : public ReplyRequest {
public:
        FreeCookieReply() : ReplyRequest(FREE_COOKIE_REPLY) {}
};

// ReadRequest
class ReadRequest : public FileRequest {
public:
        ReadRequest() : FileRequest(READ_REQUEST) {}

        off_t           pos;
        size_t          size;
};

// ReadReply
class ReadReply : public ReplyRequest {
public:
        ReadReply() : ReplyRequest(READ_REPLY) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         buffer;
        size_t          bytesRead;
};

// WriteRequest
class WriteRequest : public FileRequest {
public:
        WriteRequest() : FileRequest(WRITE_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         buffer;
        off_t           pos;
};

// WriteReply
class WriteReply : public ReplyRequest {
public:
        WriteReply() : ReplyRequest(WRITE_REPLY) {}

        size_t          bytesWritten;
};


// #pragma mark - directories


// CreateDirRequest
class CreateDirRequest : public NodeRequest {
public:
        CreateDirRequest() : NodeRequest(CREATE_DIR_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         name;
        int                     mode;
};

// CreateDirReply
class CreateDirReply : public ReplyRequest {
public:
        CreateDirReply() : ReplyRequest(CREATE_DIR_REPLY) {}
};

// RemoveDirRequest
class RemoveDirRequest : public NodeRequest {
public:
        RemoveDirRequest() : NodeRequest(REMOVE_DIR_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         name;
};

// RemoveDirReply
class RemoveDirReply : public ReplyRequest {
public:
        RemoveDirReply() : ReplyRequest(REMOVE_DIR_REPLY) {}
};

// OpenDirRequest
class OpenDirRequest : public NodeRequest {
public:
        OpenDirRequest() : NodeRequest(OPEN_DIR_REQUEST) {}
};

// OpenDirReply
class OpenDirReply : public ReplyRequest {
public:
        OpenDirReply() : ReplyRequest(OPEN_DIR_REPLY) {}

        void*           dirCookie;
};

// CloseDirRequest
class CloseDirRequest : public DirRequest {
public:
        CloseDirRequest() : DirRequest(CLOSE_DIR_REQUEST) {}
};

// CloseDirReply
class CloseDirReply : public ReplyRequest {
public:
        CloseDirReply() : ReplyRequest(CLOSE_DIR_REPLY) {}
};

// FreeDirCookieRequest
class FreeDirCookieRequest : public DirRequest {
public:
        FreeDirCookieRequest() : DirRequest(FREE_DIR_COOKIE_REQUEST) {}
};

// FreeDirCookieReply
class FreeDirCookieReply : public ReplyRequest {
public:
        FreeDirCookieReply() : ReplyRequest(FREE_DIR_COOKIE_REPLY) {}
};

// ReadDirRequest
class ReadDirRequest : public DirRequest {
public:
        ReadDirRequest() : DirRequest(READ_DIR_REQUEST) {}

        size_t          bufferSize;
        uint32          count;
};

// ReadDirReply
class ReadDirReply : public ReplyRequest {
public:
        ReadDirReply() : ReplyRequest(READ_DIR_REPLY) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        uint32          count;
        Address         buffer;
};

// RewindDirRequest
class RewindDirRequest : public DirRequest {
public:
        RewindDirRequest() : DirRequest(REWIND_DIR_REQUEST) {}
};

// RewindDirReply
class RewindDirReply : public ReplyRequest {
public:
        RewindDirReply() : ReplyRequest(REWIND_DIR_REPLY) {}
};


// #pragma mark - attribute directories


// OpenAttrDirRequest
class OpenAttrDirRequest : public NodeRequest {
public:
        OpenAttrDirRequest() : NodeRequest(OPEN_ATTR_DIR_REQUEST) {}
};

// OpenAttrDirReply
class OpenAttrDirReply : public ReplyRequest {
public:
        OpenAttrDirReply() : ReplyRequest(OPEN_ATTR_DIR_REPLY) {}

        void*           attrDirCookie;
};

// CloseAttrDirRequest
class CloseAttrDirRequest : public AttrDirRequest {
public:
        CloseAttrDirRequest() : AttrDirRequest(CLOSE_ATTR_DIR_REQUEST) {}
};

// CloseAttrDirReply
class CloseAttrDirReply : public ReplyRequest {
public:
        CloseAttrDirReply() : ReplyRequest(CLOSE_ATTR_DIR_REPLY) {}
};

// FreeAttrDirCookieRequest
class FreeAttrDirCookieRequest : public AttrDirRequest {
public:
        FreeAttrDirCookieRequest() : AttrDirRequest(FREE_ATTR_DIR_COOKIE_REQUEST) {}
};

// FreeAttrDirCookieReply
class FreeAttrDirCookieReply : public ReplyRequest {
public:
        FreeAttrDirCookieReply() : ReplyRequest(FREE_ATTR_DIR_COOKIE_REPLY) {}
};

// ReadAttrDirRequest
class ReadAttrDirRequest : public AttrDirRequest {
public:
        ReadAttrDirRequest() : AttrDirRequest(READ_ATTR_DIR_REQUEST) {}

        size_t          bufferSize;
        uint32          count;
};

// ReadAttrDirReply
class ReadAttrDirReply : public ReplyRequest {
public:
        ReadAttrDirReply() : ReplyRequest(READ_ATTR_DIR_REPLY) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        uint32          count;
        Address         buffer;
};

// RewindAttrDirRequest
class RewindAttrDirRequest : public AttrDirRequest {
public:
        RewindAttrDirRequest() : AttrDirRequest(REWIND_ATTR_DIR_REQUEST) {}
};

// RewindAttrDirReply
class RewindAttrDirReply : public ReplyRequest {
public:
        RewindAttrDirReply() : ReplyRequest(REWIND_ATTR_DIR_REPLY) {}
};


// #pragma mark - attributes


// CreateAttrRequest
class CreateAttrRequest : public NodeRequest {
public:
        CreateAttrRequest() : NodeRequest(CREATE_ATTR_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         name;
        uint32          type;
        int                     openMode;
};

// CreateAttrReply
class CreateAttrReply : public ReplyRequest {
public:
        CreateAttrReply() : ReplyRequest(CREATE_ATTR_REPLY) {}

        void*           attrCookie;
};

// OpenAttrRequest
class OpenAttrRequest : public NodeRequest {
public:
        OpenAttrRequest() : NodeRequest(OPEN_ATTR_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         name;
        int                     openMode;
};

// OpenAttrReply
class OpenAttrReply : public ReplyRequest {
public:
        OpenAttrReply() : ReplyRequest(OPEN_ATTR_REPLY) {}

        void*           attrCookie;
};

// CloseAttrRequest
class CloseAttrRequest : public AttributeRequest {
public:
        CloseAttrRequest() : AttributeRequest(CLOSE_ATTR_REQUEST) {}
};

// CloseAttrReply
class CloseAttrReply : public ReplyRequest {
public:
        CloseAttrReply() : ReplyRequest(CLOSE_ATTR_REPLY) {}
};

// FreeAttrCookieRequest
class FreeAttrCookieRequest : public AttributeRequest {
public:
        FreeAttrCookieRequest() : AttributeRequest(FREE_ATTR_COOKIE_REQUEST) {}
};

// FreeAttrCookieReply
class FreeAttrCookieReply : public ReplyRequest {
public:
        FreeAttrCookieReply() : ReplyRequest(FREE_ATTR_COOKIE_REPLY) {}
};

// ReadAttrRequest
class ReadAttrRequest : public AttributeRequest {
public:
        ReadAttrRequest() : AttributeRequest(READ_ATTR_REQUEST) {}

        off_t           pos;
        size_t          size;
};

// ReadAttrReply
class ReadAttrReply : public ReplyRequest {
public:
        ReadAttrReply() : ReplyRequest(READ_ATTR_REPLY) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         buffer;
        size_t          bytesRead;
};

// WriteAttrRequest
class WriteAttrRequest : public AttributeRequest {
public:
        WriteAttrRequest() : AttributeRequest(WRITE_ATTR_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         buffer;
        off_t           pos;
        size_t          size;
};

// WriteAttrReply
class WriteAttrReply : public ReplyRequest {
public:
        WriteAttrReply() : ReplyRequest(WRITE_ATTR_REPLY) {}

        size_t          bytesWritten;
};

// ReadAttrStatRequest
class ReadAttrStatRequest : public AttributeRequest {
public:
        ReadAttrStatRequest() : AttributeRequest(READ_ATTR_STAT_REQUEST) {}
};

// ReadAttrStatReply
class ReadAttrStatReply : public ReplyRequest {
public:
        ReadAttrStatReply() : ReplyRequest(READ_ATTR_STAT_REPLY) {}

        struct stat     st;
};

// WriteAttrStatRequest
class WriteAttrStatRequest : public AttributeRequest {
public:
        WriteAttrStatRequest() : AttributeRequest(WRITE_ATTR_STAT_REQUEST) {}

        struct stat     st;
        uint32          mask;
};

// WriteAttrStatReply
class WriteAttrStatReply : public ReplyRequest {
public:
        WriteAttrStatReply() : ReplyRequest(WRITE_ATTR_STAT_REPLY) {}
};

// RenameAttrRequest
class RenameAttrRequest : public VolumeRequest {
public:
        RenameAttrRequest() : VolumeRequest(RENAME_ATTR_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        void*           oldNode;
        void*           newNode;
        Address         oldName;
        Address         newName;
};

// RenameAttrReply
class RenameAttrReply : public ReplyRequest {
public:
        RenameAttrReply() : ReplyRequest(RENAME_ATTR_REPLY) {}
};

// RemoveAttrRequest
class RemoveAttrRequest : public NodeRequest {
public:
        RemoveAttrRequest() : NodeRequest(REMOVE_ATTR_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         name;
};

// RemoveAttrReply
class RemoveAttrReply : public ReplyRequest {
public:
        RemoveAttrReply() : ReplyRequest(REMOVE_ATTR_REPLY) {}
};


// #pragma mark - indices


// OpenIndexDirRequest
class OpenIndexDirRequest : public VolumeRequest {
public:
        OpenIndexDirRequest() : VolumeRequest(OPEN_INDEX_DIR_REQUEST) {}
};

// OpenIndexDirReply
class OpenIndexDirReply : public ReplyRequest {
public:
        OpenIndexDirReply() : ReplyRequest(OPEN_INDEX_DIR_REPLY) {}

        void*           indexDirCookie;
};

// CloseIndexDirRequest
class CloseIndexDirRequest : public IndexDirRequest {
public:
        CloseIndexDirRequest() : IndexDirRequest(CLOSE_INDEX_DIR_REQUEST) {}
};

// CloseIndexDirReply
class CloseIndexDirReply : public ReplyRequest {
public:
        CloseIndexDirReply() : ReplyRequest(CLOSE_INDEX_DIR_REPLY) {}
};

// FreeIndexDirCookieRequest
class FreeIndexDirCookieRequest : public IndexDirRequest {
public:
        FreeIndexDirCookieRequest()
                : IndexDirRequest(FREE_INDEX_DIR_COOKIE_REQUEST) {}
};

// FreeIndexDirCookieReply
class FreeIndexDirCookieReply : public ReplyRequest {
public:
        FreeIndexDirCookieReply() : ReplyRequest(FREE_INDEX_DIR_COOKIE_REPLY) {}
};

// ReadIndexDirRequest
class ReadIndexDirRequest : public IndexDirRequest {
public:
        ReadIndexDirRequest() : IndexDirRequest(READ_INDEX_DIR_REQUEST) {}

        size_t          bufferSize;
        uint32          count;
};

// ReadIndexDirReply
class ReadIndexDirReply : public ReplyRequest {
public:
        ReadIndexDirReply() : ReplyRequest(READ_INDEX_DIR_REPLY) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        uint32          count;
        Address         buffer;
};

// RewindIndexDirRequest
class RewindIndexDirRequest : public IndexDirRequest {
public:
        RewindIndexDirRequest() : IndexDirRequest(REWIND_INDEX_DIR_REQUEST) {}
};

// RewindIndexDirReply
class RewindIndexDirReply : public ReplyRequest {
public:
        RewindIndexDirReply() : ReplyRequest(REWIND_INDEX_DIR_REPLY) {}
};

// CreateIndexRequest
class CreateIndexRequest : public VolumeRequest {
public:
        CreateIndexRequest() : VolumeRequest(CREATE_INDEX_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         name;
        uint32          type;
        uint32          flags;
};

// CreateIndexReply
class CreateIndexReply : public ReplyRequest {
public:
        CreateIndexReply() : ReplyRequest(CREATE_INDEX_REPLY) {}
};

// RemoveIndexRequest
class RemoveIndexRequest : public VolumeRequest {
public:
        RemoveIndexRequest() : VolumeRequest(REMOVE_INDEX_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         name;
};

// RemoveIndexReply
class RemoveIndexReply : public ReplyRequest {
public:
        RemoveIndexReply() : ReplyRequest(REMOVE_INDEX_REPLY) {}
};

// ReadIndexStatRequest
class ReadIndexStatRequest : public VolumeRequest {
public:
        ReadIndexStatRequest() : VolumeRequest(READ_INDEX_STAT_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         name;
};

// ReadIndexStatReply
class ReadIndexStatReply : public ReplyRequest {
public:
        ReadIndexStatReply() : ReplyRequest(READ_INDEX_STAT_REPLY) {}

        struct stat     st;
};


// #pragma mark - queries


// OpenQueryRequest
class OpenQueryRequest : public VolumeRequest {
public:
        OpenQueryRequest() : VolumeRequest(OPEN_QUERY_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         queryString;
        uint32          flags;
        port_id         port;
        uint32          token;
};

// OpenQueryReply
class OpenQueryReply : public ReplyRequest {
public:
        OpenQueryReply() : ReplyRequest(OPEN_QUERY_REPLY) {}

        void*           queryCookie;
};

// CloseQueryRequest
class CloseQueryRequest : public QueryRequest {
public:
        CloseQueryRequest() : QueryRequest(CLOSE_QUERY_REQUEST) {}
};

// CloseQueryReply
class CloseQueryReply : public ReplyRequest {
public:
        CloseQueryReply() : ReplyRequest(CLOSE_QUERY_REPLY) {}
};

// FreeQueryCookieRequest
class FreeQueryCookieRequest : public QueryRequest {
public:
        FreeQueryCookieRequest() : QueryRequest(FREE_QUERY_COOKIE_REQUEST) {}
};

// FreeQueryCookieReply
class FreeQueryCookieReply : public ReplyRequest {
public:
        FreeQueryCookieReply() : ReplyRequest(FREE_QUERY_COOKIE_REPLY) {}
};

// ReadQueryRequest
class ReadQueryRequest : public QueryRequest {
public:
        ReadQueryRequest() : QueryRequest(READ_QUERY_REQUEST) {}

        size_t          bufferSize;
        uint32          count;
};

// ReadQueryReply
class ReadQueryReply : public ReplyRequest {
public:
        ReadQueryReply() : ReplyRequest(READ_QUERY_REPLY) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        uint32          count;
        Address         buffer;
};

// RewindQueryRequest
class RewindQueryRequest : public QueryRequest {
public:
        RewindQueryRequest() : QueryRequest(REWIND_QUERY_REQUEST) {}
};

// RewindQueryReply
class RewindQueryReply : public ReplyRequest {
public:
        RewindQueryReply() : ReplyRequest(REWIND_QUERY_REPLY) {}
};


// #pragma mark ----- node monitoring -----


// NodeMonitoringEventRequest
class NodeMonitoringEventRequest : public KernelRequest {
public:
        NodeMonitoringEventRequest()
                : KernelRequest(NODE_MONITORING_EVENT_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        void*           listener;
        Address         event;
};

// NodeMonitoringEventReply
class NodeMonitoringEventReply : public ReplyRequest {
public:
        NodeMonitoringEventReply() : ReplyRequest(NODE_MONITORING_EVENT_REPLY) {}
};


// #pragma mark -
// #pragma mark ----- userland requests -----

// #pragma mark -
// #pragma mark ----- notifications -----

// NotifyListenerRequest
class NotifyListenerRequest : public Request {
public:
        NotifyListenerRequest() : Request(NOTIFY_LISTENER_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        int32           operation;
        uint32          details;                        // for B_STAT_CHANGED:statFields
                                                                        // and B_ATTRIBUTE_CHANGED:cause
        dev_t           device;
        ino_t           oldDirectory;
        ino_t           directory;
        ino_t           node;
        Address         oldName;
        Address         name;
};

// NotifyListenerReply
class NotifyListenerReply : public ReplyRequest {
public:
        NotifyListenerReply() : ReplyRequest(NOTIFY_LISTENER_REPLY) {}
};

// NotifySelectRequest
class NotifySelectEventRequest : public Request {
public:
        NotifySelectEventRequest() : Request(NOTIFY_SELECT_EVENT_REQUEST) {}

        selectsync*     sync;
        uint8           event;
        bool            unspecifiedEvent;
};

// NotifySelectEventReply
class NotifySelectEventReply : public ReplyRequest {
public:
        NotifySelectEventReply() : ReplyRequest(NOTIFY_SELECT_EVENT_REPLY) {}
};

// NotifyQueryRequest
class NotifyQueryRequest : public Request {
public:
        NotifyQueryRequest() : Request(NOTIFY_QUERY_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        port_id         port;
        int32           token;
        int32           operation;                      // B_ENTRY_{CREATED,REMOVED}
        dev_t           device;
        ino_t           directory;
        ino_t           node;
        Address         name;
};

// NotifyQueryReply
class NotifyQueryReply : public ReplyRequest {
public:
        NotifyQueryReply() : ReplyRequest(NOTIFY_QUERY_REPLY) {}
};


// #pragma mark -
// #pragma mark ----- vnodes -----

// GetVNodeRequest
class GetVNodeRequest : public Request {
public:
        GetVNodeRequest() : Request(GET_VNODE_REQUEST) {}

        dev_t           nsid;
        ino_t           vnid;
};

// GetVNodeReply
class GetVNodeReply : public ReplyRequest {
public:
        GetVNodeReply() : ReplyRequest(GET_VNODE_REPLY) {}

        void*           node;
};

// PutVNodeRequest
class PutVNodeRequest : public Request {
public:
        PutVNodeRequest() : Request(PUT_VNODE_REQUEST) {}

        dev_t           nsid;
        ino_t           vnid;
};

// PutVNodeReply
class PutVNodeReply : public ReplyRequest {
public:
        PutVNodeReply() : ReplyRequest(PUT_VNODE_REPLY) {}
};

// AcquireVNodeRequest
class AcquireVNodeRequest : public Request {
public:
        AcquireVNodeRequest() : Request(ACQUIRE_VNODE_REQUEST) {}

        dev_t           nsid;
        ino_t           vnid;
};

// AcquireVNodeReply
class AcquireVNodeReply : public ReplyRequest {
public:
        AcquireVNodeReply() : ReplyRequest(ACQUIRE_VNODE_REPLY) {}
};

// NewVNodeRequest
class NewVNodeRequest : public Request {
public:
        NewVNodeRequest() : Request(NEW_VNODE_REQUEST) {}

        dev_t                           nsid;
        ino_t                           vnid;
        void*                           node;
        FSVNodeCapabilities     capabilities;
};

// NewVNodeReply
class NewVNodeReply : public ReplyRequest {
public:
        NewVNodeReply() : ReplyRequest(NEW_VNODE_REPLY) {}
};

// PublishVNodeRequest
class PublishVNodeRequest : public Request {
public:
        PublishVNodeRequest() : Request(PUBLISH_VNODE_REQUEST) {}

        dev_t                           nsid;
        ino_t                           vnid;
        void*                           node;
        int                                     type;
        uint32                          flags;
        FSVNodeCapabilities     capabilities;
};

// PublishVNodeReply
class PublishVNodeReply : public ReplyRequest {
public:
        PublishVNodeReply() : ReplyRequest(PUBLISH_VNODE_REPLY) {}
};

// RemoveVNodeRequest
class RemoveVNodeRequest : public Request {
public:
        RemoveVNodeRequest() : Request(REMOVE_VNODE_REQUEST) {}

        dev_t           nsid;
        ino_t           vnid;
};

// RemoveVNodeReply
class RemoveVNodeReply : public ReplyRequest {
public:
        RemoveVNodeReply() : ReplyRequest(REMOVE_VNODE_REPLY) {}
};

// UnremoveVNodeRequest
class UnremoveVNodeRequest : public Request {
public:
        UnremoveVNodeRequest() : Request(UNREMOVE_VNODE_REQUEST) {}

        dev_t           nsid;
        ino_t           vnid;
};

// UnremoveVNodeReply
class UnremoveVNodeReply : public ReplyRequest {
public:
        UnremoveVNodeReply() : ReplyRequest(UNREMOVE_VNODE_REPLY) {}
};

// GetVNodeRemovedRequest
class GetVNodeRemovedRequest : public Request {
public:
        GetVNodeRemovedRequest() : Request(GET_VNODE_REMOVED_REQUEST) {}

        dev_t           nsid;
        ino_t           vnid;
};

// GetVNodeRemovedReply
class GetVNodeRemovedReply : public ReplyRequest {
public:
        GetVNodeRemovedReply() : ReplyRequest(GET_VNODE_REMOVED_REPLY) {}

        bool            removed;
};


// #pragma mark - file cache


// FileCacheCreateRequest
class FileCacheCreateRequest : public FileCacheRequest {
public:
        FileCacheCreateRequest() : FileCacheRequest(FILE_CACHE_CREATE_REQUEST) {}

        off_t           size;
};

// FileCacheCreateReply
class FileCacheCreateReply : public ReplyRequest {
public:
        FileCacheCreateReply() : ReplyRequest(FILE_CACHE_CREATE_REPLY) {}
};

// FileCacheDeleteRequest
class FileCacheDeleteRequest : public FileCacheRequest {
public:
        FileCacheDeleteRequest() : FileCacheRequest(FILE_CACHE_DELETE_REQUEST) {}
};

// FileCacheDeleteReply
class FileCacheDeleteReply : public ReplyRequest {
public:
        FileCacheDeleteReply() : ReplyRequest(FILE_CACHE_DELETE_REPLY) {}
};

// FileCacheSetEnabledRequest
class FileCacheSetEnabledRequest : public FileCacheRequest {
public:
        FileCacheSetEnabledRequest()
                : FileCacheRequest(FILE_CACHE_SET_ENABLED_REQUEST) {}

        bool            enabled;
};

// FileCacheSetEnabledReply
class FileCacheSetEnabledReply : public ReplyRequest {
public:
        FileCacheSetEnabledReply() : ReplyRequest(FILE_CACHE_SET_ENABLED_REPLY) {}
};

// FileCacheSetSizeRequest
class FileCacheSetSizeRequest : public FileCacheRequest {
public:
        FileCacheSetSizeRequest() : FileCacheRequest(FILE_CACHE_SET_SIZE_REQUEST) {}

        size_t          size;
};

// FileCacheSetSizeReply
class FileCacheSetSizeReply : public ReplyRequest {
public:
        FileCacheSetSizeReply() : ReplyRequest(FILE_CACHE_SET_SIZE_REPLY) {}
};


// FileCacheSyncRequest
class FileCacheSyncRequest : public FileCacheRequest {
public:
        FileCacheSyncRequest() : FileCacheRequest(FILE_CACHE_SYNC_REQUEST) {}
};

// FileCacheSyncReply
class FileCacheSyncReply : public ReplyRequest {
public:
        FileCacheSyncReply() : ReplyRequest(FILE_CACHE_SYNC_REPLY) {}
};


// FileCacheReadRequest
class FileCacheReadRequest : public FileCacheRequest {
public:
        FileCacheReadRequest() : FileCacheRequest(FILE_CACHE_READ_REQUEST) {}

        void*           cookie;
        off_t           pos;
        size_t          size;
};

// FileCacheReadReply
class FileCacheReadReply : public ReplyRequest {
public:
        FileCacheReadReply() : ReplyRequest(FILE_CACHE_READ_REPLY) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         buffer;
        size_t          bytesRead;
};

// FileCacheWriteRequest
class FileCacheWriteRequest : public FileCacheRequest {
public:
        FileCacheWriteRequest() : FileCacheRequest(FILE_CACHE_WRITE_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        void*           cookie;
        Address         buffer;
        size_t          size;
        off_t           pos;
};

// FileCacheWriteReply
class FileCacheWriteReply : public ReplyRequest {
public:
        FileCacheWriteReply() : ReplyRequest(FILE_CACHE_WRITE_REPLY) {}

        size_t          bytesWritten;
};


// #pragma mark - I/O


// DoIterativeFDIORequest
class DoIterativeFDIORequest : public Request {
public:
        DoIterativeFDIORequest() : Request(DO_ITERATIVE_FD_IO_REQUEST) {}

        enum { MAX_VECS = 8 };

        dev_t           nsid;
        int                     fd;
        int32           request;
        void*           cookie;
        file_io_vec     vecs[MAX_VECS];
        uint32          vecCount;
};

// DoIterativeFDIOReply
class DoIterativeFDIOReply : public ReplyRequest {
public:
        DoIterativeFDIOReply() : ReplyRequest(DO_ITERATIVE_FD_IO_REPLY) {}
};

// ReadFromIORequestRequest
class ReadFromIORequestRequest : public IORequestRequest {
public:
        ReadFromIORequestRequest()
                : IORequestRequest(READ_FROM_IO_REQUEST_REQUEST) {}

        size_t          size;
};

// ReadFromIORequestReply
class ReadFromIORequestReply : public ReplyRequest {
public:
        ReadFromIORequestReply() : ReplyRequest(READ_FROM_IO_REQUEST_REPLY) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         buffer;
};

// WriteToIORequestRequest
class WriteToIORequestRequest : public IORequestRequest {
public:
        WriteToIORequestRequest() : IORequestRequest(WRITE_TO_IO_REQUEST_REQUEST) {}
        status_t GetAddressInfos(AddressInfo* infos, int32* count);

        Address         buffer;
};

// WriteToIORequestReply
class WriteToIORequestReply : public ReplyRequest {
public:
        WriteToIORequestReply() : ReplyRequest(WRITE_TO_IO_REQUEST_REPLY) {}
};

// NotifyIORequestRequest
class NotifyIORequestRequest : public IORequestRequest {
public:
        NotifyIORequestRequest() : IORequestRequest(NOTIFY_IO_REQUEST_REQUEST) {}

        enum { MAX_VECS = 8 };

        status_t        status;
};

// NotifyIORequestReply
class NotifyIORequestReply : public ReplyRequest {
public:
        NotifyIORequestReply() : ReplyRequest(NOTIFY_IO_REQUEST_REPLY) {}
};


// #pragma mark - node monitoring


// AddNodeListenerRequest
class AddNodeListenerRequest : public Request {
public:
        AddNodeListenerRequest() : Request(ADD_NODE_LISTENER_REQUEST) {}

        dev_t           device;
        ino_t           node;
        uint32          flags;
        void*           listener;
};

// AddNodeListenerReply
class AddNodeListenerReply : public ReplyRequest {
public:
        AddNodeListenerReply() : ReplyRequest(ADD_NODE_LISTENER_REPLY) {}
};

// RemoveNodeListenerRequest
class RemoveNodeListenerRequest : public Request {
public:
        RemoveNodeListenerRequest() : Request(REMOVE_NODE_LISTENER_REQUEST) {}

        dev_t           device;
        ino_t           node;
        void*           listener;
};

// RemoveNodeListenerReply
class RemoveNodeListenerReply : public ReplyRequest {
public:
        RemoveNodeListenerReply() : ReplyRequest(REMOVE_NODE_LISTENER_REPLY) {}
};


//////////////////
// General Reply

// ReceiptAckReply
class ReceiptAckReply : public ReplyRequest {
public:
        ReceiptAckReply() : ReplyRequest(RECEIPT_ACK_REPLY) {}
};


///////////////////
// Request Checks

// do_for_request
template<class Task>
static
status_t
do_for_request(Request* request, Task& task)
{
        if (!request)
                return B_BAD_VALUE;
        switch (request->GetType()) {
                // kernel -> userland requests
                // administrative
                case UFS_DISCONNECT_REQUEST:
                        return task((UFSDisconnectRequest*)request);
                case FS_CONNECT_REQUEST:
                        return task((FSConnectRequest*)request);
                case FS_CONNECT_REPLY:
                        return task((FSConnectReply*)request);
                // FS
                case MOUNT_VOLUME_REQUEST:
                        return task((MountVolumeRequest*)request);
                case MOUNT_VOLUME_REPLY:
                        return task((MountVolumeReply*)request);
                case UNMOUNT_VOLUME_REQUEST:
                        return task((UnmountVolumeRequest*)request);
                case UNMOUNT_VOLUME_REPLY:
                        return task((UnmountVolumeReply*)request);
//              case INITIALIZE_VOLUME_REQUEST:
//                      return task((InitializeVolumeRequest*)request);
//              case INITIALIZE_VOLUME_REPLY:
//                      return task((InitializeVolumeReply*)request);
                case SYNC_VOLUME_REQUEST:
                        return task((SyncVolumeRequest*)request);
                case SYNC_VOLUME_REPLY:
                        return task((SyncVolumeReply*)request);
                case READ_FS_INFO_REQUEST:
                        return task((ReadFSInfoRequest*)request);
                case READ_FS_INFO_REPLY:
                        return task((ReadFSInfoReply*)request);
                case WRITE_FS_INFO_REQUEST:
                        return task((WriteFSInfoRequest*)request);
                case WRITE_FS_INFO_REPLY:
                        return task((WriteFSInfoReply*)request);
                // vnodes
                case LOOKUP_REQUEST:
                        return task((LookupRequest*)request);
                case LOOKUP_REPLY:
                        return task((LookupReply*)request);
                case GET_VNODE_NAME_REQUEST:
                        return task((GetVNodeNameRequest*)request);
                case GET_VNODE_NAME_REPLY:
                        return task((GetVNodeNameReply*)request);
                case READ_VNODE_REQUEST:
                        return task((ReadVNodeRequest*)request);
                case READ_VNODE_REPLY:
                        return task((ReadVNodeReply*)request);
                case WRITE_VNODE_REQUEST:
                        return task((WriteVNodeRequest*)request);
                case WRITE_VNODE_REPLY:
                        return task((WriteVNodeReply*)request);
                case FS_REMOVE_VNODE_REQUEST:
                        return task((FSRemoveVNodeRequest*)request);
                case FS_REMOVE_VNODE_REPLY:
                        return task((FSRemoveVNodeReply*)request);
                // asynchronous I/O
                case DO_IO_REQUEST:
                        return task((DoIORequest*)request);
                case DO_IO_REPLY:
                        return task((DoIOReply*)request);
                case CANCEL_IO_REQUEST:
                        return task((CancelIORequest*)request);
                case CANCEL_IO_REPLY:
                        return task((CancelIOReply*)request);
                case ITERATIVE_IO_GET_VECS_REQUEST:
                        return task((IterativeIOGetVecsRequest*)request);
                case ITERATIVE_IO_GET_VECS_REPLY:
                        return task((IterativeIOGetVecsReply*)request);
                case ITERATIVE_IO_FINISHED_REQUEST:
                        return task((IterativeIOFinishedRequest*)request);
                case ITERATIVE_IO_FINISHED_REPLY:
                        return task((IterativeIOFinishedReply*)request);
                // nodes
                case IOCTL_REQUEST:
                        return task((IOCtlRequest*)request);
                case IOCTL_REPLY:
                        return task((IOCtlReply*)request);
                case SET_FLAGS_REQUEST:
                        return task((SetFlagsRequest*)request);
                case SET_FLAGS_REPLY:
                        return task((SetFlagsReply*)request);
                case SELECT_REQUEST:
                        return task((SelectRequest*)request);
                case SELECT_REPLY:
                        return task((SelectReply*)request);
                case DESELECT_REQUEST:
                        return task((DeselectRequest*)request);
                case DESELECT_REPLY:
                        return task((DeselectReply*)request);
                case FSYNC_REQUEST:
                        return task((FSyncRequest*)request);
                case FSYNC_REPLY:
                        return task((FSyncReply*)request);
                case READ_SYMLINK_REQUEST:
                        return task((ReadSymlinkRequest*)request);
                case READ_SYMLINK_REPLY:
                        return task((ReadSymlinkReply*)request);
                case CREATE_SYMLINK_REQUEST:
                        return task((CreateSymlinkRequest*)request);
                case CREATE_SYMLINK_REPLY:
                        return task((CreateSymlinkReply*)request);
                case LINK_REQUEST:
                        return task((LinkRequest*)request);
                case LINK_REPLY:
                        return task((LinkReply*)request);
                case UNLINK_REQUEST:
                        return task((UnlinkRequest*)request);
                case UNLINK_REPLY:
                        return task((UnlinkReply*)request);
                case RENAME_REQUEST:
                        return task((RenameRequest*)request);
                case RENAME_REPLY:
                        return task((RenameReply*)request);
                case ACCESS_REQUEST:
                        return task((AccessRequest*)request);
                case ACCESS_REPLY:
                        return task((AccessReply*)request);
                case READ_STAT_REQUEST:
                        return task((ReadStatRequest*)request);
                case READ_STAT_REPLY:
                        return task((ReadStatReply*)request);
                case WRITE_STAT_REQUEST:
                        return task((WriteStatRequest*)request);
                case WRITE_STAT_REPLY:
                        return task((WriteStatReply*)request);
                // files
                case CREATE_REQUEST:
                        return task((CreateRequest*)request);
                case CREATE_REPLY:
                        return task((CreateReply*)request);
                case OPEN_REQUEST:
                        return task((OpenRequest*)request);
                case OPEN_REPLY:
                        return task((OpenReply*)request);
                case CLOSE_REQUEST:
                        return task((CloseRequest*)request);
                case CLOSE_REPLY:
                        return task((CloseReply*)request);
                case FREE_COOKIE_REQUEST:
                        return task((FreeCookieRequest*)request);
                case FREE_COOKIE_REPLY:
                        return task((FreeCookieReply*)request);
                case READ_REQUEST:
                        return task((ReadRequest*)request);
                case READ_REPLY:
                        return task((ReadReply*)request);
                case WRITE_REQUEST:
                        return task((WriteRequest*)request);
                case WRITE_REPLY:
                        return task((WriteReply*)request);
                // directories
                case CREATE_DIR_REQUEST:
                        return task((CreateDirRequest*)request);
                case CREATE_DIR_REPLY:
                        return task((CreateDirReply*)request);
                case REMOVE_DIR_REQUEST:
                        return task((RemoveDirRequest*)request);
                case REMOVE_DIR_REPLY:
                        return task((RemoveDirReply*)request);
                case OPEN_DIR_REQUEST:
                        return task((OpenDirRequest*)request);
                case OPEN_DIR_REPLY:
                        return task((OpenDirReply*)request);
                case CLOSE_DIR_REQUEST:
                        return task((CloseDirRequest*)request);
                case CLOSE_DIR_REPLY:
                        return task((CloseDirReply*)request);
                case FREE_DIR_COOKIE_REQUEST:
                        return task((FreeDirCookieRequest*)request);
                case FREE_DIR_COOKIE_REPLY:
                        return task((FreeDirCookieReply*)request);
                case READ_DIR_REQUEST:
                        return task((ReadDirRequest*)request);
                case READ_DIR_REPLY:
                        return task((ReadDirReply*)request);
                case REWIND_DIR_REQUEST:
                        return task((RewindDirRequest*)request);
                case REWIND_DIR_REPLY:
                        return task((RewindDirReply*)request);
                // attribute directories
                case OPEN_ATTR_DIR_REQUEST:
                        return task((OpenAttrDirRequest*)request);
                case OPEN_ATTR_DIR_REPLY:
                        return task((OpenAttrDirReply*)request);
                case CLOSE_ATTR_DIR_REQUEST:
                        return task((CloseAttrDirRequest*)request);
                case CLOSE_ATTR_DIR_REPLY:
                        return task((CloseAttrDirReply*)request);
                case FREE_ATTR_DIR_COOKIE_REQUEST:
                        return task((FreeAttrDirCookieRequest*)request);
                case FREE_ATTR_DIR_COOKIE_REPLY:
                        return task((FreeAttrDirCookieReply*)request);
                case READ_ATTR_DIR_REQUEST:
                        return task((ReadAttrDirRequest*)request);
                case READ_ATTR_DIR_REPLY:
                        return task((ReadAttrDirReply*)request);
                case REWIND_ATTR_DIR_REQUEST:
                        return task((RewindAttrDirRequest*)request);
                case REWIND_ATTR_DIR_REPLY:
                        return task((RewindAttrDirReply*)request);
                // attributes
                case CREATE_ATTR_REQUEST:
                        return task((CreateAttrRequest*)request);
                case CREATE_ATTR_REPLY:
                        return task((CreateAttrReply*)request);
                case OPEN_ATTR_REQUEST:
                        return task((OpenAttrRequest*)request);
                case OPEN_ATTR_REPLY:
                        return task((OpenAttrReply*)request);
                case CLOSE_ATTR_REQUEST:
                        return task((CloseAttrRequest*)request);
                case CLOSE_ATTR_REPLY:
                        return task((CloseAttrReply*)request);
                case FREE_ATTR_COOKIE_REQUEST:
                        return task((FreeAttrCookieRequest*)request);
                case FREE_ATTR_COOKIE_REPLY:
                        return task((FreeAttrCookieReply*)request);
                case READ_ATTR_REQUEST:
                        return task((ReadAttrRequest*)request);
                case READ_ATTR_REPLY:
                        return task((ReadAttrReply*)request);
                case WRITE_ATTR_REQUEST:
                        return task((WriteAttrRequest*)request);
                case WRITE_ATTR_REPLY:
                        return task((WriteAttrReply*)request);
                case READ_ATTR_STAT_REQUEST:
                        return task((ReadAttrStatRequest*)request);
                case READ_ATTR_STAT_REPLY:
                        return task((ReadAttrStatReply*)request);
                case WRITE_ATTR_STAT_REQUEST:
                        return task((WriteAttrStatRequest*)request);
                case WRITE_ATTR_STAT_REPLY:
                        return task((WriteAttrStatReply*)request);
                case RENAME_ATTR_REQUEST:
                        return task((RenameAttrRequest*)request);
                case RENAME_ATTR_REPLY:
                        return task((RenameAttrReply*)request);
                case REMOVE_ATTR_REQUEST:
                        return task((RemoveAttrRequest*)request);
                case REMOVE_ATTR_REPLY:
                        return task((RemoveAttrReply*)request);
                // indices
                case OPEN_INDEX_DIR_REQUEST:
                        return task((OpenIndexDirRequest*)request);
                case OPEN_INDEX_DIR_REPLY:
                        return task((OpenIndexDirReply*)request);
                case CLOSE_INDEX_DIR_REQUEST:
                        return task((CloseIndexDirRequest*)request);
                case CLOSE_INDEX_DIR_REPLY:
                        return task((CloseIndexDirReply*)request);
                case FREE_INDEX_DIR_COOKIE_REQUEST:
                        return task((FreeIndexDirCookieRequest*)request);
                case FREE_INDEX_DIR_COOKIE_REPLY:
                        return task((FreeIndexDirCookieReply*)request);
                case READ_INDEX_DIR_REQUEST:
                        return task((ReadIndexDirRequest*)request);
                case READ_INDEX_DIR_REPLY:
                        return task((ReadIndexDirReply*)request);
                case REWIND_INDEX_DIR_REQUEST:
                        return task((RewindIndexDirRequest*)request);
                case REWIND_INDEX_DIR_REPLY:
                        return task((RewindIndexDirReply*)request);
                case CREATE_INDEX_REQUEST:
                        return task((CreateIndexRequest*)request);
                case CREATE_INDEX_REPLY:
                        return task((CreateIndexReply*)request);
                case REMOVE_INDEX_REQUEST:
                        return task((RemoveIndexRequest*)request);
                case REMOVE_INDEX_REPLY:
                        return task((RemoveIndexReply*)request);
                case READ_INDEX_STAT_REQUEST:
                        return task((ReadIndexStatRequest*)request);
                case READ_INDEX_STAT_REPLY:
                        return task((ReadIndexStatReply*)request);
                // queries
                case OPEN_QUERY_REQUEST:
                        return task((OpenQueryRequest*)request);
                case OPEN_QUERY_REPLY:
                        return task((OpenQueryReply*)request);
                case CLOSE_QUERY_REQUEST:
                        return task((CloseQueryRequest*)request);
                case CLOSE_QUERY_REPLY:
                        return task((CloseQueryReply*)request);
                case FREE_QUERY_COOKIE_REQUEST:
                        return task((FreeQueryCookieRequest*)request);
                case FREE_QUERY_COOKIE_REPLY:
                        return task((FreeQueryCookieReply*)request);
                case READ_QUERY_REQUEST:
                        return task((ReadQueryRequest*)request);
                case READ_QUERY_REPLY:
                        return task((ReadQueryReply*)request);
                case REWIND_QUERY_REQUEST:
                        return task((RewindQueryRequest*)request);
                case REWIND_QUERY_REPLY:
                        return task((RewindQueryReply*)request);
                // node monitoring
                case NODE_MONITORING_EVENT_REQUEST:
                        return task((NodeMonitoringEventRequest*)request);
                case NODE_MONITORING_EVENT_REPLY:
                        return task((NodeMonitoringEventReply*)request);

                // userland -> kernel requests
                // notifications
                case NOTIFY_LISTENER_REQUEST:
                        return task((NotifyListenerRequest*)request);
                case NOTIFY_LISTENER_REPLY:
                        return task((NotifyListenerReply*)request);
                case NOTIFY_SELECT_EVENT_REQUEST:
                        return task((NotifySelectEventRequest*)request);
                case NOTIFY_SELECT_EVENT_REPLY:
                        return task((NotifySelectEventReply*)request);
                case NOTIFY_QUERY_REQUEST:
                        return task((NotifyQueryRequest*)request);
                case NOTIFY_QUERY_REPLY:
                        return task((NotifyQueryReply*)request);
                // vnodes
                case GET_VNODE_REQUEST:
                        return task((GetVNodeRequest*)request);
                case GET_VNODE_REPLY:
                        return task((GetVNodeReply*)request);
                case PUT_VNODE_REQUEST:
                        return task((PutVNodeRequest*)request);
                case PUT_VNODE_REPLY:
                        return task((PutVNodeReply*)request);
                case ACQUIRE_VNODE_REQUEST:
                        return task((PutVNodeRequest*)request);
                case ACQUIRE_VNODE_REPLY:
                        return task((AcquireVNodeReply*)request);
                case NEW_VNODE_REQUEST:
                        return task((NewVNodeRequest*)request);
                case NEW_VNODE_REPLY:
                        return task((NewVNodeReply*)request);
                case PUBLISH_VNODE_REQUEST:
                        return task((PublishVNodeRequest*)request);
                case PUBLISH_VNODE_REPLY:
                        return task((PublishVNodeReply*)request);
                case REMOVE_VNODE_REQUEST:
                        return task((RemoveVNodeRequest*)request);
                case REMOVE_VNODE_REPLY:
                        return task((RemoveVNodeReply*)request);
                case UNREMOVE_VNODE_REQUEST:
                        return task((UnremoveVNodeRequest*)request);
                case UNREMOVE_VNODE_REPLY:
                        return task((UnremoveVNodeReply*)request);
                case GET_VNODE_REMOVED_REQUEST:
                        return task((GetVNodeRemovedRequest*)request);
                case GET_VNODE_REMOVED_REPLY:
                        return task((GetVNodeRemovedReply*)request);
                // file cache
                case FILE_CACHE_CREATE_REQUEST:
                        return task((FileCacheCreateRequest*)request);
                case FILE_CACHE_CREATE_REPLY:
                        return task((FileCacheCreateReply*)request);
                case FILE_CACHE_DELETE_REQUEST:
                        return task((FileCacheDeleteRequest*)request);
                case FILE_CACHE_DELETE_REPLY:
                        return task((FileCacheDeleteReply*)request);
                case FILE_CACHE_SET_ENABLED_REQUEST:
                        return task((FileCacheSetEnabledRequest*)request);
                case FILE_CACHE_SET_ENABLED_REPLY:
                        return task((FileCacheSetEnabledReply*)request);
                case FILE_CACHE_SET_SIZE_REQUEST:
                        return task((FileCacheSetSizeRequest*)request);
                case FILE_CACHE_SET_SIZE_REPLY:
                        return task((FileCacheSetSizeReply*)request);
                case FILE_CACHE_SYNC_REQUEST:
                        return task((FileCacheSyncRequest*)request);
                case FILE_CACHE_SYNC_REPLY:
                        return task((FileCacheSyncReply*)request);
                case FILE_CACHE_READ_REQUEST:
                        return task((FileCacheReadRequest*)request);
                case FILE_CACHE_READ_REPLY:
                        return task((FileCacheReadReply*)request);
                case FILE_CACHE_WRITE_REQUEST:
                        return task((FileCacheWriteRequest*)request);
                case FILE_CACHE_WRITE_REPLY:
                        return task((FileCacheWriteReply*)request);
                // I/O
                case DO_ITERATIVE_FD_IO_REQUEST:
                        return task((DoIterativeFDIORequest*)request);
                case DO_ITERATIVE_FD_IO_REPLY:
                        return task((DoIterativeFDIOReply*)request);
                case READ_FROM_IO_REQUEST_REQUEST:
                        return task((ReadFromIORequestRequest*)request);
                case READ_FROM_IO_REQUEST_REPLY:
                        return task((ReadFromIORequestReply*)request);
                case WRITE_TO_IO_REQUEST_REQUEST:
                        return task((WriteToIORequestRequest*)request);
                case WRITE_TO_IO_REQUEST_REPLY:
                        return task((WriteToIORequestReply*)request);
                case NOTIFY_IO_REQUEST_REQUEST:
                        return task((NotifyIORequestRequest*)request);
                case NOTIFY_IO_REQUEST_REPLY:
                        return task((NotifyIORequestReply*)request);
                // node monitoring
                case ADD_NODE_LISTENER_REQUEST:
                        return task((AddNodeListenerRequest*)request);
                case ADD_NODE_LISTENER_REPLY:
                        return task((AddNodeListenerReply*)request);
                case REMOVE_NODE_LISTENER_REQUEST:
                        return task((RemoveNodeListenerRequest*)request);
                case REMOVE_NODE_LISTENER_REPLY:
                        return task((RemoveNodeListenerReply*)request);
                // general reply
                case RECEIPT_ACK_REPLY:
                        return task((ReceiptAckReply*)request);
                default:
                        return B_BAD_DATA;
        }
}

status_t get_request_address_infos(Request* request, AddressInfo* infos,
        int32* count);
status_t check_request(Request* request);
status_t relocate_request(Request* request, int32 requestBufferSize,
        area_id* areas, int32* count);

}       // namespace UserlandFSUtil

using UserlandFSUtil::ReplyRequest;
using UserlandFSUtil::KernelRequest;
using UserlandFSUtil::VolumeRequest;
using UserlandFSUtil::NodeRequest;
using UserlandFSUtil::FileRequest;
using UserlandFSUtil::DirRequest;
using UserlandFSUtil::AttrDirRequest;
using UserlandFSUtil::IndexDirRequest;

// kernel -> userland requests
// administrative
using UserlandFSUtil::UFSDisconnectRequest;
using UserlandFSUtil::FSConnectRequest;
using UserlandFSUtil::FSConnectReply;
// FS
using UserlandFSUtil::MountVolumeRequest;
using UserlandFSUtil::MountVolumeReply;
using UserlandFSUtil::UnmountVolumeRequest;
using UserlandFSUtil::UnmountVolumeReply;
//using UserlandFSUtil::InitializeVolumeRequest;
//using UserlandFSUtil::InitializeVolumeReply;
using UserlandFSUtil::SyncVolumeRequest;
using UserlandFSUtil::SyncVolumeReply;
using UserlandFSUtil::ReadFSInfoRequest;
using UserlandFSUtil::ReadFSInfoReply;
using UserlandFSUtil::WriteFSInfoRequest;
using UserlandFSUtil::WriteFSInfoReply;
// vnodes
using UserlandFSUtil::LookupRequest;
using UserlandFSUtil::LookupReply;
using UserlandFSUtil::GetVNodeNameRequest;
using UserlandFSUtil::GetVNodeNameReply;
using UserlandFSUtil::ReadVNodeRequest;
using UserlandFSUtil::ReadVNodeReply;
using UserlandFSUtil::WriteVNodeRequest;
using UserlandFSUtil::WriteVNodeReply;
using UserlandFSUtil::FSRemoveVNodeRequest;
using UserlandFSUtil::FSRemoveVNodeReply;
// asynchronous I/O
using UserlandFSUtil::DoIORequest;
using UserlandFSUtil::DoIOReply;
using UserlandFSUtil::CancelIORequest;
using UserlandFSUtil::CancelIOReply;
using UserlandFSUtil::IterativeIOGetVecsRequest;
using UserlandFSUtil::IterativeIOGetVecsReply;
using UserlandFSUtil::IterativeIOFinishedRequest;
using UserlandFSUtil::IterativeIOFinishedReply;
// nodes
using UserlandFSUtil::IOCtlRequest;
using UserlandFSUtil::IOCtlReply;
using UserlandFSUtil::SetFlagsRequest;
using UserlandFSUtil::SetFlagsReply;
using UserlandFSUtil::SelectRequest;
using UserlandFSUtil::SelectReply;
using UserlandFSUtil::DeselectRequest;
using UserlandFSUtil::DeselectReply;
using UserlandFSUtil::FSyncRequest;
using UserlandFSUtil::FSyncReply;
using UserlandFSUtil::ReadSymlinkRequest;
using UserlandFSUtil::ReadSymlinkReply;
using UserlandFSUtil::CreateSymlinkRequest;
using UserlandFSUtil::CreateSymlinkReply;
using UserlandFSUtil::LinkRequest;
using UserlandFSUtil::LinkReply;
using UserlandFSUtil::UnlinkRequest;
using UserlandFSUtil::UnlinkReply;
using UserlandFSUtil::RenameRequest;
using UserlandFSUtil::RenameReply;
using UserlandFSUtil::AccessRequest;
using UserlandFSUtil::AccessReply;
using UserlandFSUtil::ReadStatRequest;
using UserlandFSUtil::ReadStatReply;
using UserlandFSUtil::WriteStatRequest;
using UserlandFSUtil::WriteStatReply;
// files
using UserlandFSUtil::CreateRequest;
using UserlandFSUtil::CreateReply;
using UserlandFSUtil::OpenRequest;
using UserlandFSUtil::OpenReply;
using UserlandFSUtil::CloseRequest;
using UserlandFSUtil::CloseReply;
using UserlandFSUtil::FreeCookieRequest;
using UserlandFSUtil::FreeCookieReply;
using UserlandFSUtil::ReadRequest;
using UserlandFSUtil::ReadReply;
using UserlandFSUtil::WriteRequest;
using UserlandFSUtil::WriteReply;
// directories
using UserlandFSUtil::CreateDirRequest;
using UserlandFSUtil::CreateDirReply;
using UserlandFSUtil::RemoveDirRequest;
using UserlandFSUtil::RemoveDirReply;
using UserlandFSUtil::OpenDirRequest;
using UserlandFSUtil::OpenDirReply;
using UserlandFSUtil::CloseDirRequest;
using UserlandFSUtil::CloseDirReply;
using UserlandFSUtil::FreeDirCookieRequest;
using UserlandFSUtil::FreeDirCookieReply;
using UserlandFSUtil::ReadDirRequest;
using UserlandFSUtil::ReadDirReply;
using UserlandFSUtil::RewindDirRequest;
using UserlandFSUtil::RewindDirReply;
// attribute directories
using UserlandFSUtil::OpenAttrDirRequest;
using UserlandFSUtil::OpenAttrDirReply;
using UserlandFSUtil::CloseAttrDirRequest;
using UserlandFSUtil::CloseAttrDirReply;
using UserlandFSUtil::FreeAttrDirCookieRequest;
using UserlandFSUtil::FreeAttrDirCookieReply;
using UserlandFSUtil::ReadAttrDirRequest;
using UserlandFSUtil::ReadAttrDirReply;
using UserlandFSUtil::RewindAttrDirRequest;
using UserlandFSUtil::RewindAttrDirReply;
// attributes
using UserlandFSUtil::CreateAttrRequest;
using UserlandFSUtil::CreateAttrReply;
using UserlandFSUtil::OpenAttrRequest;
using UserlandFSUtil::OpenAttrReply;
using UserlandFSUtil::CloseAttrRequest;
using UserlandFSUtil::CloseAttrReply;
using UserlandFSUtil::FreeAttrCookieRequest;
using UserlandFSUtil::FreeAttrCookieReply;
using UserlandFSUtil::ReadAttrRequest;
using UserlandFSUtil::ReadAttrReply;
using UserlandFSUtil::WriteAttrRequest;
using UserlandFSUtil::WriteAttrReply;
using UserlandFSUtil::ReadAttrStatRequest;
using UserlandFSUtil::ReadAttrStatReply;
using UserlandFSUtil::WriteAttrStatRequest;
using UserlandFSUtil::WriteAttrStatReply;
using UserlandFSUtil::RenameAttrRequest;
using UserlandFSUtil::RenameAttrReply;
using UserlandFSUtil::RemoveAttrRequest;
using UserlandFSUtil::RemoveAttrReply;
// indices
using UserlandFSUtil::OpenIndexDirRequest;
using UserlandFSUtil::OpenIndexDirReply;
using UserlandFSUtil::CloseIndexDirRequest;
using UserlandFSUtil::CloseIndexDirReply;
using UserlandFSUtil::FreeIndexDirCookieRequest;
using UserlandFSUtil::FreeIndexDirCookieReply;
using UserlandFSUtil::ReadIndexDirRequest;
using UserlandFSUtil::ReadIndexDirReply;
using UserlandFSUtil::RewindIndexDirRequest;
using UserlandFSUtil::RewindIndexDirReply;
using UserlandFSUtil::CreateIndexRequest;
using UserlandFSUtil::CreateIndexReply;
using UserlandFSUtil::RemoveIndexRequest;
using UserlandFSUtil::RemoveIndexReply;
using UserlandFSUtil::ReadIndexStatRequest;
using UserlandFSUtil::ReadIndexStatReply;
// queries
using UserlandFSUtil::OpenQueryRequest;
using UserlandFSUtil::OpenQueryReply;
using UserlandFSUtil::CloseQueryRequest;
using UserlandFSUtil::CloseQueryReply;
using UserlandFSUtil::FreeQueryCookieRequest;
using UserlandFSUtil::FreeQueryCookieReply;
using UserlandFSUtil::ReadQueryRequest;
using UserlandFSUtil::ReadQueryReply;
using UserlandFSUtil::RewindQueryRequest;
using UserlandFSUtil::RewindQueryReply;
// node monitoring
using UserlandFSUtil::NodeMonitoringEventRequest;
using UserlandFSUtil::NodeMonitoringEventReply;

// userland -> kernel requests
// notifications
using UserlandFSUtil::NotifyListenerRequest;
using UserlandFSUtil::NotifyListenerReply;
using UserlandFSUtil::NotifySelectEventRequest;
using UserlandFSUtil::NotifySelectEventReply;
using UserlandFSUtil::NotifyQueryRequest;
using UserlandFSUtil::NotifyQueryReply;
// vnodes
using UserlandFSUtil::GetVNodeRequest;
using UserlandFSUtil::GetVNodeReply;
using UserlandFSUtil::PutVNodeRequest;
using UserlandFSUtil::PutVNodeReply;
using UserlandFSUtil::AcquireVNodeRequest;
using UserlandFSUtil::AcquireVNodeReply;
using UserlandFSUtil::NewVNodeRequest;
using UserlandFSUtil::NewVNodeReply;
using UserlandFSUtil::PublishVNodeRequest;
using UserlandFSUtil::PublishVNodeReply;
using UserlandFSUtil::RemoveVNodeRequest;
using UserlandFSUtil::RemoveVNodeReply;
using UserlandFSUtil::UnremoveVNodeRequest;
using UserlandFSUtil::UnremoveVNodeReply;
using UserlandFSUtil::GetVNodeRemovedRequest;
using UserlandFSUtil::GetVNodeRemovedReply;
// file cache
using UserlandFSUtil::FileCacheCreateRequest;
using UserlandFSUtil::FileCacheCreateReply;
using UserlandFSUtil::FileCacheDeleteRequest;
using UserlandFSUtil::FileCacheDeleteReply;
using UserlandFSUtil::FileCacheSetEnabledRequest;
using UserlandFSUtil::FileCacheSetEnabledReply;
using UserlandFSUtil::FileCacheSetSizeRequest;
using UserlandFSUtil::FileCacheSetSizeReply;
using UserlandFSUtil::FileCacheSyncRequest;
using UserlandFSUtil::FileCacheSyncReply;
using UserlandFSUtil::FileCacheReadRequest;
using UserlandFSUtil::FileCacheReadReply;
using UserlandFSUtil::FileCacheWriteRequest;
using UserlandFSUtil::FileCacheWriteReply;
// I/O
using UserlandFSUtil::DoIterativeFDIORequest;
using UserlandFSUtil::DoIterativeFDIOReply;
using UserlandFSUtil::ReadFromIORequestRequest;
using UserlandFSUtil::ReadFromIORequestReply;
using UserlandFSUtil::WriteToIORequestRequest;
using UserlandFSUtil::WriteToIORequestReply;
using UserlandFSUtil::NotifyIORequestRequest;
using UserlandFSUtil::NotifyIORequestReply;
                // node monitoring
using UserlandFSUtil::AddNodeListenerRequest;
using UserlandFSUtil::AddNodeListenerReply;
using UserlandFSUtil::RemoveNodeListenerRequest;
using UserlandFSUtil::RemoveNodeListenerReply;
// general reply
using UserlandFSUtil::ReceiptAckReply;

using UserlandFSUtil::do_for_request;
using UserlandFSUtil::get_request_address_infos;
using UserlandFSUtil::check_request;
using UserlandFSUtil::relocate_request;

#endif  // USERLAND_FS_REQUESTS_H