diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelVolume.cpp b/src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelVolume.cpp
index 5943f58673..5d1aa5e4e2 100644
--- a/src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelVolume.cpp
+++ b/src/add-ons/kernel/file_systems/userlandfs/server/HaikuKernelVolume.cpp
@@ -323,39 +323,48 @@ HaikuKernelVolume::Unlink(void* _dir, const char* name)
 
 // Rename
 status_t
-HaikuKernelVolume::Rename(void* oldDir, const char* oldName, void* newDir,
+HaikuKernelVolume::Rename(void* _oldDir, const char* oldName, void* _newDir,
 	const char* newName)
 {
-	if (!fFSModule->rename)
+	HaikuKernelNode* oldDir = (HaikuKernelNode*)_oldDir;
+	HaikuKernelNode* newDir = (HaikuKernelNode*)_newDir;
+
+	if (!oldDir->ops->rename)
 		return B_BAD_VALUE;
-	return fFSModule->rename(&fVolume, oldDir, oldName, newDir, newName);
+	return oldDir->ops->rename(&fVolume, oldDir, oldName, newDir, newName);
 }
 
 // Access
 status_t
-HaikuKernelVolume::Access(void* node, int mode)
+HaikuKernelVolume::Access(void* _node, int mode)
 {
-	if (!fFSModule->access)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->access)
 		return B_OK;
-	return fFSModule->access(&fVolume, node, mode);
+	return node->ops->access(&fVolume, node, mode);
 }
 
 // ReadStat
 status_t
-HaikuKernelVolume::ReadStat(void* node, struct stat* st)
+HaikuKernelVolume::ReadStat(void* _node, struct stat* st)
 {
-	if (!fFSModule->read_stat)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->read_stat)
 		return B_BAD_VALUE;
-	return fFSModule->read_stat(&fVolume, node, st);
+	return node->ops->read_stat(&fVolume, node, st);
 }
 
 // WriteStat
 status_t
-HaikuKernelVolume::WriteStat(void* node, const struct stat *st, uint32 mask)
+HaikuKernelVolume::WriteStat(void* _node, const struct stat *st, uint32 mask)
 {
-	if (!fFSModule->write_stat)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->write_stat)
 		return B_BAD_VALUE;
-	return fFSModule->write_stat(&fVolume, node, st, mask);
+	return node->ops->write_stat(&fVolume, node, st, mask);
 }
 
 
@@ -364,66 +373,78 @@ HaikuKernelVolume::WriteStat(void* node, const struct stat *st, uint32 mask)
 
 // Create
 status_t
-HaikuKernelVolume::Create(void* dir, const char* name, int openMode, int mode,
+HaikuKernelVolume::Create(void* _dir, const char* name, int openMode, int mode,
 	void** cookie, ino_t* vnid)
 {
-	if (!fFSModule->create)
+	HaikuKernelNode* dir = (HaikuKernelNode*)_dir;
+
+	if (!dir->ops->create)
 		return B_BAD_VALUE;
-	return fFSModule->create(&fVolume, dir, name, openMode, mode, cookie,
+	return dir->ops->create(&fVolume, dir, name, openMode, mode, cookie,
 		vnid);
 }
 
 // Open
 status_t
-HaikuKernelVolume::Open(void* node, int openMode, void** cookie)
+HaikuKernelVolume::Open(void* _node, int openMode, void** cookie)
 {
-	if (!fFSModule->open)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->open)
 		return B_BAD_VALUE;
-	return fFSModule->open(&fVolume, node, openMode, cookie);
+	return node->ops->open(&fVolume, node, openMode, cookie);
 }
 
 // Close
 status_t
-HaikuKernelVolume::Close(void* node, void* cookie)
+HaikuKernelVolume::Close(void* _node, void* cookie)
 {
-	if (!fFSModule->close)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->close)
 		return B_OK;
-	return fFSModule->close(&fVolume, node, cookie);
+	return node->ops->close(&fVolume, node, cookie);
 }
 
 // FreeCookie
 status_t
-HaikuKernelVolume::FreeCookie(void* node, void* cookie)
+HaikuKernelVolume::FreeCookie(void* _node, void* cookie)
 {
-	if (!fFSModule->free_cookie)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->free_cookie)
 		return B_OK;
-	return fFSModule->free_cookie(&fVolume, node, cookie);
+	return node->ops->free_cookie(&fVolume, node, cookie);
 }
 
 // Read
 status_t
-HaikuKernelVolume::Read(void* node, void* cookie, off_t pos, void* buffer,
+HaikuKernelVolume::Read(void* _node, void* cookie, off_t pos, void* buffer,
 	size_t bufferSize, size_t* bytesRead)
 {
-	if (!fFSModule->read)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->read)
 		return B_BAD_VALUE;
 
 	*bytesRead = bufferSize;
 
-	return fFSModule->read(&fVolume, node, cookie, pos, buffer, bytesRead);
+	return node->ops->read(&fVolume, node, cookie, pos, buffer, bytesRead);
 }
 
 // Write
 status_t
-HaikuKernelVolume::Write(void* node, void* cookie, off_t pos,
+HaikuKernelVolume::Write(void* _node, void* cookie, off_t pos,
 	const void* buffer, size_t bufferSize, size_t* bytesWritten)
 {
-	if (!fFSModule->write)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->write)
 		return B_BAD_VALUE;
 
 	*bytesWritten = bufferSize;
 
-	return fFSModule->write(&fVolume, node, cookie, pos, buffer,
+	return node->ops->write(&fVolume, node, cookie, pos, buffer,
 		bytesWritten);
 }
 
@@ -433,71 +454,85 @@ HaikuKernelVolume::Write(void* node, void* cookie, off_t pos,
 
 // CreateDir
 status_t
-HaikuKernelVolume::CreateDir(void* dir, const char* name, int mode,
+HaikuKernelVolume::CreateDir(void* _dir, const char* name, int mode,
 	ino_t *newDir)
 {
-	if (!fFSModule->create_dir)
+	HaikuKernelNode* dir = (HaikuKernelNode*)_dir;
+
+	if (!dir->ops->create_dir)
 		return B_BAD_VALUE;
-	return fFSModule->create_dir(&fVolume, dir, name, mode, newDir);
+	return dir->ops->create_dir(&fVolume, dir, name, mode, newDir);
 }
 
 // RemoveDir
 status_t
-HaikuKernelVolume::RemoveDir(void* dir, const char* name)
+HaikuKernelVolume::RemoveDir(void* _dir, const char* name)
 {
-	if (!fFSModule->remove_dir)
+	HaikuKernelNode* dir = (HaikuKernelNode*)_dir;
+
+	if (!dir->ops->remove_dir)
 		return B_BAD_VALUE;
-	return fFSModule->remove_dir(&fVolume, dir, name);
+	return dir->ops->remove_dir(&fVolume, dir, name);
 }
 
 // OpenDir
 status_t
-HaikuKernelVolume::OpenDir(void* node, void** cookie)
+HaikuKernelVolume::OpenDir(void* _node, void** cookie)
 {
-	if (!fFSModule->open_dir)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->open_dir)
 		return B_BAD_VALUE;
-	return fFSModule->open_dir(&fVolume, node, cookie);
+	return node->ops->open_dir(&fVolume, node, cookie);
 }
 
 // CloseDir
 status_t
-HaikuKernelVolume::CloseDir(void* node, void* cookie)
+HaikuKernelVolume::CloseDir(void* _node, void* cookie)
 {
-	if (!fFSModule->close_dir)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->close_dir)
 		return B_OK;
-	return fFSModule->close_dir(&fVolume, node, cookie);
+	return node->ops->close_dir(&fVolume, node, cookie);
 }
 
 // FreeDirCookie
 status_t
-HaikuKernelVolume::FreeDirCookie(void* node, void* cookie)
+HaikuKernelVolume::FreeDirCookie(void* _node, void* cookie)
 {
-	if (!fFSModule->free_dir_cookie)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->free_dir_cookie)
 		return B_OK;
-	return fFSModule->free_dir_cookie(&fVolume, node, cookie);
+	return node->ops->free_dir_cookie(&fVolume, node, cookie);
 }
 
 // ReadDir
 status_t
-HaikuKernelVolume::ReadDir(void* node, void* cookie, void* buffer,
+HaikuKernelVolume::ReadDir(void* _node, void* cookie, void* buffer,
 	size_t bufferSize, uint32 count, uint32* countRead)
 {
-	if (!fFSModule->read_dir)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->read_dir)
 		return B_BAD_VALUE;
 
 	*countRead = count;
 
-	return fFSModule->read_dir(&fVolume, node, cookie,
+	return node->ops->read_dir(&fVolume, node, cookie,
 		(struct dirent*)buffer, bufferSize, countRead);
 }
 
 // RewindDir
 status_t
-HaikuKernelVolume::RewindDir(void* node, void* cookie)
+HaikuKernelVolume::RewindDir(void* _node, void* cookie)
 {
-	if (!fFSModule->rewind_dir)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->rewind_dir)
 		return B_BAD_VALUE;
-	return fFSModule->rewind_dir(&fVolume, node, cookie);
+	return node->ops->rewind_dir(&fVolume, node, cookie);
 }
 
 
@@ -506,52 +541,62 @@ HaikuKernelVolume::RewindDir(void* node, void* cookie)
 
 // OpenAttrDir
 status_t
-HaikuKernelVolume::OpenAttrDir(void* node, void** cookie)
+HaikuKernelVolume::OpenAttrDir(void* _node, void** cookie)
 {
-	if (!fFSModule->open_attr_dir)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->open_attr_dir)
 		return B_BAD_VALUE;
-	return fFSModule->open_attr_dir(&fVolume, node, cookie);
+	return node->ops->open_attr_dir(&fVolume, node, cookie);
 }
 
 // CloseAttrDir
 status_t
-HaikuKernelVolume::CloseAttrDir(void* node, void* cookie)
+HaikuKernelVolume::CloseAttrDir(void* _node, void* cookie)
 {
-	if (!fFSModule->close_attr_dir)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->close_attr_dir)
 		return B_OK;
-	return fFSModule->close_attr_dir(&fVolume, node, cookie);
+	return node->ops->close_attr_dir(&fVolume, node, cookie);
 }
 
 // FreeAttrDirCookie
 status_t
-HaikuKernelVolume::FreeAttrDirCookie(void* node, void* cookie)
+HaikuKernelVolume::FreeAttrDirCookie(void* _node, void* cookie)
 {
-	if (!fFSModule->free_attr_dir_cookie)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->free_attr_dir_cookie)
 		return B_OK;
-	return fFSModule->free_attr_dir_cookie(&fVolume, node, cookie);
+	return node->ops->free_attr_dir_cookie(&fVolume, node, cookie);
 }
 
 // ReadAttrDir
 status_t
-HaikuKernelVolume::ReadAttrDir(void* node, void* cookie, void* buffer,
+HaikuKernelVolume::ReadAttrDir(void* _node, void* cookie, void* buffer,
 	size_t bufferSize, uint32 count, uint32* countRead)
 {
-	if (!fFSModule->read_attr_dir)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->read_attr_dir)
 		return B_BAD_VALUE;
 
 	*countRead = count;
 
-	return fFSModule->read_attr_dir(&fVolume, node, cookie,
+	return node->ops->read_attr_dir(&fVolume, node, cookie,
 		(struct dirent*)buffer, bufferSize, countRead);
 }
 
 // RewindAttrDir
 status_t
-HaikuKernelVolume::RewindAttrDir(void* node, void* cookie)
+HaikuKernelVolume::RewindAttrDir(void* _node, void* cookie)
 {
-	if (!fFSModule->rewind_attr_dir)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->rewind_attr_dir)
 		return B_BAD_VALUE;
-	return fFSModule->rewind_attr_dir(&fVolume, node, cookie);
+	return node->ops->rewind_attr_dir(&fVolume, node, cookie);
 }
 
 
@@ -560,110 +605,131 @@ HaikuKernelVolume::RewindAttrDir(void* node, void* cookie)
 
 // CreateAttr
 status_t
-HaikuKernelVolume::CreateAttr(void* node, const char* name, uint32 type,
+HaikuKernelVolume::CreateAttr(void* _node, const char* name, uint32 type,
 	int openMode, void** cookie)
 {
-	if (!fFSModule->create_attr)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->create_attr)
 		return B_BAD_VALUE;
-	return fFSModule->create_attr(&fVolume, node, name, type, openMode,
+	return node->ops->create_attr(&fVolume, node, name, type, openMode,
 		cookie);
 }
 
 // OpenAttr
 status_t
-HaikuKernelVolume::OpenAttr(void* node, const char* name, int openMode,
+HaikuKernelVolume::OpenAttr(void* _node, const char* name, int openMode,
 	void** cookie)
 {
-	if (!fFSModule->open_attr)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->open_attr)
 		return B_BAD_VALUE;
-	return fFSModule->open_attr(&fVolume, node, name, openMode, cookie);
+	return node->ops->open_attr(&fVolume, node, name, openMode, cookie);
 }
 
 // CloseAttr
 status_t
-HaikuKernelVolume::CloseAttr(void* node, void* cookie)
+HaikuKernelVolume::CloseAttr(void* _node, void* cookie)
 {
-	if (!fFSModule->close_attr)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->close_attr)
 		return B_OK;
-	return fFSModule->close_attr(&fVolume, node, cookie);
+	return node->ops->close_attr(&fVolume, node, cookie);
 }
 
 // FreeAttrCookie
 status_t
-HaikuKernelVolume::FreeAttrCookie(void* node, void* cookie)
+HaikuKernelVolume::FreeAttrCookie(void* _node, void* cookie)
 {
-	if (!fFSModule->free_attr_cookie)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->free_attr_cookie)
 		return B_OK;
-	return fFSModule->free_attr_cookie(&fVolume, node, cookie);
+	return node->ops->free_attr_cookie(&fVolume, node, cookie);
 }
 
 // ReadAttr
 status_t
-HaikuKernelVolume::ReadAttr(void* node, void* cookie, off_t pos,
+HaikuKernelVolume::ReadAttr(void* _node, void* cookie, off_t pos,
 	void* buffer, size_t bufferSize, size_t* bytesRead)
 {
-	if (!fFSModule->read_attr)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->read_attr)
 		return B_BAD_VALUE;
 
 	*bytesRead = bufferSize;
 
-	return fFSModule->read_attr(&fVolume, node, cookie, pos, buffer,
+	return node->ops->read_attr(&fVolume, node, cookie, pos, buffer,
 		bytesRead);
 }
 
 // WriteAttr
 status_t
-HaikuKernelVolume::WriteAttr(void* node, void* cookie, off_t pos,
+HaikuKernelVolume::WriteAttr(void* _node, void* cookie, off_t pos,
 	const void* buffer, size_t bufferSize, size_t* bytesWritten)
 {
-	if (!fFSModule->write_attr)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->write_attr)
 		return B_BAD_VALUE;
 
 	*bytesWritten = bufferSize;
 
-	return fFSModule->write_attr(&fVolume, node, cookie, pos, buffer,
+	return node->ops->write_attr(&fVolume, node, cookie, pos, buffer,
 		bytesWritten);
 }
 
 // ReadAttrStat
 status_t
-HaikuKernelVolume::ReadAttrStat(void* node, void* cookie,
+HaikuKernelVolume::ReadAttrStat(void* _node, void* cookie,
 	struct stat *st)
 {
-	if (!fFSModule->read_attr_stat)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->read_attr_stat)
 		return B_BAD_VALUE;
-	return fFSModule->read_attr_stat(&fVolume, node, cookie, st);
+	return node->ops->read_attr_stat(&fVolume, node, cookie, st);
 }
 
 // WriteAttrStat
 status_t
-HaikuKernelVolume::WriteAttrStat(void* node, void* cookie,
+HaikuKernelVolume::WriteAttrStat(void* _node, void* cookie,
 	const struct stat* st, int statMask)
 {
-	if (!fFSModule->write_attr_stat)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->write_attr_stat)
 		return B_BAD_VALUE;
-	return fFSModule->write_attr_stat(&fVolume, node, cookie, st,
+	return node->ops->write_attr_stat(&fVolume, node, cookie, st,
 		statMask);
 }
 
 // RenameAttr
 status_t
-HaikuKernelVolume::RenameAttr(void* oldNode, const char* oldName,
-	void* newNode, const char* newName)
+HaikuKernelVolume::RenameAttr(void* _oldNode, const char* oldName,
+	void* _newNode, const char* newName)
 {
-	if (!fFSModule->rename_attr)
+	HaikuKernelNode* oldNode = (HaikuKernelNode*)_oldNode;
+	HaikuKernelNode* newNode = (HaikuKernelNode*)_newNode;
+
+	if (!oldNode->ops->rename_attr)
 		return B_BAD_VALUE;
-	return fFSModule->rename_attr(&fVolume, oldNode, oldName, newNode,
+	return oldNode->ops->rename_attr(&fVolume, oldNode, oldName, newNode,
 		newName);
 }
 
 // RemoveAttr
 status_t
-HaikuKernelVolume::RemoveAttr(void* node, const char* name)
+HaikuKernelVolume::RemoveAttr(void* _node, const char* name)
 {
-	if (!fFSModule->remove_attr)
+	HaikuKernelNode* node = (HaikuKernelNode*)_node;
+
+	if (!node->ops->remove_attr)
 		return B_BAD_VALUE;
-	return fFSModule->remove_attr(&fVolume, node, name);
+	return node->ops->remove_attr(&fVolume, node, name);
 }
 
 
diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/UserlandFSServer.cpp b/src/add-ons/kernel/file_systems/userlandfs/server/UserlandFSServer.cpp
index fbcf08c8b9..b395019bc2 100644
--- a/src/add-ons/kernel/file_systems/userlandfs/server/UserlandFSServer.cpp
+++ b/src/add-ons/kernel/file_systems/userlandfs/server/UserlandFSServer.cpp
@@ -111,7 +111,7 @@ UserlandFSServer::Init(const char* fileSystem)
 		error = fRequestThreads[i].Init(fFileSystem);
 		if (error != B_OK)
 			RETURN_ERROR(error);
-	} 
+	}
 
 	// run the threads
 	for (int32 i = 0; i < kRequestThreadCount; i++)
@@ -185,7 +185,7 @@ UserlandFSServer::_RegisterWithDispatcher(const char* fsName)
 	// init an FS info
 	FSInfo info;
 	status_t error = info.SetTo(fsName, infos, kRequestThreadCount + 1,
-		capabilities);
+		capabilities, fFileSystem->GetClientFSType());
 
 	// prepare the message
 	BMessage message(UFS_REGISTER_FS);
diff --git a/src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.cpp b/src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.cpp
index 0705d7b6bc..a0b8b6aa70 100644
--- a/src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.cpp
+++ b/src/add-ons/kernel/file_systems/userlandfs/server/UserlandRequestHandler.cpp
@@ -254,7 +254,7 @@ UserlandRequestHandler::_HandleRequest(MountVolumeRequest* request)
 	reply->error = result;
 	reply->volume = volume;
 	reply->rootID = rootID;
-	reply->capabilities = volume->GetCapabilities();
+	volume->GetCapabilities(reply->capabilities);
 
 	// send the reply
 	return _SendReply(allocator, false);
@@ -393,7 +393,6 @@ UserlandRequestHandler::_HandleRequest(LookupRequest* request)
 		RETURN_ERROR(error);
 
 	reply->vnid = vnid;
-	reply->type = type;
 	reply->error = result;
 
 	// send the reply
@@ -449,10 +448,13 @@ UserlandRequestHandler::_HandleRequest(ReadVNodeRequest* request)
 	if (!volume)
 		result = B_BAD_VALUE;
 
-	fs_vnode node;
+	void* node;
+	int type;
+	uint32 flags;
 	if (result == B_OK) {
 		RequestThreadContext context(volume);
-		result = volume->ReadVNode(request->vnid, request->reenter, &node);
+		result = volume->ReadVNode(request->vnid, request->reenter, &node,
+			&type, &flags);
 	}
 
 	// prepare the reply
@@ -464,6 +466,8 @@ UserlandRequestHandler::_HandleRequest(ReadVNodeRequest* request)
 
 	reply->error = result;
 	reply->node = node;
+	reply->type = type;
+	reply->flags = flags;
 
 	// send the reply
 	return _SendReply(allocator, false);
@@ -627,7 +631,7 @@ UserlandRequestHandler::_HandleRequest(SelectRequest* request)
 	if (result == B_OK) {
 		RequestThreadContext context(volume);
 		result = volume->Select(request->node, request->fileCookie,
-			request->event, 0, request->sync);
+			request->event, request->sync);
 	}
 
 	// prepare the reply
@@ -960,7 +964,7 @@ UserlandRequestHandler::_HandleRequest(CreateRequest* request)
 		result = B_BAD_VALUE;
 
 	ino_t vnid;
-	fs_cookie fileCookie;
+	void* fileCookie;
 	if (result == B_OK) {
 		RequestThreadContext context(volume);
 		result = volume->Create(request->node,
@@ -993,7 +997,7 @@ UserlandRequestHandler::_HandleRequest(OpenRequest* request)
 	if (!volume)
 		result = B_BAD_VALUE;
 
-	fs_cookie fileCookie;
+	void* fileCookie;
 	if (result == B_OK) {
 		RequestThreadContext context(volume);
 		result = volume->Open(request->node, request->openMode, &fileCookie);
@@ -1079,8 +1083,8 @@ UserlandRequestHandler::_HandleRequest(ReadRequest* request)
 	if (!volume)
 		result = B_BAD_VALUE;
 
-	fs_vnode node = request->node;
-	fs_cookie fileCookie = request->fileCookie;
+	void* node = request->node;
+	void* fileCookie = request->fileCookie;
 	off_t pos = request->pos;
 	size_t size = request->size;
 
@@ -1219,7 +1223,7 @@ UserlandRequestHandler::_HandleRequest(OpenDirRequest* request)
 	if (!volume)
 		result = B_BAD_VALUE;
 
-	fs_cookie dirCookie = NULL;
+	void* dirCookie = NULL;
 	if (result == B_OK) {
 		RequestThreadContext context(volume);
 		result = volume->OpenDir(request->node, &dirCookie);
@@ -1305,8 +1309,8 @@ UserlandRequestHandler::_HandleRequest(ReadDirRequest* request)
 	if (!volume)
 		result = B_BAD_VALUE;
 
-	fs_vnode node = request->node;
-	fs_vnode dirCookie = request->dirCookie;
+	void* node = request->node;
+	void* dirCookie = request->dirCookie;
 	size_t bufferSize = request->bufferSize;
 	uint32 count = request->count;
 
@@ -1392,7 +1396,7 @@ UserlandRequestHandler::_HandleRequest(OpenAttrDirRequest* request)
 	if (!volume)
 		result = B_BAD_VALUE;
 
-	fs_cookie attrDirCookie;
+	void* attrDirCookie;
 	if (result == B_OK) {
 		RequestThreadContext context(volume);
 		result = volume->OpenAttrDir(request->node, &attrDirCookie);
@@ -1479,8 +1483,8 @@ UserlandRequestHandler::_HandleRequest(ReadAttrDirRequest* request)
 	if (!volume)
 		result = B_BAD_VALUE;
 
-	fs_vnode node = request->node;
-	fs_cookie attrDirCookie = request->attrDirCookie;
+	void* node = request->node;
+	void* attrDirCookie = request->attrDirCookie;
 	size_t bufferSize = request->bufferSize;
 	uint32 count = request->count;
 
@@ -1556,7 +1560,7 @@ UserlandRequestHandler::_HandleRequest(CreateAttrRequest* request)
 	if (!volume)
 		result = B_BAD_VALUE;
 
-	fs_cookie attrCookie;
+	void* attrCookie;
 	if (result == B_OK) {
 		RequestThreadContext context(volume);
 		result = volume->CreateAttr(request->node,
@@ -1588,7 +1592,7 @@ UserlandRequestHandler::_HandleRequest(OpenAttrRequest* request)
 	if (!volume)
 		result = B_BAD_VALUE;
 
-	fs_cookie attrCookie;
+	void* attrCookie;
 	if (result == B_OK) {
 		RequestThreadContext context(volume);
 		result = volume->OpenAttr(request->node,
@@ -1677,7 +1681,7 @@ UserlandRequestHandler::_HandleRequest(ReadAttrRequest* request)
 		result = B_BAD_VALUE;
 
 	void* node = request->node;
-	fs_cookie attrCookie = request->attrCookie;
+	void* attrCookie = request->attrCookie;
 	off_t pos = request->pos;
 	size_t size = request->size;
 
@@ -1876,7 +1880,7 @@ UserlandRequestHandler::_HandleRequest(OpenIndexDirRequest* request)
 	if (!volume)
 		result = B_BAD_VALUE;
 
-	fs_cookie indexDirCookie;
+	void* indexDirCookie;
 	if (result == B_OK) {
 		RequestThreadContext context(volume);
 		result = volume->OpenIndexDir(&indexDirCookie);
@@ -1962,7 +1966,7 @@ UserlandRequestHandler::_HandleRequest(ReadIndexDirRequest* request)
 	if (!volume)
 		result = B_BAD_VALUE;
 
-	fs_cookie indexDirCookie = request->indexDirCookie;
+	void* indexDirCookie = request->indexDirCookie;
 	size_t bufferSize = request->bufferSize;
 	uint32 count = request->count;
 
@@ -2126,7 +2130,7 @@ UserlandRequestHandler::_HandleRequest(OpenQueryRequest* request)
 	if (!volume)
 		result = B_BAD_VALUE;
 
-	fs_cookie queryCookie;
+	void* queryCookie;
 	if (result == B_OK) {
 		RequestThreadContext context(volume);
 		result = volume->OpenQuery((const char*)request->queryString.GetData(),
@@ -2213,7 +2217,7 @@ UserlandRequestHandler::_HandleRequest(ReadQueryRequest* request)
 	if (!volume)
 		result = B_BAD_VALUE;
 
-	fs_cookie queryCookie = request->queryCookie;
+	void* queryCookie = request->queryCookie;
 	size_t bufferSize = request->bufferSize;
 	uint32 count = request->count;