* Adjusted BeOSKernelFileSystem and BeOSKernelVolume to Haiku's FS interface.

* Moved stuff need for the BeOS interface only into the beos_* namespace.
* Shuffled a few things around to reduce the block cache implementation
  dependencies. compat.h and sysdep.c are gone accordingly.
* The whole UserlandFSServer builds now and could (at least theorectically)
  drive a FS add-on implementing the old interface. The required emulation of
  the BeOS kernel is not yet provided, though.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@20247 a95241bf-73f2-0310-859d-f6bbb57e9c96

src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelVolume.cpp

@@ -2,9 +2,12 @@
 
 #include "BeOSKernelVolume.h"
 
+#include "beos_fs_interface.h"
+#include "kernel_emu.h"
+
 // constructor
-BeOSKernelVolume::BeOSKernelVolume(FileSystem* fileSystem, nspace_id id,
-	vnode_ops* fsOps)
+BeOSKernelVolume::BeOSKernelVolume(FileSystem* fileSystem, mount_id id,
+	beos_vnode_ops* fsOps)
 	: Volume(fileSystem, id),
 	  fFSOps(fsOps),
 	  fVolumeCookie(NULL)
@@ -21,11 +24,13 @@ BeOSKernelVolume::~BeOSKernelVolume()
 
 // Mount
 status_t
-BeOSKernelVolume::Mount(const char* device, ulong flags, const char* parameters,
-	int32 len, vnode_id* rootID)
+BeOSKernelVolume::Mount(const char* device, uint32 flags,
+	const char* parameters, vnode_id* rootID)
 {
 	if (!fFSOps->mount)
 		return B_BAD_VALUE;
+
+	size_t len = (parameters ? strlen(parameters) : 0);
 	return fFSOps->mount(GetID(), device, flags, (void*)parameters, len,
 		&fVolumeCookie, rootID);
 }
@@ -48,100 +53,253 @@ BeOSKernelVolume::Sync()
 	return fFSOps->sync(fVolumeCookie);
 }
 
-// ReadFSStat
+// ReadFSInfo
 status_t
-BeOSKernelVolume::ReadFSStat(fs_info* info)
+BeOSKernelVolume::ReadFSInfo(fs_info* info)
 {
 	if (!fFSOps->rfsstat)
 		return B_BAD_VALUE;
-	return fFSOps->rfsstat(fVolumeCookie, info);
+
+	// Haiku's fs_info equals BeOS's version
+	return fFSOps->rfsstat(fVolumeCookie, (beos_fs_info*)info);
 }
 
-// WriteFSStat
+// WriteFSInfo
 status_t
-BeOSKernelVolume::WriteFSStat(struct fs_info *info, long mask)
+BeOSKernelVolume::WriteFSInfo(const struct fs_info* info, uint32 mask)
 {
 	if (!fFSOps->wfsstat)
 		return B_BAD_VALUE;
-	return fFSOps->wfsstat(fVolumeCookie, info, mask);
+
+	// Haiku's fs_info equals BeOS's version
+	return fFSOps->wfsstat(fVolumeCookie, (beos_fs_info*)info, (long)mask);
 }
 
-// #pragma mark -
-// #pragma mark ----- vnodes -----
+
+// #pragma mark - vnodes
+
+
+// Lookup
+status_t
+BeOSKernelVolume::Lookup(fs_vnode dir, const char* entryName, vnode_id* vnid,
+	int* type)
+{
+	if (!fFSOps->walk)
+		return B_BAD_VALUE;
+
+	status_t error = fFSOps->walk(fVolumeCookie, dir, entryName, NULL, vnid);
+	if (error != B_OK)
+		return error;
+
+	// We need to get the node stat to return the node's type.
+// TODO: This is quite expensive. get_vnode() and put_vnode() cause trips to
+// the kernel. If it is implemented properly walk() has already called
+// get_vnode() for our node. Introducing a mechanism that would allow us to
+// temporarily track the {get,put,new}_vnode() calls of our thread would save
+// those two kernel trips.
+
+	// get the vnode
+	fs_vnode node;
+	error = UserlandFS::KernelEmu::get_vnode(GetID(), *vnid, &node);
+	if (error != B_OK) {
+		// walk() has called get_vnode() for the caller, so we need to put the
+		// node
+		UserlandFS::KernelEmu::put_vnode(GetID(), *vnid);
+		return error;
+	}
+
+	// get the node's stat
+	struct stat st;
+	error = ReadStat(node, &st);
+	if (error == B_OK)
+		*type = (st.st_mode & S_IFMT);
+
+	// put the node for our get_vnode()	
+	UserlandFS::KernelEmu::put_vnode(GetID(), *vnid);
+
+	// on error put the node for walk()'s get_vnode()
+	if (error != B_OK)
+		UserlandFS::KernelEmu::put_vnode(GetID(), *vnid);
+
+	return error;
+}
 
 // ReadVNode
 status_t
-BeOSKernelVolume::ReadVNode(vnode_id vnid, char reenter, void** node)
+BeOSKernelVolume::ReadVNode(vnode_id vnid, bool reenter, fs_vnode* node)
 {
 	if (!fFSOps->read_vnode)
 		return B_BAD_VALUE;
-	return fFSOps->read_vnode(fVolumeCookie, vnid, reenter, node);
+	return fFSOps->read_vnode(fVolumeCookie, vnid, (char)reenter, node);
 }
 
 // WriteVNode
 status_t
-BeOSKernelVolume::WriteVNode(void* node, char reenter)
+BeOSKernelVolume::WriteVNode(fs_vnode node, bool reenter)
 {
 	if (!fFSOps->write_vnode)
 		return B_BAD_VALUE;
-	return fFSOps->write_vnode(fVolumeCookie, node, reenter);
+	return fFSOps->write_vnode(fVolumeCookie, node, (char)reenter);
 }
 
 // RemoveVNode
 status_t
-BeOSKernelVolume::RemoveVNode(void* node, char reenter)
+BeOSKernelVolume::RemoveVNode(fs_vnode node, bool reenter)
 {
 	if (!fFSOps->remove_vnode)
 		return B_BAD_VALUE;
-	return fFSOps->remove_vnode(fVolumeCookie, node, reenter);
+	return fFSOps->remove_vnode(fVolumeCookie, node, (char)reenter);
 }
 
-// #pragma mark -
-// #pragma mark ----- nodes -----
+
+// #pragma mark - nodes
+
+
+// IOCtl
+status_t
+BeOSKernelVolume::IOCtl(fs_vnode node, fs_cookie cookie, uint32 command,
+	void* buffer, size_t size)
+{
+	if (!fFSOps->ioctl)
+		return B_BAD_VALUE;
+	return fFSOps->ioctl(fVolumeCookie, node, cookie, (int)command, buffer,
+		size);
+}
+
+// SetFlags
+status_t
+BeOSKernelVolume::SetFlags(fs_vnode node, fs_cookie cookie, int flags)
+{
+	if (!fFSOps->setflags)
+		return B_BAD_VALUE;
+	return fFSOps->setflags(fVolumeCookie, node, cookie, flags);
+}
+
+// Select
+status_t
+BeOSKernelVolume::Select(fs_vnode node, fs_cookie cookie, uint8 event,
+	uint32 ref, selectsync* sync)
+{
+	if (!fFSOps->select) {
+// TODO: ...
+//		UserlandFS::KernelEmu::notify_select_event(sync, ref, event);
+		UserlandFS::KernelEmu::notify_select_event(sync, ref);
+		return B_OK;
+	}
+	return fFSOps->select(fVolumeCookie, node, cookie, event, ref, sync);
+}
+
+// Deselect
+status_t
+BeOSKernelVolume::Deselect(fs_vnode node, fs_cookie cookie, uint8 event,
+	selectsync* sync)
+{
+	if (!fFSOps->select || !fFSOps->deselect)
+		return B_OK;
+	return fFSOps->deselect(fVolumeCookie, node, cookie, event, sync);
+}
 
 // FSync
 status_t
-BeOSKernelVolume::FSync(void* node)
+BeOSKernelVolume::FSync(fs_vnode node)
 {
 	if (!fFSOps->fsync)
 		return B_BAD_VALUE;
 	return fFSOps->fsync(fVolumeCookie, node);
 }
 
-// ReadStat
+// ReadSymlink
 status_t
-BeOSKernelVolume::ReadStat(void* node, struct stat* st)
+BeOSKernelVolume::ReadSymlink(fs_vnode node, char* buffer, size_t bufferSize,
+	size_t* bytesRead)
 {
-	if (!fFSOps->rstat)
+	if (!fFSOps->readlink)
 		return B_BAD_VALUE;
-	return fFSOps->rstat(fVolumeCookie, node, st);
+	*bytesRead = bufferSize;
+	return fFSOps->readlink(fVolumeCookie, node, buffer, bytesRead);
 }
 
-// WriteStat
+// CreateSymlink
 status_t
-BeOSKernelVolume::WriteStat(void* node, struct stat* st, long mask)
+BeOSKernelVolume::CreateSymlink(fs_vnode dir, const char* name,
+	const char* target, int mode)
 {
-	if (!fFSOps->wstat)
+	if (!fFSOps->symlink)
 		return B_BAD_VALUE;
-	return fFSOps->wstat(fVolumeCookie, node, st, mask);
+// TODO: Don't ignore mode?
+	return fFSOps->symlink(fVolumeCookie, dir, name, target);
+}
+
+// Link
+status_t
+BeOSKernelVolume::Link(fs_vnode dir, const char* name, fs_vnode node)
+{
+	if (!fFSOps->link)
+		return B_BAD_VALUE;
+	return fFSOps->link(fVolumeCookie, dir, name, node);
+}
+
+// Unlink
+status_t
+BeOSKernelVolume::Unlink(fs_vnode dir, const char* name)
+{
+	if (!fFSOps->unlink)
+		return B_BAD_VALUE;
+	return fFSOps->unlink(fVolumeCookie, dir, name);
+}
+
+// Rename
+status_t
+BeOSKernelVolume::Rename(fs_vnode oldDir, const char* oldName, fs_vnode newDir,
+	const char* newName)
+{
+	if (!fFSOps->rename)
+		return B_BAD_VALUE;
+	return fFSOps->rename(fVolumeCookie, oldDir, oldName, newDir, newName);
 }
 
 // Access
 status_t
-BeOSKernelVolume::Access(void* node, int mode)
+BeOSKernelVolume::Access(fs_vnode node, int mode)
 {
 	if (!fFSOps->access)
 		return B_BAD_VALUE;
 	return fFSOps->access(fVolumeCookie, node, mode);
 }
 
-// #pragma mark -
-// #pragma mark ----- files -----
+// ReadStat
+status_t
+BeOSKernelVolume::ReadStat(fs_vnode node, struct stat* st)
+{
+	if (!fFSOps->rstat)
+		return B_BAD_VALUE;
+
+	// Haiku's struct stat has an additional st_type field (for an attribute
+	// type), but that doesn't matter here
+	return fFSOps->rstat(fVolumeCookie, node, (struct beos_stat*)st);
+}
+
+// WriteStat
+status_t
+BeOSKernelVolume::WriteStat(fs_vnode node, const struct stat *st, uint32 mask)
+{
+	if (!fFSOps->wstat)
+		return B_BAD_VALUE;
+	
+	// Haiku's struct stat has an additional st_type field (for an attribute
+	// type), but that doesn't matter here
+	return fFSOps->wstat(fVolumeCookie, node, (struct beos_stat*)st,
+		(long)mask);
+}
+
+
+// #pragma mark - files
+
 
 // Create
 status_t
-BeOSKernelVolume::Create(void* dir, const char* name, int openMode, int mode,
-	vnode_id* vnid, void** cookie)
+BeOSKernelVolume::Create(fs_vnode dir, const char* name, int openMode, int mode,
+	fs_cookie* cookie, vnode_id* vnid)
 {
 	if (!fFSOps->create)
 		return B_BAD_VALUE;
@@ -151,7 +309,7 @@ BeOSKernelVolume::Create(void* dir, const char* name, int openMode, int mode,
 
 // Open
 status_t
-BeOSKernelVolume::Open(void* node, int openMode, void** cookie)
+BeOSKernelVolume::Open(fs_vnode node, int openMode, fs_cookie* cookie)
 {
 	if (!fFSOps->open)
 		return B_BAD_VALUE;
@@ -160,7 +318,7 @@ BeOSKernelVolume::Open(void* node, int openMode, void** cookie)
 
 // Close
 status_t
-BeOSKernelVolume::Close(void* node, void* cookie)
+BeOSKernelVolume::Close(fs_vnode node, fs_cookie cookie)
 {
 	if (!fFSOps->close)
 		return B_OK;
@@ -169,7 +327,7 @@ BeOSKernelVolume::Close(void* node, void* cookie)
 
 // FreeCookie
 status_t
-BeOSKernelVolume::FreeCookie(void* node, void* cookie)
+BeOSKernelVolume::FreeCookie(fs_vnode node, fs_cookie cookie)
 {
 	if (!fFSOps->free_cookie)
 		return B_OK;
@@ -178,7 +336,7 @@ BeOSKernelVolume::FreeCookie(void* node, void* cookie)
 
 // Read
 status_t
-BeOSKernelVolume::Read(void* node, void* cookie, off_t pos, void* buffer,
+BeOSKernelVolume::Read(fs_vnode node, fs_cookie cookie, off_t pos, void* buffer,
 	size_t bufferSize, size_t* bytesRead)
 {
 	if (!fFSOps->read)
@@ -189,8 +347,8 @@ BeOSKernelVolume::Read(void* node, void* cookie, off_t pos, void* buffer,
 
 // Write
 status_t
-BeOSKernelVolume::Write(void* node, void* cookie, off_t pos, const void* buffer,
-	size_t bufferSize, size_t* bytesWritten)
+BeOSKernelVolume::Write(fs_vnode node, fs_cookie cookie, off_t pos,
+	const void* buffer, size_t bufferSize, size_t* bytesWritten)
 {
 	if (!fFSOps->write)
 		return B_BAD_VALUE;
@@ -199,113 +357,38 @@ BeOSKernelVolume::Write(void* node, void* cookie, off_t pos, const void* buffer,
 		bytesWritten);
 }
 
-// IOCtl
+
+// #pragma mark -  directories
+
+
+// CreateDir
 status_t
-BeOSKernelVolume::IOCtl(void* node, void* cookie, int command, void *buffer,
-	size_t size)
+BeOSKernelVolume::CreateDir(fs_vnode dir, const char* name, int mode,
+	vnode_id *newDir)
 {
-	if (!fFSOps->ioctl)
+	if (!fFSOps->mkdir || !fFSOps->walk)	// we need walk() too
 		return B_BAD_VALUE;
-	return fFSOps->ioctl(fVolumeCookie, node, cookie, command, buffer, size);
+
+	status_t error = fFSOps->mkdir(fVolumeCookie, dir, name, mode);
+	if (error != B_OK)
+		return error;
+
+	// we need to get the node ID by invoking walk()
+	vnode_id id;
+	error = fFSOps->walk(fVolumeCookie, dir, name, NULL, &id);
+	if (error != B_OK)
+		return error;
+
+	// put the node for walk()'s get_vnode()
+	UserlandFS::KernelEmu::put_vnode(GetID(), id);
+
+	*newDir = id;
+	return B_OK;
 }
 
-// SetFlags
+// RemoveDir
 status_t
-BeOSKernelVolume::SetFlags(void* node, void* cookie, int flags)
-{
-	if (!fFSOps->setflags)
-		return B_BAD_VALUE;
-	return fFSOps->setflags(fVolumeCookie, node, cookie, flags);
-}
-
-// Select
-status_t
-BeOSKernelVolume::Select(void* node, void* cookie, uint8 event, uint32 ref,
-	selectsync* sync)
-{
-	if (!fFSOps->select) {
-		notify_select_event(sync, ref);
-		return B_OK;
-	}
-	return fFSOps->select(fVolumeCookie, node, cookie, event, ref, sync);
-}
-
-// Deselect
-status_t
-BeOSKernelVolume::Deselect(void* node, void* cookie, uint8 event,
-	selectsync* sync)
-{
-	if (!fFSOps->select || !fFSOps->deselect)
-		return B_OK;
-	return fFSOps->deselect(fVolumeCookie, node, cookie, event, sync);
-}
-
-// #pragma mark -
-// #pragma mark ----- hard links / symlinks -----
-
-// Link
-status_t
-BeOSKernelVolume::Link(void* dir, const char* name, void* node)
-{
-	if (!fFSOps->link)
-		return B_BAD_VALUE;
-	return fFSOps->link(fVolumeCookie, dir, name, node);
-}
-
-// Unlink
-status_t
-BeOSKernelVolume::Unlink(void* dir, const char* name)
-{
-	if (!fFSOps->unlink)
-		return B_BAD_VALUE;
-	return fFSOps->unlink(fVolumeCookie, dir, name);
-}
-
-// Symlink
-status_t
-BeOSKernelVolume::Symlink(void* dir, const char* name, const char* target)
-{
-	if (!fFSOps->symlink)
-		return B_BAD_VALUE;
-	return fFSOps->symlink(fVolumeCookie, dir, name, target);
-}
-
-// ReadLink
-status_t
-BeOSKernelVolume::ReadLink(void* node, char* buffer, size_t bufferSize,
-	size_t* bytesRead)
-{
-	if (!fFSOps->readlink)
-		return B_BAD_VALUE;
-	*bytesRead = bufferSize;
-	return fFSOps->readlink(fVolumeCookie, node, buffer, bytesRead);
-}
-
-// Rename
-status_t
-BeOSKernelVolume::Rename(void* oldDir, const char* oldName, void* newDir,
-	const char* newName)
-{
-	if (!fFSOps->rename)
-		return B_BAD_VALUE;
-	return fFSOps->rename(fVolumeCookie, oldDir, oldName, newDir, newName);
-}
-
-// #pragma mark -
-// #pragma mark ----- directories -----
-
-// MkDir
-status_t
-BeOSKernelVolume::MkDir(void* dir, const char* name, int mode)
-{
-	if (!fFSOps->mkdir)
-		return B_BAD_VALUE;
-	return fFSOps->mkdir(fVolumeCookie, dir, name, mode);
-}
-
-// RmDir
-status_t
-BeOSKernelVolume::RmDir(void* dir, const char* name)
+BeOSKernelVolume::RemoveDir(fs_vnode dir, const char* name)
 {
 	if (!fFSOps->rmdir)
 		return B_BAD_VALUE;
@@ -314,7 +397,7 @@ BeOSKernelVolume::RmDir(void* dir, const char* name)
 
 // OpenDir
 status_t
-BeOSKernelVolume::OpenDir(void* node, void** cookie)
+BeOSKernelVolume::OpenDir(fs_vnode node, fs_cookie* cookie)
 {
 	if (!fFSOps->opendir)
 		return B_BAD_VALUE;
@@ -323,7 +406,7 @@ BeOSKernelVolume::OpenDir(void* node, void** cookie)
 
 // CloseDir
 status_t
-BeOSKernelVolume::CloseDir(void* node, void* cookie)
+BeOSKernelVolume::CloseDir(fs_vnode node, fs_vnode cookie)
 {
 	if (!fFSOps->closedir)
 		return B_OK;
@@ -332,7 +415,7 @@ BeOSKernelVolume::CloseDir(void* node, void* cookie)
 
 // FreeDirCookie
 status_t
-BeOSKernelVolume::FreeDirCookie(void* node, void* cookie)
+BeOSKernelVolume::FreeDirCookie(fs_vnode node, fs_vnode cookie)
 {
 	if (!fFSOps->free_dircookie)
 		return B_OK;
@@ -341,41 +424,35 @@ BeOSKernelVolume::FreeDirCookie(void* node, void* cookie)
 
 // ReadDir
 status_t
-BeOSKernelVolume::ReadDir(void* node, void* cookie, void* buffer,
-	size_t bufferSize, int32 count, int32* countRead)
+BeOSKernelVolume::ReadDir(fs_vnode node, fs_vnode cookie, void* buffer,
+	size_t bufferSize, uint32 count, uint32* countRead)
 {
 	if (!fFSOps->readdir)
 		return B_BAD_VALUE;
+
 	*countRead = count;
-	return fFSOps->readdir(fVolumeCookie, node, cookie, countRead,
-		(dirent*)buffer, bufferSize);
+	
+	// Haiku's struct dirent equals BeOS's version
+	return fFSOps->readdir(fVolumeCookie, node, cookie, (long*)countRead,
+		(beos_dirent*)buffer, bufferSize);
 }
 
 // RewindDir
 status_t
-BeOSKernelVolume::RewindDir(void* node, void* cookie)
+BeOSKernelVolume::RewindDir(fs_vnode node, fs_vnode cookie)
 {
 	if (!fFSOps->rewinddir)
 		return B_BAD_VALUE;
 	return fFSOps->rewinddir(fVolumeCookie, node, cookie);
 }
 
-// Walk
-status_t
-BeOSKernelVolume::Walk(void* dir, const char* entryName, char** resolvedPath,
-	vnode_id* vnid)
-{
-	if (!fFSOps->walk)
-		return B_BAD_VALUE;
-	return fFSOps->walk(fVolumeCookie, dir, entryName, resolvedPath, vnid);
-}
 
-// #pragma mark -
-// #pragma mark ----- attributes -----
+// #pragma mark - attribute directories
+
 
 // OpenAttrDir
 status_t
-BeOSKernelVolume::OpenAttrDir(void* node, void** cookie)
+BeOSKernelVolume::OpenAttrDir(fs_vnode node, fs_cookie *cookie)
 {
 	if (!fFSOps->open_attrdir)
 		return B_BAD_VALUE;
@@ -384,7 +461,7 @@ BeOSKernelVolume::OpenAttrDir(void* node, void** cookie)
 
 // CloseAttrDir
 status_t
-BeOSKernelVolume::CloseAttrDir(void* node, void* cookie)
+BeOSKernelVolume::CloseAttrDir(fs_vnode node, fs_cookie cookie)
 {
 	if (!fFSOps->close_attrdir)
 		return B_OK;
@@ -393,7 +470,7 @@ BeOSKernelVolume::CloseAttrDir(void* node, void* cookie)
 
 // FreeAttrDirCookie
 status_t
-BeOSKernelVolume::FreeAttrDirCookie(void* node, void* cookie)
+BeOSKernelVolume::FreeAttrDirCookie(fs_vnode node, fs_cookie cookie)
 {
 	if (!fFSOps->free_attrdircookie)
 		return B_OK;
@@ -402,83 +479,100 @@ BeOSKernelVolume::FreeAttrDirCookie(void* node, void* cookie)
 
 // ReadAttrDir
 status_t
-BeOSKernelVolume::ReadAttrDir(void* node, void* cookie, void* buffer,
-	size_t bufferSize, int32 count, int32* countRead)
+BeOSKernelVolume::ReadAttrDir(fs_vnode node, fs_cookie cookie, void* buffer,
+	size_t bufferSize, uint32 count, uint32* countRead)
 {
 	if (!fFSOps->read_attrdir)
 		return B_BAD_VALUE;
+
 	*countRead = count;
-	return fFSOps->read_attrdir(fVolumeCookie, node, cookie, countRead,
-		(struct dirent*)buffer, bufferSize);
+
+	// Haiku's struct dirent equals BeOS's version
+	return fFSOps->read_attrdir(fVolumeCookie, node, cookie, (long*)countRead,
+		(struct beos_dirent*)buffer, bufferSize);
 }
 
 // RewindAttrDir
 status_t
-BeOSKernelVolume::RewindAttrDir(void* node, void* cookie)
+BeOSKernelVolume::RewindAttrDir(fs_vnode node, fs_cookie cookie)
 {
 	if (!fFSOps->rewind_attrdir)
 		return B_BAD_VALUE;
 	return fFSOps->rewind_attrdir(fVolumeCookie, node, cookie);
 }
 
+
+// #pragma mark - attributes
+
+
 // ReadAttr
 status_t
-BeOSKernelVolume::ReadAttr(void* node, const char* name, int type, off_t pos,
+BeOSKernelVolume::ReadAttr(fs_vnode node, fs_cookie cookie, off_t pos,
 	void* buffer, size_t bufferSize, size_t* bytesRead)
 {
-	if (!fFSOps->read_attr)
-		return B_BAD_VALUE;
-	*bytesRead = bufferSize;
-	return fFSOps->read_attr(fVolumeCookie, node, name, type, buffer, bytesRead,
-		pos);
+// TODO: Implement!
+return B_BAD_VALUE;
+//	if (!fFSOps->read_attr)
+//		return B_BAD_VALUE;
+//	*bytesRead = bufferSize;
+//	return fFSOps->read_attr(fVolumeCookie, node, name, type, buffer, bytesRead,
+//		pos);
 }
 
 // WriteAttr
 status_t
-BeOSKernelVolume::WriteAttr(void* node, const char* name, int type, off_t pos,
+BeOSKernelVolume::WriteAttr(fs_vnode node, fs_cookie cookie, off_t pos,
 	const void* buffer, size_t bufferSize, size_t* bytesWritten)
 {
-	if (!fFSOps->write_attr)
+// TODO: Implement!
+return B_BAD_VALUE;
+//	if (!fFSOps->write_attr)
+//		return B_BAD_VALUE;
+//	*bytesWritten = bufferSize;
+//	return fFSOps->write_attr(fVolumeCookie, node, name, type, buffer,
+//		bytesWritten, pos);
+}
+
+// ReadAttrStat
+status_t
+BeOSKernelVolume::ReadAttrStat(fs_vnode node, fs_cookie cookie, struct stat *st)
+{
+// TODO: Implement!
+return B_BAD_VALUE;
+//	if (!fFSOps->stat_attr)
+//		return B_BAD_VALUE;
+//	return fFSOps->stat_attr(fVolumeCookie, node, name, attrInfo);
+}
+
+// RenameAttr
+status_t
+BeOSKernelVolume::RenameAttr(fs_vnode oldNode, const char* oldName,
+	fs_vnode newNode, const char* newName)
+{
+	if (!fFSOps->rename_attr)
 		return B_BAD_VALUE;
-	*bytesWritten = bufferSize;
-	return fFSOps->write_attr(fVolumeCookie, node, name, type, buffer,
-		bytesWritten, pos);
+	if (oldNode != newNode)
+		return B_BAD_VALUE;
+
+	return fFSOps->rename_attr(fVolumeCookie, oldNode, oldName, newName);
 }
 
 // RemoveAttr
 status_t
-BeOSKernelVolume::RemoveAttr(void* node, const char* name)
+BeOSKernelVolume::RemoveAttr(fs_vnode node, const char* name)
 {
 	if (!fFSOps->remove_attr)
 		return B_BAD_VALUE;
 	return fFSOps->remove_attr(fVolumeCookie, node, name);
 }
 
-// RenameAttr
-status_t
-BeOSKernelVolume::RenameAttr(void* node, const char* oldName, const char* newName)
-{
-	if (!fFSOps->rename_attr)
-		return B_BAD_VALUE;
-	return fFSOps->rename_attr(fVolumeCookie, node, oldName, newName);
-}
 
-// StatAttr
-status_t
-BeOSKernelVolume::StatAttr(void* node, const char* name,
-	struct attr_info* attrInfo)
-{
-	if (!fFSOps->stat_attr)
-		return B_BAD_VALUE;
-	return fFSOps->stat_attr(fVolumeCookie, node, name, attrInfo);
-}
+// #pragma mark - indices
 
-// #pragma mark -
-// #pragma mark ----- indices -----
 
 // OpenIndexDir
 status_t
-BeOSKernelVolume::OpenIndexDir(void** cookie)
+BeOSKernelVolume::OpenIndexDir(fs_cookie *cookie)
 {
 	if (!fFSOps->open_indexdir)
 		return B_BAD_VALUE;
@@ -487,7 +581,7 @@ BeOSKernelVolume::OpenIndexDir(void** cookie)
 
 // CloseIndexDir
 status_t
-BeOSKernelVolume::CloseIndexDir(void* cookie)
+BeOSKernelVolume::CloseIndexDir(fs_cookie cookie)
 {
 	if (!fFSOps->close_indexdir)
 		return B_OK;
@@ -496,7 +590,7 @@ BeOSKernelVolume::CloseIndexDir(void* cookie)
 
 // FreeIndexDirCookie
 status_t
-BeOSKernelVolume::FreeIndexDirCookie(void* cookie)
+BeOSKernelVolume::FreeIndexDirCookie(fs_cookie cookie)
 {
 	if (!fFSOps->free_indexdircookie)
 		return B_OK;
@@ -505,19 +599,22 @@ BeOSKernelVolume::FreeIndexDirCookie(void* cookie)
 
 // ReadIndexDir
 status_t
-BeOSKernelVolume::ReadIndexDir(void* cookie, void* buffer, size_t bufferSize,
-	int32 count, int32* countRead)
+BeOSKernelVolume::ReadIndexDir(fs_cookie cookie, void* buffer,
+	size_t bufferSize, uint32 count, uint32* countRead)
 {
 	if (!fFSOps->read_indexdir)
 		return B_BAD_VALUE;
+
 	*countRead = count;
-	return fFSOps->read_indexdir(fVolumeCookie, cookie, countRead,
-		(struct dirent*)buffer, bufferSize);
+
+	// Haiku's struct dirent equals BeOS's version
+	return fFSOps->read_indexdir(fVolumeCookie, cookie, (long*)countRead,
+		(struct beos_dirent*)buffer, bufferSize);
 }
 
 // RewindIndexDir
 status_t
-BeOSKernelVolume::RewindIndexDir(void* cookie)
+BeOSKernelVolume::RewindIndexDir(fs_cookie cookie)
 {
 	if (!fFSOps->rewind_indexdir)
 		return B_BAD_VALUE;
@@ -526,11 +623,11 @@ BeOSKernelVolume::RewindIndexDir(void* cookie)
 
 // CreateIndex
 status_t
-BeOSKernelVolume::CreateIndex(const char* name, int type, int flags)
+BeOSKernelVolume::CreateIndex(const char* name, uint32 type, uint32 flags)
 {
 	if (!fFSOps->create_index)
 		return B_BAD_VALUE;
-	return fFSOps->create_index(fVolumeCookie, name, type, flags);
+	return fFSOps->create_index(fVolumeCookie, name, (int)type, (int)flags);
 }
 
 // RemoveIndex
@@ -542,41 +639,47 @@ BeOSKernelVolume::RemoveIndex(const char* name)
 	return fFSOps->remove_index(fVolumeCookie, name);
 }
 
-// RenameIndex
-status_t
-BeOSKernelVolume::RenameIndex(const char* oldName, const char* newName)
-{
-	if (!fFSOps->rename_index)
-		return B_BAD_VALUE;
-	return fFSOps->rename_index(fVolumeCookie, oldName, newName);
-}
-
 // StatIndex
 status_t
-BeOSKernelVolume::StatIndex(const char *name, struct index_info* indexInfo)
+BeOSKernelVolume::ReadIndexStat(const char *name, struct stat *st)
 {
 	if (!fFSOps->stat_index)
 		return B_BAD_VALUE;
-	return fFSOps->stat_index(fVolumeCookie, name, indexInfo);
+
+	beos_index_info indexInfo;
+	status_t error = fFSOps->stat_index(fVolumeCookie, name, &indexInfo);
+	if (error != B_OK)
+		return error;
+
+	// translate index_info into struct stat
+	st->st_type = indexInfo.type;
+	st->st_size = indexInfo.size;
+	st->st_mtime = indexInfo.modification_time;
+	st->st_crtime = indexInfo.creation_time;
+	st->st_uid = indexInfo.uid;
+	st->st_gid = indexInfo.gid;
+
+	return B_OK;
 }
 
-// #pragma mark -
-// #pragma mark ----- queries -----
+
+// #pragma mark - queries
+
 
 // OpenQuery
 status_t
-BeOSKernelVolume::OpenQuery(const char* queryString, ulong flags, port_id port,
-	long token, void** cookie)
+BeOSKernelVolume::OpenQuery(const char* queryString, uint32 flags, port_id port,
+	uint32 token, fs_cookie *cookie)
 {
 	if (!fFSOps->open_query)
 		return B_BAD_VALUE;
 	return fFSOps->open_query(fVolumeCookie, queryString, flags, port,
-		token, cookie);
+		(long)token, cookie);
 }
 
 // CloseQuery
 status_t
-BeOSKernelVolume::CloseQuery(void* cookie)
+BeOSKernelVolume::CloseQuery(fs_cookie cookie)
 {
 	if (!fFSOps->close_query)
 		return B_OK;
@@ -585,7 +688,7 @@ BeOSKernelVolume::CloseQuery(void* cookie)
 
 // FreeQueryCookie
 status_t
-BeOSKernelVolume::FreeQueryCookie(void* cookie)
+BeOSKernelVolume::FreeQueryCookie(fs_cookie cookie)
 {
 	if (!fFSOps->free_querycookie)
 		return B_OK;
@@ -594,13 +697,16 @@ BeOSKernelVolume::FreeQueryCookie(void* cookie)
 
 // ReadQuery
 status_t
-BeOSKernelVolume::ReadQuery(void* cookie, void* buffer, size_t bufferSize,
-	int32 count, int32* countRead)
+BeOSKernelVolume::ReadQuery(fs_cookie cookie, void* buffer, size_t bufferSize,
+	uint32 count, uint32* countRead)
 {
 	if (!fFSOps->read_query)
 		return B_BAD_VALUE;
+
 	*countRead = count;
-	return fFSOps->read_query(fVolumeCookie, cookie, countRead,
-		(struct dirent*)buffer, bufferSize);
+
+	// Haiku's struct dirent equals BeOS's version
+	return fFSOps->read_query(fVolumeCookie, cookie, (long*)countRead,
+		(struct beos_dirent*)buffer, bufferSize);
 }