Adjusted the FileSystem, Volume, and UserlandRequestHandler to the new FS

interface. The classes actually interfacing with the client FS add-on still
need to be adjusted.


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

headers/private/userlandfs/private/Requests.h

@@ -384,7 +384,7 @@ public:
 	WriteFSInfoRequest() : VolumeRequest(WRITE_FS_INFO_REQUEST) {}
 
 	fs_info		info;
-	long		mask;
+	uint32		mask;
 };
 
 // WriteFSInfoReply
@@ -412,7 +412,6 @@ class LookupReply : public ReplyRequest {
 public:
 	LookupReply() : ReplyRequest(LOOKUP_REPLY) {}
 
-	Address		resolvedPath;
 	vnode_id	vnid;
 	int			type;
 };

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

@@ -19,13 +19,12 @@ BeOSKernelFileSystem::~BeOSKernelFileSystem()
 
 // CreateVolume
 status_t
-BeOSKernelFileSystem::CreateVolume(Volume** volume, nspace_id id)
+BeOSKernelFileSystem::CreateVolume(Volume** volume, mount_id id)
 {
 	// check initialization and parameters
-	if (!fFSOps)
+	if (!fFSOps || !volume)
-		return B_BAD_VALUE;
-	if (!volume)
 		return B_BAD_VALUE;
+
 	// create the volume
 	*volume = new(nothrow) BeOSKernelVolume(this, id, fFSOps);
 	if (!*volume)

src/add-ons/kernel/file_systems/userlandfs/server/BeOSKernelFileSystem.h

@@ -12,7 +12,7 @@ public:
 								BeOSKernelFileSystem(vnode_ops* fsOps);
 	virtual						~BeOSKernelFileSystem();
 
-	virtual	status_t			CreateVolume(Volume** volume, nspace_id id);
+	virtual	status_t			CreateVolume(Volume** volume, mount_id id);
 	virtual	status_t			DeleteVolume(Volume* volume);
 
 private:

src/add-ons/kernel/file_systems/userlandfs/server/FileSystem.h

@@ -3,7 +3,7 @@
 #ifndef USERLAND_FS_FILE_SYSTEM_H
 #define USERLAND_FS_FILE_SYSTEM_H
 
-#include <fsproto.h>
+#include <fs_interface.h>
 #include <SupportDefs.h>
 
 namespace UserlandFS {
@@ -15,8 +15,7 @@ public:
 								FileSystem();
 	virtual						~FileSystem();
 
-	virtual	status_t			CreateVolume(Volume** volume,
+	virtual	status_t			CreateVolume(Volume** volume, mount_id id) = 0;
-									nspace_id id) = 0;
 	virtual	status_t			DeleteVolume(Volume* volume) = 0;
 };
 

src/add-ons/kernel/file_systems/userlandfs/server/Jamfile

@@ -38,14 +38,14 @@ Application UserlandFSServer
 #	  BeOSKernelFileSystem.cpp
 #	  BeOSKernelVolume.cpp
 	  DispatcherFileSystem.cpp
-#	  FileSystem.cpp
+	  FileSystem.cpp
 #	  kernel_emu.cpp
 	  main.cpp
-#	  RequestThread.cpp
+	  RequestThread.cpp
 	  ServerDefs.cpp
 	  UserlandFSDispatcher.cpp
 #	  UserlandFSServer.cpp
-#	  UserlandRequestHandler.cpp
+	  UserlandRequestHandler.cpp
-#	  Volume.cpp
+	  Volume.cpp
 	: be
 ;

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

@@ -8,7 +8,7 @@
 #include <cache.h>
 #include <Clipboard.h>
 #include <FindDirectory.h>
-#include <fsproto.h>
+#include <fs_interface.h>
 #include <image.h>
 #include <Locker.h>
 #include <Path.h>

src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.h

@@ -7,27 +7,79 @@
 
 namespace UserlandFSUtil {
 
+// FS
 class MountVolumeRequest;
 class UnmountVolumeRequest;
-class ReadFSStatRequest;
+class SyncVolumeRequest;
+class ReadFSInfoRequest;
+class WriteFSInfoRequest;
+// vnodes
+class LookupRequest;
 class ReadVNodeRequest;
 class WriteVNodeRequest;
-class ReadStatRequest;
+class FSRemoveVNodeRequest;
+// nodes
+class IOCtlRequest;
+class SetFlagsRequest;
+class SelectRequest;
+class DeselectRequest;
+class FSyncRequest;
+class ReadSymlinkRequest;
+class CreateSymlinkRequest;
+class LinkRequest;
+class UnlinkRequest;
+class RenameRequest;
 class AccessRequest;
+class ReadStatRequest;
+class WriteStatRequest;
+// files
+class CreateRequest;
 class OpenRequest;
 class CloseRequest;
 class FreeCookieRequest;
 class ReadRequest;
-class WalkRequest;
+class WriteRequest;
+// directories
+class CreateDirRequest;
+class RemoveDirRequest;
 class OpenDirRequest;
-class ReadDirRequest;
-class RewindDirRequest;
 class CloseDirRequest;
 class FreeDirCookieRequest;
-class ReadLinkRequest;
+class ReadDirRequest;
+class RewindDirRequest;
+// attribute directories
+class OpenAttrDirRequest;
+class CloseAttrDirRequest;
+class FreeAttrDirCookieRequest;
+class ReadAttrDirRequest;
+class RewindAttrDirRequest;
+// attributes
+class ReadAttrRequest;
+class WriteAttrRequest;
+class ReadAttrStatRequest;
+class RenameAttrRequest;
+class RemoveAttrRequest;
+// indices
+class OpenIndexDirRequest;
+class CloseIndexDirRequest;
+class FreeIndexDirCookieRequest;
+class ReadIndexDirRequest;
+class RewindIndexDirRequest;
+class CreateIndexRequest;
+class RemoveIndexRequest;
+class ReadIndexStatRequest;
+// queries
+class OpenQueryRequest;
+class CloseQueryRequest;
+class FreeQueryCookieRequest;
+class ReadQueryRequest;
+
+class RequestAllocator;
 
 }	// namespace UserlandFSUtil
 
+using namespace UserlandFSUtil;
+
 namespace UserlandFS {
 
 class FileSystem;
@@ -46,19 +98,29 @@ private:
 			status_t			_HandleRequest(MountVolumeRequest* request);
 			status_t			_HandleRequest(UnmountVolumeRequest* request);
 			status_t			_HandleRequest(SyncVolumeRequest* request);
-			status_t			_HandleRequest(ReadFSStatRequest* request);
+			status_t			_HandleRequest(ReadFSInfoRequest* request);
-			status_t			_HandleRequest(WriteFSStatRequest* request);
+			status_t			_HandleRequest(WriteFSInfoRequest* request);
 
 			// vnodes
+			status_t			_HandleRequest(LookupRequest* request);
 			status_t			_HandleRequest(ReadVNodeRequest* request);
 			status_t			_HandleRequest(WriteVNodeRequest* request);
 			status_t			_HandleRequest(FSRemoveVNodeRequest* request);
 
 			// nodes
+			status_t			_HandleRequest(IOCtlRequest* request);
+			status_t			_HandleRequest(SetFlagsRequest* request);
+			status_t			_HandleRequest(SelectRequest* request);
+			status_t			_HandleRequest(DeselectRequest* request);
 			status_t			_HandleRequest(FSyncRequest* request);
+			status_t			_HandleRequest(ReadSymlinkRequest* request);
+			status_t			_HandleRequest(CreateSymlinkRequest* request);
+			status_t			_HandleRequest(LinkRequest* request);
+			status_t			_HandleRequest(UnlinkRequest* request);
+			status_t			_HandleRequest(RenameRequest* request);
+			status_t			_HandleRequest(AccessRequest* request);
 			status_t			_HandleRequest(ReadStatRequest* request);
 			status_t			_HandleRequest(WriteStatRequest* request);
-			status_t			_HandleRequest(AccessRequest* request);
 
 			// files
 			status_t			_HandleRequest(CreateRequest* request);
@@ -67,40 +129,30 @@ private:
 			status_t			_HandleRequest(FreeCookieRequest* request);
 			status_t			_HandleRequest(ReadRequest* request);
 			status_t			_HandleRequest(WriteRequest* request);
-			status_t			_HandleRequest(IOCtlRequest* request);
-			status_t			_HandleRequest(SetFlagsRequest* request);
-			status_t			_HandleRequest(SelectRequest* request);
-			status_t			_HandleRequest(DeselectRequest* request);
-
-			// hard links / symlinks
-			status_t			_HandleRequest(LinkRequest* request);
-			status_t			_HandleRequest(UnlinkRequest* request);
-			status_t			_HandleRequest(SymlinkRequest* request);
-			status_t			_HandleRequest(ReadLinkRequest* request);
-			status_t			_HandleRequest(RenameRequest* request);
 
 			// directories
-			status_t			_HandleRequest(MkDirRequest* request);
+			status_t			_HandleRequest(CreateDirRequest* request);
-			status_t			_HandleRequest(RmDirRequest* request);
+			status_t			_HandleRequest(RemoveDirRequest* request);
 			status_t			_HandleRequest(OpenDirRequest* request);
 			status_t			_HandleRequest(CloseDirRequest* request);
 			status_t			_HandleRequest(FreeDirCookieRequest* request);
 			status_t			_HandleRequest(ReadDirRequest* request);
 			status_t			_HandleRequest(RewindDirRequest* request);
-			status_t			_HandleRequest(WalkRequest* request);
 
-			// attributes
+			// attribute directories
 			status_t			_HandleRequest(OpenAttrDirRequest* request);
 			status_t			_HandleRequest(CloseAttrDirRequest* request);
 			status_t			_HandleRequest(
 									FreeAttrDirCookieRequest* request);
 			status_t			_HandleRequest(ReadAttrDirRequest* request);
 			status_t			_HandleRequest(RewindAttrDirRequest* request);
+
+			// attributes
 			status_t			_HandleRequest(ReadAttrRequest* request);
 			status_t			_HandleRequest(WriteAttrRequest* request);
-			status_t			_HandleRequest(RemoveAttrRequest* request);
+			status_t			_HandleRequest(ReadAttrStatRequest* request);
 			status_t			_HandleRequest(RenameAttrRequest* request);
-			status_t			_HandleRequest(StatAttrRequest* request);
+			status_t			_HandleRequest(RemoveAttrRequest* request);
 
 			// indices
 			status_t			_HandleRequest(OpenIndexDirRequest* request);
@@ -111,8 +163,7 @@ private:
 			status_t			_HandleRequest(RewindIndexDirRequest* request);
 			status_t			_HandleRequest(CreateIndexRequest* request);
 			status_t			_HandleRequest(RemoveIndexRequest* request);
-			status_t			_HandleRequest(RenameIndexRequest* request);
+			status_t			_HandleRequest(ReadIndexStatRequest* request);
-			status_t			_HandleRequest(StatIndexRequest* request);
 
 			// queries
 			status_t			_HandleRequest(OpenQueryRequest* request);

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

@@ -3,7 +3,7 @@
 #include "Volume.h"
 
 // constructor
-Volume::Volume(FileSystem* fileSystem, nspace_id id)
+Volume::Volume(FileSystem* fileSystem, mount_id id)
 	: fFileSystem(fileSystem),
 	  fID(id)
 {
@@ -22,19 +22,20 @@ Volume::GetFileSystem() const
 }
 
 // GetID
-nspace_id
+mount_id
 Volume::GetID() const
 {
 	return fID;
 }
 
-// #pragma mark -
+
-// #pragma mark ----- FS -----
+// #pragma mark - FS
+
 
 // Mount
 status_t
-Volume::Mount(const char* device, ulong flags, const char* parameters,
+Volume::Mount(const char* device, uint32 flags, const char* parameters,
-	int32 len, vnode_id* rootID)
+	vnode_id* rootID)
 {
 	return B_BAD_VALUE;
 }
@@ -53,126 +54,59 @@ Volume::Sync()
 	return B_BAD_VALUE;
 }
 
-// ReadFSStat
+// ReadFSInfo
 status_t
-Volume::ReadFSStat(fs_info* info)
+Volume::ReadFSInfo(fs_info* info)
 {
 	return B_BAD_VALUE;
 }
 
-// WriteFSStat
+// WriteFSInfo
 status_t
-Volume::WriteFSStat(struct fs_info *info, long mask)
+Volume::WriteFSInfo(const struct fs_info *info, uint32 mask)
 {
 	return B_BAD_VALUE;
 }
 
-// #pragma mark -
+
-// #pragma mark ----- vnodes -----
+// #pragma mark - vnodes
+
+
+// Lookup
+status_t
+Volume::Lookup(fs_vnode dir, const char* entryName, vnode_id* vnid, int* type)
+{
+	return B_BAD_VALUE;
+}
 
 // ReadVNode
 status_t
-Volume::ReadVNode(vnode_id vnid, char reenter, void** node)
+Volume::ReadVNode(vnode_id vnid, bool reenter, fs_vnode* node)
 {
 	return B_BAD_VALUE;
 }
 
 // WriteVNode
 status_t
-Volume::WriteVNode(void* node, char reenter)
+Volume::WriteVNode(fs_vnode node, bool reenter)
 {
 	return B_BAD_VALUE;
 }
 
 // RemoveVNode
 status_t
-Volume::RemoveVNode(void* node, char reenter)
+Volume::RemoveVNode(fs_vnode node, bool reenter)
 {
 	return B_BAD_VALUE;
 }
 
-// #pragma mark -
-// #pragma mark ----- nodes -----
 
-// FSync
+// #pragma mark - nodes
-status_t
-Volume::FSync(void* node)
-{
-	return B_BAD_VALUE;
-}
 
-// ReadStat
-status_t
-Volume::ReadStat(void* node, struct stat* st)
-{
-	return B_BAD_VALUE;
-}
-
-// WriteStat
-status_t
-Volume::WriteStat(void* node, struct stat* st, long mask)
-{
-	return B_BAD_VALUE;
-}
-
-// Access
-status_t
-Volume::Access(void* node, int mode)
-{
-	return B_BAD_VALUE;
-}
-
-// #pragma mark -
-// #pragma mark ----- files -----
-
-// Create
-status_t
-Volume::Create(void* dir, const char* name, int openMode, int mode,
-	vnode_id* vnid, void** cookie)
-{
-	return B_BAD_VALUE;
-}
-
-// Open
-status_t
-Volume::Open(void* node, int openMode, void** cookie)
-{
-	return B_BAD_VALUE;
-}
-
-// Close
-status_t
-Volume::Close(void* node, void* cookie)
-{
-	return B_BAD_VALUE;
-}
-
-// FreeCookie
-status_t
-Volume::FreeCookie(void* node, void* cookie)
-{
-	return B_BAD_VALUE;
-}
-
-// Read
-status_t
-Volume::Read(void* node, void* cookie, off_t pos, void* buffer,
-	size_t bufferSize, size_t* bytesRead)
-{
-	return B_BAD_VALUE;
-}
-
-// Write
-status_t
-Volume::Write(void* node, void* cookie, off_t pos, const void* buffer,
-	size_t bufferSize, size_t* bytesWritten)
-{
-	return B_BAD_VALUE;
-}
 
 // IOCtl
 status_t
-Volume::IOCtl(void* node, void* cookie, int command, void *buffer,
+Volume::IOCtl(fs_vnode node, fs_cookie cookie, uint32 command, void *buffer,
 	size_t size)
 {
 	return B_BAD_VALUE;
@@ -180,14 +114,14 @@ Volume::IOCtl(void* node, void* cookie, int command, void *buffer,
 
 // SetFlags
 status_t
-Volume::SetFlags(void* node, void* cookie, int flags)
+Volume::SetFlags(fs_vnode node, fs_cookie cookie, int flags)
 {
 	return B_BAD_VALUE;
 }
 
 // Select
 status_t
-Volume::Select(void* node, void* cookie, uint8 event, uint32 ref,
+Volume::Select(fs_vnode node, fs_cookie cookie, uint8 event, uint32 ref,
 	selectsync* sync)
 {
 	return B_BAD_VALUE;
@@ -195,230 +129,305 @@ Volume::Select(void* node, void* cookie, uint8 event, uint32 ref,
 
 // Deselect
 status_t
-Volume::Deselect(void* node, void* cookie, uint8 event, selectsync* sync)
+Volume::Deselect(fs_vnode node, fs_cookie cookie, uint8 event, selectsync* sync)
 {
 	return B_BAD_VALUE;
 }
 
-// #pragma mark -
+// FSync
-// #pragma mark ----- hard links / symlinks -----
+status_t
+Volume::FSync(fs_vnode node)
+{
+	return B_BAD_VALUE;
+}
+
+// ReadSymlink
+status_t
+Volume::ReadSymlink(fs_vnode node, char* buffer, size_t bufferSize,
+	size_t* bytesRead)
+{
+	return B_BAD_VALUE;
+}
+
+// CreateSymlink
+status_t
+Volume::CreateSymlink(fs_vnode dir, const char* name, const char* target,
+	int mode)
+{
+	return B_BAD_VALUE;
+}
 
 // Link
 status_t
-Volume::Link(void* dir, const char* name, void* node)
+Volume::Link(fs_vnode dir, const char* name, fs_vnode node)
 {
 	return B_BAD_VALUE;
 }
 
 // Unlink
 status_t
-Volume::Unlink(void* dir, const char* name)
+Volume::Unlink(fs_vnode dir, const char* name)
-{
-	return B_BAD_VALUE;
-}
-
-// Symlink
-status_t
-Volume::Symlink(void* dir, const char* name, const char* target)
-{
-	return B_BAD_VALUE;
-}
-
-// ReadLink
-status_t
-Volume::ReadLink(void* node, char* buffer, size_t bufferSize,
-	size_t* bytesRead)
 {
 	return B_BAD_VALUE;
 }
 
 // Rename
 status_t
-Volume::Rename(void* oldDir, const char* oldName, void* newDir,
+Volume::Rename(fs_vnode oldDir, const char* oldName, fs_vnode newDir,
 	const char* newName)
 {
 	return B_BAD_VALUE;
 }
 
-// #pragma mark -
+// Access
-// #pragma mark ----- directories -----
-
-// MkDir
 status_t
-Volume::MkDir(void* dir, const char* name, int mode)
+Volume::Access(fs_vnode node, int mode)
 {
 	return B_BAD_VALUE;
 }
 
-// RmDir
+// ReadStat
 status_t
-Volume::RmDir(void* dir, const char* name)
+Volume::ReadStat(fs_vnode node, struct stat* st)
+{
+	return B_BAD_VALUE;
+}
+
+// WriteStat
+status_t
+Volume::WriteStat(fs_vnode node, const struct stat *st, uint32 mask)
+{
+	return B_BAD_VALUE;
+}
+
+
+// #pragma mark - files
+
+
+// Create
+status_t
+Volume::Create(fs_vnode dir, const char* name, int openMode, int mode,
+	fs_cookie* cookie, vnode_id* vnid)
+{
+	return B_BAD_VALUE;
+}
+
+// Open
+status_t
+Volume::Open(fs_vnode node, int openMode, fs_cookie* cookie)
+{
+	return B_BAD_VALUE;
+}
+
+// Close
+status_t
+Volume::Close(fs_vnode node, fs_cookie cookie)
+{
+	return B_BAD_VALUE;
+}
+
+// FreeCookie
+status_t
+Volume::FreeCookie(fs_vnode node, fs_cookie cookie)
+{
+	return B_BAD_VALUE;
+}
+
+// Read
+status_t
+Volume::Read(fs_vnode node, fs_cookie cookie, off_t pos, void* buffer,
+	size_t bufferSize, size_t* bytesRead)
+{
+	return B_BAD_VALUE;
+}
+
+// Write
+status_t
+Volume::Write(fs_vnode node, fs_cookie cookie, off_t pos, const void* buffer,
+	size_t bufferSize, size_t* bytesWritten)
+{
+	return B_BAD_VALUE;
+}
+
+
+// #pragma mark - directories
+
+
+// CreateDir
+status_t
+Volume::CreateDir(fs_vnode dir, const char* name, int mode, vnode_id *newDir)
+{
+	return B_BAD_VALUE;
+}
+
+// RemoveDir
+status_t
+Volume::RemoveDir(fs_vnode dir, const char* name)
 {
 	return B_BAD_VALUE;
 }
 
 // OpenDir
 status_t
-Volume::OpenDir(void* node, void** cookie)
+Volume::OpenDir(fs_vnode node, fs_cookie* cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // CloseDir
 status_t
-Volume::CloseDir(void* node, void* cookie)
+Volume::CloseDir(fs_vnode node, fs_vnode cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // FreeDirCookie
 status_t
-Volume::FreeDirCookie(void* node, void* cookie)
+Volume::FreeDirCookie(fs_vnode node, fs_vnode cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // ReadDir
 status_t
-Volume::ReadDir(void* node, void* cookie, void* buffer, size_t bufferSize,
+Volume::ReadDir(fs_vnode node, fs_vnode cookie, void* buffer, size_t bufferSize,
-	int32 count, int32* countRead)
+	uint32 count, uint32* countRead)
 {
 	return B_BAD_VALUE;
 }
 
 // RewindDir
 status_t
-Volume::RewindDir(void* node, void* cookie)
+Volume::RewindDir(fs_vnode node, fs_vnode cookie)
 {
 	return B_BAD_VALUE;
 }
 
-// Walk
-status_t
-Volume::Walk(void* dir, const char* entryName, char** resolvedPath,
-	vnode_id* vnid)
-{
-	return B_BAD_VALUE;
-}
 
-// #pragma mark -
+// #pragma mark - attribute directories
-// #pragma mark ----- attributes -----
+
 
 // OpenAttrDir
 status_t
-Volume::OpenAttrDir(void* node, void** cookie)
+Volume::OpenAttrDir(fs_vnode node, fs_cookie *cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // CloseAttrDir
 status_t
-Volume::CloseAttrDir(void* node, void* cookie)
+Volume::CloseAttrDir(fs_vnode node, fs_cookie cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // FreeAttrDirCookie
 status_t
-Volume::FreeAttrDirCookie(void* node, void* cookie)
+Volume::FreeAttrDirCookie(fs_vnode node, fs_cookie cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // ReadAttrDir
 status_t
-Volume::ReadAttrDir(void* node, void* cookie, void* buffer, size_t bufferSize,
+Volume::ReadAttrDir(fs_vnode node, fs_cookie cookie, void* buffer,
-	int32 count, int32* countRead)
+	size_t bufferSize, uint32 count, uint32* countRead)
 {
 	return B_BAD_VALUE;
 }
 
 // RewindAttrDir
 status_t
-Volume::RewindAttrDir(void* node, void* cookie)
+Volume::RewindAttrDir(fs_vnode node, fs_cookie cookie)
 {
 	return B_BAD_VALUE;
 }
 
+
+// #pragma mark - attributes
+
+
 // ReadAttr
 status_t
-Volume::ReadAttr(void* node, const char* name, int type, off_t pos,
+Volume::ReadAttr(fs_vnode node, fs_cookie cookie, off_t pos, void* buffer,
-	void* buffer, size_t bufferSize, size_t* bytesRead)
+	size_t bufferSize, size_t* bytesRead)
 {
 	return B_BAD_VALUE;
 }
 
 // WriteAttr
 status_t
-Volume::WriteAttr(void* node, const char* name, int type, off_t pos,
+Volume::WriteAttr(fs_vnode node, fs_cookie cookie, off_t pos,
 	const void* buffer, size_t bufferSize, size_t* bytesWritten)
 {
 	return B_BAD_VALUE;
 }
 
-// RemoveAttr
-status_t
-Volume::RemoveAttr(void* node, const char* name)
-{
-	return B_BAD_VALUE;
-}
-
-// RenameAttr
-status_t
-Volume::RenameAttr(void* node, const char* oldName, const char* newName)
-{
-	return B_BAD_VALUE;
-}
-
 // StatAttr
 status_t
-Volume::StatAttr(void* node, const char* name, struct attr_info* attrInfo)
+Volume::ReadAttrStat(fs_vnode node, fs_cookie cookie, struct stat *st)
 {
 	return B_BAD_VALUE;
 }
 
-// #pragma mark -
+// RenameAttr
-// #pragma mark ----- indices -----
+status_t
+Volume::RenameAttr(fs_vnode oldNode, const char* oldName, fs_vnode newNode,
+	const char* newName)
+{
+	return B_BAD_VALUE;
+}
+
+// RemoveAttr
+status_t
+Volume::RemoveAttr(fs_vnode node, const char* name)
+{
+	return B_BAD_VALUE;
+}
+
+
+// #pragma mark - indices
+
 
 // OpenIndexDir
 status_t
-Volume::OpenIndexDir(void** cookie)
+Volume::OpenIndexDir(fs_cookie *cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // CloseIndexDir
 status_t
-Volume::CloseIndexDir(void* cookie)
+Volume::CloseIndexDir(fs_cookie cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // FreeIndexDirCookie
 status_t
-Volume::FreeIndexDirCookie(void* cookie)
+Volume::FreeIndexDirCookie(fs_cookie cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // ReadIndexDir
 status_t
-Volume::ReadIndexDir(void* cookie, void* buffer, size_t bufferSize,
+Volume::ReadIndexDir(fs_cookie cookie, void* buffer, size_t bufferSize,
-	int32 count, int32* countRead)
+	uint32 count, uint32* countRead)
 {
 	return B_BAD_VALUE;
 }
 
 // RewindIndexDir
 status_t
-Volume::RewindIndexDir(void* cookie)
+Volume::RewindIndexDir(fs_cookie cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // CreateIndex
 status_t
-Volume::CreateIndex(const char* name, int type, int flags)
+Volume::CreateIndex(const char* name, uint32 type, uint32 flags)
 {
 	return B_BAD_VALUE;
 }
@@ -430,49 +439,43 @@ Volume::RemoveIndex(const char* name)
 	return B_BAD_VALUE;
 }
 
-// RenameIndex
+// ReadIndexStat
 status_t
-Volume::RenameIndex(const char* oldName, const char* newName)
+Volume::ReadIndexStat(const char *name, struct stat *st)
 {
 	return B_BAD_VALUE;
 }
 
-// StatIndex
-status_t
-Volume::StatIndex(const char *name, struct index_info* indexInfo)
-{
-	return B_BAD_VALUE;
-}
 
-// #pragma mark -
+// #pragma mark - queries
-// #pragma mark ----- queries -----
+
 
 // OpenQuery
 status_t
-Volume::OpenQuery(const char* queryString, ulong flags, port_id port,
+Volume::OpenQuery(const char* queryString, uint32 flags, port_id port,
-	long token, void** cookie)
+	uint32 token, fs_cookie *cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // CloseQuery
 status_t
-Volume::CloseQuery(void* cookie)
+Volume::CloseQuery(fs_cookie cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // FreeQueryCookie
 status_t
-Volume::FreeQueryCookie(void* cookie)
+Volume::FreeQueryCookie(fs_cookie cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // ReadQuery
 status_t
-Volume::ReadQuery(void* cookie, void* buffer, size_t bufferSize, int32 count,
+Volume::ReadQuery(fs_cookie cookie, void* buffer, size_t bufferSize,
-	int32* countRead)
+	uint32 count, uint32* countRead)
 {
 	return B_BAD_VALUE;
 }

src/add-ons/kernel/file_systems/userlandfs/server/Volume.h

@@ -3,7 +3,7 @@
 #ifndef USERLAND_FS_VOLUME_H
 #define USERLAND_FS_VOLUME_H
 
-#include <fsproto.h>
+#include <fs_interface.h>
 #include <SupportDefs.h>
 
 namespace UserlandFS {
@@ -12,128 +12,135 @@ class FileSystem;
 
 class Volume {
 public:
-								Volume(FileSystem* fileSystem,
+								Volume(FileSystem* fileSystem, mount_id id);
-									nspace_id id);
 	virtual						~Volume();
 
-			FileSystem*		GetFileSystem() const;
+			FileSystem*			GetFileSystem() const;
-			nspace_id			GetID() const;
+			mount_id			GetID() const;
 
 	// FS
-	virtual	status_t			Mount(const char* device, ulong flags,
+	virtual	status_t			Mount(const char* device, uint32 flags,
-									const char* parameters, int32 len,
+									const char* parameters, vnode_id* rootID);
-									vnode_id* rootID);
 	virtual	status_t			Unmount();
 	virtual	status_t			Sync();
-	virtual	status_t			ReadFSStat(fs_info* info);
+	virtual	status_t			ReadFSInfo(fs_info* info);
-	virtual	status_t			WriteFSStat(struct fs_info *info, long mask);
+	virtual	status_t			WriteFSInfo(const struct fs_info *info,
+									uint32 mask);
 
 	// vnodes
-	virtual	status_t			ReadVNode(vnode_id vnid, char reenter,
+	virtual	status_t			Lookup(fs_vnode dir, const char* entryName,
-									void** node);
+									vnode_id* vnid, int* type);
-	virtual	status_t			WriteVNode(void* node, char reenter);
+	virtual	status_t			ReadVNode(vnode_id vnid, bool reenter,
-	virtual	status_t			RemoveVNode(void* node, char reenter);
+									fs_vnode* node);
+	virtual	status_t			WriteVNode(fs_vnode node, bool reenter);
+	virtual	status_t			RemoveVNode(fs_vnode node, bool reenter);
 
 	// nodes
-	virtual	status_t			FSync(void* node);
+	virtual	status_t			IOCtl(fs_vnode node, fs_cookie cookie,
-	virtual	status_t			ReadStat(void* node, struct stat* st);
+									uint32 command, void* buffer, size_t size);
-	virtual	status_t			WriteStat(void* node, struct stat* st,
+	virtual	status_t			SetFlags(fs_vnode node, fs_cookie cookie,
-									long mask);
+									int flags);
-	virtual	status_t			Access(void* node, int mode);
+	virtual	status_t			Select(fs_vnode node, fs_cookie cookie,
+									uint8 event, uint32 ref, selectsync* sync);
+	virtual	status_t			Deselect(fs_vnode node, fs_cookie cookie,
+									uint8 event, selectsync* sync);
+
+	virtual	status_t			FSync(fs_vnode node);
+
+	virtual	status_t			ReadSymlink(fs_vnode node, char* buffer,
+									size_t bufferSize, size_t* bytesRead);
+	virtual	status_t			CreateSymlink(fs_vnode dir, const char* name,
+									const char* target, int mode);
+
+	virtual	status_t			Link(fs_vnode dir, const char* name,
+									fs_vnode node);
+	virtual	status_t			Unlink(fs_vnode dir, const char* name);
+	virtual	status_t			Rename(fs_vnode oldDir, const char* oldName,
+									fs_vnode newDir, const char* newName);
+
+	virtual	status_t			Access(fs_vnode node, int mode);
+	virtual	status_t			ReadStat(fs_vnode node, struct stat* st);
+	virtual	status_t			WriteStat(fs_vnode node, const struct stat *st,
+									uint32 mask);
 
 	// files
-	virtual	status_t			Create(void* dir, const char* name,
+	virtual	status_t			Create(fs_vnode dir, const char* name,
-									int openMode, int mode, vnode_id* vnid,
+									int openMode, int mode, fs_cookie* cookie,
-									void** cookie);
+									vnode_id* vnid);
-	virtual	status_t			Open(void* node, int openMode, void** cookie);
+	virtual	status_t			Open(fs_vnode node, int openMode,
-	virtual	status_t			Close(void* node, void* cookie);
+									fs_cookie* cookie);
-	virtual	status_t			FreeCookie(void* node, void* cookie);
+	virtual	status_t			Close(fs_vnode node, fs_cookie cookie);
-	virtual	status_t			Read(void* node, void* cookie, off_t pos,
+	virtual	status_t			FreeCookie(fs_vnode node, fs_cookie cookie);
+	virtual	status_t			Read(fs_vnode node, fs_cookie cookie, off_t pos,
 									void* buffer, size_t bufferSize,
 									size_t* bytesRead);
-	virtual	status_t			Write(void* node, void* cookie, off_t pos,
+	virtual	status_t			Write(fs_vnode node, fs_cookie cookie,
-									const void* buffer, size_t bufferSize,
+									off_t pos, const void* buffer,
-									size_t* bytesWritten);
+									size_t bufferSize, size_t* bytesWritten);
-	virtual	status_t			IOCtl(void* node, void* cookie, int command,
-									void *buffer, size_t size);
-	virtual	status_t			SetFlags(void* node, void* cookie, int flags);
-	virtual	status_t			Select(void* node, void* cookie, uint8 event,
-									uint32 ref, selectsync* sync);
-	virtual	status_t			Deselect(void* node, void* cookie, uint8 event,
-									selectsync* sync);
-
-	// hard links / symlinks
-	virtual	status_t			Link(void* dir, const char* name, void* node);
-	virtual	status_t			Unlink(void* dir, const char* name);
-	virtual	status_t			Symlink(void* dir, const char* name,
-									const char* target);
-	virtual	status_t			ReadLink(void* node, char* buffer,
-									size_t bufferSize, size_t* bytesRead);
-	virtual	status_t			Rename(void* oldDir, const char* oldName,
-									void* newDir, const char* newName);
 
 	// directories
-	virtual	status_t			MkDir(void* dir, const char* name, int mode);
+	virtual	status_t			CreateDir(fs_vnode dir, const char* name,
-	virtual	status_t			RmDir(void* dir, const char* name);
+									int mode, vnode_id *newDir);
-	virtual	status_t			OpenDir(void* node, void** cookie);
+	virtual	status_t			RemoveDir(fs_vnode dir, const char* name);
-	virtual	status_t			CloseDir(void* node, void* cookie);
+	virtual	status_t			OpenDir(fs_vnode node, fs_cookie* cookie);
-	virtual	status_t			FreeDirCookie(void* node, void* cookie);
+	virtual	status_t			CloseDir(fs_vnode node, fs_vnode cookie);
-	virtual	status_t			ReadDir(void* node, void* cookie,
+	virtual	status_t			FreeDirCookie(fs_vnode node, fs_vnode cookie);
+	virtual	status_t			ReadDir(fs_vnode node, fs_vnode cookie,
 									void* buffer, size_t bufferSize,
-									int32 count, int32* countRead);
+									uint32 count, uint32* countRead);
-	virtual	status_t			RewindDir(void* node, void* cookie);
+	virtual	status_t			RewindDir(fs_vnode node, fs_vnode cookie);
-	virtual	status_t			Walk(void* dir, const char* entryName,
+
-									char** resolvedPath, vnode_id* vnid);
+	// attribute directories
+	virtual	status_t			OpenAttrDir(fs_vnode node, fs_cookie *cookie);
+	virtual	status_t			CloseAttrDir(fs_vnode node, fs_cookie cookie);
+	virtual	status_t			FreeAttrDirCookie(fs_vnode node,
+									fs_cookie cookie);
+	virtual	status_t			ReadAttrDir(fs_vnode node, fs_cookie cookie,
+									void* buffer, size_t bufferSize,
+									uint32 count, uint32* countRead);
+	virtual	status_t			RewindAttrDir(fs_vnode node, fs_cookie cookie);
 
 	// attributes
-	virtual	status_t			OpenAttrDir(void* node, void** cookie);
+	virtual	status_t			ReadAttr(fs_vnode node, fs_cookie cookie,
-	virtual	status_t			CloseAttrDir(void* node, void* cookie);
+									off_t pos, void* buffer, size_t bufferSize,
-	virtual	status_t			FreeAttrDirCookie(void* node, void* cookie);
+									size_t* bytesRead);
-	virtual	status_t			ReadAttrDir(void* node, void* cookie,
+	virtual	status_t			WriteAttr(fs_vnode node, fs_cookie cookie,
-									void* buffer, size_t bufferSize,
+									off_t pos, const void* buffer,
-									int32 count, int32* countRead);
-	virtual	status_t			RewindAttrDir(void* node, void* cookie);
-	virtual	status_t			ReadAttr(void* node, const char* name,
-									int type, off_t pos, void* buffer,
-									size_t bufferSize, size_t* bytesRead);
-	virtual	status_t			WriteAttr(void* node, const char* name,
-									int type, off_t pos, const void* buffer,
 									size_t bufferSize, size_t* bytesWritten);
-	virtual	status_t			RemoveAttr(void* node, const char* name);
+	virtual	status_t			ReadAttrStat(fs_vnode node, fs_cookie cookie,
-	virtual	status_t			RenameAttr(void* node, const char* oldName,
+									struct stat *st);
+	virtual	status_t			RenameAttr(fs_vnode oldNode,
+									const char* oldName, fs_vnode newNode,
 									const char* newName);
-	virtual	status_t			StatAttr(void* node, const char* name,
+	virtual	status_t			RemoveAttr(fs_vnode node, const char* name);
-									struct attr_info* attrInfo);
 
 	// indices
-	virtual	status_t			OpenIndexDir(void** cookie);
+	virtual	status_t			OpenIndexDir(fs_cookie *cookie);
-	virtual	status_t			CloseIndexDir(void* cookie);
+	virtual	status_t			CloseIndexDir(fs_cookie cookie);
-	virtual	status_t			FreeIndexDirCookie(void* cookie);
+	virtual	status_t			FreeIndexDirCookie(fs_cookie cookie);
-	virtual	status_t			ReadIndexDir(void* cookie, void* buffer,
+	virtual	status_t			ReadIndexDir(fs_cookie cookie, void* buffer,
-									size_t bufferSize, int32 count,
+									size_t bufferSize, uint32 count,
-									int32* countRead);
+									uint32* countRead);
-	virtual	status_t			RewindIndexDir(void* cookie);
+	virtual	status_t			RewindIndexDir(fs_cookie cookie);
-	virtual	status_t			CreateIndex(const char* name, int type,
+	virtual	status_t			CreateIndex(const char* name, uint32 type,
-									int flags);
+									uint32 flags);
 	virtual	status_t			RemoveIndex(const char* name);
-	virtual	status_t			RenameIndex(const char* oldName,
+	virtual	status_t			ReadIndexStat(const char *name,
-									const char* newName);
+									struct stat *st);
-	virtual	status_t			StatIndex(const char *name,
-									struct index_info* indexInfo);
 
 	// queries
 	virtual	status_t			OpenQuery(const char* queryString,
-									ulong flags, port_id port, long token,
+									uint32 flags, port_id port, uint32 token,
-									void** cookie);
+									fs_cookie *cookie);
-	virtual	status_t			CloseQuery(void* cookie);
+	virtual	status_t			CloseQuery(fs_cookie cookie);
-	virtual	status_t			FreeQueryCookie(void* cookie);
+	virtual	status_t			FreeQueryCookie(fs_cookie cookie);
-	virtual	status_t			ReadQuery(void* cookie, void* buffer,
+	virtual	status_t			ReadQuery(fs_cookie cookie, void* buffer,
-									size_t bufferSize, int32 count,
+									size_t bufferSize, uint32 count,
-									int32* countRead);
+									uint32* countRead);
 
 protected:
 			FileSystem*			fFileSystem;
-			nspace_id			fID;
+			mount_id			fID;
 };
 
 }	// namespace UserlandFS