haiku.git

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

#include "HaikuKernelVolume.h"

#include <new>

#include <fcntl.h>
#include <string.h>
#include <unistd.h>

#include "AutoDeleter.h"
#include "AutoLocker.h"
#include "Debug.h"
#include "HashMap.h"

#include "../IORequestInfo.h"
#include "../kernel_emu.h"

#include "HaikuKernelFileSystem.h"
#include "HaikuKernelIORequest.h"
#include "HaikuKernelNode.h"


// NodeMap
class HaikuKernelVolume::NodeMap
	: public SynchronizedHashMap<HashKey64<ino_t>, HaikuKernelNode*, Locker> {
};


// _FileSystem
inline HaikuKernelFileSystem*
HaikuKernelVolume::_FileSystem() const
{
	return static_cast<HaikuKernelFileSystem*>(fFileSystem);
}


// constructor
HaikuKernelVolume::HaikuKernelVolume(FileSystem* fileSystem, dev_t id,
	file_system_module_info* fsModule)
	:
	Volume(fileSystem, id),
	fFSModule(fsModule),
	fNodes(NULL)
{
	fVolume.id = id;
	fVolume.partition = -1;
	fVolume.layer = 0;
	fVolume.private_volume = NULL;		// filled in by the FS
	fVolume.ops = NULL;					// filled in by the FS
	fVolume.sub_volume = NULL;
	fVolume.super_volume = NULL;
	fVolume.file_system = fFSModule;
	fVolume.file_system_name = const_cast<char*>(fileSystem->GetName());
	fVolume.haikuVolume = this;
}

// destructor
HaikuKernelVolume::~HaikuKernelVolume()
{
	delete fNodes;
}


// Init
status_t
HaikuKernelVolume::Init()
{
	fNodes = new(std::nothrow) NodeMap;
	if (fNodes == NULL)
		return B_NO_MEMORY;
	return fNodes->InitCheck();
}


// NewVNode
status_t
HaikuKernelVolume::NewVNode(ino_t vnodeID, void* privateNode, fs_vnode_ops* ops,
	HaikuKernelNode** _node)
{
	AutoLocker<NodeMap> _(fNodes);

	// check whether we do already know the node
	HaikuKernelNode* node = fNodes->Get(vnodeID);
	if (node != NULL)
		return B_BAD_VALUE;

	// get node capabilities
	HaikuKernelNode::Capabilities* capabilities
		= _FileSystem()->GetNodeCapabilities(ops);
	if (capabilities == NULL)
		return B_NO_MEMORY;

	// create a new node
	node = new(std::nothrow) HaikuKernelNode(this, vnodeID, privateNode, ops,
		capabilities);
	if (node == NULL) {
		_FileSystem()->PutNodeCapabilities(capabilities);
		return B_NO_MEMORY;
	}

	// add to map
	status_t error = fNodes->Put(vnodeID, node);
	if (error != B_OK) {
		delete node;
		return error;
	}

	*_node = node;

	return B_OK;
}


// PublishVNode
status_t
HaikuKernelVolume::PublishVNode(ino_t vnodeID, void* privateNode,
	fs_vnode_ops* ops, int type, uint32 flags, HaikuKernelNode** _node)
{
	AutoLocker<NodeMap> _(fNodes);

	// check whether we do already know the node
	HaikuKernelNode* node = fNodes->Get(vnodeID);
	if (node != NULL) {
		if (node->published)
			return B_BAD_VALUE;
	} else {
		// get node capabilities
		HaikuKernelNode::Capabilities* capabilities
			= _FileSystem()->GetNodeCapabilities(ops);
		if (capabilities == NULL)
			return B_NO_MEMORY;

		// create a new node
		node = new(std::nothrow) HaikuKernelNode(this, vnodeID, privateNode,
			ops, capabilities);
		if (node == NULL) {
			_FileSystem()->PutNodeCapabilities(capabilities);
			return B_NO_MEMORY;
		}

		// add to map
		status_t error = fNodes->Put(vnodeID, node);
		if (error != B_OK) {
			delete node;
			return error;
		}
	}

	node->published = true;

	*_node = node;

	return B_OK;
}


// UndoNewVNode
void
HaikuKernelVolume::UndoNewVNode(HaikuKernelNode* node)
{
	fNodes->Remove(node->id);
	delete node;
}


// UndoPublishVNode
void
HaikuKernelVolume::UndoPublishVNode(HaikuKernelNode* node)
{
	fNodes->Remove(node->id);
	delete node;
}


// NodeWithID
HaikuKernelNode*
HaikuKernelVolume::NodeWithID(ino_t vnodeID) const
{
	return fNodes->Get(vnodeID);
}


// #pragma mark -
// #pragma mark ----- FS -----

// Mount
status_t
HaikuKernelVolume::Mount(const char* device, uint32 flags,
	const char* parameters, ino_t* rootID)
{
	if (!fFSModule->mount)
		return B_BAD_VALUE;

	// mount
	status_t error = fFSModule->mount(&fVolume, device, flags, parameters,
		rootID);
	if (error != B_OK)
		return error;

	_InitCapabilities();

	return B_OK;
}

// Unmount
status_t
HaikuKernelVolume::Unmount()
{
	if (!fVolume.ops->unmount)
		return B_BAD_VALUE;

	return fVolume.ops->unmount(&fVolume);
}

// Sync
status_t
HaikuKernelVolume::Sync()
{
	if (!fVolume.ops->sync)
		return B_BAD_VALUE;
	return fVolume.ops->sync(&fVolume);
}

// ReadFSInfo
status_t
HaikuKernelVolume::ReadFSInfo(fs_info* info)
{
	if (!fVolume.ops->read_fs_info)
		return B_BAD_VALUE;
	return fVolume.ops->read_fs_info(&fVolume, info);
}

// WriteFSInfo
status_t
HaikuKernelVolume::WriteFSInfo(const struct fs_info* info, uint32 mask)
{
	if (!fVolume.ops->write_fs_info)
		return B_BAD_VALUE;
	return fVolume.ops->write_fs_info(&fVolume, info, mask);
}


// #pragma mark - file cache


// GetFileMap
status_t
HaikuKernelVolume::GetFileMap(void* _node, off_t offset, size_t size,
	struct file_io_vec* vecs, size_t* count)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->get_file_map)
		return B_BAD_VALUE;
	return node->ops->get_file_map(&fVolume, node, offset, size, vecs,
		count);
}


// #pragma mark - vnodes


// Lookup
status_t
HaikuKernelVolume::Lookup(void* _dir, const char* entryName, ino_t* vnid)
{
	HaikuKernelNode* dir = (HaikuKernelNode*)_dir;

	if (!dir->ops->lookup)
		return B_BAD_VALUE;
	return dir->ops->lookup(&fVolume, dir, entryName, vnid);

}

// GetVNodeName
status_t
HaikuKernelVolume::GetVNodeName(void* _node, char* buffer, size_t bufferSize)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	// If not implemented by the client file system, we invoke our super class
	// version, which emulates the functionality.
	if (!node->ops->get_vnode_name)
		return Volume::GetVNodeName(_node, buffer, bufferSize);
	return node->ops->get_vnode_name(&fVolume, node, buffer, bufferSize);
}

// ReadVNode
status_t
HaikuKernelVolume::ReadVNode(ino_t vnid, bool reenter, void** _node, int* type,
	uint32* flags, FSVNodeCapabilities* _capabilities)
{
	if (!fVolume.ops->get_vnode)
		return B_BAD_VALUE;

	// create a new wrapper node and add it to the map
	HaikuKernelNode* node = new(std::nothrow) HaikuKernelNode(this, vnid, NULL,
		NULL, NULL);
	if (node == NULL)
		return B_NO_MEMORY;
	ObjectDeleter<HaikuKernelNode> nodeDeleter(node);

	AutoLocker<NodeMap> locker(fNodes);
	if (fNodes->Get(vnid) != NULL)
		return B_BAD_VALUE;

	status_t error = fNodes->Put(vnid, node);
	if (error != B_OK)
		return error;

	locker.Unlock();

	// get the node
	error = fVolume.ops->get_vnode(&fVolume, vnid, node, type, flags, reenter);
	if (error != B_OK) {
		locker.Lock();
		fNodes->Remove(vnid);
		return error;
	}

	// get node capabilities
	HaikuKernelNode::Capabilities* capabilities
		= _FileSystem()->GetNodeCapabilities(node->ops);
	if (capabilities == NULL) {
		node->ops->put_vnode(&fVolume, node, reenter);
		locker.Lock();
		fNodes->Remove(vnid);
		return B_NO_MEMORY;
	}

	locker.Lock();
	node->capabilities = capabilities;
	node->published = true;
	nodeDeleter.Detach();

	*_node = node;
	*_capabilities = capabilities->capabilities;

	return B_OK;
}

// WriteVNode
status_t
HaikuKernelVolume::WriteVNode(void* _node, bool reenter)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	fNodes->Remove(node->id);

	if (!node->ops->put_vnode)
		return B_BAD_VALUE;
	status_t error = node->ops->put_vnode(&fVolume, node, reenter);

	delete node;

	return error;
}

// RemoveVNode
status_t
HaikuKernelVolume::RemoveVNode(void* _node, bool reenter)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	fNodes->Remove(node->id);

	if (!node->ops->remove_vnode)
		return B_BAD_VALUE;
	return node->ops->remove_vnode(&fVolume, node, reenter);
}


// #pragma mark - asynchronous I/O


status_t
HaikuKernelVolume::DoIO(void* _node, void* cookie,
	const IORequestInfo& requestInfo)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->io)
		return B_BAD_VALUE;

	// create a request object
	HaikuKernelIORequest* request
		= new(std::nothrow) HaikuKernelIORequest(this, requestInfo);
	if (request == NULL)
		RETURN_ERROR(B_NO_MEMORY);

	status_t error = _FileSystem()->AddIORequest(request);
	if (error != B_OK) {
		delete request;
		RETURN_ERROR(error);
	}

	// call the hook
	error = node->ops->io(&fVolume, node, cookie, (io_request*)request);

	// directly put our reference to the request, if the call failed
	if (error != B_OK) {
		_FileSystem()->PutIORequest(request);
		RETURN_ERROR(error);
	}

	// TODO: ATM we don't release our reference when the request is finished
	// normally!

	return B_OK;
}


status_t
HaikuKernelVolume::CancelIO(void* _node, void* cookie, int32 ioRequestID)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->cancel_io)
		return B_BAD_VALUE;

	// get the request
	HaikuKernelIORequest* request = _FileSystem()->GetIORequest(ioRequestID);
	if (request == NULL)
		RETURN_ERROR(B_BAD_VALUE);

	// call the hook
	status_t error = node->ops->cancel_io(&fVolume, node, cookie,
		(io_request*)request);

	// put the request -- once for the reference we got above, once for the
	// reference we've got in DoIO()
	_FileSystem()->PutIORequest(request, 2);

	return error;
}


// IterativeIOGetVecs
status_t
HaikuKernelVolume::IterativeIOGetVecs(void* _cookie, int32 requestID,
	off_t offset, size_t size, struct file_io_vec* vecs, size_t* _count)
{
	HaikuKernelIterativeFDIOCookie* cookie
		= (HaikuKernelIterativeFDIOCookie*)_cookie;

	// get the request
	HaikuKernelIORequest* request = _FileSystem()->GetIORequest(requestID);
	if (request == NULL)
		RETURN_ERROR(B_BAD_VALUE);

	// call the callback
	status_t error = cookie->getVecs(cookie->cookie, (io_request*)request,
		offset, size, vecs, _count);

	// put the reference we got above
	_FileSystem()->PutIORequest(request, 1);

	return error;
}


// IterativeIOFinished
status_t
HaikuKernelVolume::IterativeIOFinished(void* _cookie, int32 requestID,
	status_t status, bool partialTransfer, size_t bytesTransferred)
{
	HaikuKernelIterativeFDIOCookie* cookie
		= (HaikuKernelIterativeFDIOCookie*)_cookie;

	// we're definitely done with the cookie, now
	ObjectDeleter<HaikuKernelIterativeFDIOCookie> _(cookie);

	// get the request
	HaikuKernelIORequest* request = _FileSystem()->GetIORequest(requestID);
	if (request == NULL)
		RETURN_ERROR(B_BAD_VALUE);

	// call the callback
	status_t error = cookie->finished(cookie->cookie, (io_request*)request,
		status, partialTransfer, bytesTransferred);

	// We're done with the request, too, so put the reference we got above and
	// the one added by DoIO().
	_FileSystem()->PutIORequest(request, 2);

	return error;
}


// #pragma mark - nodes


// IOCtl
status_t
HaikuKernelVolume::IOCtl(void* _node, void* cookie, uint32 command,
	void* buffer, size_t size)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->ioctl)
		return B_BAD_VALUE;
	return node->ops->ioctl(&fVolume, node, cookie, command, buffer,
		size);
}

// SetFlags
status_t
HaikuKernelVolume::SetFlags(void* _node, void* cookie, int flags)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->set_flags)
		return B_BAD_VALUE;
	return node->ops->set_flags(&fVolume, node, cookie, flags);
}

// Select
status_t
HaikuKernelVolume::Select(void* _node, void* cookie, uint8 event,
	selectsync* sync)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->select) {
		UserlandFS::KernelEmu::notify_select_event(sync, event, false);
		return B_OK;
	}
	return node->ops->select(&fVolume, node, cookie, event, sync);
}

// Deselect
status_t
HaikuKernelVolume::Deselect(void* _node, void* cookie, uint8 event,
	selectsync* sync)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->select || !node->ops->deselect)
		return B_OK;
	return node->ops->deselect(&fVolume, node, cookie, event, sync);
}

// FSync
status_t
HaikuKernelVolume::FSync(void* _node)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->fsync)
		return B_BAD_VALUE;
	return node->ops->fsync(&fVolume, node, false);
}

// ReadSymlink
status_t
HaikuKernelVolume::ReadSymlink(void* _node, char* buffer, size_t bufferSize,
	size_t* bytesRead)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->read_symlink)
		return B_BAD_VALUE;

	*bytesRead = bufferSize;

	return node->ops->read_symlink(&fVolume, node, buffer, bytesRead);
}

// CreateSymlink
status_t
HaikuKernelVolume::CreateSymlink(void* _dir, const char* name,
	const char* target, int mode)
{
	HaikuKernelNode* dir = (HaikuKernelNode*)_dir;

	if (!dir->ops->create_symlink)
		return B_BAD_VALUE;
	return dir->ops->create_symlink(&fVolume, dir, name, target, mode);
}

// Link
status_t
HaikuKernelVolume::Link(void* _dir, const char* name, void* _node)
{
	HaikuKernelNode* dir = (HaikuKernelNode*)_dir;
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!dir->ops->link)
		return B_BAD_VALUE;
	return dir->ops->link(&fVolume, dir, name, node);
}

// Unlink
status_t
HaikuKernelVolume::Unlink(void* _dir, const char* name)
{
	HaikuKernelNode* dir = (HaikuKernelNode*)_dir;

	if (!dir->ops->unlink)
		return B_BAD_VALUE;
	return dir->ops->unlink(&fVolume, dir, name);
}

// Rename
status_t
HaikuKernelVolume::Rename(void* _oldDir, const char* oldName, void* _newDir,
	const char* newName)
{
	HaikuKernelNode* oldDir = (HaikuKernelNode*)_oldDir;
	HaikuKernelNode* newDir = (HaikuKernelNode*)_newDir;

	if (!oldDir->ops->rename)
		return B_BAD_VALUE;
	return oldDir->ops->rename(&fVolume, oldDir, oldName, newDir, newName);
}

// Access
status_t
HaikuKernelVolume::Access(void* _node, int mode)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->access)
		return B_OK;
	return node->ops->access(&fVolume, node, mode);
}

// ReadStat
status_t
HaikuKernelVolume::ReadStat(void* _node, struct stat* st)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->read_stat)
		return B_BAD_VALUE;
	return node->ops->read_stat(&fVolume, node, st);
}

// WriteStat
status_t
HaikuKernelVolume::WriteStat(void* _node, const struct stat *st, uint32 mask)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->write_stat)
		return B_BAD_VALUE;
	return node->ops->write_stat(&fVolume, node, st, mask);
}


// #pragma mark - files


// Create
status_t
HaikuKernelVolume::Create(void* _dir, const char* name, int openMode, int mode,
	void** cookie, ino_t* vnid)
{
	HaikuKernelNode* dir = (HaikuKernelNode*)_dir;

	if (!dir->ops->create)
		return B_BAD_VALUE;
	return dir->ops->create(&fVolume, dir, name, openMode, mode, cookie,
		vnid);
}

// Open
status_t
HaikuKernelVolume::Open(void* _node, int openMode, void** cookie)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->open)
		return B_BAD_VALUE;
	return node->ops->open(&fVolume, node, openMode, cookie);
}

// Close
status_t
HaikuKernelVolume::Close(void* _node, void* cookie)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->close)
		return B_OK;
	return node->ops->close(&fVolume, node, cookie);
}

// FreeCookie
status_t
HaikuKernelVolume::FreeCookie(void* _node, void* cookie)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->free_cookie)
		return B_OK;
	return node->ops->free_cookie(&fVolume, node, cookie);
}

// Read
status_t
HaikuKernelVolume::Read(void* _node, void* cookie, off_t pos, void* buffer,
	size_t bufferSize, size_t* bytesRead)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->read)
		return B_BAD_VALUE;

	*bytesRead = bufferSize;

	return node->ops->read(&fVolume, node, cookie, pos, buffer, bytesRead);
}

// Write
status_t
HaikuKernelVolume::Write(void* _node, void* cookie, off_t pos,
	const void* buffer, size_t bufferSize, size_t* bytesWritten)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->write)
		return B_BAD_VALUE;

	*bytesWritten = bufferSize;

	return node->ops->write(&fVolume, node, cookie, pos, buffer,
		bytesWritten);
}


// #pragma mark -  directories


// CreateDir
status_t
HaikuKernelVolume::CreateDir(void* _dir, const char* name, int mode)
{
	HaikuKernelNode* dir = (HaikuKernelNode*)_dir;

	if (!dir->ops->create_dir)
		return B_BAD_VALUE;
	return dir->ops->create_dir(&fVolume, dir, name, mode);
}

// RemoveDir
status_t
HaikuKernelVolume::RemoveDir(void* _dir, const char* name)
{
	HaikuKernelNode* dir = (HaikuKernelNode*)_dir;

	if (!dir->ops->remove_dir)
		return B_BAD_VALUE;
	return dir->ops->remove_dir(&fVolume, dir, name);
}

// OpenDir
status_t
HaikuKernelVolume::OpenDir(void* _node, void** cookie)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->open_dir)
		return B_BAD_VALUE;
	return node->ops->open_dir(&fVolume, node, cookie);
}

// CloseDir
status_t
HaikuKernelVolume::CloseDir(void* _node, void* cookie)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->close_dir)
		return B_OK;
	return node->ops->close_dir(&fVolume, node, cookie);
}

// FreeDirCookie
status_t
HaikuKernelVolume::FreeDirCookie(void* _node, void* cookie)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->free_dir_cookie)
		return B_OK;
	return node->ops->free_dir_cookie(&fVolume, node, cookie);
}

// ReadDir
status_t
HaikuKernelVolume::ReadDir(void* _node, void* cookie, void* buffer,
	size_t bufferSize, uint32 count, uint32* countRead)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->read_dir)
		return B_BAD_VALUE;

	*countRead = count;

	return node->ops->read_dir(&fVolume, node, cookie,
		(struct dirent*)buffer, bufferSize, countRead);
}

// RewindDir
status_t
HaikuKernelVolume::RewindDir(void* _node, void* cookie)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->rewind_dir)
		return B_BAD_VALUE;
	return node->ops->rewind_dir(&fVolume, node, cookie);
}


// #pragma mark - attribute directories


// OpenAttrDir
status_t
HaikuKernelVolume::OpenAttrDir(void* _node, void** cookie)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->open_attr_dir)
		return B_BAD_VALUE;
	return node->ops->open_attr_dir(&fVolume, node, cookie);
}

// CloseAttrDir
status_t
HaikuKernelVolume::CloseAttrDir(void* _node, void* cookie)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->close_attr_dir)
		return B_OK;
	return node->ops->close_attr_dir(&fVolume, node, cookie);
}

// FreeAttrDirCookie
status_t
HaikuKernelVolume::FreeAttrDirCookie(void* _node, void* cookie)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->free_attr_dir_cookie)
		return B_OK;
	return node->ops->free_attr_dir_cookie(&fVolume, node, cookie);
}

// ReadAttrDir
status_t
HaikuKernelVolume::ReadAttrDir(void* _node, void* cookie, void* buffer,
	size_t bufferSize, uint32 count, uint32* countRead)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->read_attr_dir)
		return B_BAD_VALUE;

	*countRead = count;

	return node->ops->read_attr_dir(&fVolume, node, cookie,
		(struct dirent*)buffer, bufferSize, countRead);
}

// RewindAttrDir
status_t
HaikuKernelVolume::RewindAttrDir(void* _node, void* cookie)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->rewind_attr_dir)
		return B_BAD_VALUE;
	return node->ops->rewind_attr_dir(&fVolume, node, cookie);
}


// #pragma mark - attributes


// CreateAttr
status_t
HaikuKernelVolume::CreateAttr(void* _node, const char* name, uint32 type,
	int openMode, void** cookie)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->create_attr)
		return B_BAD_VALUE;
	return node->ops->create_attr(&fVolume, node, name, type, openMode,
		cookie);
}

// OpenAttr
status_t
HaikuKernelVolume::OpenAttr(void* _node, const char* name, int openMode,
	void** cookie)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->open_attr)
		return B_BAD_VALUE;
	return node->ops->open_attr(&fVolume, node, name, openMode, cookie);
}

// CloseAttr
status_t
HaikuKernelVolume::CloseAttr(void* _node, void* cookie)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->close_attr)
		return B_OK;
	return node->ops->close_attr(&fVolume, node, cookie);
}

// FreeAttrCookie
status_t
HaikuKernelVolume::FreeAttrCookie(void* _node, void* cookie)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->free_attr_cookie)
		return B_OK;
	return node->ops->free_attr_cookie(&fVolume, node, cookie);
}

// ReadAttr
status_t
HaikuKernelVolume::ReadAttr(void* _node, void* cookie, off_t pos,
	void* buffer, size_t bufferSize, size_t* bytesRead)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->read_attr)
		return B_BAD_VALUE;

	*bytesRead = bufferSize;

	return node->ops->read_attr(&fVolume, node, cookie, pos, buffer,
		bytesRead);
}

// WriteAttr
status_t
HaikuKernelVolume::WriteAttr(void* _node, void* cookie, off_t pos,
	const void* buffer, size_t bufferSize, size_t* bytesWritten)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->write_attr)
		return B_BAD_VALUE;

	*bytesWritten = bufferSize;

	return node->ops->write_attr(&fVolume, node, cookie, pos, buffer,
		bytesWritten);
}

// ReadAttrStat
status_t
HaikuKernelVolume::ReadAttrStat(void* _node, void* cookie,
	struct stat *st)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->read_attr_stat)
		return B_BAD_VALUE;
	return node->ops->read_attr_stat(&fVolume, node, cookie, st);
}

// WriteAttrStat
status_t
HaikuKernelVolume::WriteAttrStat(void* _node, void* cookie,
	const struct stat* st, int statMask)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->write_attr_stat)
		return B_BAD_VALUE;
	return node->ops->write_attr_stat(&fVolume, node, cookie, st,
		statMask);
}

// RenameAttr
status_t
HaikuKernelVolume::RenameAttr(void* _oldNode, const char* oldName,
	void* _newNode, const char* newName)
{
	HaikuKernelNode* oldNode = (HaikuKernelNode*)_oldNode;
	HaikuKernelNode* newNode = (HaikuKernelNode*)_newNode;

	if (!oldNode->ops->rename_attr)
		return B_BAD_VALUE;
	return oldNode->ops->rename_attr(&fVolume, oldNode, oldName, newNode,
		newName);
}

// RemoveAttr
status_t
HaikuKernelVolume::RemoveAttr(void* _node, const char* name)
{
	HaikuKernelNode* node = (HaikuKernelNode*)_node;

	if (!node->ops->remove_attr)
		return B_BAD_VALUE;
	return node->ops->remove_attr(&fVolume, node, name);
}


// #pragma mark - indices


// OpenIndexDir
status_t
HaikuKernelVolume::OpenIndexDir(void** cookie)
{
	if (!fVolume.ops->open_index_dir)
		return B_BAD_VALUE;
	return fVolume.ops->open_index_dir(&fVolume, cookie);
}

// CloseIndexDir
status_t
HaikuKernelVolume::CloseIndexDir(void* cookie)
{
	if (!fVolume.ops->close_index_dir)
		return B_OK;
	return fVolume.ops->close_index_dir(&fVolume, cookie);
}

// FreeIndexDirCookie
status_t
HaikuKernelVolume::FreeIndexDirCookie(void* cookie)
{
	if (!fVolume.ops->free_index_dir_cookie)
		return B_OK;
	return fVolume.ops->free_index_dir_cookie(&fVolume, cookie);
}

// ReadIndexDir
status_t
HaikuKernelVolume::ReadIndexDir(void* cookie, void* buffer,
	size_t bufferSize, uint32 count, uint32* countRead)
{
	if (!fVolume.ops->read_index_dir)
		return B_BAD_VALUE;

	*countRead = count;

	return fVolume.ops->read_index_dir(&fVolume, cookie,
		(struct dirent*)buffer, bufferSize, countRead);
}

// RewindIndexDir
status_t
HaikuKernelVolume::RewindIndexDir(void* cookie)
{
	if (!fVolume.ops->rewind_index_dir)
		return B_BAD_VALUE;
	return fVolume.ops->rewind_index_dir(&fVolume, cookie);
}

// CreateIndex
status_t
HaikuKernelVolume::CreateIndex(const char* name, uint32 type, uint32 flags)
{
	if (!fVolume.ops->create_index)
		return B_BAD_VALUE;
	return fVolume.ops->create_index(&fVolume, name, type, flags);
}

// RemoveIndex
status_t
HaikuKernelVolume::RemoveIndex(const char* name)
{
	if (!fVolume.ops->remove_index)
		return B_BAD_VALUE;
	return fVolume.ops->remove_index(&fVolume, name);
}

// StatIndex
status_t
HaikuKernelVolume::ReadIndexStat(const char *name, struct stat *st)
{
	if (!fVolume.ops->read_index_stat)
		return B_BAD_VALUE;
	return fVolume.ops->read_index_stat(&fVolume, name, st);
}


// #pragma mark - queries


// OpenQuery
status_t
HaikuKernelVolume::OpenQuery(const char* queryString, uint32 flags,
	port_id port, uint32 token, void** cookie)
{
	if (!fVolume.ops->open_query)
		return B_BAD_VALUE;
	return fVolume.ops->open_query(&fVolume, queryString, flags, port,
		token, cookie);
}

// CloseQuery
status_t
HaikuKernelVolume::CloseQuery(void* cookie)
{
	if (!fVolume.ops->close_query)
		return B_OK;
	return fVolume.ops->close_query(&fVolume, cookie);
}

// FreeQueryCookie
status_t
HaikuKernelVolume::FreeQueryCookie(void* cookie)
{
	if (!fVolume.ops->free_query_cookie)
		return B_OK;
	return fVolume.ops->free_query_cookie(&fVolume, cookie);
}

// ReadQuery
status_t
HaikuKernelVolume::ReadQuery(void* cookie, void* buffer, size_t bufferSize,
	uint32 count, uint32* countRead)
{
	if (!fVolume.ops->read_query)
		return B_BAD_VALUE;

	*countRead = count;

	return fVolume.ops->read_query(&fVolume, cookie, (struct dirent*)buffer,
		bufferSize, countRead);
}

// RewindQuery
status_t
HaikuKernelVolume::RewindQuery(void* cookie)
{
	if (!fVolume.ops->rewind_query)
		return B_BAD_VALUE;
	return fVolume.ops->rewind_query(&fVolume, cookie);
}

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

	// FS operations
	fCapabilities.Set(FS_VOLUME_CAPABILITY_UNMOUNT, fVolume.ops->unmount);

	fCapabilities.Set(FS_VOLUME_CAPABILITY_READ_FS_INFO,
		fVolume.ops->read_fs_info);
	fCapabilities.Set(FS_VOLUME_CAPABILITY_WRITE_FS_INFO,
		fVolume.ops->write_fs_info);
	fCapabilities.Set(FS_VOLUME_CAPABILITY_SYNC, fVolume.ops->sync);

	// vnode operations
	fCapabilities.Set(FS_VOLUME_CAPABILITY_GET_VNODE, fVolume.ops->get_vnode);

	// index directory & index operations
	fCapabilities.Set(FS_VOLUME_CAPABILITY_OPEN_INDEX_DIR,
		fVolume.ops->open_index_dir);
	fCapabilities.Set(FS_VOLUME_CAPABILITY_CLOSE_INDEX_DIR,
		fVolume.ops->close_index_dir);
	fCapabilities.Set(FS_VOLUME_CAPABILITY_FREE_INDEX_DIR_COOKIE,
		fVolume.ops->free_index_dir_cookie);
	fCapabilities.Set(FS_VOLUME_CAPABILITY_READ_INDEX_DIR,
		fVolume.ops->read_index_dir);
	fCapabilities.Set(FS_VOLUME_CAPABILITY_REWIND_INDEX_DIR,
		fVolume.ops->rewind_index_dir);

	fCapabilities.Set(FS_VOLUME_CAPABILITY_CREATE_INDEX,
		fVolume.ops->create_index);
	fCapabilities.Set(FS_VOLUME_CAPABILITY_REMOVE_INDEX,
		fVolume.ops->remove_index);
	fCapabilities.Set(FS_VOLUME_CAPABILITY_READ_INDEX_STAT,
		fVolume.ops->read_index_stat);

	// query operations
	fCapabilities.Set(FS_VOLUME_CAPABILITY_OPEN_QUERY, fVolume.ops->open_query);
	fCapabilities.Set(FS_VOLUME_CAPABILITY_CLOSE_QUERY,
		fVolume.ops->close_query);
	fCapabilities.Set(FS_VOLUME_CAPABILITY_FREE_QUERY_COOKIE,
		fVolume.ops->free_query_cookie);
	fCapabilities.Set(FS_VOLUME_CAPABILITY_READ_QUERY, fVolume.ops->read_query);
	fCapabilities.Set(FS_VOLUME_CAPABILITY_REWIND_QUERY,
		fVolume.ops->rewind_query);
}