Some more work towards adjusting the UserlandFS to the current FS interface:

* Split the FSCapabilities bit mask into three bit masks for the FS, the
  volume, and the vnodes, since we have three independent FS interface
  structures, now. The latter is not supported in the kernel add-on, yet.
* Server:
  - Temporarily removed some things from the build (the BeOS interface
    and the cache implementations).
  - Some WIP in HaikuKernelVolume and [haiku_]kernel_emu.{h,cpp}.
  - Added HaikuKernelNode, which wraps fs_vnode for the client FS.
  The server is still quite a bit away from being buildable again.


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

headers/private/userlandfs/private/FSCapabilities.h

@@ -13,113 +13,139 @@ enum client_fs_type {
 	CLIENT_FS_HAIKU_KERNEL,
 };
 
+// FS capabilities
 enum {
 	// FS operations
 	FS_CAPABILITY_MOUNT	= 0,
-	FS_CAPABILITY_UNMOUNT,
 
-	FS_CAPABILITY_READ_FS_INFO,
+	FS_CAPABILITY_COUNT
-	FS_CAPABILITY_WRITE_FS_INFO,
-	FS_CAPABILITY_SYNC,
-
-	// vnode operations
-	FS_CAPABILITY_LOOKUP,
-	FS_CAPABILITY_GET_VNODE_NAME,
-
-	FS_CAPABILITY_GET_VNODE,
-	FS_CAPABILITY_PUT_VNODE,
-	FS_CAPABILITY_REMOVE_VNODE,
-
-	// VM file access
-	FS_CAPABILITY_CAN_PAGE,
-	FS_CAPABILITY_READ_PAGES,
-	FS_CAPABILITY_WRITE_PAGES,
-
-	// cache file access
-	FS_CAPABILITY_GET_FILE_MAP,
-
-	// common operations
-	FS_CAPABILITY_IOCTL,
-	FS_CAPABILITY_SET_FLAGS,
-	FS_CAPABILITY_SELECT,
-	FS_CAPABILITY_DESELECT,
-	FS_CAPABILITY_FSYNC,
-
-	FS_CAPABILITY_READ_SYMLINK,
-	FS_CAPABILITY_CREATE_SYMLINK,
-
-	FS_CAPABILITY_LINK,
-	FS_CAPABILITY_UNLINK,
-	FS_CAPABILITY_RENAME,
-
-	FS_CAPABILITY_ACCESS,
-	FS_CAPABILITY_READ_STAT,
-	FS_CAPABILITY_WRITE_STAT,
-
-	// file operations
-	FS_CAPABILITY_CREATE,
-	FS_CAPABILITY_OPEN,
-	FS_CAPABILITY_CLOSE,
-	FS_CAPABILITY_FREE_COOKIE,
-	FS_CAPABILITY_READ,
-	FS_CAPABILITY_WRITE,
-
-	// directory operations
-	FS_CAPABILITY_CREATE_DIR,
-	FS_CAPABILITY_REMOVE_DIR,
-	FS_CAPABILITY_OPEN_DIR,
-	FS_CAPABILITY_CLOSE_DIR,
-	FS_CAPABILITY_FREE_DIR_COOKIE,
-	FS_CAPABILITY_READ_DIR,
-	FS_CAPABILITY_REWIND_DIR,
-
-	// attribute directory operations
-	FS_CAPABILITY_OPEN_ATTR_DIR,
-	FS_CAPABILITY_CLOSE_ATTR_DIR,
-	FS_CAPABILITY_FREE_ATTR_DIR_COOKIE,
-	FS_CAPABILITY_READ_ATTR_DIR,
-	FS_CAPABILITY_REWIND_ATTR_DIR,
-
-	// attribute operations
-	FS_CAPABILITY_CREATE_ATTR,
-	FS_CAPABILITY_OPEN_ATTR,
-	FS_CAPABILITY_CLOSE_ATTR,
-	FS_CAPABILITY_FREE_ATTR_COOKIE,
-	FS_CAPABILITY_READ_ATTR,
-	FS_CAPABILITY_WRITE_ATTR,
-
-	FS_CAPABILITY_READ_ATTR_STAT,
-	FS_CAPABILITY_WRITE_ATTR_STAT,
-	FS_CAPABILITY_RENAME_ATTR,
-	FS_CAPABILITY_REMOVE_ATTR,
-
-	// index directory & index operations
-	FS_CAPABILITY_OPEN_INDEX_DIR,
-	FS_CAPABILITY_CLOSE_INDEX_DIR,
-	FS_CAPABILITY_FREE_INDEX_DIR_COOKIE,
-	FS_CAPABILITY_READ_INDEX_DIR,
-	FS_CAPABILITY_REWIND_INDEX_DIR,
-
-	FS_CAPABILITY_CREATE_INDEX,
-	FS_CAPABILITY_REMOVE_INDEX,
-	FS_CAPABILITY_READ_INDEX_STAT,
-
-	// query operations
-	FS_CAPABILITY_OPEN_QUERY,
-	FS_CAPABILITY_CLOSE_QUERY,
-	FS_CAPABILITY_FREE_QUERY_COOKIE,
-	FS_CAPABILITY_READ_QUERY,
-	FS_CAPABILITY_REWIND_QUERY,
-
-	FS_CAPABILITY_COUNT,
 };
 
+// Volume capabilities
+enum {
+	// general operations
+	FS_VOLUME_CAPABILITY_UNMOUNT,
+
+	FS_VOLUME_CAPABILITY_READ_FS_INFO,
+	FS_VOLUME_CAPABILITY_WRITE_FS_INFO,
+	FS_VOLUME_CAPABILITY_SYNC,
+
+	FS_VOLUME_CAPABILITY_GET_VNODE,
+
+	// index directory & index operations
+	FS_VOLUME_CAPABILITY_OPEN_INDEX_DIR,
+	FS_VOLUME_CAPABILITY_CLOSE_INDEX_DIR,
+	FS_VOLUME_CAPABILITY_FREE_INDEX_DIR_COOKIE,
+	FS_VOLUME_CAPABILITY_READ_INDEX_DIR,
+	FS_VOLUME_CAPABILITY_REWIND_INDEX_DIR,
+
+	FS_VOLUME_CAPABILITY_CREATE_INDEX,
+	FS_VOLUME_CAPABILITY_REMOVE_INDEX,
+	FS_VOLUME_CAPABILITY_READ_INDEX_STAT,
+
+	// query operations
+	FS_VOLUME_CAPABILITY_OPEN_QUERY,
+	FS_VOLUME_CAPABILITY_CLOSE_QUERY,
+	FS_VOLUME_CAPABILITY_FREE_QUERY_COOKIE,
+	FS_VOLUME_CAPABILITY_READ_QUERY,
+	FS_VOLUME_CAPABILITY_REWIND_QUERY,
+
+	// support for FS layers
+	FS_VOLUME_CAPABILITY_ALL_LAYERS_MOUNTED,
+	FS_VOLUME_CAPABILITY_CREATE_SUB_VNODE,
+	FS_VOLUME_CAPABILITY_DELETE_SUB_VNODE,
+
+	FS_VOLUME_CAPABILITY_COUNT
+};
+
+// VNode capabilities
+enum {
+	// vnode operations
+	FS_VNODE_CAPABILITY_LOOKUP,
+	FS_VNODE_CAPABILITY_GET_VNODE_NAME,
+
+	FS_VNODE_CAPABILITY_PUT_VNODE,
+	FS_VNODE_CAPABILITY_REMOVE_VNODE,
+
+	// VM file access
+	FS_VNODE_CAPABILITY_CAN_PAGE,
+	FS_VNODE_CAPABILITY_READ_PAGES,
+	FS_VNODE_CAPABILITY_WRITE_PAGES,
+
+	// asynchronous I/O
+	FS_VNODE_CAPABILITY_IO,
+	FS_VNODE_CAPABILITY_CANCEL_IO,
+
+	// cache file access
+	FS_VNODE_CAPABILITY_GET_FILE_MAP,
+
+	// common operations
+	FS_VNODE_CAPABILITY_IOCTL,
+	FS_VNODE_CAPABILITY_SET_FLAGS,
+	FS_VNODE_CAPABILITY_SELECT,
+	FS_VNODE_CAPABILITY_DESELECT,
+	FS_VNODE_CAPABILITY_FSYNC,
+
+	FS_VNODE_CAPABILITY_READ_SYMLINK,
+	FS_VNODE_CAPABILITY_CREATE_SYMLINK,
+
+	FS_VNODE_CAPABILITY_LINK,
+	FS_VNODE_CAPABILITY_UNLINK,
+	FS_VNODE_CAPABILITY_RENAME,
+
+	FS_VNODE_CAPABILITY_ACCESS,
+	FS_VNODE_CAPABILITY_READ_STAT,
+	FS_VNODE_CAPABILITY_WRITE_STAT,
+
+	// file operations
+	FS_VNODE_CAPABILITY_CREATE,
+	FS_VNODE_CAPABILITY_OPEN,
+	FS_VNODE_CAPABILITY_CLOSE,
+	FS_VNODE_CAPABILITY_FREE_COOKIE,
+	FS_VNODE_CAPABILITY_READ,
+	FS_VNODE_CAPABILITY_WRITE,
+
+	// directory operations
+	FS_VNODE_CAPABILITY_CREATE_DIR,
+	FS_VNODE_CAPABILITY_REMOVE_DIR,
+	FS_VNODE_CAPABILITY_OPEN_DIR,
+	FS_VNODE_CAPABILITY_CLOSE_DIR,
+	FS_VNODE_CAPABILITY_FREE_DIR_COOKIE,
+	FS_VNODE_CAPABILITY_READ_DIR,
+	FS_VNODE_CAPABILITY_REWIND_DIR,
+
+	// attribute directory operations
+	FS_VNODE_CAPABILITY_OPEN_ATTR_DIR,
+	FS_VNODE_CAPABILITY_CLOSE_ATTR_DIR,
+	FS_VNODE_CAPABILITY_FREE_ATTR_DIR_COOKIE,
+	FS_VNODE_CAPABILITY_READ_ATTR_DIR,
+	FS_VNODE_CAPABILITY_REWIND_ATTR_DIR,
+
+	// attribute operations
+	FS_VNODE_CAPABILITY_CREATE_ATTR,
+	FS_VNODE_CAPABILITY_OPEN_ATTR,
+	FS_VNODE_CAPABILITY_CLOSE_ATTR,
+	FS_VNODE_CAPABILITY_FREE_ATTR_COOKIE,
+	FS_VNODE_CAPABILITY_READ_ATTR,
+	FS_VNODE_CAPABILITY_WRITE_ATTR,
+
+	FS_VNODE_CAPABILITY_READ_ATTR_STAT,
+	FS_VNODE_CAPABILITY_WRITE_ATTR_STAT,
+	FS_VNODE_CAPABILITY_RENAME_ATTR,
+	FS_VNODE_CAPABILITY_REMOVE_ATTR,
+
+	// support for node and FS layers
+	FS_VNODE_CAPABILITY_CREATE_SPECIAL_NODE,
+	FS_VNODE_CAPABILITY_GET_SUPER_VNODE,
+
+	FS_VNODE_CAPABILITY_COUNT
+};
 
 namespace UserlandFSUtil {
 
-struct FSCapabilities {
+template<const int CapabilityCount>
-			client_fs_type		clientFSType;
+struct FSCapabilitiesBase {
-			uint8				capabilities[(FS_CAPABILITY_COUNT + 7) / 8];
+			uint8				capabilities[(CapabilityCount + 7) / 8];
 
 	inline	void				ClearAll();
 
@@ -131,17 +157,19 @@ struct FSCapabilities {
 };
 
 // ClearAll
+template<const int CapabilityCount>
 inline void
-FSCapabilities::ClearAll()
+FSCapabilitiesBase<CapabilityCount>::ClearAll()
 {
 	memset(capabilities, 0, sizeof(capabilities));
 }
 
 // Set
+template<const int CapabilityCount>
 inline void
-FSCapabilities::Set(uint32 capability, bool set)
+FSCapabilitiesBase<CapabilityCount>::Set(uint32 capability, bool set)
 {
-	if (capability >= FS_CAPABILITY_COUNT)
+	if (capability >= CapabilityCount)
 		return;
 
 	uint8 flag = uint8(1 << (capability % 8));
@@ -152,17 +180,19 @@ FSCapabilities::Set(uint32 capability, bool set)
 }
 
 // Clear
+template<const int CapabilityCount>
 inline void
-FSCapabilities::Clear(uint32 capability)
+FSCapabilitiesBase<CapabilityCount>::Clear(uint32 capability)
 {
 	Set(capability, false);
 }
 
 // Get
+template<const int CapabilityCount>
 inline bool
-FSCapabilities::Get(uint32 capability) const
+FSCapabilitiesBase<CapabilityCount>::Get(uint32 capability) const
 {
-	if (capability >= FS_CAPABILITY_COUNT)
+	if (capability >= CapabilityCount)
 		return false;
 
 	uint8 flag = uint8(1 << (capability % 8));
@@ -170,8 +200,9 @@ FSCapabilities::Get(uint32 capability) const
 }
 
 // Dump
+template<const int CapabilityCount>
 inline void
-FSCapabilities::Dump() const
+FSCapabilitiesBase<CapabilityCount>::Dump() const
 {
 	D(
 		char buffer[128];
@@ -179,11 +210,15 @@ FSCapabilities::Dump() const
 		for (int i = 0; i < byteCount; i++)
 			sprintf(buffer + 2 * i, "%02x", (int)capabilities[i]);
 
-		PRINT(("FSCapabilities[%d, %s]\n", clientFSType, buffer));
+		PRINT(("FSCapabilities[%s]\n", buffer));
 	)
 }
 
 
+typedef FSCapabilitiesBase<FS_CAPABILITY_COUNT>			FSCapabilities;
+typedef FSCapabilitiesBase<FS_VOLUME_CAPABILITY_COUNT>	FSVolumeCapabilities;
+typedef FSCapabilitiesBase<FS_VNODE_CAPABILITY_COUNT>	FSVNodeCapabilities;
+
 }	// namespace UserlandFSUtil
 
 using UserlandFSUtil::FSCapabilities;

headers/private/userlandfs/private/Requests.h

@@ -316,6 +316,7 @@ public:
 	Address			portInfos;
 	int32			portInfoCount;
 	FSCapabilities	capabilities;
+	client_fs_type	clientFSType;
 };
 
 
@@ -340,8 +341,9 @@ class MountVolumeReply : public ReplyRequest {
 public:
 	MountVolumeReply() : ReplyRequest(MOUNT_VOLUME_REPLY) {}
 
-	ino_t		rootID;
+	ino_t					rootID;
-	void*		volume;
+	void*					volume;
+	FSVolumeCapabilities	capabilities;
 };
 
 // UnmountVolumeRequest

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

@@ -282,7 +282,7 @@ status_t
 Volume::Sync()
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_SYNC))
+	if (!HasCapability(FS_VOLUME_CAPABILITY_SYNC))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -343,7 +343,7 @@ status_t
 Volume::WriteFSInfo(const struct fs_info *info, uint32 mask)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_WRITE_FS_INFO))
+	if (!HasCapability(FS_VOLUME_CAPABILITY_WRITE_FS_INFO))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -635,7 +635,7 @@ Volume::IOCtl(void* node, void* cookie, uint32 command, void *buffer,
 	}
 
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_IOCTL))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_IOCTL))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -695,7 +695,7 @@ status_t
 Volume::SetFlags(void* node, void* cookie, int flags)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_SET_FLAGS))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_SET_FLAGS))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -735,7 +735,7 @@ status_t
 Volume::Select(void* node, void* cookie, uint8 event, selectsync* sync)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_SELECT)) {
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_SELECT)) {
 		notify_select_event(sync, event);
 		return B_OK;
 	}
@@ -787,7 +787,7 @@ status_t
 Volume::Deselect(void* node, void* cookie, uint8 event, selectsync* sync)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_DESELECT))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_DESELECT))
 		return B_OK;
 
 	struct SyncRemover {
@@ -837,7 +837,7 @@ status_t
 Volume::FSync(void* node)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_FSYNC))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_FSYNC))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -878,7 +878,7 @@ Volume::ReadSymlink(void* node, char* buffer, size_t bufferSize,
 	*bytesRead = 0;
 
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_SYMLINK))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_READ_SYMLINK))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -927,7 +927,7 @@ Volume::CreateSymlink(void* dir, const char* name, const char* target,
 	int mode)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_CREATE_SYMLINK))
+	if (!HasVNodeCapability(dir, FS_VNODE_CAPABILITY_CREATE_SYMLINK))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -971,7 +971,7 @@ status_t
 Volume::Link(void* dir, const char* name, void* node)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_LINK))
+	if (!HasVNodeCapability(dir, FS_VNODE_CAPABILITY_LINK))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -1013,7 +1013,7 @@ status_t
 Volume::Unlink(void* dir, const char* name)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_UNLINK))
+	if (!HasVNodeCapability(dir, FS_VNODE_CAPABILITY_UNLINK))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -1055,7 +1055,7 @@ Volume::Rename(void* oldDir, const char* oldName, void* newDir,
 	const char* newName)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_RENAME))
+	if (!HasVNodeCapability(oldDir, FS_VNODE_CAPABILITY_RENAME))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -1099,7 +1099,7 @@ status_t
 Volume::Access(void* node, int mode)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_ACCESS))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_ACCESS))
 		return B_OK;
 
 	// get a free port
@@ -1168,7 +1168,7 @@ status_t
 Volume::WriteStat(void* node, const struct stat* st, uint32 mask)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_WRITE_STAT))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_WRITE_STAT))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -1212,7 +1212,7 @@ Volume::Create(void* dir, const char* name, int openMode, int mode,
 	void** cookie, ino_t* vnid)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_CREATE))
+	if (!HasVNodeCapability(dir, FS_VNODE_CAPABILITY_CREATE))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -1262,7 +1262,7 @@ status_t
 Volume::Open(void* node, int openMode, void** cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_OPEN))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_OPEN))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -1341,7 +1341,7 @@ Volume::Read(void* node, void* cookie, off_t pos, void* buffer,
 	*bytesRead = 0;
 
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_READ))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_READ))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -1394,7 +1394,7 @@ Volume::Write(void* node, void* cookie, off_t pos, const void* buffer,
 	*bytesWritten = 0;
 
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_WRITE))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_WRITE))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -1441,7 +1441,7 @@ status_t
 Volume::CreateDir(void* dir, const char* name, int mode, ino_t *newDir)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_CREATE_DIR))
+	if (!HasVNodeCapability(dir, FS_VNODE_CAPABILITY_CREATE_DIR))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -1484,7 +1484,7 @@ status_t
 Volume::RemoveDir(void* dir, const char* name)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_REMOVE_DIR))
+	if (!HasVNodeCapability(dir, FS_VNODE_CAPABILITY_REMOVE_DIR))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -1525,7 +1525,7 @@ status_t
 Volume::OpenDir(void* node, void** cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_OPEN_DIR))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_OPEN_DIR))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -1604,7 +1604,7 @@ Volume::ReadDir(void* node, void* cookie, void* buffer, size_t bufferSize,
 	*countRead = 0;
 
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_DIR))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_READ_DIR))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -1663,7 +1663,7 @@ status_t
 Volume::RewindDir(void* node, void* cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_REWIND_DIR))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_REWIND_DIR))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -1706,7 +1706,7 @@ status_t
 Volume::OpenAttrDir(void* node, void** cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_OPEN_ATTR_DIR))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_OPEN_ATTR_DIR))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -1785,7 +1785,7 @@ Volume::ReadAttrDir(void* node, void* cookie, void* buffer,
 	size_t bufferSize, uint32 count, uint32* countRead)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_ATTR_DIR))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_READ_ATTR_DIR))
 		return B_BAD_VALUE;
 
 	*countRead = 0;
@@ -1843,7 +1843,7 @@ status_t
 Volume::RewindAttrDir(void* node, void* cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_REWIND_ATTR_DIR))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_REWIND_ATTR_DIR))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -1886,7 +1886,7 @@ Volume::CreateAttr(void* node, const char* name, uint32 type, int openMode,
 	void** cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_CREATE_ATTR))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_CREATE_ATTR))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -1933,7 +1933,7 @@ Volume::OpenAttr(void* node, const char* name, int openMode,
 	void** cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_OPEN_ATTR))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_OPEN_ATTR))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -2017,7 +2017,7 @@ Volume::ReadAttr(void* node, void* cookie, off_t pos,
 	*bytesRead = 0;
 
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_ATTR))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_READ_ATTR))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -2070,7 +2070,7 @@ Volume::WriteAttr(void* node, void* cookie, off_t pos,
 	*bytesWritten = 0;
 
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_WRITE_ATTR))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_WRITE_ATTR))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -2114,7 +2114,7 @@ status_t
 Volume::ReadAttrStat(void* node, void* cookie, struct stat *st)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_ATTR_STAT))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_READ_ATTR_STAT))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -2155,7 +2155,7 @@ Volume::WriteAttrStat(void* node, void* cookie, const struct stat *st,
 	int statMask)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_WRITE_ATTR_STAT))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_WRITE_ATTR_STAT))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -2197,7 +2197,7 @@ Volume::RenameAttr(void* oldNode, const char* oldName, void* newNode,
 	const char* newName)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_RENAME_ATTR))
+	if (!HasVNodeCapability(oldNode, FS_VNODE_CAPABILITY_RENAME_ATTR))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -2241,7 +2241,7 @@ status_t
 Volume::RemoveAttr(void* node, const char* name)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_REMOVE_ATTR))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_REMOVE_ATTR))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -2286,7 +2286,7 @@ status_t
 Volume::OpenIndexDir(void** cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_OPEN_INDEX_DIR))
+	if (!HasCapability(FS_VOLUME_CAPABILITY_OPEN_INDEX_DIR))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -2366,7 +2366,7 @@ Volume::ReadIndexDir(void* cookie, void* buffer, size_t bufferSize,
 	*countRead = 0;
 
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_INDEX_DIR))
+	if (!HasCapability(FS_VOLUME_CAPABILITY_READ_INDEX_DIR))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -2422,7 +2422,7 @@ status_t
 Volume::RewindIndexDir(void* cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_REWIND_INDEX_DIR))
+	if (!HasCapability(FS_VOLUME_CAPABILITY_REWIND_INDEX_DIR))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -2460,7 +2460,7 @@ status_t
 Volume::CreateIndex(const char* name, uint32 type, uint32 flags)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_CREATE_INDEX))
+	if (!HasCapability(FS_VOLUME_CAPABILITY_CREATE_INDEX))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -2502,7 +2502,7 @@ status_t
 Volume::RemoveIndex(const char* name)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_REMOVE_INDEX))
+	if (!HasCapability(FS_VOLUME_CAPABILITY_REMOVE_INDEX))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -2542,7 +2542,7 @@ status_t
 Volume::ReadIndexStat(const char* name, struct stat *st)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_INDEX_STAT))
+	if (!HasCapability(FS_VOLUME_CAPABILITY_READ_INDEX_STAT))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -2588,7 +2588,7 @@ Volume::OpenQuery(const char* queryString, uint32 flags, port_id targetPort,
 	uint32 token, void** cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_OPEN_QUERY))
+	if (!HasCapability(FS_VOLUME_CAPABILITY_OPEN_QUERY))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -2673,7 +2673,7 @@ Volume::ReadQuery(void* cookie, void* buffer, size_t bufferSize,
 	*countRead = 0;
 
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_QUERY))
+	if (!HasCapability(FS_VOLUME_CAPABILITY_READ_QUERY))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -2729,7 +2729,7 @@ status_t
 Volume::RewindQuery(void* cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_REWIND_QUERY))
+	if (!HasCapability(FS_VOLUME_CAPABILITY_REWIND_QUERY))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -2810,6 +2810,7 @@ Volume::_Mount(const char* device, uint32 flags, const char* parameters)
 		return reply->error;
 	fRootID = reply->rootID;
 	fUserlandVolume = reply->volume;
+	fCapabilities = reply->capabilities;
 
 	// enable vnode counting
 	fVNodeCountMap = new(nothrow) VNodeCountMap;
@@ -2858,7 +2859,7 @@ status_t
 Volume::_ReadFSInfo(fs_info* info)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_FS_INFO))
+	if (!HasCapability(FS_VOLUME_CAPABILITY_READ_FS_INFO))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -2970,7 +2971,7 @@ status_t
 Volume::_ReadStat(void* node, struct stat* st)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_READ_STAT))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_READ_STAT))
 		return B_BAD_VALUE;
 
 	// get a free port
@@ -3009,7 +3010,7 @@ status_t
 Volume::_Close(void* node, void* cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_CLOSE))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_CLOSE))
 		return B_OK;
 
 	// get a free port
@@ -3048,7 +3049,7 @@ status_t
 Volume::_FreeCookie(void* node, void* cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_FREE_COOKIE))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_FREE_COOKIE))
 		return B_OK;
 
 	// get a free port
@@ -3087,7 +3088,7 @@ status_t
 Volume::_CloseDir(void* node, void* cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_CLOSE_DIR))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_CLOSE_DIR))
 		return B_OK;
 
 	// get a free port
@@ -3126,7 +3127,7 @@ status_t
 Volume::_FreeDirCookie(void* node, void* cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_FREE_DIR_COOKIE))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_FREE_DIR_COOKIE))
 		return B_OK;
 
 	// get a free port
@@ -3165,7 +3166,7 @@ status_t
 Volume::_CloseAttrDir(void* node, void* cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_CLOSE_ATTR_DIR))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_CLOSE_ATTR_DIR))
 		return B_OK;
 
 	// get a free port
@@ -3204,7 +3205,7 @@ status_t
 Volume::_FreeAttrDirCookie(void* node, void* cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_FREE_ATTR_DIR_COOKIE))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_FREE_ATTR_DIR_COOKIE))
 		return B_OK;
 
 	// get a free port
@@ -3243,7 +3244,7 @@ status_t
 Volume::_CloseAttr(void* node, void* cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_CLOSE_ATTR))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_CLOSE_ATTR))
 		return B_OK;
 
 	// get a free port
@@ -3282,7 +3283,7 @@ status_t
 Volume::_FreeAttrCookie(void* node, void* cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_FREE_ATTR_COOKIE))
+	if (!HasVNodeCapability(node, FS_VNODE_CAPABILITY_FREE_ATTR_COOKIE))
 		return B_OK;
 
 	// get a free port
@@ -3321,7 +3322,7 @@ status_t
 Volume::_CloseIndexDir(void* cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_CLOSE_INDEX_DIR))
+	if (!HasCapability(FS_VOLUME_CAPABILITY_CLOSE_INDEX_DIR))
 		return B_OK;
 
 	// get a free port
@@ -3359,7 +3360,7 @@ status_t
 Volume::_FreeIndexDirCookie(void* cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_FREE_INDEX_DIR_COOKIE))
+	if (!HasCapability(FS_VOLUME_CAPABILITY_FREE_INDEX_DIR_COOKIE))
 		return B_OK;
 
 	// get a free port
@@ -3397,7 +3398,7 @@ status_t
 Volume::_CloseQuery(void* cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_CLOSE_QUERY))
+	if (!HasCapability(FS_VOLUME_CAPABILITY_CLOSE_QUERY))
 		return B_OK;
 
 	// get a free port
@@ -3435,7 +3436,7 @@ status_t
 Volume::_FreeQueryCookie(void* cookie)
 {
 	// check capability
-	if (!fFileSystem->HasCapability(FS_CAPABILITY_FREE_QUERY_COOKIE))
+	if (!HasCapability(FS_VOLUME_CAPABILITY_FREE_QUERY_COOKIE))
 		return B_OK;
 
 	// get a free port

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

@@ -7,6 +7,7 @@
 
 #include <fs_interface.h>
 
+#include "FSCapabilities.h"
 #include "Referencable.h"
 
 namespace UserlandFSUtil {
@@ -19,6 +20,7 @@ struct userlandfs_ioctl;
 
 }
 
+using UserlandFSUtil::FSVolumeCapabilities;
 using UserlandFSUtil::Request;
 using UserlandFSUtil::RequestAllocator;
 using UserlandFSUtil::RequestHandler;
@@ -36,6 +38,10 @@ public:
 			FileSystem*			GetFileSystem() const;
 	inline	dev_t				GetID() const;
 
+	inline	bool				HasCapability(int capability) const;
+	inline	bool				HasVNodeCapability(void* vnode,
+									int capability) const;
+
 			void*				GetUserlandVolume() const;
 			ino_t				GetRootID() const;
 			bool				IsMounting() const;
@@ -226,6 +232,7 @@ private:
 
 			FileSystem*			fFileSystem;
 			fs_volume*			fFSVolume;
+			FSVolumeCapabilities fCapabilities;
 			void*				fUserlandVolume;
 			ino_t				fRootID;
 			void*				fRootNode;
@@ -252,4 +259,19 @@ Volume::GetID() const
 }
 
 
+inline bool
+Volume::HasCapability(int capability) const
+{
+	return fCapabilities.Get(capability);
+}
+
+
+inline bool
+Volume::HasVNodeCapability(void* vnode, int capability) const
+{
+	// TODO: Implement for real!
+	return true;
+}
+
+
 #endif	// USERLAND_FS_VOLUME_H

src/add-ons/kernel/file_systems/userlandfs/kernel_add_on/kernel_interface.cpp

@@ -1168,13 +1168,11 @@ fs_vnode_ops gUserlandFSVnodeOps = {
 	&userlandfs_put_vnode,
 	&userlandfs_remove_vnode,
 
-
 	// VM file access
 	NULL,	// &userlandfs_can_page,
 	NULL,	// &userlandfs_read_pages,
 	NULL,	// &userlandfs_write_pages,
 
-
 	// asynchronous I/O
 	NULL,	// &userlandfs_io
 	NULL,	// &userlandfs_cancel_io

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

@@ -114,8 +114,7 @@ BeOSKernelVolume::WriteFSInfo(const struct fs_info* info, uint32 mask)
 
 // Lookup
 status_t
-BeOSKernelVolume::Lookup(fs_vnode dir, const char* entryName, ino_t* vnid,
+BeOSKernelVolume::Lookup(fs_vnode dir, const char* entryName, ino_t* vnid)
-	int* type)
 {
 	if (!fFSOps->walk)
 		return B_BAD_VALUE;
@@ -169,8 +168,10 @@ BeOSKernelVolume::LookupNoType(fs_vnode dir, const char* entryName,
 
 // ReadVNode
 status_t
-BeOSKernelVolume::ReadVNode(ino_t vnid, bool reenter, fs_vnode* node)
+BeOSKernelVolume::ReadVNode(ino_t vnid, bool reenter, fs_vnode* node, int* type,
+	uint32* flags)
 {
+#error Return type and flags!
 	if (!fFSOps->read_vnode)
 		return B_BAD_VALUE;
 	return fFSOps->read_vnode(fVolumeCookie, vnid, (char)reenter, node);
@@ -221,13 +222,13 @@ BeOSKernelVolume::SetFlags(fs_vnode node, fs_cookie cookie, int flags)
 // Select
 status_t
 BeOSKernelVolume::Select(fs_vnode node, fs_cookie cookie, uint8 event,
-	uint32 ref, selectsync* sync)
+	selectsync* sync)
 {
 	if (!fFSOps->select) {
 		UserlandFS::KernelEmu::notify_select_event(sync, event, false);
 		return B_OK;
 	}
-	return fFSOps->select(fVolumeCookie, node, cookie, event, ref, sync);
+	return fFSOps->select(fVolumeCookie, node, cookie, event, 0, sync);
 }
 
 // Deselect

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

@@ -26,12 +26,12 @@ public:
 
 	// vnodes
 	virtual	status_t			Lookup(fs_vnode dir, const char* entryName,
-									ino_t* vnid, int* type);
+									ino_t* vnid);
 	virtual	status_t			LookupNoType(fs_vnode dir,
 									const char* entryName, ino_t* vnid);
 									// not required
 	virtual	status_t			ReadVNode(ino_t vnid, bool reenter,
-									fs_vnode* node);
+									fs_vnode* node, int* type, uint32* flags);
 	virtual	status_t			WriteVNode(fs_vnode node, bool reenter);
 	virtual	status_t			RemoveVNode(fs_vnode node, bool reenter);
 
@@ -41,7 +41,7 @@ public:
 	virtual	status_t			SetFlags(fs_vnode node, fs_cookie cookie,
 									int flags);
 	virtual	status_t			Select(fs_vnode node, fs_cookie cookie,
-									uint8 event, uint32 ref, selectsync* sync);
+									uint8 event, selectsync* sync);
 	virtual	status_t			Deselect(fs_vnode node, fs_cookie cookie,
 									uint8 event, selectsync* sync);
 

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

@@ -27,12 +27,12 @@ public:
 	}
 
 	FSInfo(const char* fsName, const Port::Info* infos, int32 count,
-		const FSCapabilities& capabilities)
+		const FSCapabilities& capabilities, client_fs_type clientFSType)
 		: fName(),
 		  fInfos(NULL),
 		  fCount(0)
 	{
-		SetTo(fsName, infos, count, capabilities);
+		SetTo(fsName, infos, count, capabilities, clientFSType);
 	}
 
 	FSInfo(const BMessage* message)
@@ -48,7 +48,8 @@ public:
 		  fInfos(NULL),
 		  fCount(0)
 	{
-		SetTo(other.GetName(), other.fInfos, other.fCount, other.fCapabilities);
+		SetTo(other.GetName(), other.fInfos, other.fCount, other.fCapabilities,
+			other.fClientFSType);
 	}
 
 	~FSInfo()
@@ -57,7 +58,7 @@ public:
 	}
 
 	status_t SetTo(const char* fsName, const Port::Info* infos, int32 count,
-		const FSCapabilities& capabilities)
+		const FSCapabilities& capabilities, client_fs_type clientFSType)
 	{
 		Unset();
 
@@ -73,6 +74,7 @@ public:
 		memcpy(fInfos, infos, sizeof(Port::Info) * count);
 
 		fCapabilities = capabilities;
+		fClientFSType = clientFSType;
 
 		fCount = count;
 		return B_OK;
@@ -90,16 +92,19 @@ public:
 		const char* fsName;
 		const void* capabilities;
 		ssize_t capabilitiesSize;
+		int32 clientFSType;
 
 		if (message->FindData("infos", B_RAW_TYPE, &infos, &size) != B_OK
 			|| size < 0 || message->FindString("fsName", &fsName) != B_OK
 			|| message->FindData("capabilities", B_RAW_TYPE, &capabilities,
 				&capabilitiesSize) != B_OK
-			|| capabilitiesSize != sizeof(FSCapabilities)) {
+			|| capabilitiesSize != sizeof(FSCapabilities)
+			|| message->FindInt32("clientFSType", &clientFSType) != B_OK) {
 			return B_BAD_VALUE;
 		}
 		return SetTo(fsName, (const Port::Info*)infos,
-			size / sizeof(Port::Info), *(const FSCapabilities*)capabilities);
+			size / sizeof(Port::Info), *(const FSCapabilities*)capabilities,
+			(client_fs_type)clientFSType);
 	}
 
 	void Unset()
@@ -135,6 +140,11 @@ public:
 		return fCapabilities;
 	}
 
+	client_fs_type GetClientFSType() const
+	{
+		return fClientFSType;
+	}
+
 	status_t Archive(BMessage* archive)
 	{
 		if (!fName.GetString() || !fInfos)
@@ -149,8 +159,12 @@ public:
 		if (error != B_OK)
 			return error;
 
-		return archive->AddData("capabilities", B_RAW_TYPE, &fCapabilities,
+		error = archive->AddData("capabilities", B_RAW_TYPE, &fCapabilities,
 			sizeof(FSCapabilities));
+		if (error != B_OK)
+			return error;
+
+		return archive->AddInt32("clientFSType", fClientFSType);
 	}
 
 private:
@@ -158,6 +172,7 @@ private:
 	Port::Info*		fInfos;
 	int32			fCount;
 	FSCapabilities	fCapabilities;
+	client_fs_type	fClientFSType;
 };
 
 }	// namespace UserlandFS

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

@@ -23,9 +23,12 @@ public:
 			void				GetCapabilities(
 									FSCapabilities& capabilities) const
 									{ capabilities = fCapabilities; }
+			client_fs_type		GetClientFSType() const
+									{ return fClientFSType; }
 
 protected:
 			FSCapabilities		fCapabilities;
+			client_fs_type		fClientFSType;
 };
 
 }	// namespace UserlandFS

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

@@ -68,106 +68,8 @@ HaikuKernelFileSystem::_InitCapabilities()
 	fCapabilities.ClearAll();
 
 	// FS interface type
-	fCapabilities.clientFSType = CLIENT_FS_HAIKU_KERNEL;
+	fClientFSType = CLIENT_FS_HAIKU_KERNEL;
 
 	// FS operations
 	fCapabilities.Set(FS_CAPABILITY_MOUNT, fFSModule->mount);
-	fCapabilities.Set(FS_CAPABILITY_UNMOUNT, fFSModule->unmount);
-
-	fCapabilities.Set(FS_CAPABILITY_READ_FS_INFO, fFSModule->read_fs_info);
-	fCapabilities.Set(FS_CAPABILITY_WRITE_FS_INFO, fFSModule->write_fs_info);
-	fCapabilities.Set(FS_CAPABILITY_SYNC, fFSModule->sync);
-
-	// vnode operations
-	fCapabilities.Set(FS_CAPABILITY_LOOKUP, fFSModule->lookup);
-	fCapabilities.Set(FS_CAPABILITY_GET_VNODE_NAME, fFSModule->get_vnode_name);
-
-	fCapabilities.Set(FS_CAPABILITY_GET_VNODE, fFSModule->get_vnode);
-	fCapabilities.Set(FS_CAPABILITY_PUT_VNODE, fFSModule->put_vnode);
-	fCapabilities.Set(FS_CAPABILITY_REMOVE_VNODE, fFSModule->remove_vnode);
-
-	// VM file access
-	fCapabilities.Set(FS_CAPABILITY_CAN_PAGE, fFSModule->can_page);
-	fCapabilities.Set(FS_CAPABILITY_READ_PAGES, fFSModule->read_pages);
-	fCapabilities.Set(FS_CAPABILITY_WRITE_PAGES, fFSModule->write_pages);
-
-	// cache file access
-	fCapabilities.Set(FS_CAPABILITY_GET_FILE_MAP, fFSModule->get_file_map);
-
-	// common operations
-	fCapabilities.Set(FS_CAPABILITY_IOCTL, fFSModule->ioctl);
-	fCapabilities.Set(FS_CAPABILITY_SET_FLAGS, fFSModule->set_flags);
-	fCapabilities.Set(FS_CAPABILITY_SELECT, fFSModule->select);
-	fCapabilities.Set(FS_CAPABILITY_DESELECT, fFSModule->deselect);
-	fCapabilities.Set(FS_CAPABILITY_FSYNC, fFSModule->fsync);
-
-	fCapabilities.Set(FS_CAPABILITY_READ_SYMLINK, fFSModule->read_symlink);
-	fCapabilities.Set(FS_CAPABILITY_CREATE_SYMLINK, fFSModule->create_symlink);
-
-	fCapabilities.Set(FS_CAPABILITY_LINK, fFSModule->link);
-	fCapabilities.Set(FS_CAPABILITY_UNLINK, fFSModule->unlink);
-	fCapabilities.Set(FS_CAPABILITY_RENAME, fFSModule->rename);
-
-	fCapabilities.Set(FS_CAPABILITY_ACCESS, fFSModule->access);
-	fCapabilities.Set(FS_CAPABILITY_READ_STAT, fFSModule->read_stat);
-	fCapabilities.Set(FS_CAPABILITY_WRITE_STAT, fFSModule->write_stat);
-
-	// file operations
-	fCapabilities.Set(FS_CAPABILITY_CREATE, fFSModule->create);
-	fCapabilities.Set(FS_CAPABILITY_OPEN, fFSModule->open);
-	fCapabilities.Set(FS_CAPABILITY_CLOSE, fFSModule->close);
-	fCapabilities.Set(FS_CAPABILITY_FREE_COOKIE, fFSModule->free_cookie);
-	fCapabilities.Set(FS_CAPABILITY_READ, fFSModule->read);
-	fCapabilities.Set(FS_CAPABILITY_WRITE, fFSModule->write);
-
-	// directory operations
-	fCapabilities.Set(FS_CAPABILITY_CREATE_DIR, fFSModule->create_dir);
-	fCapabilities.Set(FS_CAPABILITY_REMOVE_DIR, fFSModule->remove_dir);
-	fCapabilities.Set(FS_CAPABILITY_OPEN_DIR, fFSModule->open_dir);
-	fCapabilities.Set(FS_CAPABILITY_CLOSE_DIR, fFSModule->close_dir);
-	fCapabilities.Set(FS_CAPABILITY_FREE_DIR_COOKIE, fFSModule->free_dir_cookie);
-	fCapabilities.Set(FS_CAPABILITY_READ_DIR, fFSModule->read_dir);
-	fCapabilities.Set(FS_CAPABILITY_REWIND_DIR, fFSModule->rewind_dir);
-
-	// attribute directory operations
-	fCapabilities.Set(FS_CAPABILITY_OPEN_ATTR_DIR, fFSModule->open_attr_dir);
-	fCapabilities.Set(FS_CAPABILITY_CLOSE_ATTR_DIR, fFSModule->close_attr_dir);
-	fCapabilities.Set(FS_CAPABILITY_FREE_ATTR_DIR_COOKIE,
-		fFSModule->free_attr_dir_cookie);
-	fCapabilities.Set(FS_CAPABILITY_READ_ATTR_DIR, fFSModule->read_attr_dir);
-	fCapabilities.Set(FS_CAPABILITY_REWIND_ATTR_DIR, fFSModule->rewind_attr_dir);
-
-	// attribute operations
-	fCapabilities.Set(FS_CAPABILITY_CREATE_ATTR, fFSModule->create_attr);
-	fCapabilities.Set(FS_CAPABILITY_OPEN_ATTR, fFSModule->open_attr);
-	fCapabilities.Set(FS_CAPABILITY_CLOSE_ATTR, fFSModule->close_attr);
-	fCapabilities.Set(FS_CAPABILITY_FREE_ATTR_COOKIE,
-		fFSModule->free_attr_cookie);
-	fCapabilities.Set(FS_CAPABILITY_READ_ATTR, fFSModule->read_attr);
-	fCapabilities.Set(FS_CAPABILITY_WRITE_ATTR, fFSModule->write_attr);
-
-	fCapabilities.Set(FS_CAPABILITY_READ_ATTR_STAT, fFSModule->read_attr_stat);
-	fCapabilities.Set(FS_CAPABILITY_WRITE_ATTR_STAT,
-		fFSModule->write_attr_stat);
-	fCapabilities.Set(FS_CAPABILITY_RENAME_ATTR, fFSModule->rename_attr);
-	fCapabilities.Set(FS_CAPABILITY_REMOVE_ATTR, fFSModule->remove_attr);
-
-	// index directory & index operations
-	fCapabilities.Set(FS_CAPABILITY_OPEN_INDEX_DIR, fFSModule->open_index_dir);
-	fCapabilities.Set(FS_CAPABILITY_CLOSE_INDEX_DIR, fFSModule->close_index_dir);
-	fCapabilities.Set(FS_CAPABILITY_FREE_INDEX_DIR_COOKIE,
-		fFSModule->free_index_dir_cookie);
-	fCapabilities.Set(FS_CAPABILITY_READ_INDEX_DIR, fFSModule->read_index_dir);
-	fCapabilities.Set(FS_CAPABILITY_REWIND_INDEX_DIR, fFSModule->rewind_index_dir);
-
-	fCapabilities.Set(FS_CAPABILITY_CREATE_INDEX, fFSModule->create_index);
-	fCapabilities.Set(FS_CAPABILITY_REMOVE_INDEX, fFSModule->remove_index);
-	fCapabilities.Set(FS_CAPABILITY_READ_INDEX_STAT, fFSModule->read_index_stat);
-
-	// query operations
-	fCapabilities.Set(FS_CAPABILITY_OPEN_QUERY, fFSModule->open_query);
-	fCapabilities.Set(FS_CAPABILITY_CLOSE_QUERY, fFSModule->close_query);
-	fCapabilities.Set(FS_CAPABILITY_FREE_QUERY_COOKIE, fFSModule->free_query_cookie);
-	fCapabilities.Set(FS_CAPABILITY_READ_QUERY, fFSModule->read_query);
-	fCapabilities.Set(FS_CAPABILITY_REWIND_QUERY, fFSModule->rewind_query);
 }

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

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2009, Ingo Weinhold, ingo_weinhold@gmx.de.
+ * Distributed under the terms of the MIT License.
+ */
+#ifndef USERLAND_FS_HAIKU_KERNEL_NODE_H
+#define USERLAND_FS_HAIKU_KERNEL_NODE_H
+
+#include <fs_interface.h>
+#include <SupportDefs.h>
+
+#include "FSCapabilities.h"
+
+namespace UserlandFS {
+
+class HaikuKernelVolume;
+
+using UserlandFSUtil::FSVNodeCapabilities;
+
+
+struct HaikuKernelNode : fs_vnode {
+			HaikuKernelVolume*	volume;
+
+public:
+	static	HaikuKernelNode*	GetNode(fs_vnode* node);
+
+			HaikuKernelVolume*	GetVolume() const	{ return volume; }
+};
+
+
+/*static*/ inline HaikuKernelNode*
+HaikuKernelNode::GetNode(fs_vnode* node)
+{
+	return static_cast<HaikuKernelNode*>(node);
+}
+
+
+}	// namespace UserlandFS
+
+using UserlandFS::HaikuKernelNode;
+
+#endif	// USERLAND_FS_NODE_H

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

@@ -1,7 +1,7 @@
 // HaikuKernelVolume.h
 
-#ifndef USERLAND_FS_BEOS_KERNEL_VOLUME_H
+#ifndef USERLAND_FS_HAIKU_KERNEL_VOLUME_H
-#define USERLAND_FS_BEOS_KERNEL_VOLUME_H
+#define USERLAND_FS_HAIKU_KERNEL_VOLUME_H
 
 #include <fs_interface.h>
 
@@ -9,6 +9,9 @@
 
 namespace UserlandFS {
 
+class HaikuKernelNode;
+
+
 class HaikuKernelVolume : public Volume {
 public:
 								HaikuKernelVolume(FileSystem* fileSystem,
@@ -16,6 +19,18 @@ public:
 									file_system_module_info* fsModule);
 	virtual						~HaikuKernelVolume();
 
+	static	HaikuKernelVolume*	GetVolume(const fs_volume* volume);
+
+	inline	fs_volume*			GetFSVolume()	{ return &fVolume; }
+
+			status_t			NewVNode(ino_t vnodeID, void* privateNode,
+									fs_vnode_ops* ops, HaikuKernelNode** node);
+			status_t			PublishVNode(ino_t vnodeID, void* privateNode,
+									fs_vnode_ops* ops, int type, uint32 flags,
+									HaikuKernelNode** node);
+			status_t			UndoNewVNode(HaikuKernelNode* node);
+			status_t			UndoPublishVNode(HaikuKernelNode* node);
+
 	// FS
 	virtual	status_t			Mount(const char* device, uint32 flags,
 									const char* parameters, ino_t* rootID);
@@ -26,116 +41,116 @@ public:
 									uint32 mask);
 
 	// file cache
-	virtual	status_t			GetFileMap(fs_vnode node, off_t offset,
+	virtual	status_t			GetFileMap(void* node, off_t offset,
 									size_t size, struct file_io_vec* vecs,
 									size_t* count);
 
 	// vnodes
-	virtual	status_t			Lookup(fs_vnode dir, const char* entryName,
+	virtual	status_t			Lookup(void* dir, const char* entryName,
-									ino_t* vnid, int* type);
+									ino_t* vnid);
-	virtual	status_t			GetVNodeName(fs_vnode node, char* buffer,
+	virtual	status_t			GetVNodeName(void* node, char* buffer,
 									size_t bufferSize);
 	virtual	status_t			ReadVNode(ino_t vnid, bool reenter,
-									fs_vnode* node);
+									void** node, int* type, uint32* flags);
-	virtual	status_t			WriteVNode(fs_vnode node, bool reenter);
+	virtual	status_t			WriteVNode(void* node, bool reenter);
-	virtual	status_t			RemoveVNode(fs_vnode node, bool reenter);
+	virtual	status_t			RemoveVNode(void* node, bool reenter);
 
 	// nodes
-	virtual	status_t			IOCtl(fs_vnode node, fs_cookie cookie,
+	virtual	status_t			IOCtl(void* node, void* cookie,
 									uint32 command, void* buffer, size_t size);
-	virtual	status_t			SetFlags(fs_vnode node, fs_cookie cookie,
+	virtual	status_t			SetFlags(void* node, void* cookie,
 									int flags);
-	virtual	status_t			Select(fs_vnode node, fs_cookie cookie,
+	virtual	status_t			Select(void* node, void* cookie,
-									uint8 event, uint32 ref, selectsync* sync);
+									uint8 event, selectsync* sync);
-	virtual	status_t			Deselect(fs_vnode node, fs_cookie cookie,
+	virtual	status_t			Deselect(void* node, void* cookie,
 									uint8 event, selectsync* sync);
 
-	virtual	status_t			FSync(fs_vnode node);
+	virtual	status_t			FSync(void* node);
 
-	virtual	status_t			ReadSymlink(fs_vnode node, char* buffer,
+	virtual	status_t			ReadSymlink(void* node, char* buffer,
 									size_t bufferSize, size_t* bytesRead);
-	virtual	status_t			CreateSymlink(fs_vnode dir, const char* name,
+	virtual	status_t			CreateSymlink(void* dir, const char* name,
 									const char* target, int mode);
 
-	virtual	status_t			Link(fs_vnode dir, const char* name,
+	virtual	status_t			Link(void* dir, const char* name,
-									fs_vnode node);
+									void* node);
-	virtual	status_t			Unlink(fs_vnode dir, const char* name);
+	virtual	status_t			Unlink(void* dir, const char* name);
-	virtual	status_t			Rename(fs_vnode oldDir, const char* oldName,
+	virtual	status_t			Rename(void* oldDir, const char* oldName,
-									fs_vnode newDir, const char* newName);
+									void* newDir, const char* newName);
 
-	virtual	status_t			Access(fs_vnode node, int mode);
+	virtual	status_t			Access(void* node, int mode);
-	virtual	status_t			ReadStat(fs_vnode node, struct stat* st);
+	virtual	status_t			ReadStat(void* node, struct stat* st);
-	virtual	status_t			WriteStat(fs_vnode node, const struct stat *st,
+	virtual	status_t			WriteStat(void* node, const struct stat *st,
 									uint32 mask);
 
 	// files
-	virtual	status_t			Create(fs_vnode dir, const char* name,
+	virtual	status_t			Create(void* dir, const char* name,
-									int openMode, int mode, fs_cookie* cookie,
+									int openMode, int mode, void** cookie,
 									ino_t* vnid);
-	virtual	status_t			Open(fs_vnode node, int openMode,
+	virtual	status_t			Open(void* node, int openMode,
-									fs_cookie* cookie);
+									void** cookie);
-	virtual	status_t			Close(fs_vnode node, fs_cookie cookie);
+	virtual	status_t			Close(void* node, void* cookie);
-	virtual	status_t			FreeCookie(fs_vnode node, fs_cookie cookie);
+	virtual	status_t			FreeCookie(void* node, void* cookie);
-	virtual	status_t			Read(fs_vnode node, fs_cookie cookie, off_t pos,
+	virtual	status_t			Read(void* node, void* cookie, off_t pos,
 									void* buffer, size_t bufferSize,
 									size_t* bytesRead);
-	virtual	status_t			Write(fs_vnode node, fs_cookie cookie,
+	virtual	status_t			Write(void* node, void* cookie,
 									off_t pos, const void* buffer,
 									size_t bufferSize, size_t* bytesWritten);
 
 	// directories
-	virtual	status_t			CreateDir(fs_vnode dir, const char* name,
+	virtual	status_t			CreateDir(void* dir, const char* name,
 									int mode, ino_t *newDir);
-	virtual	status_t			RemoveDir(fs_vnode dir, const char* name);
+	virtual	status_t			RemoveDir(void* dir, const char* name);
-	virtual	status_t			OpenDir(fs_vnode node, fs_cookie* cookie);
+	virtual	status_t			OpenDir(void* node, void** cookie);
-	virtual	status_t			CloseDir(fs_vnode node, fs_vnode cookie);
+	virtual	status_t			CloseDir(void* node, void* cookie);
-	virtual	status_t			FreeDirCookie(fs_vnode node, fs_vnode cookie);
+	virtual	status_t			FreeDirCookie(void* node, void* cookie);
-	virtual	status_t			ReadDir(fs_vnode node, fs_vnode cookie,
+	virtual	status_t			ReadDir(void* node, void* cookie,
 									void* buffer, size_t bufferSize,
 									uint32 count, uint32* countRead);
-	virtual	status_t			RewindDir(fs_vnode node, fs_vnode cookie);
+	virtual	status_t			RewindDir(void* node, void* cookie);
 
 	// attribute directories
-	virtual	status_t			OpenAttrDir(fs_vnode node, fs_cookie *cookie);
+	virtual	status_t			OpenAttrDir(void* node, void** cookie);
-	virtual	status_t			CloseAttrDir(fs_vnode node, fs_cookie cookie);
+	virtual	status_t			CloseAttrDir(void* node, void* cookie);
-	virtual	status_t			FreeAttrDirCookie(fs_vnode node,
+	virtual	status_t			FreeAttrDirCookie(void* node,
-									fs_cookie cookie);
+									void* cookie);
-	virtual	status_t			ReadAttrDir(fs_vnode node, fs_cookie cookie,
+	virtual	status_t			ReadAttrDir(void* node, void* cookie,
 									void* buffer, size_t bufferSize,
 									uint32 count, uint32* countRead);
-	virtual	status_t			RewindAttrDir(fs_vnode node, fs_cookie cookie);
+	virtual	status_t			RewindAttrDir(void* node, void* cookie);
 
 	// attributes
-	virtual	status_t			CreateAttr(fs_vnode node, const char *name,
+	virtual	status_t			CreateAttr(void* node, const char *name,
 									uint32 type, int openMode,
-									fs_cookie *cookie);
+									void** cookie);
-	virtual	status_t			OpenAttr(fs_vnode node, const char *name,
+	virtual	status_t			OpenAttr(void* node, const char *name,
-									int openMode, fs_cookie *cookie);
+									int openMode, void** cookie);
-	virtual	status_t			CloseAttr(fs_vnode node, fs_cookie cookie);
+	virtual	status_t			CloseAttr(void* node, void* cookie);
-	virtual	status_t			FreeAttrCookie(fs_vnode node, fs_cookie cookie);
+	virtual	status_t			FreeAttrCookie(void* node, void* cookie);
-	virtual	status_t			ReadAttr(fs_vnode node, fs_cookie cookie,
+	virtual	status_t			ReadAttr(void* node, void* cookie,
 									off_t pos, void* buffer, size_t bufferSize,
 									size_t* bytesRead);
-	virtual	status_t			WriteAttr(fs_vnode node, fs_cookie cookie,
+	virtual	status_t			WriteAttr(void* node, void* cookie,
 									off_t pos, const void* buffer,
 									size_t bufferSize, size_t* bytesWritten);
-	virtual	status_t			ReadAttrStat(fs_vnode node, fs_cookie cookie,
+	virtual	status_t			ReadAttrStat(void* node, void* cookie,
 									struct stat *st);
-	virtual	status_t			WriteAttrStat(fs_vnode node, fs_cookie cookie,
+	virtual	status_t			WriteAttrStat(void* node, void* cookie,
 									const struct stat* st, int statMask);
-	virtual	status_t			RenameAttr(fs_vnode oldNode,
+	virtual	status_t			RenameAttr(void* oldNode,
-									const char* oldName, fs_vnode newNode,
+									const char* oldName, void* newNode,
 									const char* newName);
-	virtual	status_t			RemoveAttr(fs_vnode node, const char* name);
+	virtual	status_t			RemoveAttr(void* node, const char* name);
 
 	// indices
-	virtual	status_t			OpenIndexDir(fs_cookie *cookie);
+	virtual	status_t			OpenIndexDir(void** cookie);
-	virtual	status_t			CloseIndexDir(fs_cookie cookie);
+	virtual	status_t			CloseIndexDir(void* cookie);
-	virtual	status_t			FreeIndexDirCookie(fs_cookie cookie);
+	virtual	status_t			FreeIndexDirCookie(void* cookie);
-	virtual	status_t			ReadIndexDir(fs_cookie cookie, void* buffer,
+	virtual	status_t			ReadIndexDir(void* cookie, void* buffer,
 									size_t bufferSize, uint32 count,
 									uint32* countRead);
-	virtual	status_t			RewindIndexDir(fs_cookie cookie);
+	virtual	status_t			RewindIndexDir(void* cookie);
 	virtual	status_t			CreateIndex(const char* name, uint32 type,
 									uint32 flags);
 	virtual	status_t			RemoveIndex(const char* name);
@@ -145,21 +160,37 @@ public:
 	// queries
 	virtual	status_t			OpenQuery(const char* queryString,
 									uint32 flags, port_id port, uint32 token,
-									fs_cookie *cookie);
+									void** cookie);
-	virtual	status_t			CloseQuery(fs_cookie cookie);
+	virtual	status_t			CloseQuery(void* cookie);
-	virtual	status_t			FreeQueryCookie(fs_cookie cookie);
+	virtual	status_t			FreeQueryCookie(void* cookie);
-	virtual	status_t			ReadQuery(fs_cookie cookie, void* buffer,
+	virtual	status_t			ReadQuery(void* cookie, void* buffer,
 									size_t bufferSize, uint32 count,
 									uint32* countRead);
-	virtual	status_t			RewindQuery(fs_cookie cookie);
+	virtual	status_t			RewindQuery(void* cookie);
+
+private:
+	struct FSVolume : fs_volume {
+		HaikuKernelVolume*	haikuVolume;
+	};
+
+private:
+			void				_InitCapabilities();
 
 private:
 			file_system_module_info* fFSModule;
-			fs_cookie			fVolumeCookie;
+			FSVolume			fVolume;
 };
 
+
+/*static*/ inline HaikuKernelVolume*
+HaikuKernelVolume::GetVolume(const fs_volume* volume)
+{
+	return static_cast<const FSVolume*>(volume)->haikuVolume;
+}
+
+
 }	// namespace UserlandFS
 
 using UserlandFS::HaikuKernelVolume;
 
-#endif	// USERLAND_FS_BEOS_KERNEL_VOLUME_H
+#endif	// USERLAND_FS_HAIKU_KERNEL_VOLUME_H

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

@@ -33,15 +33,15 @@ Application UserlandFSServer
 	  SingleReplyRequestHandler.cpp
 	  String.cpp
 
-	  beos_fs_cache.c
+#	  beos_fs_cache.c
 
-	  beos_lock.cpp
+#	  beos_lock.cpp
-	  BeOSKernelFileSystem.cpp
+#	  BeOSKernelFileSystem.cpp
-	  BeOSKernelVolume.cpp
+#	  BeOSKernelVolume.cpp
 	  DispatcherFileSystem.cpp
 	  FileSystem.cpp
-	  haiku_block_cache.cpp
+#	  haiku_block_cache.cpp
-	  haiku_file_cache.cpp
+#	  haiku_file_cache.cpp
 	  haiku_hash.cpp
 	  haiku_lock.cpp
 	  HaikuKernelFileSystem.cpp

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

@@ -357,6 +357,7 @@ UserlandFSDispatcher::_ProcessRequests()
 				info->GetInfos(), info->GetInfosSize(), sizeof(Port::Info));
 			reply->portInfoCount = info->CountInfos();
 			reply->capabilities = info->GetCapabilities();
+			reply->clientFSType = info->GetClientFSType();
 			_PutFileSystem(fileSystem);
 		}
 		reply->error = result;

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

@@ -254,6 +254,7 @@ UserlandRequestHandler::_HandleRequest(MountVolumeRequest* request)
 	reply->error = result;
 	reply->volume = volume;
 	reply->rootID = rootID;
+	reply->capabilities = volume->GetCapabilities();
 
 	// send the reply
 	return _SendReply(allocator, false);
@@ -378,11 +379,10 @@ UserlandRequestHandler::_HandleRequest(LookupRequest* request)
 		result = B_BAD_VALUE;
 
 	ino_t vnid = 0;
-	int type = 0;
 	if (result == B_OK) {
 		RequestThreadContext context(volume);
 		result = volume->Lookup(request->node,
-			(const char*)request->entryName.GetData(), &vnid, &type);
+			(const char*)request->entryName.GetData(), &vnid);
 	}
 
 	// prepare the reply

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

@@ -80,14 +80,14 @@ Volume::WriteFSInfo(const struct fs_info* info, uint32 mask)
 
 // Lookup
 status_t
-Volume::Lookup(fs_vnode dir, const char* entryName, ino_t* vnid, int* type)
+Volume::Lookup(void* dir, const char* entryName, ino_t* vnid)
 {
 	return B_BAD_VALUE;
 }
 
 // LookupNoType
 status_t
-Volume::LookupNoType(fs_vnode dir, const char* entryName, ino_t* vnid)
+Volume::LookupNoType(void* dir, const char* entryName, ino_t* vnid)
 {
 	int type;
 	return Lookup(dir, entryName, vnid, &type);
@@ -95,7 +95,7 @@ Volume::LookupNoType(fs_vnode dir, const char* entryName, ino_t* vnid)
 
 // GetVNodeName
 status_t
-Volume::GetVNodeName(fs_vnode node, char* buffer, size_t bufferSize)
+Volume::GetVNodeName(void* node, char* buffer, size_t bufferSize)
 {
 	// stat the node to get its ID
 	struct stat st;
@@ -110,7 +110,7 @@ Volume::GetVNodeName(fs_vnode node, char* buffer, size_t bufferSize)
 		return error;
 
 	// get the parent node handle
-	fs_vnode parentNode;
+	void* parentNode;
 	error = UserlandFS::KernelEmu::get_vnode(GetID(), parentID, &parentNode);
 	// Lookup() has already called get_vnode() for us, so we need to put it once
 	UserlandFS::KernelEmu::put_vnode(GetID(), parentID);
@@ -118,7 +118,7 @@ Volume::GetVNodeName(fs_vnode node, char* buffer, size_t bufferSize)
 		return error;
 
 	// open the parent dir
-	fs_cookie cookie;
+	void* cookie;
 	error = OpenDir(parentNode, &cookie);
 	if (error == B_OK) {
 
@@ -163,21 +163,22 @@ Volume::GetVNodeName(fs_vnode node, char* buffer, size_t bufferSize)
 
 // ReadVNode
 status_t
-Volume::ReadVNode(ino_t vnid, bool reenter, fs_vnode* node)
+Volume::ReadVNode(ino_t vnid, bool reenter, void** node, int* type,
+	uint32* flags)
 {
 	return B_BAD_VALUE;
 }
 
 // WriteVNode
 status_t
-Volume::WriteVNode(fs_vnode node, bool reenter)
+Volume::WriteVNode(void* node, bool reenter)
 {
 	return B_BAD_VALUE;
 }
 
 // RemoveVNode
 status_t
-Volume::RemoveVNode(fs_vnode node, bool reenter)
+Volume::RemoveVNode(void* node, bool reenter)
 {
 	return B_BAD_VALUE;
 }
@@ -188,7 +189,7 @@ Volume::RemoveVNode(fs_vnode node, bool reenter)
 
 // IOCtl
 status_t
-Volume::IOCtl(fs_vnode node, fs_cookie cookie, uint32 command, void *buffer,
+Volume::IOCtl(void* node, void* cookie, uint32 command, void *buffer,
 	size_t size)
 {
 	return B_BAD_VALUE;
@@ -196,36 +197,35 @@ Volume::IOCtl(fs_vnode node, fs_cookie cookie, uint32 command, void *buffer,
 
 // SetFlags
 status_t
-Volume::SetFlags(fs_vnode node, fs_cookie cookie, int flags)
+Volume::SetFlags(void* node, void* cookie, int flags)
 {
 	return B_BAD_VALUE;
 }
 
 // Select
 status_t
-Volume::Select(fs_vnode node, fs_cookie cookie, uint8 event, uint32 ref,
+Volume::Select(void* node, void* cookie, uint8 event, selectsync* sync)
-	selectsync* sync)
 {
 	return B_BAD_VALUE;
 }
 
 // Deselect
 status_t
-Volume::Deselect(fs_vnode node, fs_cookie cookie, uint8 event, selectsync* sync)
+Volume::Deselect(void* node, void* cookie, uint8 event, selectsync* sync)
 {
 	return B_BAD_VALUE;
 }
 
 // FSync
 status_t
-Volume::FSync(fs_vnode node)
+Volume::FSync(void* node)
 {
 	return B_BAD_VALUE;
 }
 
 // ReadSymlink
 status_t
-Volume::ReadSymlink(fs_vnode node, char* buffer, size_t bufferSize,
+Volume::ReadSymlink(void* node, char* buffer, size_t bufferSize,
 	size_t* bytesRead)
 {
 	return B_BAD_VALUE;
@@ -233,7 +233,7 @@ Volume::ReadSymlink(fs_vnode node, char* buffer, size_t bufferSize,
 
 // CreateSymlink
 status_t
-Volume::CreateSymlink(fs_vnode dir, const char* name, const char* target,
+Volume::CreateSymlink(void* dir, const char* name, const char* target,
 	int mode)
 {
 	return B_BAD_VALUE;
@@ -241,21 +241,21 @@ Volume::CreateSymlink(fs_vnode dir, const char* name, const char* target,
 
 // Link
 status_t
-Volume::Link(fs_vnode dir, const char* name, fs_vnode node)
+Volume::Link(void* dir, const char* name, void* node)
 {
 	return B_BAD_VALUE;
 }
 
 // Unlink
 status_t
-Volume::Unlink(fs_vnode dir, const char* name)
+Volume::Unlink(void* dir, const char* name)
 {
 	return B_BAD_VALUE;
 }
 
 // Rename
 status_t
-Volume::Rename(fs_vnode oldDir, const char* oldName, fs_vnode newDir,
+Volume::Rename(void* oldDir, const char* oldName, void* newDir,
 	const char* newName)
 {
 	return B_BAD_VALUE;
@@ -263,21 +263,21 @@ Volume::Rename(fs_vnode oldDir, const char* oldName, fs_vnode newDir,
 
 // Access
 status_t
-Volume::Access(fs_vnode node, int mode)
+Volume::Access(void* node, int mode)
 {
 	return B_BAD_VALUE;
 }
 
 // ReadStat
 status_t
-Volume::ReadStat(fs_vnode node, struct stat* st)
+Volume::ReadStat(void* node, struct stat* st)
 {
 	return B_BAD_VALUE;
 }
 
 // WriteStat
 status_t
-Volume::WriteStat(fs_vnode node, const struct stat *st, uint32 mask)
+Volume::WriteStat(void* node, const struct stat *st, uint32 mask)
 {
 	return B_BAD_VALUE;
 }
@@ -288,36 +288,36 @@ Volume::WriteStat(fs_vnode node, const struct stat *st, uint32 mask)
 
 // Create
 status_t
-Volume::Create(fs_vnode dir, const char* name, int openMode, int mode,
+Volume::Create(void* dir, const char* name, int openMode, int mode,
-	fs_cookie* cookie, ino_t* vnid)
+	void** cookie, ino_t* vnid)
 {
 	return B_BAD_VALUE;
 }
 
 // Open
 status_t
-Volume::Open(fs_vnode node, int openMode, fs_cookie* cookie)
+Volume::Open(void* node, int openMode, void** cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // Close
 status_t
-Volume::Close(fs_vnode node, fs_cookie cookie)
+Volume::Close(void* node, void* cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // FreeCookie
 status_t
-Volume::FreeCookie(fs_vnode node, fs_cookie cookie)
+Volume::FreeCookie(void* node, void* cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // Read
 status_t
-Volume::Read(fs_vnode node, fs_cookie cookie, off_t pos, void* buffer,
+Volume::Read(void* node, void* cookie, off_t pos, void* buffer,
 	size_t bufferSize, size_t* bytesRead)
 {
 	return B_BAD_VALUE;
@@ -325,7 +325,7 @@ Volume::Read(fs_vnode node, fs_cookie cookie, off_t pos, void* buffer,
 
 // Write
 status_t
-Volume::Write(fs_vnode node, fs_cookie cookie, off_t pos, const void* buffer,
+Volume::Write(void* node, void* cookie, off_t pos, const void* buffer,
 	size_t bufferSize, size_t* bytesWritten)
 {
 	return B_BAD_VALUE;
@@ -337,42 +337,42 @@ Volume::Write(fs_vnode node, fs_cookie cookie, off_t pos, const void* buffer,
 
 // CreateDir
 status_t
-Volume::CreateDir(fs_vnode dir, const char* name, int mode, ino_t *newDir)
+Volume::CreateDir(void* dir, const char* name, int mode, ino_t *newDir)
 {
 	return B_BAD_VALUE;
 }
 
 // RemoveDir
 status_t
-Volume::RemoveDir(fs_vnode dir, const char* name)
+Volume::RemoveDir(void* dir, const char* name)
 {
 	return B_BAD_VALUE;
 }
 
 // OpenDir
 status_t
-Volume::OpenDir(fs_vnode node, fs_cookie* cookie)
+Volume::OpenDir(void* node, void** cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // CloseDir
 status_t
-Volume::CloseDir(fs_vnode node, fs_vnode cookie)
+Volume::CloseDir(void* node, void* cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // FreeDirCookie
 status_t
-Volume::FreeDirCookie(fs_vnode node, fs_vnode cookie)
+Volume::FreeDirCookie(void* node, void* cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // ReadDir
 status_t
-Volume::ReadDir(fs_vnode node, fs_vnode cookie, void* buffer, size_t bufferSize,
+Volume::ReadDir(void* node, void* cookie, void* buffer, size_t bufferSize,
 	uint32 count, uint32* countRead)
 {
 	return B_BAD_VALUE;
@@ -380,7 +380,7 @@ Volume::ReadDir(fs_vnode node, fs_vnode cookie, void* buffer, size_t bufferSize,
 
 // RewindDir
 status_t
-Volume::RewindDir(fs_vnode node, fs_vnode cookie)
+Volume::RewindDir(void* node, void* cookie)
 {
 	return B_BAD_VALUE;
 }
@@ -391,28 +391,28 @@ Volume::RewindDir(fs_vnode node, fs_vnode cookie)
 
 // OpenAttrDir
 status_t
-Volume::OpenAttrDir(fs_vnode node, fs_cookie *cookie)
+Volume::OpenAttrDir(void* node, void** cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // CloseAttrDir
 status_t
-Volume::CloseAttrDir(fs_vnode node, fs_cookie cookie)
+Volume::CloseAttrDir(void* node, void* cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // FreeAttrDirCookie
 status_t
-Volume::FreeAttrDirCookie(fs_vnode node, fs_cookie cookie)
+Volume::FreeAttrDirCookie(void* node, void* cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // ReadAttrDir
 status_t
-Volume::ReadAttrDir(fs_vnode node, fs_cookie cookie, void* buffer,
+Volume::ReadAttrDir(void* node, void* cookie, void* buffer,
 	size_t bufferSize, uint32 count, uint32* countRead)
 {
 	return B_BAD_VALUE;
@@ -420,7 +420,7 @@ Volume::ReadAttrDir(fs_vnode node, fs_cookie cookie, void* buffer,
 
 // RewindAttrDir
 status_t
-Volume::RewindAttrDir(fs_vnode node, fs_cookie cookie)
+Volume::RewindAttrDir(void* node, void* cookie)
 {
 	return B_BAD_VALUE;
 }
@@ -431,37 +431,37 @@ Volume::RewindAttrDir(fs_vnode node, fs_cookie cookie)
 
 // CreateAttr
 status_t
-Volume::CreateAttr(fs_vnode node, const char* name, uint32 type, int openMode,
+Volume::CreateAttr(void* node, const char* name, uint32 type, int openMode,
-	fs_cookie* cookie)
+	void** cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // OpenAttr
 status_t
-Volume::OpenAttr(fs_vnode node, const char* name, int openMode,
+Volume::OpenAttr(void* node, const char* name, int openMode,
-	fs_cookie* cookie)
+	void** cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // CloseAttr
 status_t
-Volume::CloseAttr(fs_vnode node, fs_cookie cookie)
+Volume::CloseAttr(void* node, void* cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // FreeAttrCookie
 status_t
-Volume::FreeAttrCookie(fs_vnode node, fs_cookie cookie)
+Volume::FreeAttrCookie(void* node, void* cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // ReadAttr
 status_t
-Volume::ReadAttr(fs_vnode node, fs_cookie cookie, off_t pos, void* buffer,
+Volume::ReadAttr(void* node, void* cookie, off_t pos, void* buffer,
 	size_t bufferSize, size_t* bytesRead)
 {
 	return B_BAD_VALUE;
@@ -469,7 +469,7 @@ Volume::ReadAttr(fs_vnode node, fs_cookie cookie, off_t pos, void* buffer,
 
 // WriteAttr
 status_t
-Volume::WriteAttr(fs_vnode node, fs_cookie cookie, off_t pos,
+Volume::WriteAttr(void* node, void* cookie, off_t pos,
 	const void* buffer, size_t bufferSize, size_t* bytesWritten)
 {
 	return B_BAD_VALUE;
@@ -477,14 +477,14 @@ Volume::WriteAttr(fs_vnode node, fs_cookie cookie, off_t pos,
 
 // ReadAttrStat
 status_t
-Volume::ReadAttrStat(fs_vnode node, fs_cookie cookie, struct stat *st)
+Volume::ReadAttrStat(void* node, void* cookie, struct stat *st)
 {
 	return B_BAD_VALUE;
 }
 
 // WriteAttrStat
 status_t
-Volume::WriteAttrStat(fs_vnode node, fs_cookie cookie, const struct stat* st,
+Volume::WriteAttrStat(void* node, void* cookie, const struct stat* st,
 	int statMask)
 {
 	return B_BAD_VALUE;
@@ -492,7 +492,7 @@ Volume::WriteAttrStat(fs_vnode node, fs_cookie cookie, const struct stat* st,
 
 // RenameAttr
 status_t
-Volume::RenameAttr(fs_vnode oldNode, const char* oldName, fs_vnode newNode,
+Volume::RenameAttr(void* oldNode, const char* oldName, void* newNode,
 	const char* newName)
 {
 	return B_BAD_VALUE;
@@ -500,7 +500,7 @@ Volume::RenameAttr(fs_vnode oldNode, const char* oldName, fs_vnode newNode,
 
 // RemoveAttr
 status_t
-Volume::RemoveAttr(fs_vnode node, const char* name)
+Volume::RemoveAttr(void* node, const char* name)
 {
 	return B_BAD_VALUE;
 }
@@ -511,28 +511,28 @@ Volume::RemoveAttr(fs_vnode node, const char* name)
 
 // OpenIndexDir
 status_t
-Volume::OpenIndexDir(fs_cookie *cookie)
+Volume::OpenIndexDir(void** cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // CloseIndexDir
 status_t
-Volume::CloseIndexDir(fs_cookie cookie)
+Volume::CloseIndexDir(void* cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // FreeIndexDirCookie
 status_t
-Volume::FreeIndexDirCookie(fs_cookie cookie)
+Volume::FreeIndexDirCookie(void* cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // ReadIndexDir
 status_t
-Volume::ReadIndexDir(fs_cookie cookie, void* buffer, size_t bufferSize,
+Volume::ReadIndexDir(void* cookie, void* buffer, size_t bufferSize,
 	uint32 count, uint32* countRead)
 {
 	return B_BAD_VALUE;
@@ -540,7 +540,7 @@ Volume::ReadIndexDir(fs_cookie cookie, void* buffer, size_t bufferSize,
 
 // RewindIndexDir
 status_t
-Volume::RewindIndexDir(fs_cookie cookie)
+Volume::RewindIndexDir(void* cookie)
 {
 	return B_BAD_VALUE;
 }
@@ -573,28 +573,28 @@ Volume::ReadIndexStat(const char *name, struct stat *st)
 // OpenQuery
 status_t
 Volume::OpenQuery(const char* queryString, uint32 flags, port_id port,
-	uint32 token, fs_cookie *cookie)
+	uint32 token, void** cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // CloseQuery
 status_t
-Volume::CloseQuery(fs_cookie cookie)
+Volume::CloseQuery(void* cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // FreeQueryCookie
 status_t
-Volume::FreeQueryCookie(fs_cookie cookie)
+Volume::FreeQueryCookie(void* cookie)
 {
 	return B_BAD_VALUE;
 }
 
 // ReadQuery
 status_t
-Volume::ReadQuery(fs_cookie cookie, void* buffer, size_t bufferSize,
+Volume::ReadQuery(void* cookie, void* buffer, size_t bufferSize,
 	uint32 count, uint32* countRead)
 {
 	return B_BAD_VALUE;
@@ -602,7 +602,7 @@ Volume::ReadQuery(fs_cookie cookie, void* buffer, size_t bufferSize,
 
 // RewindQuery
 status_t
-Volume::RewindQuery(fs_cookie cookie)
+Volume::RewindQuery(void* cookie)
 {
 	return B_BAD_VALUE;
 }

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

@@ -6,10 +6,14 @@
 #include <fs_interface.h>
 #include <SupportDefs.h>
 
+#include "FSCapabilities.h"
+
 namespace UserlandFS {
 
 class FileSystem;
 
+using UserlandFSUtil::FSVolumeCapabilities;
+
 class Volume {
 public:
 								Volume(FileSystem* fileSystem, dev_t id);
@@ -18,6 +22,10 @@ public:
 			FileSystem*			GetFileSystem() const;
 			dev_t				GetID() const;
 
+			void				GetCapabilities(
+									FSVolumeCapabilities& capabilities) const
+									{ capabilities = fCapabilities; }
+
 	// FS
 	virtual	status_t			Mount(const char* device, uint32 flags,
 									const char* parameters, ino_t* rootID);
@@ -28,114 +36,114 @@ public:
 									uint32 mask);
 
 	// vnodes
-	virtual	status_t			Lookup(fs_vnode dir, const char* entryName,
+	virtual	status_t			Lookup(void* dir, const char* entryName,
-									ino_t* vnid, int* type);
+									ino_t* vnid);
-	virtual	status_t			LookupNoType(fs_vnode dir,
+	virtual	status_t			LookupNoType(void* dir,
 									const char* entryName, ino_t* vnid);
 									// not required
-	virtual	status_t			GetVNodeName(fs_vnode node, char* buffer,
+	virtual	status_t			GetVNodeName(void* node, char* buffer,
 									size_t bufferSize);
 	virtual	status_t			ReadVNode(ino_t vnid, bool reenter,
-									fs_vnode* node);
+									void** node, int* type, uint32* flags);
-	virtual	status_t			WriteVNode(fs_vnode node, bool reenter);
+	virtual	status_t			WriteVNode(void* node, bool reenter);
-	virtual	status_t			RemoveVNode(fs_vnode node, bool reenter);
+	virtual	status_t			RemoveVNode(void* node, bool reenter);
 
 	// nodes
-	virtual	status_t			IOCtl(fs_vnode node, fs_cookie cookie,
+	virtual	status_t			IOCtl(void* node, void* cookie,
 									uint32 command, void* buffer, size_t size);
-	virtual	status_t			SetFlags(fs_vnode node, fs_cookie cookie,
+	virtual	status_t			SetFlags(void* node, void* cookie,
 									int flags);
-	virtual	status_t			Select(fs_vnode node, fs_cookie cookie,
+	virtual	status_t			Select(void* node, void* cookie,
-									uint8 event, uint32 ref, selectsync* sync);
+									uint8 event, selectsync* sync);
-	virtual	status_t			Deselect(fs_vnode node, fs_cookie cookie,
+	virtual	status_t			Deselect(void* node, void* cookie,
 									uint8 event, selectsync* sync);
 
-	virtual	status_t			FSync(fs_vnode node);
+	virtual	status_t			FSync(void* node);
 
-	virtual	status_t			ReadSymlink(fs_vnode node, char* buffer,
+	virtual	status_t			ReadSymlink(void* node, char* buffer,
 									size_t bufferSize, size_t* bytesRead);
-	virtual	status_t			CreateSymlink(fs_vnode dir, const char* name,
+	virtual	status_t			CreateSymlink(void* dir, const char* name,
 									const char* target, int mode);
 
-	virtual	status_t			Link(fs_vnode dir, const char* name,
+	virtual	status_t			Link(void* dir, const char* name,
-									fs_vnode node);
+									void* node);
-	virtual	status_t			Unlink(fs_vnode dir, const char* name);
+	virtual	status_t			Unlink(void* dir, const char* name);
-	virtual	status_t			Rename(fs_vnode oldDir, const char* oldName,
+	virtual	status_t			Rename(void* oldDir, const char* oldName,
-									fs_vnode newDir, const char* newName);
+									void* newDir, const char* newName);
 
-	virtual	status_t			Access(fs_vnode node, int mode);
+	virtual	status_t			Access(void* node, int mode);
-	virtual	status_t			ReadStat(fs_vnode node, struct stat* st);
+	virtual	status_t			ReadStat(void* node, struct stat* st);
-	virtual	status_t			WriteStat(fs_vnode node, const struct stat *st,
+	virtual	status_t			WriteStat(void* node, const struct stat *st,
 									uint32 mask);
 
 	// files
-	virtual	status_t			Create(fs_vnode dir, const char* name,
+	virtual	status_t			Create(void* dir, const char* name,
-									int openMode, int mode, fs_cookie* cookie,
+									int openMode, int mode, void** cookie,
 									ino_t* vnid);
-	virtual	status_t			Open(fs_vnode node, int openMode,
+	virtual	status_t			Open(void* node, int openMode,
-									fs_cookie* cookie);
+									void** cookie);
-	virtual	status_t			Close(fs_vnode node, fs_cookie cookie);
+	virtual	status_t			Close(void* node, void* cookie);
-	virtual	status_t			FreeCookie(fs_vnode node, fs_cookie cookie);
+	virtual	status_t			FreeCookie(void* node, void* cookie);
-	virtual	status_t			Read(fs_vnode node, fs_cookie cookie, off_t pos,
+	virtual	status_t			Read(void* node, void* cookie, off_t pos,
 									void* buffer, size_t bufferSize,
 									size_t* bytesRead);
-	virtual	status_t			Write(fs_vnode node, fs_cookie cookie,
+	virtual	status_t			Write(void* node, void* cookie,
 									off_t pos, const void* buffer,
 									size_t bufferSize, size_t* bytesWritten);
 
 	// directories
-	virtual	status_t			CreateDir(fs_vnode dir, const char* name,
+	virtual	status_t			CreateDir(void* dir, const char* name,
 									int mode, ino_t *newDir);
-	virtual	status_t			RemoveDir(fs_vnode dir, const char* name);
+	virtual	status_t			RemoveDir(void* dir, const char* name);
-	virtual	status_t			OpenDir(fs_vnode node, fs_cookie* cookie);
+	virtual	status_t			OpenDir(void* node, void** cookie);
-	virtual	status_t			CloseDir(fs_vnode node, fs_vnode cookie);
+	virtual	status_t			CloseDir(void* node, void* cookie);
-	virtual	status_t			FreeDirCookie(fs_vnode node, fs_vnode cookie);
+	virtual	status_t			FreeDirCookie(void* node, void* cookie);
-	virtual	status_t			ReadDir(fs_vnode node, fs_vnode cookie,
+	virtual	status_t			ReadDir(void* node, void* cookie,
 									void* buffer, size_t bufferSize,
 									uint32 count, uint32* countRead);
-	virtual	status_t			RewindDir(fs_vnode node, fs_vnode cookie);
+	virtual	status_t			RewindDir(void* node, void* cookie);
 
 	// attribute directories
-	virtual	status_t			OpenAttrDir(fs_vnode node, fs_cookie *cookie);
+	virtual	status_t			OpenAttrDir(void* node, void** cookie);
-	virtual	status_t			CloseAttrDir(fs_vnode node, fs_cookie cookie);
+	virtual	status_t			CloseAttrDir(void* node, void* cookie);
-	virtual	status_t			FreeAttrDirCookie(fs_vnode node,
+	virtual	status_t			FreeAttrDirCookie(void* node,
-									fs_cookie cookie);
+									void* cookie);
-	virtual	status_t			ReadAttrDir(fs_vnode node, fs_cookie cookie,
+	virtual	status_t			ReadAttrDir(void* node, void* cookie,
 									void* buffer, size_t bufferSize,
 									uint32 count, uint32* countRead);
-	virtual	status_t			RewindAttrDir(fs_vnode node, fs_cookie cookie);
+	virtual	status_t			RewindAttrDir(void* node, void* cookie);
 
 	// attributes
-	virtual	status_t			CreateAttr(fs_vnode node, const char* name,
+	virtual	status_t			CreateAttr(void* node, const char* name,
 									uint32 type, int openMode,
-									fs_cookie* cookie);
+									void** cookie);
-	virtual	status_t			OpenAttr(fs_vnode node, const char* name,
+	virtual	status_t			OpenAttr(void* node, const char* name,
-									int openMode, fs_cookie* cookie);
+									int openMode, void** cookie);
-	virtual	status_t			CloseAttr(fs_vnode node, fs_cookie cookie);
+	virtual	status_t			CloseAttr(void* node, void* cookie);
-	virtual	status_t			FreeAttrCookie(fs_vnode node, fs_cookie cookie);
+	virtual	status_t			FreeAttrCookie(void* node, void* cookie);
-	virtual	status_t			ReadAttr(fs_vnode node, fs_cookie cookie,
+	virtual	status_t			ReadAttr(void* node, void* cookie,
 									off_t pos, void* buffer, size_t bufferSize,
 									size_t* bytesRead);
-	virtual	status_t			WriteAttr(fs_vnode node, fs_cookie cookie,
+	virtual	status_t			WriteAttr(void* node, void* cookie,
 									off_t pos, const void* buffer,
 									size_t bufferSize, size_t* bytesWritten);
-	virtual	status_t			ReadAttrStat(fs_vnode node, fs_cookie cookie,
+	virtual	status_t			ReadAttrStat(void* node, void* cookie,
 									struct stat* st);
-	virtual	status_t			WriteAttrStat(fs_vnode node, fs_cookie cookie,
+	virtual	status_t			WriteAttrStat(void* node, void* cookie,
 									const struct stat* st, int statMask);
-	virtual	status_t			RenameAttr(fs_vnode oldNode,
+	virtual	status_t			RenameAttr(void* oldNode,
-									const char* oldName, fs_vnode newNode,
+									const char* oldName, void* newNode,
 									const char* newName);
-	virtual	status_t			RemoveAttr(fs_vnode node, const char* name);
+	virtual	status_t			RemoveAttr(void* node, const char* name);
 
 	// indices
-	virtual	status_t			OpenIndexDir(fs_cookie *cookie);
+	virtual	status_t			OpenIndexDir(void** cookie);
-	virtual	status_t			CloseIndexDir(fs_cookie cookie);
+	virtual	status_t			CloseIndexDir(void* cookie);
-	virtual	status_t			FreeIndexDirCookie(fs_cookie cookie);
+	virtual	status_t			FreeIndexDirCookie(void* cookie);
-	virtual	status_t			ReadIndexDir(fs_cookie cookie, void* buffer,
+	virtual	status_t			ReadIndexDir(void* cookie, void* buffer,
 									size_t bufferSize, uint32 count,
 									uint32* countRead);
-	virtual	status_t			RewindIndexDir(fs_cookie cookie);
+	virtual	status_t			RewindIndexDir(void* cookie);
 	virtual	status_t			CreateIndex(const char* name, uint32 type,
 									uint32 flags);
 	virtual	status_t			RemoveIndex(const char* name);
@@ -145,17 +153,18 @@ public:
 	// queries
 	virtual	status_t			OpenQuery(const char* queryString,
 									uint32 flags, port_id port, uint32 token,
-									fs_cookie *cookie);
+									void** cookie);
-	virtual	status_t			CloseQuery(fs_cookie cookie);
+	virtual	status_t			CloseQuery(void* cookie);
-	virtual	status_t			FreeQueryCookie(fs_cookie cookie);
+	virtual	status_t			FreeQueryCookie(void* cookie);
-	virtual	status_t			ReadQuery(fs_cookie cookie, void* buffer,
+	virtual	status_t			ReadQuery(void* cookie, void* buffer,
 									size_t bufferSize, uint32 count,
 									uint32* countRead);
-	virtual	status_t			RewindQuery(fs_cookie cookie);
+	virtual	status_t			RewindQuery(void* cookie);
 
 protected:
 			FileSystem*			fFileSystem;
 			dev_t				fID;
+			FSVolumeCapabilities fCapabilities;
 };
 
 }	// namespace UserlandFS

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

@@ -111,51 +111,117 @@ notify_query_entry_removed(port_id port, int32 token, dev_t device,
 
 // new_vnode
 status_t
-new_vnode(dev_t mountID, ino_t vnodeID, fs_vnode privateNode)
+new_vnode(fs_volume *_volume, ino_t vnodeID, void *privateNode,
+	fs_vnode_ops *ops)
 {
-	return UserlandFS::KernelEmu::publish_vnode(mountID, vnodeID, privateNode);
+	HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume);
+
+	// translate to a wrapper node
+	HaikuKernelNode* node;
+	status_t error = volume->NewVNode(vnodeID, privateNode, ops, &node);
+	if (error != B_OK)
+		return error;
+
+	// announce the new node
+	error = UserlandFS::KernelEmu::new_vnode(volume->GetID(), vnodeID, node);
+	if (error != B_OK)
+		volume->UndoNewVNode(node);
+
+	return error;
 }
 
 // publish_vnode
 status_t
-publish_vnode(dev_t mountID, ino_t vnodeID, fs_vnode privateNode)
+publish_vnode(fs_volume *_volume, ino_t vnodeID, void *privateNode,
+	fs_vnode_ops *ops, int type, uint32 flags)
 {
-	return UserlandFS::KernelEmu::publish_vnode(mountID, vnodeID, privateNode);
+	HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume);
+
+	// translate to a wrapper node
+	HaikuKernelNode* node;
+	status_t error = volume->PublishVNode(vnodeID, privateNode, ops, type,
+		flags, &node);
+	if (error != B_OK)
+		return error;
+
+	// publish the new node
+	error = UserlandFS::KernelEmu::publish_vnode(volume, vnodeID, node, type,
+		flags);
+	if (error != B_OK)
+		volume->UndoPublishVNode(node);
+
+	return error;
 }
 
 // get_vnode
 status_t
-get_vnode(dev_t mountID, ino_t vnodeID, fs_vnode *privateNode)
+get_vnode(defs_volume *_volume, ino_t vnodeID, fs_vnode *privateNode)
 {
-	return UserlandFS::KernelEmu::get_vnode(mountID, vnodeID, privateNode);
+	HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume);
+
+	// get the node
+	void* foundNode;
+	status_t error = UserlandFS::KernelEmu::get_vnode(volume, vnodeID,
+		&foundNode);
+	if (error != B_OK)
+		return error;
+
+	((HaikuKernelNode*)foundNode)->GetFSNode(privateNode);
+
+	return B_OK;
 }
 
 // put_vnode
 status_t
-put_vnode(dev_t mountID, ino_t vnodeID)
+put_vnode(fs_volume *_volume, ino_t vnodeID)
 {
-	return UserlandFS::KernelEmu::put_vnode(mountID, vnodeID);
+	HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume);
+
+	return UserlandFS::KernelEmu::put_vnode(volume->GetID(), vnodeID);
+}
+
+// acquire_vnode
+status_t
+acquire_vnode(fs_volume *_volume, ino_t vnodeID)
+{
+	HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume);
+
+	return UserlandFS::KernelEmu::acquire_vnode(volume->GetID(), vnodeID);
 }
 
 // remove_vnode
 status_t
-remove_vnode(dev_t mountID, ino_t vnodeID)
+remove_vnode(fs_volume *_volume, ino_t vnodeID)
 {
-	return UserlandFS::KernelEmu::remove_vnode(mountID, vnodeID);
+	HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume);
+
+	return UserlandFS::KernelEmu::remove_vnode(volume->GetID(), vnodeID);
 }
 
 // unremove_vnode
 status_t
-unremove_vnode(dev_t mountID, ino_t vnodeID)
+unremove_vnode(fs_volume *_volume, ino_t vnodeID)
 {
-	return UserlandFS::KernelEmu::unremove_vnode(mountID, vnodeID);
+	HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume);
+
+	return UserlandFS::KernelEmu::unremove_vnode(volume->GetID(), vnodeID);
 }
 
 // get_vnode_removed
 status_t
-get_vnode_removed(dev_t mountID, ino_t vnodeID, bool* removed)
+get_vnode_removed(fs_volume *_volume, ino_t vnodeID, bool* removed)
 {
-	return UserlandFS::KernelEmu::get_vnode_removed(mountID, vnodeID, removed);
+	HaikuKernelVolume* volume = HaikuKernelVolume::GetVolume(_volume);
+
+	return UserlandFS::KernelEmu::get_vnode_removed(volume->GetID(), vnodeID,
+		removed);
+}
+
+// volume_for_vnode
+fs_volume*
+volume_for_vnode(fs_vnode *vnode)
+{
+	return HaikuKernelNode::GetNode(vnode)->GetVolume();
 }
 
 

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

@@ -255,7 +255,7 @@ UserlandFS::KernelEmu::notify_query(port_id targetPort, int32 token,
 
 // get_vnode
 status_t
-UserlandFS::KernelEmu::get_vnode(dev_t nsid, ino_t vnid, fs_vnode* data)
+UserlandFS::KernelEmu::get_vnode(dev_t nsid, ino_t vnid, void** node)
 {
 	// get the request port and the file system
 	RequestPort* port;
@@ -285,7 +285,7 @@ UserlandFS::KernelEmu::get_vnode(dev_t nsid, ino_t vnid, fs_vnode* data)
 	// process the reply
 	if (reply->error != B_OK)
 		return reply->error;
-	*data = reply->node;
+	*node = reply->node;
 	return error;
 }
 
@@ -326,7 +326,7 @@ UserlandFS::KernelEmu::put_vnode(dev_t nsid, ino_t vnid)
 
 // new_vnode
 status_t
-UserlandFS::KernelEmu::new_vnode(dev_t nsid, ino_t vnid, fs_vnode data)
+UserlandFS::KernelEmu::new_vnode(dev_t nsid, ino_t vnid, void* data)
 {
 	// get the request port and the file system
 	RequestPort* port;
@@ -362,8 +362,8 @@ UserlandFS::KernelEmu::new_vnode(dev_t nsid, ino_t vnid, fs_vnode data)
 
 // publish_vnode
 status_t
-UserlandFS::KernelEmu::publish_vnode(dev_t nsid, ino_t vnid,
+UserlandFS::KernelEmu::publish_vnode(dev_t nsid, ino_t vnid, void* data,
-	fs_vnode data)
+	int type, uint32 flags)
 {
 	// get the request port and the file system
 	RequestPort* port;
@@ -382,6 +382,8 @@ UserlandFS::KernelEmu::publish_vnode(dev_t nsid, ino_t vnid,
 	request->nsid = nsid;
 	request->vnid = vnid;
 	request->node = data;
+	request->type = type;
+	request->flags = flags;
 
 	// send the request
 	UserlandRequestHandler handler(fileSystem, PUBLISH_VNODE_REPLY);

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

@@ -9,8 +9,6 @@ struct selectsync;
 namespace UserlandFS {
 namespace KernelEmu {
 
-typedef void*	fs_vnode;
-
 int new_path(const char *path, char **copy);
 void free_path(char *p);
 
@@ -22,10 +20,11 @@ status_t notify_select_event(selectsync *sync, uint8 event,
 status_t notify_query(port_id port, int32 token, int32 operation,
 	dev_t device, ino_t directory, const char* name, ino_t node);
 
-status_t get_vnode(dev_t nsid, ino_t vnid, fs_vnode* data);
+status_t get_vnode(dev_t nsid, ino_t vnid, void** node);
 status_t put_vnode(dev_t nsid, ino_t vnid);
-status_t new_vnode(dev_t nsid, ino_t vnid, fs_vnode data);
+status_t new_vnode(dev_t nsid, ino_t vnid, void* data);
-status_t publish_vnode(dev_t nsid, ino_t vnid, fs_vnode data);
+status_t publish_vnode(dev_t nsid, ino_t vnid, void* data, int type,
+	uint32 flags);
 status_t remove_vnode(dev_t nsid, ino_t vnid);
 status_t unremove_vnode(dev_t nsid, ino_t vnid);
 status_t get_vnode_removed(dev_t nsid, ino_t vnid, bool* removed);