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

#include "Volume.h"

#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <sys/stat.h>

#include <algorithm>

#include <fs_cache.h>

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

#include <fs/fd.h>      // kernel private
#include <io_requests.h>
#include <thread.h>

#include "IORequest.h"  // kernel internal

#include "Compatibility.h"
#include "Debug.h"
#include "FileSystem.h"
#include "IOCtlInfo.h"
#include "kernel_interface.h"
#include "KernelRequestHandler.h"
#include "PortReleaser.h"
#include "RequestAllocator.h"
#include "RequestPort.h"
#include "Requests.h"
#include "userlandfs_ioctl.h"

// missing ioctl()s
// TODO: Place somewhere else.
#define         IOCTL_FILE_UNCACHED_IO  10000
#define         IOCTL_CREATE_TIME               10002
#define         IOCTL_MODIFIED_TIME             10003

// If a thread of the userland server enters userland FS kernel code and
// is sending a request, this is the time after which it shall time out
// waiting for a reply.
static const bigtime_t kUserlandServerlandPortTimeout = 10000000;       // 10s


// VNode
struct Volume::VNode {
        ino_t           id;
        void*           clientNode;
        void*           fileCache;
        VNodeOps*       ops;
        int32           useCount;
        bool            valid;
        bool            published;
        VNode*          hash_link;

        VNode(ino_t id, void* clientNode, VNodeOps* ops)
                :
                id(id),
                clientNode(clientNode),
                fileCache(NULL),
                ops(ops),
                useCount(0),
                valid(true),
                published(true)
        {
        }

        void Delete(Volume* volume)
        {
                if (ops != NULL)
                        volume->GetFileSystem()->PutVNodeOps(ops);
                delete this;
        }

protected:      // should be private, but gcc 2.95.3 issues a warning
        ~VNode()
        {
                if (fileCache != NULL) {
                        ERROR(("VNode %" B_PRId64 " still has a file cache!\n", id));
                        file_cache_delete(fileCache);
                }
        }
};


// VNodeHashDefinition
struct Volume::VNodeHashDefinition {
        typedef ino_t   KeyType;
        typedef VNode   ValueType;

        size_t HashKey(ino_t key) const
                { return (uint32)key ^ (uint32)(key >> 32); }
        size_t Hash(const VNode* value) const
                { return HashKey(value->id); }
        bool Compare(ino_t key, const VNode* value) const
                { return value->id == key; }
        VNode*& GetLink(VNode* value) const
                { return value->hash_link; }
};


// VNodeMap
struct Volume::VNodeMap
        : public BOpenHashTable<VNodeHashDefinition> {
};


// IORequestInfo
struct Volume::IORequestInfo {
        io_request*                                             request;
        int32                                                   id;

        IORequestInfo*                                  idLink;
        IORequestInfo*                                  structLink;

        IORequestInfo(io_request* request, int32 id)
                :
                request(request),
                id(id)
        {
        }
};


// IORequestIDHashDefinition
struct Volume::IORequestIDHashDefinition {
        typedef int32                   KeyType;
        typedef IORequestInfo   ValueType;

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


// IORequestStructHashDefinition
struct Volume::IORequestStructHashDefinition {
        typedef io_request*             KeyType;
        typedef IORequestInfo   ValueType;

        size_t HashKey(io_request* key) const
                { return (size_t)(addr_t)key; }
        size_t Hash(const IORequestInfo* value) const
                { return HashKey(value->request); }
        bool Compare(io_request* key, const IORequestInfo* value) const
                { return value->request == key; }
        IORequestInfo*& GetLink(IORequestInfo* value) const
                { return value->structLink; }
};


// IORequestIDMap
struct Volume::IORequestIDMap
        : public BOpenHashTable<IORequestIDHashDefinition> {
};


// IORequestStructMap
struct Volume::IORequestStructMap
        : public BOpenHashTable<IORequestStructHashDefinition> {
};


// IterativeFDIOCookie
struct Volume::IterativeFDIOCookie : public BReferenceable {
        Volume*                         volume;
        int                                     fd;
        int32                           requestID;
        void*                           clientCookie;
        off_t                           offset;
        const file_io_vec*      vecs;
        uint32                          vecCount;

        IterativeFDIOCookie(Volume* volume, int fd, int32 requestID,
                void* clientCookie, off_t offset, const file_io_vec* vecs,
                uint32 vecCount)
                :
                volume(volume),
                fd(fd),
                requestID(requestID),
                clientCookie(clientCookie),
                offset(offset),
                vecs(vecs),
                vecCount(vecCount)
        {
        }

        ~IterativeFDIOCookie()
        {
                if (fd >= 0)
                        close(fd);
        }
};


// AutoIncrementer
class Volume::AutoIncrementer {
public:
        AutoIncrementer(int32* variable)
                : fVariable(variable)
        {
                if (fVariable)
                        atomic_add(fVariable, 1);
        }

        ~AutoIncrementer()
        {
                if (fVariable)
                        atomic_add(fVariable, -1);
        }

        void Keep()
        {
                fVariable = NULL;
        }

private:
        int32*  fVariable;
};


// IORequestRemover
class Volume::IORequestRemover {
public:
        IORequestRemover(Volume* volume, int32 requestID)
                :
                fVolume(volume),
                fRequestID(requestID)
        {
        }

        ~IORequestRemover()
        {
                if (fVolume != NULL)
                        fVolume->_UnregisterIORequest(fRequestID);
        }

        void Detach()
        {
                fVolume = NULL;
        }

private:
        Volume* fVolume;
        int32   fRequestID;
};


// VNodeRemover
class Volume::VNodeRemover {
public:
        VNodeRemover(Volume* volume, VNode* node)
                :
                fVolume(volume),
                fNode(node)
        {
        }

        ~VNodeRemover()
        {
                if (fNode != NULL) {
                        MutexLocker locker(fVolume->fLock);
                        fVolume->fVNodes->Remove(fNode);
                        locker.Unlock();

                        fNode->Delete(fVolume);
                }
        }

private:
        Volume* fVolume;
        VNode*  fNode;
};


// HasVNodeCapability
inline bool
Volume::HasVNodeCapability(VNode* vnode, int capability) const
{
        return vnode->ops->capabilities.Get(capability);
}


// constructor
Volume::Volume(FileSystem* fileSystem, fs_volume* fsVolume)
        :
        BReferenceable(),
        fFileSystem(fileSystem),
        fFSVolume(fsVolume),
        fUserlandVolume(NULL),
        fRootID(0),
        fRootNode(NULL),
        fOpenFiles(0),
        fOpenDirectories(0),
        fOpenAttributeDirectories(0),
        fOpenAttributes(0),
        fOpenIndexDirectories(0),
        fOpenQueries(0),
        fVNodes(NULL),
        fIORequestInfosByID(NULL),
        fIORequestInfosByStruct(NULL),
        fLastIORequestID(0),
        fVNodeCountingEnabled(false)
{
        mutex_init(&fLock, "userlandfs volume");
}


// destructor
Volume::~Volume()
{
        mutex_destroy(&fLock);

        delete fIORequestInfosByID;
        delete fIORequestInfosByStruct;
        delete fVNodes;
}


// #pragma mark - client methods

// GetVNode
status_t
Volume::GetVNode(ino_t vnid, void** _node)
{
        PRINT(("get_vnode(%" B_PRId32 ", %" B_PRId64 ")\n", GetID(), vnid));
        void* vnode;
        status_t error = get_vnode(fFSVolume, vnid, &vnode);
        if (error == B_OK) {
                _IncrementVNodeCount(vnid);
                *_node = ((VNode*)vnode)->clientNode;
        }

        return error;
}

// PutVNode
status_t
Volume::PutVNode(ino_t vnid)
{
        PRINT(("put_vnode(%" B_PRId32 ", %" B_PRId64 ")\n", GetID(), vnid));
        // Decrement the count first. We might not have another chance, since
        // put_vnode() could put the last reference, thus causing the node to be
        // removed from our map. This is all not very dramatic, but this way we
        // avoid an erroneous error message from _DecrementVNodeCount().
        _DecrementVNodeCount(vnid);

        return put_vnode(fFSVolume, vnid);
}


// AcquireVNode
status_t
Volume::AcquireVNode(ino_t vnid)
{
        PRINT(("acquire_vnode(%" B_PRId32 ", %" B_PRId64 ")\n", GetID(), vnid));
        status_t error = acquire_vnode(fFSVolume, vnid);
        if (error == B_OK)
                _IncrementVNodeCount(vnid);
        return error;
}


// NewVNode
status_t
Volume::NewVNode(ino_t vnid, void* clientNode,
        const FSVNodeCapabilities& capabilities)
{
        PRINT(("new_vnode(%" B_PRId32 ", %" B_PRId64 ")\n", GetID(), vnid));
        // lookup the node
        MutexLocker locker(fLock);
        VNode* node = fVNodes->Lookup(vnid);
        if (node != NULL) {
                // The node is already known -- this is an error.
                RETURN_ERROR(B_BAD_VALUE);
        }

        // get the ops vector for the node
        VNodeOps* ops = fFileSystem->GetVNodeOps(capabilities);
        if (ops == NULL)
                RETURN_ERROR(B_NO_MEMORY);

        // create the node
        node = new(std::nothrow) VNode(vnid, clientNode, ops);
        if (node == NULL) {
                fFileSystem->PutVNodeOps(ops);
                RETURN_ERROR(B_NO_MEMORY);
        }

        node->published = false;

        locker.Unlock();

        // tell the VFS
        status_t error = new_vnode(fFSVolume, vnid, node, node->ops->ops);
        if (error != B_OK) {
                node->Delete(this);
                RETURN_ERROR(error);
        }

        // add the node to our map
        locker.Lock();
        fVNodes->Insert(node);

        // Increment its use count. After new_vnode() the caller has a reference,
        // but a subsequent publish_vnode() won't get another one. We handle that
        // there.
        if (fVNodeCountingEnabled)
                node->useCount++;

        return B_OK;
}

// PublishVNode
status_t
Volume::PublishVNode(ino_t vnid, void* clientNode, int type, uint32 flags,
        const FSVNodeCapabilities& capabilities)
{
        PRINT(("publish_vnode(%" B_PRId32 ", %" B_PRId64 ", %p)\n", GetID(), vnid,
                clientNode));

        // lookup the node
        MutexLocker locker(fLock);
        VNode* node = fVNodes->Lookup(vnid);
        bool nodeKnown = node != NULL;

        if (nodeKnown) {
                if (node->published) {
                        WARN(("publish_vnode(): vnode (%" B_PRId32 ", %" B_PRId64
                                ") already published!\n", GetID(), vnid));
                        RETURN_ERROR(B_BAD_VALUE);
                }
        } else if (!nodeKnown) {
                // The node is not yet known -- create it.

                // get the ops vector for the node
                VNodeOps* ops = fFileSystem->GetVNodeOps(capabilities);
                if (ops == NULL)
                        RETURN_ERROR(B_NO_MEMORY);

                // create the node
                node = new(std::nothrow) VNode(vnid, clientNode, ops);
                if (node == NULL) {
                        fFileSystem->PutVNodeOps(ops);
                        RETURN_ERROR(B_NO_MEMORY);
                }
        }

        locker.Unlock();

        // tell the VFS
        status_t error = publish_vnode(fFSVolume, vnid, node, node->ops->ops,
                type, flags);
        if (error != B_OK) {
                if (nodeKnown) {
                        // The node was known, i.e. it had been made known via new_vnode()
                        // and thus already had a use count of 1. Decrement that use count
                        // and remove the node completely.
                        _DecrementVNodeCount(vnid);
                        _RemoveInvalidVNode(vnid);
                } else
                        node->Delete(this);
                RETURN_ERROR(error);
        }

        // add the node to our map, if not known yet
        locker.Lock();
        if (nodeKnown) {
                // The node is now published. Don't increment its use count. It already
                // has 1 from new_vnode() and this publish_vnode() didn't increment it.
                node->published = true;
        } else {
                // New node: increment its use count and add it to the map.
                if (fVNodeCountingEnabled)
                        node->useCount++;
                fVNodes->Insert(node);
        }

        return B_OK;
}

// RemoveVNode
status_t
Volume::RemoveVNode(ino_t vnid)
{
        PRINT(("remove_vnode(%" B_PRId32 ", %" B_PRId64 ")\n", GetID(), vnid));
        return remove_vnode(fFSVolume, vnid);
}

// UnremoveVNode
status_t
Volume::UnremoveVNode(ino_t vnid)
{
        PRINT(("unremove_vnode(%" B_PRId32 ", %" B_PRId64 ")\n", GetID(), vnid));
        return unremove_vnode(fFSVolume, vnid);
}

// GetVNodeRemoved
status_t
Volume::GetVNodeRemoved(ino_t vnid, bool* removed)
{
        PRINT(("get_vnode_removed(%" B_PRId32 ", %" B_PRId64 ", %p)\n", GetID(),
                vnid, removed));
        return get_vnode_removed(fFSVolume, vnid, removed);
}


// CreateFileCache
status_t
Volume::CreateFileCache(ino_t vnodeID, off_t size)
{
        // lookup the node
        MutexLocker locker(fLock);
        VNode* vnode = fVNodes->Lookup(vnodeID);
        if (vnode == NULL)
                RETURN_ERROR(B_BAD_VALUE);

        // does the node already have a file cache?
        if (vnode->fileCache != NULL)
                RETURN_ERROR(B_BAD_VALUE);

        // create the file cache
        locker.Unlock();
        void* fileCache = file_cache_create(GetID(), vnodeID, size);
        locker.Lock();

        // re-check whether the node still lives
        vnode = fVNodes->Lookup(vnodeID);
        if (vnode == NULL) {
                file_cache_delete(fileCache);
                RETURN_ERROR(B_BAD_VALUE);
        }

        vnode->fileCache = fileCache;

        return B_OK;
}


// DeleteFileCache
status_t
Volume::DeleteFileCache(ino_t vnodeID)
{
        // lookup the node
        MutexLocker locker(fLock);
        VNode* vnode = fVNodes->Lookup(vnodeID);
        if (vnode == NULL)
                RETURN_ERROR(B_BAD_VALUE);

        // does the node have a file cache
        if (vnode->fileCache == NULL)
                RETURN_ERROR(B_BAD_VALUE);

        void* fileCache = vnode->fileCache;
        vnode->fileCache = NULL;

        locker.Unlock();

        file_cache_delete(fileCache);

        return B_OK;
}


// SetFileCacheEnabled
status_t
Volume::SetFileCacheEnabled(ino_t vnodeID, bool enabled)
{
        // lookup the node
        MutexLocker locker(fLock);
        VNode* vnode = fVNodes->Lookup(vnodeID);
        if (vnode == NULL)
                RETURN_ERROR(B_BAD_VALUE);

        // does the node have a file cache
        if (vnode->fileCache == NULL)
                RETURN_ERROR(B_BAD_VALUE);

        void* fileCache = vnode->fileCache;
        locker.Unlock();
// TODO: We should use some kind of ref counting to avoid that another thread
// deletes the file cache now that we have dropped the lock. Applies to the
// other file cache operations as well.

        // enable/disable the file cache
        if (enabled) {
                file_cache_enable(fileCache);
                return B_OK;
        }

        return file_cache_disable(fileCache);
}


// SetFileCacheSize
status_t
Volume::SetFileCacheSize(ino_t vnodeID, off_t size)
{
        // lookup the node
        MutexLocker locker(fLock);
        VNode* vnode = fVNodes->Lookup(vnodeID);
        if (vnode == NULL)
                RETURN_ERROR(B_BAD_VALUE);

        // does the node have a file cache
        if (vnode->fileCache == NULL)
                RETURN_ERROR(B_BAD_VALUE);

        void* fileCache = vnode->fileCache;
        locker.Unlock();

        // set the size
        return file_cache_set_size(fileCache, size);
}


// SyncFileCache
status_t
Volume::SyncFileCache(ino_t vnodeID)
{
        // lookup the node
        MutexLocker locker(fLock);
        VNode* vnode = fVNodes->Lookup(vnodeID);
        if (vnode == NULL)
                RETURN_ERROR(B_BAD_VALUE);

        // does the node have a file cache
        if (vnode->fileCache == NULL)
                RETURN_ERROR(B_BAD_VALUE);

        void* fileCache = vnode->fileCache;
        locker.Unlock();

        // sync
        return file_cache_sync(fileCache);
}


// ReadFileCache
status_t
Volume::ReadFileCache(ino_t vnodeID, void* cookie,
        off_t offset, void* buffer, size_t* _size)
{
        // lookup the node
        MutexLocker locker(fLock);
        VNode* vnode = fVNodes->Lookup(vnodeID);
        if (vnode == NULL)
                RETURN_ERROR(B_BAD_VALUE);

        // does the node have a file cache
        if (vnode->fileCache == NULL)
                RETURN_ERROR(B_BAD_VALUE);

        void* fileCache = vnode->fileCache;
        locker.Unlock();

        // read
        return file_cache_read(fileCache, cookie, offset, buffer, _size);
}


// WriteFileCache
status_t
Volume::WriteFileCache(ino_t vnodeID, void* cookie,
        off_t offset, const void* buffer, size_t* _size)
{
        // lookup the node
        MutexLocker locker(fLock);
        VNode* vnode = fVNodes->Lookup(vnodeID);
        if (vnode == NULL)
                RETURN_ERROR(B_BAD_VALUE);

        // does the node have a file cache
        if (vnode->fileCache == NULL)
                RETURN_ERROR(B_BAD_VALUE);

        void* fileCache = vnode->fileCache;
        locker.Unlock();

        // read
        return file_cache_write(fileCache, cookie, offset, buffer, _size);
}


status_t
Volume::ReadFromIORequest(int32 requestID, void* buffer, size_t size)
{
        // get the request
        io_request* request;
        status_t error = _FindIORequest(requestID, &request);
        if (error != B_OK)
                RETURN_ERROR(error);

        return read_from_io_request(request, buffer, size);
}


status_t
Volume::WriteToIORequest(int32 requestID, const void* buffer, size_t size)
{
        // get the request
        io_request* request;
        status_t error = _FindIORequest(requestID, &request);
        if (error != B_OK)
                RETURN_ERROR(error);

        return write_to_io_request(request, buffer, size);
}


// DoIterativeFDIO
status_t
Volume::DoIterativeFDIO(int fd, int32 requestID, void* clientCookie,
        const file_io_vec* vecs, uint32 vecCount)
{
        // get the request
        io_request* request;
        status_t error = _FindIORequest(requestID, &request);
        if (error != B_OK)
                RETURN_ERROR(error);

        // copy the FD into the kernel
        fd = dup_foreign_fd(fFileSystem->GetTeam(), fd, true);
        if (fd < 0)
                RETURN_ERROR(fd);

        // create a cookie
        IterativeFDIOCookie* cookie = new(std::nothrow) IterativeFDIOCookie(
                this, fd, requestID, clientCookie, request->Offset(), vecs, vecCount);
        if (cookie == NULL) {
                close(fd);
                RETURN_ERROR(B_NO_MEMORY);
        }

        // we need another reference, so we can still access the cookie below
        cookie->AcquireReference();

// TODO: Up to this point we're responsible for calling the finished hook on
// error!
        // call the kernel function
        error = do_iterative_fd_io(fd, request, &_IterativeFDIOGetVecs,
                &_IterativeFDIOFinished, cookie);

        // unset the vecs -- they are on the stack an will become invalid when we
        // return
        MutexLocker _(fLock);
        cookie->vecs = NULL;
        cookie->vecCount = 0;
        cookie->ReleaseReference();

        return error;
}


status_t
Volume::NotifyIORequest(int32 requestID, status_t status)
{
        // get the request
        io_request* request;
        status_t error = _FindIORequest(requestID, &request);
        if (error != B_OK)
                RETURN_ERROR(error);

        notify_io_request(request, status);
        return B_OK;
}


// #pragma mark - FS


// Mount
status_t
Volume::Mount(const char* device, uint32 flags, const char* parameters)
{
        // create the maps
        fVNodes = new(std::nothrow) VNodeMap;
        fIORequestInfosByID = new(std::nothrow) IORequestIDMap;
        fIORequestInfosByStruct = new(std::nothrow) IORequestStructMap;

        if (fVNodes == NULL || fIORequestInfosByID == NULL
                || fIORequestInfosByStruct == NULL
                || fVNodes->Init() != B_OK
                || fIORequestInfosByID->Init() != B_OK
                || fIORequestInfosByStruct->Init() != B_OK) {
                return B_NO_MEMORY;
        }

        // enable vnode counting
        fVNodeCountingEnabled = true;

        // init IORequest ID's
        fLastIORequestID = 0;

        // mount
        status_t error = _Mount(device, flags, parameters);
        if (error != B_OK)
                RETURN_ERROR(error);

        MutexLocker locker(fLock);
        // fetch the root node, so that we can serve Walk() requests on it,
        // after the connection to the userland server is gone
        fRootNode = fVNodes->Lookup(fRootID);
        if (fRootNode == NULL) {
                // The root node was not added while mounting. That's a serious
                // problem -- not only because we don't have it, but also because
                // the VFS requires publish_vnode() to be invoked for the root node.
                ERROR(("Volume::Mount(): new_vnode() was not called for root node! "
                        "Unmounting...\n"));
                locker.Unlock();
                Unmount();
                return B_ERROR;
        }

        // Decrement the root node use count. The publish_vnode() the client FS
        // did will be balanced by the VFS.
        if (fVNodeCountingEnabled)
                fRootNode->useCount--;

        // init the volume ops vector we'll give the VFS
        _InitVolumeOps();

        return B_OK;
}

// Unmount
status_t
Volume::Unmount()
{
        status_t error = _Unmount();

        // free the memory associated with the maps
        {
                // vnodes
                MutexLocker _(fLock);
                if (fVNodes != NULL) {
                        VNode* node = fVNodes->Clear(true);
                        while (node != NULL) {
                                VNode* nextNode = node->hash_link;
                                node->Delete(this);
                                node = nextNode;
                        }
                        delete fVNodes;
                        fVNodes = NULL;
                }

                // io request infos
                if (fIORequestInfosByID != NULL) {
                        fIORequestInfosByID->Clear();
                        delete fIORequestInfosByID;
                        fIORequestInfosByID = NULL;
                }

                if (fIORequestInfosByStruct != NULL) {
                        IORequestInfo* info = fIORequestInfosByStruct->Clear(true);
                        while (info != NULL) {
                                IORequestInfo* nextInfo = info->structLink;
                                delete info;
                                // TODO: We should probably also notify the request, if that
                                // hasn't happened yet.
                                info = nextInfo;
                        }
                        delete fIORequestInfosByStruct;
                        fIORequestInfosByStruct = NULL;
                }
        }

        fFileSystem->VolumeUnmounted(this);
        return error;
}

// Sync
status_t
Volume::Sync()
{
        // check capability
        if (!HasCapability(FS_VOLUME_CAPABILITY_SYNC))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        SyncVolumeRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;

        // send the request
        KernelRequestHandler handler(this, SYNC_VOLUME_REPLY);
        SyncVolumeReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// ReadFSInfo
status_t
Volume::ReadFSInfo(fs_info* info)
{
        // When the connection to the userland server is lost, we serve
        // read_fs_info() requests manually.
        status_t error = _ReadFSInfo(info);
        if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) {
                WARN(("Volume::ReadFSInfo(): connection lost, emulating lookup `.'\n"));

                info->flags = B_FS_IS_PERSISTENT | B_FS_IS_READONLY;
                info->block_size = 512;
                info->io_size = 512;
                info->total_blocks = 0;
                info->free_blocks = 0;
                strlcpy(info->volume_name, fFileSystem->GetName(),
                        sizeof(info->volume_name));
                strlcat(info->volume_name, ":disconnected", sizeof(info->volume_name));

                error = B_OK;
        }
        return error;
}

// WriteFSInfo
status_t
Volume::WriteFSInfo(const struct fs_info *info, uint32 mask)
{
        // check capability
        if (!HasCapability(FS_VOLUME_CAPABILITY_WRITE_FS_INFO))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        WriteFSInfoRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->info = *info;
        request->mask = mask;

        // send the request
        KernelRequestHandler handler(this, WRITE_FS_INFO_REPLY);
        WriteFSInfoReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}


// #pragma mark - vnodes


// Lookup
status_t
Volume::Lookup(void* dir, const char* entryName, ino_t* vnid)
{
        // When the connection to the userland server is lost, we serve
        // lookup(fRootNode, `.') requests manually to allow clean unmounting.
        status_t error = _Lookup(dir, entryName, vnid);
        if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()
                && dir == fRootNode && strcmp(entryName, ".") == 0) {
                WARN(("Volume::Lookup(): connection lost, emulating lookup `.'\n"));
                void* entryNode;
                if (GetVNode(fRootID, &entryNode) != B_OK)
                        RETURN_ERROR(B_BAD_VALUE);
                *vnid = fRootID;
                // The VFS will balance the get_vnode() call for the FS.
                _DecrementVNodeCount(*vnid);
                return B_OK;
        }
        return error;
}

// GetVNodeName
status_t
Volume::GetVNodeName(void* _node, char* buffer, size_t bufferSize)
{
        // We don't check the capability -- if not implemented by the client FS,
        // the functionality is emulated in userland.

        VNode* vnode = (VNode*)_node;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        GetVNodeNameRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->size = bufferSize;

        // send the request
        KernelRequestHandler handler(this, GET_VNODE_NAME_REPLY);
        GetVNodeNameReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;

        char* readBuffer = (char*)reply->buffer.GetData();
        size_t nameLen = reply->buffer.GetSize();
        nameLen = strnlen(readBuffer, nameLen);
        if (nameLen <= 0 || nameLen >= bufferSize)
                RETURN_ERROR(B_BAD_DATA);

        memcpy(buffer, readBuffer, nameLen);
        buffer[nameLen] = '\0';

        _SendReceiptAck(port);
        return error;
}

// ReadVNode
status_t
Volume::ReadVNode(ino_t vnid, bool reenter, void** _node, fs_vnode_ops** _ops,
        int* type, uint32* flags)
{
        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        ReadVNodeRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->vnid = vnid;
        request->reenter = reenter;

        // add the uninitialized node to our map
        VNode* vnode = new(std::nothrow) VNode(vnid, NULL, NULL);
        if (vnode == NULL)
                RETURN_ERROR(B_NO_MEMORY);
        vnode->valid = false;

        MutexLocker locker(fLock);
        fVNodes->Insert(vnode);
        locker.Unlock();

        // send the request
        KernelRequestHandler handler(this, READ_VNODE_REPLY);
        ReadVNodeReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK) {
                _RemoveInvalidVNode(vnid);
                return error;
        }
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK) {
                _RemoveInvalidVNode(vnid);
                return reply->error;
        }

        // get the ops vector for the node
        VNodeOps* ops = fFileSystem->GetVNodeOps(reply->capabilities);
        if (ops == NULL) {
                _RemoveInvalidVNode(vnid);
                RETURN_ERROR(B_NO_MEMORY);
        }

        // everything went fine -- mark the node valid
        locker.Lock();
        vnode->clientNode = reply->node;
        vnode->ops = ops;
        vnode->valid = true;

        *_node = vnode;
        *type = reply->type;
        *flags = reply->flags;
        *_ops = ops->ops;
        return B_OK;
}

// WriteVNode
status_t
Volume::WriteVNode(void* node, bool reenter)
{
        status_t error = _WriteVNode(node, reenter);
        if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) {
                // This isn't really necessary, since the VFS basically ignores the
                // return value -- at least Haiku. The fshell panic()s; didn't check
                // BeOS. It doesn't harm to appear to behave nicely. :-)
                WARN(("Volume::WriteVNode(): connection lost, forcing write vnode\n"));
                return B_OK;
        }
        return error;
}

// RemoveVNode
status_t
Volume::RemoveVNode(void* _node, bool reenter)
{
        VNode* vnode = (VNode*)_node;

        // At any rate remove the vnode from our map and delete it. We don't do that
        // right now, though, since we might still need to serve file cache requests
        // from the client FS.
        VNodeRemover nodeRemover(this, vnode);

        void* clientNode = vnode->clientNode;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        FSRemoveVNodeRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = clientNode;
        request->reenter = reenter;

        // send the request
        KernelRequestHandler handler(this, FS_REMOVE_VNODE_REPLY);
        FSRemoveVNodeReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}


// #pragma mark - asynchronous I/O


// DoIO
status_t
Volume::DoIO(void* _node, void* cookie, io_request* ioRequest)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_IO))
                return B_UNSUPPORTED;

        // register the IO request
        int32 requestID;
        status_t error = _RegisterIORequest(ioRequest, &requestID);
        if (error != B_OK) {
                notify_io_request(ioRequest, error);
                return error;
        }

        IORequestRemover requestRemover(this, requestID);

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port) {
                notify_io_request(ioRequest, B_ERROR);
                return B_ERROR;
        }
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        DoIORequest* request;
        error = AllocateRequest(allocator, &request);
        if (error != B_OK) {
                notify_io_request(ioRequest, error);
                return error;
        }

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->fileCookie = cookie;
        request->request = requestID;
        request->offset = ioRequest->Offset();
        request->length = ioRequest->Length();
        request->isWrite = ioRequest->IsWrite();
        request->isVIP = (ioRequest->Flags() & B_VIP_IO_REQUEST) != 0;

        // send the request
        KernelRequestHandler handler(this, DO_IO_REPLY);
        DoIOReply* reply;

        // TODO: when to notify the io_request?
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;

        requestRemover.Detach();

        return B_OK;
}


// CancelIO
status_t
Volume::CancelIO(void* _node, void* cookie, io_request* ioRequest)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_CANCEL_IO))
                return B_BAD_VALUE;

        // find the request
        int32 requestID;
        status_t error = _FindIORequest(ioRequest, &requestID);
        if (error != B_OK)
                return error;

        IORequestRemover requestRemover(this, requestID);

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        CancelIORequest* request;
        error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->fileCookie = cookie;
        request->request = requestID;

        // send the request
        KernelRequestHandler handler(this, CANCEL_IO_REPLY);
        CancelIOReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK) {
                _UnregisterIORequest(requestID);
                return error;
        }
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK) {
                _UnregisterIORequest(requestID);
                return reply->error;
        }

        return B_OK;
}


// #pragma mark - nodes


// IOCtl
status_t
Volume::IOCtl(void* _node, void* cookie, uint32 command, void *buffer,
        size_t len)
{
        VNode* vnode = (VNode*)_node;

        // check the command and its parameters
        bool isBuffer = false;
        int32 bufferSize = 0;
        int32 writeSize = 0;
        switch (command) {
                case IOCTL_FILE_UNCACHED_IO:
                        buffer = NULL;
                        break;
                case IOCTL_CREATE_TIME:
                case IOCTL_MODIFIED_TIME:
                        isBuffer = 0;
                        bufferSize = 0;
                        writeSize = sizeof(bigtime_t);
                        break;
                case USERLANDFS_IOCTL:
                        area_id area;
                        area_info info;
                        PRINT(("Volume::IOCtl(): USERLANDFS_IOCTL\n"));
                        if ((area = area_for(buffer)) >= 0) {
                                if (get_area_info(area, &info) == B_OK) {
                                        if ((uint8*)buffer - (uint8*)info.address
                                                        + sizeof(userlandfs_ioctl) <= info.size) {
                                                if (strncmp(((userlandfs_ioctl*)buffer)->magic,
                                                                kUserlandFSIOCtlMagic,
                                                                USERLAND_IOCTL_MAGIC_LENGTH) == 0) {
                                                        return _InternalIOCtl((userlandfs_ioctl*)buffer,
                                                                bufferSize);
                                                } else
                                                        PRINT(("Volume::IOCtl(): bad magic\n"));
                                        } else
                                                PRINT(("Volume::IOCtl(): bad buffer size\n"));
                                } else
                                        PRINT(("Volume::IOCtl(): failed to get area info\n"));
                        } else
                                PRINT(("Volume::IOCtl(): bad area\n"));
                        // fall through...
                default:
                {
                        // We don't know the command. Check whether the FileSystem knows
                        // about it.
                        const IOCtlInfo* info = fFileSystem->GetIOCtlInfo(command);
                        if (!info) {
                                PRINT(("Volume::IOCtl(): unknown command\n"));
                                return B_BAD_VALUE;
                        }

                        isBuffer = info->isBuffer;
                        bufferSize = info->bufferSize;
                        writeSize = info->writeBufferSize;

                        // If the buffer shall indeed specify a buffer, check it.
                        if (info->isBuffer) {
                                if (!buffer) {
                                        PRINT(("Volume::IOCtl(): buffer is NULL\n"));
                                        return B_BAD_VALUE;
                                }

                                area_id area = area_for(buffer);
                                if (area < 0) {
                                        PRINT(("Volume::IOCtl(): bad area\n"));
                                        return B_BAD_VALUE;
                                }

                                area_info info;
                                if (get_area_info(area, &info) != B_OK) {
                                        PRINT(("Volume::IOCtl(): failed to get area info\n"));
                                        return B_BAD_VALUE;
                                }

                                int32 areaSize = info.size - ((uint8*)buffer
                                        - (uint8*)info.address);
                                if (bufferSize > areaSize || writeSize > areaSize) {
                                        PRINT(("Volume::IOCtl(): bad buffer size\n"));
                                        return B_BAD_VALUE;
                                }

                                if (writeSize > 0 && !(info.protection & B_WRITE_AREA)) {
                                        PRINT(("Volume::IOCtl(): buffer not writable\n"));
                                        return B_BAD_VALUE;
                                }
                        }
                        break;
                }
        }

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_IOCTL))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        IOCtlRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->fileCookie = cookie;
        request->command = command;
        request->bufferParameter = buffer;
        request->isBuffer = isBuffer;
        request->lenParameter = len;
        request->writeSize = writeSize;

        if (isBuffer && bufferSize > 0) {
                error = allocator.AllocateData(request->buffer, buffer, bufferSize, 8);
                if (error != B_OK)
                        return error;
        }

        // send the request
        KernelRequestHandler handler(this, IOCTL_REPLY);
        IOCtlReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;

        // Copy back the buffer even if the result is not B_OK. The protocol
        // is defined by the FS developer and may include writing data into
        // the buffer in some error cases.
        if (isBuffer && writeSize > 0 && reply->buffer.GetData()) {
                if (writeSize > reply->buffer.GetSize())
                        writeSize = reply->buffer.GetSize();
                memcpy(buffer, reply->buffer.GetData(), writeSize);
                _SendReceiptAck(port);
        }
        return reply->ioctlError;
}

// SetFlags
status_t
Volume::SetFlags(void* _node, void* cookie, int flags)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_SET_FLAGS))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        SetFlagsRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->fileCookie = cookie;
        request->flags = flags;

        // send the request
        KernelRequestHandler handler(this, SET_FLAGS_REPLY);
        SetFlagsReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// Select
status_t
Volume::Select(void* _node, void* cookie, uint8 event, selectsync* sync)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_SELECT)) {
                notify_select_event(sync, event);
                return B_OK;
        }

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        SelectRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->fileCookie = cookie;
        request->event = event;
        request->sync = sync;

        // add a selectsync entry
        error = fFileSystem->AddSelectSyncEntry(sync);
        if (error != B_OK)
                return error;

        // send the request
        KernelRequestHandler handler(this, SELECT_REPLY);
        SelectReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK) {
                fFileSystem->RemoveSelectSyncEntry(sync);
                return error;
        }
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK) {
                fFileSystem->RemoveSelectSyncEntry(sync);
                return reply->error;
        }
        return error;
}

// Deselect
status_t
Volume::Deselect(void* _node, void* cookie, uint8 event, selectsync* sync)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_DESELECT))
                return B_OK;

        struct SyncRemover {
                SyncRemover(FileSystem* fs, selectsync* sync)
                        : fs(fs), sync(sync) {}
                ~SyncRemover() { fs->RemoveSelectSyncEntry(sync); }

                FileSystem*     fs;
                selectsync*     sync;
        } syncRemover(fFileSystem, sync);

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        DeselectRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->fileCookie = cookie;
        request->event = event;
        request->sync = sync;

        // send the request
        KernelRequestHandler handler(this, DESELECT_REPLY);
        DeselectReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// FSync
status_t
Volume::FSync(void* _node)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_FSYNC))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        FSyncRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;

        // send the request
        KernelRequestHandler handler(this, FSYNC_REPLY);
        FSyncReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// ReadSymlink
status_t
Volume::ReadSymlink(void* _node, char* buffer, size_t bufferSize,
        size_t* bytesRead)
{
        VNode* vnode = (VNode*)_node;

        *bytesRead = 0;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_READ_SYMLINK))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        ReadSymlinkRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->size = bufferSize;

        // send the request
        KernelRequestHandler handler(this, READ_SYMLINK_REPLY);
        ReadSymlinkReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        void* readBuffer = reply->buffer.GetData();
        if (reply->bytesRead > (uint32)reply->buffer.GetSize()
                || reply->bytesRead > bufferSize) {
                return B_BAD_DATA;
        }
        if (reply->bytesRead > 0)
                memcpy(buffer, readBuffer, reply->bytesRead);
        *bytesRead = reply->bytesRead;
        _SendReceiptAck(port);
        return error;
}

// CreateSymlink
status_t
Volume::CreateSymlink(void* _dir, const char* name, const char* target,
        int mode)
{
        VNode* vnode = (VNode*)_dir;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_CREATE_SYMLINK))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        CreateSymlinkRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        error = allocator.AllocateString(request->name, name);
        if (error == B_OK)
                error = allocator.AllocateString(request->target, target);
        if (error != B_OK)
                return error;
        request->mode = mode;

        // send the request
        KernelRequestHandler handler(this, CREATE_SYMLINK_REPLY);
        CreateSymlinkReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// Link
status_t
Volume::Link(void* _dir, const char* name, void* node)
{
        VNode* vnode = (VNode*)_dir;
        VNode* targetVnode = (VNode*)node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_LINK))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        LinkRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        error = allocator.AllocateString(request->name, name);
        request->target = targetVnode->clientNode;
        if (error != B_OK)
                return error;

        // send the request
        KernelRequestHandler handler(this, LINK_REPLY);
        LinkReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// Unlink
status_t
Volume::Unlink(void* _dir, const char* name)
{
        VNode* vnode = (VNode*)_dir;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_UNLINK))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        UnlinkRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        error = allocator.AllocateString(request->name, name);
        if (error != B_OK)
                return error;

        // send the request
        KernelRequestHandler handler(this, UNLINK_REPLY);
        UnlinkReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// Rename
status_t
Volume::Rename(void* _oldDir, const char* oldName, void* _newDir,
        const char* newName)
{
        VNode* oldVNode = (VNode*)_oldDir;
        VNode* newVNode = (VNode*)_newDir;

        // check capability
        if (!HasVNodeCapability(oldVNode, FS_VNODE_CAPABILITY_RENAME))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        RenameRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->oldDir = oldVNode->clientNode;
        request->newDir = newVNode->clientNode;
        error = allocator.AllocateString(request->oldName, oldName);
        if (error == B_OK)
                error = allocator.AllocateString(request->newName, newName);
        if (error != B_OK)
                return error;

        // send the request
        KernelRequestHandler handler(this, RENAME_REPLY);
        RenameReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// Access
status_t
Volume::Access(void* _node, int mode)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_ACCESS))
                return B_OK;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        AccessRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->mode = mode;

        // send the request
        KernelRequestHandler handler(this, ACCESS_REPLY);
        AccessReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// ReadStat
status_t
Volume::ReadStat(void* node, struct stat* st)
{
        // When the connection to the userland server is lost, we serve
        // read_stat(fRootNode) requests manually to allow clean unmounting.
        status_t error = _ReadStat(node, st);
        if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()
                && node == fRootNode) {
                WARN(("Volume::ReadStat(): connection lost, emulating stat for the "
                        "root node\n"));

                st->st_dev = GetID();
                st->st_ino = fRootID;
                st->st_mode = ACCESSPERMS;
                st->st_nlink = 1;
                st->st_uid = 0;
                st->st_gid = 0;
                st->st_size = 512;
                st->st_blksize = 512;
                st->st_atime = 0;
                st->st_mtime = 0;
                st->st_ctime = 0;
                st->st_crtime = 0;

                error = B_OK;
        }
        return error;
}

// WriteStat
status_t
Volume::WriteStat(void* _node, const struct stat* st, uint32 mask)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_WRITE_STAT))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        WriteStatRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->st = *st;
        request->mask = mask;

        // send the request
        KernelRequestHandler handler(this, WRITE_STAT_REPLY);
        WriteStatReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}


// #pragma mark - files

// Create
status_t
Volume::Create(void* _dir, const char* name, int openMode, int mode,
        void** cookie, ino_t* vnid)
{
        VNode* vnode = (VNode*)_dir;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_CREATE))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);
        AutoIncrementer incrementer(&fOpenFiles);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        CreateRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        error = allocator.AllocateString(request->name, name);
        request->openMode = openMode;
        request->mode = mode;
        if (error != B_OK)
                return error;

        // send the request
        KernelRequestHandler handler(this, CREATE_REPLY);
        CreateReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        incrementer.Keep();
        *vnid = reply->vnid;
        *cookie = reply->fileCookie;

        // The VFS will balance the publish_vnode() call for the FS.
        if (error == B_OK)
                _DecrementVNodeCount(*vnid);
        return error;
}

// Open
status_t
Volume::Open(void* _node, int openMode, void** cookie)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_OPEN))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);
        AutoIncrementer incrementer(&fOpenFiles);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        OpenRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;
        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->openMode = openMode;

        // send the request
        KernelRequestHandler handler(this, OPEN_REPLY);
        OpenReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        incrementer.Keep();
        *cookie = reply->fileCookie;
        return error;
}

// Close
status_t
Volume::Close(void* node, void* cookie)
{
        status_t error = _Close(node, cookie);
        if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) {
                // This isn't really necessary, as the return value is irrelevant to
                // the VFS. Haiku ignores it completely. The fsshell returns it to the
                // userland, but considers the node closed anyway.
                WARN(("Volume::Close(): connection lost, forcing close\n"));
                return B_OK;
        }
        return error;
}

// FreeCookie
status_t
Volume::FreeCookie(void* node, void* cookie)
{
        status_t error = _FreeCookie(node, cookie);
        bool disconnected = false;
        if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) {
                // This isn't really necessary, as the return value is irrelevant to
                // the VFS. It's completely ignored by Haiku as well as by the fsshell.
                WARN(("Volume::FreeCookie(): connection lost, forcing free cookie\n"));
                error = B_OK;
                disconnected = true;
        }

        int32 openFiles = atomic_add(&fOpenFiles, -1);
        if (openFiles <= 1 && disconnected)
                _PutAllPendingVNodes();
        return error;
}

// Read
status_t
Volume::Read(void* _node, void* cookie, off_t pos, void* buffer,
        size_t bufferSize, size_t* bytesRead)
{
        VNode* vnode = (VNode*)_node;

        *bytesRead = 0;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_READ))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        ReadRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->fileCookie = cookie;
        request->pos = pos;
        request->size = bufferSize;

        // send the request
        KernelRequestHandler handler(this, READ_REPLY);
        ReadReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        void* readBuffer = reply->buffer.GetData();
        if (reply->bytesRead > (uint32)reply->buffer.GetSize()
                || reply->bytesRead > bufferSize) {
                return B_BAD_DATA;
        }
        if (reply->bytesRead > 0
                && user_memcpy(buffer, readBuffer, reply->bytesRead) < B_OK) {
                return B_BAD_ADDRESS;
        }

        *bytesRead = reply->bytesRead;
        _SendReceiptAck(port);
        return error;
}

// Write
status_t
Volume::Write(void* _node, void* cookie, off_t pos, const void* buffer,
        size_t size, size_t* bytesWritten)
{
        VNode* vnode = (VNode*)_node;

        *bytesWritten = 0;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_WRITE))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        WriteRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->fileCookie = cookie;
        request->pos = pos;
        error = allocator.AllocateData(request->buffer, buffer, size, 1, false, sizeof(DoIORequest));
        if (error != B_OK)
                return error;

        // send the request
        KernelRequestHandler handler(this, WRITE_REPLY);
        WriteReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        *bytesWritten = reply->bytesWritten;
        return error;
}


// #pragma mark - directories

// CreateDir
status_t
Volume::CreateDir(void* _dir, const char* name, int mode)
{
        VNode* vnode = (VNode*)_dir;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_CREATE_DIR))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        CreateDirRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        error = allocator.AllocateString(request->name, name);
        request->mode = mode;
        if (error != B_OK)
                return error;

        // send the request
        KernelRequestHandler handler(this, CREATE_DIR_REPLY);
        CreateDirReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// RemoveDir
status_t
Volume::RemoveDir(void* _dir, const char* name)
{
        VNode* vnode = (VNode*)_dir;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_REMOVE_DIR))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        RemoveDirRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        error = allocator.AllocateString(request->name, name);
        if (error != B_OK)
                return error;

        // send the request
        KernelRequestHandler handler(this, REMOVE_DIR_REPLY);
        RemoveDirReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// OpenDir
status_t
Volume::OpenDir(void* _node, void** cookie)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_OPEN_DIR))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);
        AutoIncrementer incrementer(&fOpenDirectories);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        OpenDirRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;

        // send the request
        KernelRequestHandler handler(this, OPEN_DIR_REPLY);
        OpenDirReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        incrementer.Keep();
        *cookie = reply->dirCookie;
        return error;
}

// CloseDir
status_t
Volume::CloseDir(void* node, void* cookie)
{
        status_t error = _CloseDir(node, cookie);
        if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) {
                // This isn't really necessary, as the return value is irrelevant to
                // the VFS. Haiku ignores it completely. The fsshell returns it to the
                // userland, but considers the node closed anyway.
                WARN(("Volume::CloseDir(): connection lost, forcing close dir\n"));
                return B_OK;
        }
        return error;
}

// FreeDirCookie
status_t
Volume::FreeDirCookie(void* node, void* cookie)
{
        status_t error = _FreeDirCookie(node, cookie);
        bool disconnected = false;
        if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) {
                // This isn't really necessary, as the return value is irrelevant to
                // the VFS. It's completely ignored by Haiku as well as by the fsshell.
                WARN(("Volume::FreeDirCookie(): connection lost, forcing free dir "
                        "cookie\n"));
                error = B_OK;
                disconnected = true;
        }
        int32 openDirs = atomic_add(&fOpenDirectories, -1);
        if (openDirs <= 1 && disconnected)
                _PutAllPendingVNodes();
        return error;
}

// ReadDir
status_t
Volume::ReadDir(void* _node, void* cookie, void* buffer, size_t bufferSize,
        uint32 count, uint32* countRead)
{
        VNode* vnode = (VNode*)_node;

        *countRead = 0;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_READ_DIR))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        ReadDirRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->dirCookie = cookie;
        request->bufferSize = bufferSize;
        request->count = count;

        // send the request
        KernelRequestHandler handler(this, READ_DIR_REPLY);
        ReadDirReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        if (reply->count < 0 || reply->count > count)
                return B_BAD_DATA;
        if ((int32)bufferSize < reply->buffer.GetSize())
                return B_BAD_DATA;

        PRINT(("Volume::ReadDir(): buffer returned: %" B_PRId32 " bytes\n",
                reply->buffer.GetSize()));

        *countRead = reply->count;
        if (*countRead > 0) {
                // copy the buffer -- limit the number of bytes to copy
                uint32 maxBytes = *countRead
                        * (sizeof(struct dirent) + B_FILE_NAME_LENGTH);
                uint32 copyBytes = reply->buffer.GetSize();
                if (copyBytes > maxBytes)
                        copyBytes = maxBytes;
                memcpy(buffer, reply->buffer.GetData(), copyBytes);
        }
        _SendReceiptAck(port);
        return error;
}

// RewindDir
status_t
Volume::RewindDir(void* _node, void* cookie)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_REWIND_DIR))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        RewindDirRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->dirCookie = cookie;

        // send the request
        KernelRequestHandler handler(this, REWIND_DIR_REPLY);
        RewindDirReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}


// #pragma mark - attribute directories


// OpenAttrDir
status_t
Volume::OpenAttrDir(void* _node, void** cookie)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_OPEN_ATTR_DIR))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);
        AutoIncrementer incrementer(&fOpenAttributeDirectories);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        OpenAttrDirRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;

        // send the request
        KernelRequestHandler handler(this, OPEN_ATTR_DIR_REPLY);
        OpenAttrDirReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        incrementer.Keep();
        *cookie = reply->attrDirCookie;
        return error;
}

// CloseAttrDir
status_t
Volume::CloseAttrDir(void* node, void* cookie)
{
        status_t error = _CloseAttrDir(node, cookie);
        if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) {
                // This isn't really necessary, as the return value is irrelevant to
                // the VFS. Haiku ignores it completely. The fsshell returns it to the
                // userland, but considers the node closed anyway.
                WARN(("Volume::CloseAttrDir(): connection lost, forcing close attr "
                        "dir\n"));
                return B_OK;
        }
        return error;
}

// FreeAttrDirCookie
status_t
Volume::FreeAttrDirCookie(void* node, void* cookie)
{
        status_t error = _FreeAttrDirCookie(node, cookie);
        bool disconnected = false;
        if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) {
                // This isn't really necessary, as the return value is irrelevant to
                // the VFS. It's completely ignored by Haiku as well as by the fsshell.
                WARN(("Volume::FreeAttrDirCookie(): connection lost, forcing free attr "
                        "dir cookie\n"));
                error = B_OK;
                disconnected = true;
        }

        int32 openAttrDirs = atomic_add(&fOpenAttributeDirectories, -1);
        if (openAttrDirs <= 1 && disconnected)
                _PutAllPendingVNodes();
        return error;
}

// ReadAttrDir
status_t
Volume::ReadAttrDir(void* _node, void* cookie, void* buffer,
        size_t bufferSize, uint32 count, uint32* countRead)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_READ_ATTR_DIR))
                return B_BAD_VALUE;

        *countRead = 0;
        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        ReadAttrDirRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->attrDirCookie = cookie;
        request->bufferSize = bufferSize;
        request->count = count;

        // send the request
        KernelRequestHandler handler(this, READ_ATTR_DIR_REPLY);
        ReadAttrDirReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        if (reply->count < 0 || reply->count > count)
                return B_BAD_DATA;
        if ((int32)bufferSize < reply->buffer.GetSize())
                return B_BAD_DATA;

        *countRead = reply->count;
        if (*countRead > 0) {
                // copy the buffer -- limit the number of bytes to copy
                uint32 maxBytes = *countRead
                        * (sizeof(struct dirent) + B_ATTR_NAME_LENGTH);
                uint32 copyBytes = reply->buffer.GetSize();
                if (copyBytes > maxBytes)
                        copyBytes = maxBytes;
                memcpy(buffer, reply->buffer.GetData(), copyBytes);
        }
        _SendReceiptAck(port);
        return error;
}

// RewindAttrDir
status_t
Volume::RewindAttrDir(void* _node, void* cookie)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_REWIND_ATTR_DIR))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        RewindAttrDirRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->attrDirCookie = cookie;

        // send the request
        KernelRequestHandler handler(this, REWIND_ATTR_DIR_REPLY);
        RewindAttrDirReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}


// #pragma mark - attributes

// CreateAttr
status_t
Volume::CreateAttr(void* _node, const char* name, uint32 type, int openMode,
        void** cookie)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_CREATE_ATTR))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);
        AutoIncrementer incrementer(&fOpenAttributes);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        CreateAttrRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        error = allocator.AllocateString(request->name, name);
        request->type = type;
        request->openMode = openMode;
        if (error != B_OK)
                return error;

        // send the request
        KernelRequestHandler handler(this, CREATE_ATTR_REPLY);
        CreateAttrReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        incrementer.Keep();
        *cookie = reply->attrCookie;
        return error;
}

// OpenAttr
status_t
Volume::OpenAttr(void* _node, const char* name, int openMode,
        void** cookie)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_OPEN_ATTR))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);
        AutoIncrementer incrementer(&fOpenAttributes);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        OpenAttrRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        error = allocator.AllocateString(request->name, name);
        request->openMode = openMode;
        if (error != B_OK)
                return error;

        // send the request
        KernelRequestHandler handler(this, OPEN_ATTR_REPLY);
        OpenAttrReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        incrementer.Keep();
        *cookie = reply->attrCookie;
        return error;
}

// CloseAttr
status_t
Volume::CloseAttr(void* node, void* cookie)
{
        status_t error = _CloseAttr(node, cookie);
        if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) {
                // This isn't really necessary, as the return value is irrelevant to
                // the VFS. Haiku ignores it completely. The fsshell returns it to the
                // userland, but considers the node closed anyway.
                WARN(("Volume::CloseAttr(): connection lost, forcing close attr\n"));
                return B_OK;
        }
        return error;
}

// FreeAttrCookie
status_t
Volume::FreeAttrCookie(void* node, void* cookie)
{
        status_t error = _FreeAttrCookie(node, cookie);
        bool disconnected = false;
        if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) {
                // This isn't really necessary, as the return value is irrelevant to
                // the VFS. It's completely ignored by Haiku as well as by the fsshell.
                WARN(("Volume::FreeAttrCookie(): connection lost, forcing free attr "
                        "cookie\n"));
                error = B_OK;
                disconnected = true;
        }

        int32 openAttributes = atomic_add(&fOpenAttributes, -1);
        if (openAttributes <= 1 && disconnected)
                _PutAllPendingVNodes();
        return error;
}

// ReadAttr
status_t
Volume::ReadAttr(void* _node, void* cookie, off_t pos,
        void* buffer, size_t bufferSize, size_t* bytesRead)
{
        VNode* vnode = (VNode*)_node;

        *bytesRead = 0;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_READ_ATTR))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        ReadAttrRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->attrCookie = cookie;
        request->pos = pos;
        request->size = bufferSize;

        // send the request
        KernelRequestHandler handler(this, READ_ATTR_REPLY);
        ReadAttrReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        void* readBuffer = reply->buffer.GetData();
        if (reply->bytesRead > (uint32)reply->buffer.GetSize()
                || reply->bytesRead > bufferSize) {
                return B_BAD_DATA;
        }
        if (reply->bytesRead > 0
                && user_memcpy(buffer, readBuffer, reply->bytesRead) < B_OK) {
                return B_BAD_ADDRESS;
        }
        *bytesRead = reply->bytesRead;
        _SendReceiptAck(port);
        return error;
}

// WriteAttr
status_t
Volume::WriteAttr(void* _node, void* cookie, off_t pos,
        const void* buffer, size_t bufferSize, size_t* bytesWritten)
{
        VNode* vnode = (VNode*)_node;

        *bytesWritten = 0;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_WRITE_ATTR))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        WriteAttrRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->attrCookie = cookie;
        request->pos = pos;
        error = allocator.AllocateData(request->buffer, buffer, bufferSize, 1);
        if (error != B_OK)
                return error;

        // send the request
        KernelRequestHandler handler(this, WRITE_ATTR_REPLY);
        WriteAttrReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        *bytesWritten = reply->bytesWritten;
        return error;
}

// ReadAttrStat
status_t
Volume::ReadAttrStat(void* _node, void* cookie, struct stat *st)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_READ_ATTR_STAT))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        ReadAttrStatRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->attrCookie = cookie;

        // send the request
        KernelRequestHandler handler(this, READ_ATTR_STAT_REPLY);
        ReadAttrStatReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        *st = reply->st;
        return error;
}

// WriteAttrStat
status_t
Volume::WriteAttrStat(void* _node, void* cookie, const struct stat *st,
        int statMask)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_WRITE_ATTR_STAT))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        WriteAttrStatRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->attrCookie = cookie;
        request->st = *st;
        request->mask = statMask;

        // send the request
        KernelRequestHandler handler(this, WRITE_ATTR_STAT_REPLY);
        WriteAttrStatReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// RenameAttr
status_t
Volume::RenameAttr(void* _oldNode, const char* oldName, void* _newNode,
        const char* newName)
{
        VNode* oldVNode = (VNode*)_oldNode;
        VNode* newVNode = (VNode*)_newNode;

        // check capability
        if (!HasVNodeCapability(oldVNode, FS_VNODE_CAPABILITY_RENAME_ATTR))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        RenameAttrRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->oldNode = oldVNode->clientNode;
        request->newNode = newVNode->clientNode;
        error = allocator.AllocateString(request->oldName, oldName);
        if (error == B_OK)
                error = allocator.AllocateString(request->newName, newName);
        if (error != B_OK)
                return error;

        // send the request
        KernelRequestHandler handler(this, RENAME_ATTR_REPLY);
        RenameAttrReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// RemoveAttr
status_t
Volume::RemoveAttr(void* _node, const char* name)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_REMOVE_ATTR))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        RemoveAttrRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        error = allocator.AllocateString(request->name, name);
        if (error != B_OK)
                return error;

        // send the request
        KernelRequestHandler handler(this, REMOVE_ATTR_REPLY);
        RemoveAttrReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}


// #pragma mark - indices


// OpenIndexDir
status_t
Volume::OpenIndexDir(void** cookie)
{
        // check capability
        if (!HasCapability(FS_VOLUME_CAPABILITY_OPEN_INDEX_DIR))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);
        AutoIncrementer incrementer(&fOpenIndexDirectories);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        OpenIndexDirRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;

        // send the request
        KernelRequestHandler handler(this, OPEN_INDEX_DIR_REPLY);
        OpenIndexDirReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        incrementer.Keep();
        *cookie = reply->indexDirCookie;
        return error;
}

// CloseIndexDir
status_t
Volume::CloseIndexDir(void* cookie)
{
        status_t error = _CloseIndexDir(cookie);
        if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) {
                // This isn't really necessary, as the return value is irrelevant to
                // the VFS. Haiku ignores it completely. The fsshell returns it to the
                // userland, but considers the node closed anyway.
                WARN(("Volume::CloseIndexDir(): connection lost, forcing close "
                        "index dir\n"));
                return B_OK;
        }
        return error;
}

// FreeIndexDirCookie
status_t
Volume::FreeIndexDirCookie(void* cookie)
{
        status_t error = _FreeIndexDirCookie(cookie);
        bool disconnected = false;
        if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) {
                // This isn't really necessary, as the return value is irrelevant to
                // the VFS. It's completely ignored by Haiku as well as by the fsshell.
                WARN(("Volume::FreeIndexDirCookie(): connection lost, forcing free "
                        "index dir cookie\n"));
                error = B_OK;
                disconnected = true;
        }

        int32 openIndexDirs = atomic_add(&fOpenIndexDirectories, -1);
        if (openIndexDirs <= 1 && disconnected)
                _PutAllPendingVNodes();
        return error;
}

// ReadIndexDir
status_t
Volume::ReadIndexDir(void* cookie, void* buffer, size_t bufferSize,
        uint32 count, uint32* countRead)
{
        *countRead = 0;

        // check capability
        if (!HasCapability(FS_VOLUME_CAPABILITY_READ_INDEX_DIR))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        ReadIndexDirRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->indexDirCookie = cookie;
        request->bufferSize = bufferSize;
        request->count = count;

        // send the request
        KernelRequestHandler handler(this, READ_INDEX_DIR_REPLY);
        ReadIndexDirReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        if (reply->count < 0 || reply->count > count)
                return B_BAD_DATA;
        if ((int32)bufferSize < reply->buffer.GetSize())
                return B_BAD_DATA;

        *countRead = reply->count;
        if (*countRead > 0) {
                // copy the buffer -- limit the number of bytes to copy
                uint32 maxBytes = *countRead
                        * (sizeof(struct dirent) + B_FILE_NAME_LENGTH);
                uint32 copyBytes = reply->buffer.GetSize();
                if (copyBytes > maxBytes)
                        copyBytes = maxBytes;
                memcpy(buffer, reply->buffer.GetData(), copyBytes);
        }
        _SendReceiptAck(port);
        return error;
}

// RewindIndexDir
status_t
Volume::RewindIndexDir(void* cookie)
{
        // check capability
        if (!HasCapability(FS_VOLUME_CAPABILITY_REWIND_INDEX_DIR))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        RewindIndexDirRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->indexDirCookie = cookie;

        // send the request
        KernelRequestHandler handler(this, REWIND_INDEX_DIR_REPLY);
        RewindIndexDirReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// CreateIndex
status_t
Volume::CreateIndex(const char* name, uint32 type, uint32 flags)
{
        // check capability
        if (!HasCapability(FS_VOLUME_CAPABILITY_CREATE_INDEX))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        CreateIndexRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        error = allocator.AllocateString(request->name, name);
        request->type = type;
        request->flags = flags;
        if (error != B_OK)
                return error;

        // send the request
        KernelRequestHandler handler(this, CREATE_INDEX_REPLY);
        CreateIndexReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// RemoveIndex
status_t
Volume::RemoveIndex(const char* name)
{
        // check capability
        if (!HasCapability(FS_VOLUME_CAPABILITY_REMOVE_INDEX))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        RemoveIndexRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        error = allocator.AllocateString(request->name, name);
        if (error != B_OK)
                return error;

        // send the request
        KernelRequestHandler handler(this, REMOVE_INDEX_REPLY);
        RemoveIndexReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// ReadIndexStat
status_t
Volume::ReadIndexStat(const char* name, struct stat *st)
{
        // check capability
        if (!HasCapability(FS_VOLUME_CAPABILITY_READ_INDEX_STAT))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        ReadIndexStatRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        error = allocator.AllocateString(request->name, name);
        if (error != B_OK)
                return error;

        // send the request
        KernelRequestHandler handler(this, READ_INDEX_STAT_REPLY);
        ReadIndexStatReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        *st = reply->st;
        return error;
}


// #pragma mark - queries


// OpenQuery
status_t
Volume::OpenQuery(const char* queryString, uint32 flags, port_id targetPort,
        uint32 token, void** cookie)
{
        // check capability
        if (!HasCapability(FS_VOLUME_CAPABILITY_OPEN_QUERY))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);
        AutoIncrementer incrementer(&fOpenQueries);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        OpenQueryRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        error = allocator.AllocateString(request->queryString, queryString);
        if (error != B_OK)
                return error;
        request->flags = flags;
        request->port = targetPort;
        request->token = token;

        // send the request
        KernelRequestHandler handler(this, OPEN_QUERY_REPLY);
        OpenQueryReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        incrementer.Keep();
        *cookie = reply->queryCookie;
        return error;
}

// CloseQuery
status_t
Volume::CloseQuery(void* cookie)
{
        status_t error = _CloseQuery(cookie);
        if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) {
                // This isn't really necessary, as the return value is irrelevant to
                // the VFS. Haiku ignores it completely. The fsshell returns it to the
                // userland, but considers the node closed anyway.
                WARN(("Volume::CloseQuery(): connection lost, forcing close query\n"));
                return B_OK;
        }
        return error;
}

// FreeQueryCookie
status_t
Volume::FreeQueryCookie(void* cookie)
{
        status_t error = _FreeQueryCookie(cookie);
        bool disconnected = false;
        if (error != B_OK && fFileSystem->GetPortPool()->IsDisconnected()) {
                // This isn't really necessary, as the return value is irrelevant to
                // the VFS. It's completely ignored by Haiku as well as by the fsshell.
                WARN(("Volume::FreeQueryCookie(): connection lost, forcing free "
                        "query cookie\n"));
                error = B_OK;
                disconnected = true;
        }

        int32 openQueries = atomic_add(&fOpenQueries, -1);
        if (openQueries <= 1 && disconnected)
                _PutAllPendingVNodes();
        return error;
}

// ReadQuery
status_t
Volume::ReadQuery(void* cookie, void* buffer, size_t bufferSize,
        uint32 count, uint32* countRead)
{
        *countRead = 0;

        // check capability
        if (!HasCapability(FS_VOLUME_CAPABILITY_READ_QUERY))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        ReadQueryRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->queryCookie = cookie;
        request->bufferSize = bufferSize;
        request->count = count;

        // send the request
        KernelRequestHandler handler(this, READ_QUERY_REPLY);
        ReadQueryReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        if (reply->count < 0 || reply->count > count)
                return B_BAD_DATA;
        if ((int32)bufferSize < reply->buffer.GetSize())
                return B_BAD_DATA;

        *countRead = reply->count;
        if (*countRead > 0) {
                // copy the buffer -- limit the number of bytes to copy
                uint32 maxBytes = *countRead
                        * (sizeof(struct dirent) + B_FILE_NAME_LENGTH);
                uint32 copyBytes = reply->buffer.GetSize();
                if (copyBytes > maxBytes)
                        copyBytes = maxBytes;
                memcpy(buffer, reply->buffer.GetData(), copyBytes);
        }
        _SendReceiptAck(port);
        return error;
}

// RewindQuery
status_t
Volume::RewindQuery(void* cookie)
{
        // check capability
        if (!HasCapability(FS_VOLUME_CAPABILITY_REWIND_QUERY))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        RewindQueryRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->queryCookie = cookie;

        // send the request
        KernelRequestHandler handler(this, REWIND_QUERY_REPLY);
        RewindQueryReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// #pragma mark -
// #pragma mark ----- private implementations -----


// _InitVolumeOps
void
Volume::_InitVolumeOps()
{
        memcpy(&fVolumeOps, &gUserlandFSVolumeOps, sizeof(fs_volume_ops));

        #undef CLEAR_UNSUPPORTED
        #define CLEAR_UNSUPPORTED(capability, op)       \
                if (!fCapabilities.Get(capability))                             \
                        fVolumeOps.op = NULL

        // FS operations
        // FS_VOLUME_CAPABILITY_UNMOUNT: unmount
                // always needed

        // FS_VOLUME_CAPABILITY_READ_FS_INFO: read_fs_info
                // always needed
        CLEAR_UNSUPPORTED(FS_VOLUME_CAPABILITY_WRITE_FS_INFO, write_fs_info);
        CLEAR_UNSUPPORTED(FS_VOLUME_CAPABILITY_SYNC, sync);

        // vnode operations
        // FS_VOLUME_CAPABILITY_GET_VNODE: get_vnode
                // always needed

        // index directory & index operations
        CLEAR_UNSUPPORTED(FS_VOLUME_CAPABILITY_OPEN_INDEX_DIR, open_index_dir);
        // FS_VOLUME_CAPABILITY_CLOSE_INDEX_DIR: close_index_dir
                // always needed
        // FS_VOLUME_CAPABILITY_FREE_INDEX_DIR_COOKIE: free_index_dir_cookie
                // always needed
        CLEAR_UNSUPPORTED(FS_VOLUME_CAPABILITY_READ_INDEX_DIR, read_index_dir);
        CLEAR_UNSUPPORTED(FS_VOLUME_CAPABILITY_REWIND_INDEX_DIR, rewind_index_dir);

        CLEAR_UNSUPPORTED(FS_VOLUME_CAPABILITY_CREATE_INDEX, create_index);
        CLEAR_UNSUPPORTED(FS_VOLUME_CAPABILITY_REMOVE_INDEX, remove_index);
        CLEAR_UNSUPPORTED(FS_VOLUME_CAPABILITY_READ_INDEX_STAT, read_index_stat);

        // query operations
        CLEAR_UNSUPPORTED(FS_VOLUME_CAPABILITY_OPEN_QUERY, open_query);
        // FS_VOLUME_CAPABILITY_CLOSE_QUERY: close_query
                // always needed
        // FS_VOLUME_CAPABILITY_FREE_QUERY_COOKIE: free_query_cookie
                // always needed
        CLEAR_UNSUPPORTED(FS_VOLUME_CAPABILITY_READ_QUERY, read_query);
        CLEAR_UNSUPPORTED(FS_VOLUME_CAPABILITY_REWIND_QUERY, rewind_query);

        #undef CLEAR_UNSUPPORTED
}


// #pragma mark -


// _Mount
status_t
Volume::_Mount(const char* device, uint32 flags, const char* parameters)
{
        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // get the current working directory
        char cwd[B_PATH_NAME_LENGTH];
        if (!getcwd(cwd, sizeof(cwd)))
                return errno;

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        MountVolumeRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->nsid = GetID();
        error = allocator.AllocateString(request->cwd, cwd);
        if (error == B_OK)
                error = allocator.AllocateString(request->device, device);
        request->flags = flags;
        if (error == B_OK)
                error = allocator.AllocateString(request->parameters, parameters);
        if (error != B_OK)
                return error;

        // send the request
        KernelRequestHandler handler(this, MOUNT_VOLUME_REPLY);
        MountVolumeReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        fRootID = reply->rootID;
        fUserlandVolume = reply->volume;
        fCapabilities = reply->capabilities;

        return error;
}

// _Unmount
status_t
Volume::_Unmount()
{
        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        UnmountVolumeRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;

        // send the request
        KernelRequestHandler handler(this, UNMOUNT_VOLUME_REPLY);
        UnmountVolumeReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// _ReadFSInfo
status_t
Volume::_ReadFSInfo(fs_info* info)
{
        // check capability
        if (!HasCapability(FS_VOLUME_CAPABILITY_READ_FS_INFO))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        ReadFSInfoRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;

        // send the request
        KernelRequestHandler handler(this, READ_FS_INFO_REPLY);
        ReadFSInfoReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        *info = reply->info;
        return error;
}

// _Lookup
status_t
Volume::_Lookup(void* _dir, const char* entryName, ino_t* vnid)
{
        VNode* vnode = (VNode*)_dir;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        LookupRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;
        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        error = allocator.AllocateString(request->entryName, entryName);
        if (error != B_OK)
                return error;

        // send the request
        KernelRequestHandler handler(this, LOOKUP_REPLY);
        LookupReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        *vnid = reply->vnid;

        // The VFS will balance the get_vnode() call for the FS.
        _DecrementVNodeCount(*vnid);
        return error;
}

// _WriteVNode
status_t
Volume::_WriteVNode(void* _node, bool reenter)
{
        VNode* vnode = (VNode*)_node;

        // At any rate remove the vnode from our map and delete it. We don't do that
        // right now, though, since we might still need to serve file cache requests
        // from the client FS.
        VNodeRemover nodeRemover(this, vnode);

        void* clientNode = vnode->clientNode;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        WriteVNodeRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;
        request->volume = fUserlandVolume;
        request->node = clientNode;
        request->reenter = reenter;

        // send the request
        KernelRequestHandler handler(this, WRITE_VNODE_REPLY);
        WriteVNodeReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// _ReadStat
status_t
Volume::_ReadStat(void* _node, struct stat* st)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_READ_STAT))
                return B_BAD_VALUE;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        ReadStatRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;

        // send the request
        KernelRequestHandler handler(this, READ_STAT_REPLY);
        ReadStatReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        *st = reply->st;
        return error;
}

// _Close
status_t
Volume::_Close(void* _node, void* cookie)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_CLOSE))
                return B_OK;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        CloseRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->fileCookie = cookie;

        // send the request
        KernelRequestHandler handler(this, CLOSE_REPLY);
        CloseReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// _FreeCookie
status_t
Volume::_FreeCookie(void* _node, void* cookie)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_FREE_COOKIE))
                return B_OK;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        FreeCookieRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->fileCookie = cookie;

        // send the request
        KernelRequestHandler handler(this, FREE_COOKIE_REPLY);
        FreeCookieReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// _CloseDir
status_t
Volume::_CloseDir(void* _node, void* cookie)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_CLOSE_DIR))
                return B_OK;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        CloseDirRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->dirCookie = cookie;

        // send the request
        KernelRequestHandler handler(this, CLOSE_DIR_REPLY);
        CloseDirReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// _FreeDirCookie
status_t
Volume::_FreeDirCookie(void* _node, void* cookie)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_FREE_DIR_COOKIE))
                return B_OK;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        FreeDirCookieRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->dirCookie = cookie;

        // send the request
        KernelRequestHandler handler(this, FREE_DIR_COOKIE_REPLY);
        FreeDirCookieReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// _CloseAttrDir
status_t
Volume::_CloseAttrDir(void* _node, void* cookie)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_CLOSE_ATTR_DIR))
                return B_OK;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        CloseAttrDirRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->attrDirCookie = cookie;

        // send the request
        KernelRequestHandler handler(this, CLOSE_ATTR_DIR_REPLY);
        CloseAttrDirReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// _FreeAttrDirCookie
status_t
Volume::_FreeAttrDirCookie(void* _node, void* cookie)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_FREE_ATTR_DIR_COOKIE))
                return B_OK;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        FreeAttrDirCookieRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->attrDirCookie = cookie;

        // send the request
        KernelRequestHandler handler(this, FREE_ATTR_DIR_COOKIE_REPLY);
        FreeAttrDirCookieReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// _CloseAttr
status_t
Volume::_CloseAttr(void* _node, void* cookie)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_CLOSE_ATTR))
                return B_OK;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        CloseAttrRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->attrCookie = cookie;

        // send the request
        KernelRequestHandler handler(this, CLOSE_ATTR_REPLY);
        CloseAttrReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// _FreeAttrCookie
status_t
Volume::_FreeAttrCookie(void* _node, void* cookie)
{
        VNode* vnode = (VNode*)_node;

        // check capability
        if (!HasVNodeCapability(vnode, FS_VNODE_CAPABILITY_FREE_ATTR_COOKIE))
                return B_OK;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        FreeAttrCookieRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->node = vnode->clientNode;
        request->attrCookie = cookie;

        // send the request
        KernelRequestHandler handler(this, FREE_ATTR_COOKIE_REPLY);
        FreeAttrCookieReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// _CloseIndexDir
status_t
Volume::_CloseIndexDir(void* cookie)
{
        // check capability
        if (!HasCapability(FS_VOLUME_CAPABILITY_CLOSE_INDEX_DIR))
                return B_OK;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        CloseIndexDirRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->indexDirCookie = cookie;

        // send the request
        KernelRequestHandler handler(this, CLOSE_INDEX_DIR_REPLY);
        CloseIndexDirReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// _FreeIndexDirCookie
status_t
Volume::_FreeIndexDirCookie(void* cookie)
{
        // check capability
        if (!HasCapability(FS_VOLUME_CAPABILITY_FREE_INDEX_DIR_COOKIE))
                return B_OK;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        FreeIndexDirCookieRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->indexDirCookie = cookie;

        // send the request
        KernelRequestHandler handler(this, FREE_INDEX_DIR_COOKIE_REPLY);
        FreeIndexDirCookieReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// _CloseQuery
status_t
Volume::_CloseQuery(void* cookie)
{
        // check capability
        if (!HasCapability(FS_VOLUME_CAPABILITY_CLOSE_QUERY))
                return B_OK;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        CloseQueryRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->queryCookie = cookie;

        // send the request
        KernelRequestHandler handler(this, CLOSE_QUERY_REPLY);
        CloseQueryReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// _FreeQueryCookie
status_t
Volume::_FreeQueryCookie(void* cookie)
{
        // check capability
        if (!HasCapability(FS_VOLUME_CAPABILITY_FREE_QUERY_COOKIE))
                return B_OK;

        // get a free port
        RequestPort* port = fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        FreeQueryCookieRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = fUserlandVolume;
        request->queryCookie = cookie;

        // send the request
        KernelRequestHandler handler(this, FREE_QUERY_COOKIE_REPLY);
        FreeQueryCookieReply* reply;
        error = _SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return error;
}

// _SendRequest
status_t
Volume::_SendRequest(RequestPort* port, RequestAllocator* allocator,
        RequestHandler* handler, Request** reply)
{
        // fill in the caller info
        KernelRequest* request = static_cast<KernelRequest*>(
                allocator->GetRequest());
        Thread* thread = thread_get_current_thread();
        request->team = thread->team->id;
        request->thread = thread->id;
        request->user = geteuid();
        request->group = getegid();

        if (!fFileSystem->IsUserlandServerThread())
                return port->SendRequest(allocator, handler, reply);
        // Here it gets dangerous: a thread of the userland server team being here
        // calls for trouble. We try receiving the request with a timeout, and
        // close the port -- which will disconnect the whole FS.
        status_t error = port->SendRequest(allocator, handler, reply,
                kUserlandServerlandPortTimeout);
        if (error == B_TIMED_OUT || error == B_WOULD_BLOCK)
                port->Close();
        return error;
}

// _SendReceiptAck
status_t
Volume::_SendReceiptAck(RequestPort* port)
{
        RequestAllocator allocator(port->GetPort());
        ReceiptAckReply* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;
        return port->SendRequest(&allocator);
}

// _IncrementVNodeCount
void
Volume::_IncrementVNodeCount(ino_t vnid)
{
        MutexLocker _(fLock);

        if (!fVNodeCountingEnabled)
                return;

        VNode* vnode = fVNodes->Lookup(vnid);
        if (vnode == NULL) {
                ERROR(("Volume::_IncrementVNodeCount(): Node with ID %" B_PRId64
                        " not known!\n", vnid));
                return;
        }

        vnode->useCount++;
//PRINT(("_IncrementVNodeCount(%lld): count: %ld, fVNodeCountMap size: %ld\n", vnid, *count, fVNodeCountMap->Size()));
}


// _DecrementVNodeCount
void
Volume::_DecrementVNodeCount(ino_t vnid)
{
        MutexLocker _(fLock);

        if (!fVNodeCountingEnabled)
                return;

        VNode* vnode = fVNodes->Lookup(vnid);
        if (vnode == NULL) {
                ERROR(("Volume::_DecrementVNodeCount(): Node with ID %" B_PRId64 " not "
                        "known!\n", vnid));
                return;
        }

        vnode->useCount--;
//PRINT(("_DecrementVNodeCount(%lld): count: %ld, fVNodeCountMap size: %ld\n", vnid, tmpCount, fVNodeCountMap->Size()));
}


// _RemoveInvalidVNode
void
Volume::_RemoveInvalidVNode(ino_t vnid)
{
        MutexLocker locker(fLock);

        VNode* vnode = fVNodes->Lookup(vnid);
        if (vnode == NULL) {
                ERROR(("Volume::_RemoveInvalidVNode(): Node with ID %" B_PRId64
                        " not known!\n", vnid));
                return;
        }

        fVNodes->Remove(vnode);
        locker.Unlock();

        // release all references acquired so far
        if (fVNodeCountingEnabled) {
                for (; vnode->useCount > 0; vnode->useCount--)
                        put_vnode(fFSVolume, vnid);
        }

        vnode->Delete(this);
}


// _InternalIOCtl
status_t
Volume::_InternalIOCtl(userlandfs_ioctl* buffer, int32 bufferSize)
{
        if (buffer->version != USERLAND_IOCTL_CURRENT_VERSION)
                return B_BAD_VALUE;
        status_t result = B_OK;
        switch (buffer->command) {
                case USERLAND_IOCTL_PUT_ALL_PENDING_VNODES:
                        result = _PutAllPendingVNodes();
                        break;
                default:
                        return B_BAD_VALUE;
        }
        buffer->error = result;
        return B_OK;
}

// _PutAllPendingVNodes
status_t
Volume::_PutAllPendingVNodes()
{
PRINT(("Volume::_PutAllPendingVNodes()\n"));
        if (!fFileSystem->GetPortPool()->IsDisconnected()) {
                PRINT(("Volume::_PutAllPendingVNodes() failed: still connected\n"));
                return USERLAND_IOCTL_STILL_CONNECTED;
        }

        MutexLocker locker(fLock);

        if (!fVNodeCountingEnabled) {
                PRINT(("Volume::_PutAllPendingVNodes() failed: vnode counting "
                        "disabled\n"));
                return USERLAND_IOCTL_VNODE_COUNTING_DISABLED;
        }
        // Check whether there are open entities at the moment.
        if (atomic_get(&fOpenFiles) > 0) {
                PRINT(("Volume::_PutAllPendingVNodes() failed: open files\n"));
                return USERLAND_IOCTL_OPEN_FILES;
        }
        if (atomic_get(&fOpenDirectories) > 0) {
                PRINT(("Volume::_PutAllPendingVNodes() failed: open dirs\n"));
                return USERLAND_IOCTL_OPEN_DIRECTORIES;
        }
        if (atomic_get(&fOpenAttributeDirectories) > 0) {
                PRINT(("Volume::_PutAllPendingVNodes() failed: open attr dirs\n"));
                return USERLAND_IOCTL_OPEN_ATTRIBUTE_DIRECTORIES;
        }
        if (atomic_get(&fOpenAttributes) > 0) {
                PRINT(("Volume::_PutAllPendingVNodes() failed: open attributes\n"));
                return USERLAND_IOCTL_OPEN_ATTRIBUTES;
        }
        if (atomic_get(&fOpenIndexDirectories) > 0) {
                PRINT(("Volume::_PutAllPendingVNodes() failed: open index dirs\n"));
                return USERLAND_IOCTL_OPEN_INDEX_DIRECTORIES;
        }
        if (atomic_get(&fOpenQueries) > 0) {
                PRINT(("Volume::_PutAllPendingVNodes() failed: open queries\n"));
                return USERLAND_IOCTL_OPEN_QUERIES;
        }
        // No open entities. Since the port pool is disconnected, no new
        // entities can be opened. Disable node counting and put all pending
        // vnodes.
        fVNodeCountingEnabled = false;

        int32 putVNodeCount = 0;

        // Since the vnode map can still change, we need to iterate to the first
        // node we need to put, drop the lock, put the node, and restart from the
        // beginning.
        // TODO: Optimize by extracting batches of relevant nodes to an on-stack
        // array.
        bool nodeFound;
        do {
                nodeFound = false;

                // get the next node to put
                for (VNodeMap::Iterator it = fVNodes->GetIterator();
                                VNode* vnode = it.Next();) {
                        if (vnode->useCount > 0) {
                                ino_t vnid = vnode->id;
                                int32 count = vnode->useCount;
                                vnode->useCount = 0;
                                fs_vnode_ops* ops = vnode->ops->ops;
                                bool published = vnode->published;

                                locker.Unlock();

                                // If the node has not yet been published, we have to do that
                                // before putting otherwise the VFS will complain that the node
                                // is busy when the last reference is gone.
                                if (!published)
                                        publish_vnode(fFSVolume, vnid, vnode, ops, S_IFDIR, 0);

                                for (int32 i = 0; i < count; i++) {
                                        PutVNode(vnid);
                                        putVNodeCount++;
                                }

                                locker.Lock();

                                nodeFound = true;
                                break;
                        }
                }
        } while (nodeFound);

        PRINT(("Volume::_PutAllPendingVNodes() successful: Put %" B_PRId32
                " vnodes\n", putVNodeCount));

        return B_OK;
}


// _RegisterIORequest
status_t
Volume::_RegisterIORequest(io_request* request, int32* requestID)
{
        MutexLocker _(fLock);

        // get the next free ID
        while (fIORequestInfosByID->Lookup(++fLastIORequestID) != NULL) {
        }

        // allocate the info
        IORequestInfo* info = new(std::nothrow) IORequestInfo(request,
                ++fLastIORequestID);
        if (info == NULL)
                return B_NO_MEMORY;

        // add the info to the maps
        fIORequestInfosByID->Insert(info);
        fIORequestInfosByStruct->Insert(info);

        *requestID = info->id;

        return B_OK;
}


// _UnregisterIORequest
status_t
Volume::_UnregisterIORequest(int32 requestID)
{
        MutexLocker _(fLock);

        if (IORequestInfo* info = fIORequestInfosByID->Lookup(requestID)) {
                fIORequestInfosByID->Remove(info);
                fIORequestInfosByStruct->Remove(info);
                return B_OK;
        }

        return B_ENTRY_NOT_FOUND;
}


// _FindIORequest
status_t
Volume::_FindIORequest(int32 requestID, io_request** request)
{
        MutexLocker _(fLock);

        if (IORequestInfo* info = fIORequestInfosByID->Lookup(requestID)) {
                *request = info->request;
                return B_OK;
        }

        return B_ENTRY_NOT_FOUND;
}


// _FindIORequest
status_t
Volume::_FindIORequest(io_request* request, int32* requestID)
{
        MutexLocker _(fLock);

        if (IORequestInfo* info = fIORequestInfosByStruct->Lookup(request)) {
                *requestID = info->id;
                return B_OK;
        }

        return B_ENTRY_NOT_FOUND;
}


/*static*/ status_t
Volume::_IterativeFDIOGetVecs(void* _cookie, io_request* ioRequest,
        off_t offset, size_t size, struct file_io_vec* vecs, size_t* _count)
{
        IterativeFDIOCookie* cookie = (IterativeFDIOCookie*)_cookie;
        Volume* volume = cookie->volume;

        MutexLocker locker(volume->fLock);

        // If there are vecs cached in the cookie and the offset matches, return
        // those.
        if (cookie->vecs != NULL) {
                size_t vecCount = 0;
                if (offset == cookie->offset) {
                        // good, copy the vecs
                        while (size > 0 && vecCount < cookie->vecCount
                                        && vecCount < *_count) {
                                off_t maxSize = std::min((off_t)size,
                                        cookie->vecs[vecCount].length);
                                vecs[vecCount].offset = cookie->vecs[vecCount].offset;
                                vecs[vecCount].length = maxSize;

                                size -= maxSize;
                                vecCount++;
                        }
                }

                cookie->vecs = NULL;
                cookie->vecCount = 0;

                // got some vecs? -- then we're done
                if (vecCount > 0) {
                        *_count = vecCount;
                        return B_OK;
                }
        }

        // we have to ask the client FS
        int32 requestID = cookie->requestID;
        void* clientCookie = cookie->clientCookie;
        locker.Unlock();

        // get a free port
        RequestPort* port = volume->fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _(volume->fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        IterativeIOGetVecsRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = volume->fUserlandVolume;
        request->cookie = clientCookie;
        request->offset = offset;
        request->request = requestID;
        request->size = size;
        size_t maxVecs = std::min(*_count,
                (size_t)IterativeIOGetVecsReply::MAX_VECS);
        request->vecCount = maxVecs;

        // send the request
        KernelRequestHandler handler(volume, ITERATIVE_IO_GET_VECS_REPLY);
        IterativeIOGetVecsReply* reply;
        error = volume->_SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        uint32 vecCount = reply->vecCount;
        if (vecCount < 0 || vecCount > maxVecs)
                return B_BAD_DATA;

        memcpy(vecs, reply->vecs, vecCount * sizeof(file_io_vec));
        *_count = vecCount;

        return B_OK;
}


/*static*/ status_t
Volume::_IterativeFDIOFinished(void* _cookie, io_request* ioRequest,
        status_t status, bool partialTransfer, size_t bytesTransferred)
{
        IterativeFDIOCookie* cookie = (IterativeFDIOCookie*)_cookie;
        Volume* volume = cookie->volume;

        // At any rate, we're done with the cookie after this call -- it will not
        // be used anymore.
        BReference<IterativeFDIOCookie> _(cookie, true);

        // We also want to dispose of the request.
        IORequestRemover _2(volume, cookie->requestID);

        // get a free port
        RequestPort* port = volume->fFileSystem->GetPortPool()->AcquirePort();
        if (!port)
                return B_ERROR;
        PortReleaser _3(volume->fFileSystem->GetPortPool(), port);

        // prepare the request
        RequestAllocator allocator(port->GetPort());
        IterativeIOFinishedRequest* request;
        status_t error = AllocateRequest(allocator, &request);
        if (error != B_OK)
                return error;

        request->volume = volume->fUserlandVolume;
        request->cookie = cookie->clientCookie;
        request->request = cookie->requestID;
        request->status = status;
        request->partialTransfer = partialTransfer;
        request->bytesTransferred = bytesTransferred;

        // send the request
        KernelRequestHandler handler(volume, ITERATIVE_IO_FINISHED_REPLY);
        IterativeIOFinishedReply* reply;
        error = volume->_SendRequest(port, &allocator, &handler, (Request**)&reply);
        if (error != B_OK)
                return error;
        RequestReleaser requestReleaser(port, reply);

        // process the reply
        if (reply->error != B_OK)
                return reply->error;
        return B_OK;
}