Added a Haiku file cache implementation to the UserlandFSServer.

Basically reused the kernel implementation, but needed to hack it quite
a bit and also add an emulation of the required VM interface.
Completely untested yet.


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

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

@@ -9,6 +9,7 @@
 
 #include "Debug.h"
 #include "kernel_emu.h"
+#include "haiku_fs_cache.h"
 
 
 // constructor
@@ -35,8 +36,22 @@ HaikuKernelVolume::Mount(const char* device, uint32 flags,
 {
 	if (!fFSModule->mount)
 		return B_BAD_VALUE;
-	return fFSModule->mount(GetID(), device, flags, parameters, &fVolumeCookie,
-		rootID);
+
+	// make the volume know to the file cache emulation
+	status_t error
+		= UserlandFS::HaikuKernelEmu::file_cache_register_volume(this);
+	if (error != B_OK)
+		return error;
+
+	// mount
+	error = fFSModule->mount(GetID(), device, flags, parameters,
+		&fVolumeCookie, rootID);
+	if (error != B_OK) {
+		UserlandFS::HaikuKernelEmu::file_cache_unregister_volume(this);
+		return error;
+	}
+
+	return B_OK;
 }
 
 // Unmount
@@ -45,7 +60,14 @@ HaikuKernelVolume::Unmount()
 {
 	if (!fFSModule->unmount)
 		return B_BAD_VALUE;
-	return fFSModule->unmount(fVolumeCookie);
+
+	// unmount
+	status_t error = fFSModule->unmount(fVolumeCookie);
+
+	// unregister with the file cache emulation
+	UserlandFS::HaikuKernelEmu::file_cache_unregister_volume(this);
+
+	return error;
 }
 
 // Sync
@@ -76,6 +98,21 @@ HaikuKernelVolume::WriteFSInfo(const struct fs_info* info, uint32 mask)
 }
 
 
+// #pragma mark - file cache
+
+
+// GetFileMap
+status_t
+HaikuKernelVolume::GetFileMap(fs_vnode node, off_t offset, size_t size,
+	struct file_io_vec* vecs, size_t* count)
+{
+	if (!fFSModule->get_file_map)
+		return B_BAD_VALUE;
+	return fFSModule->get_file_map(fVolumeCookie, node, offset, size, vecs,
+		count);
+}
+
+
 // #pragma mark - vnodes
 
 

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

@@ -25,6 +25,11 @@ public:
 	virtual	status_t			WriteFSInfo(const struct fs_info* info,
 									uint32 mask);
 
+	// file cache
+	virtual	status_t			GetFileMap(fs_vnode 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,
 									vnode_id* vnid, int* type);

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

@@ -41,6 +41,7 @@ Application UserlandFSServer
 	  DispatcherFileSystem.cpp
 	  FileSystem.cpp
 	  haiku_block_cache.cpp
+	  haiku_file_cache.cpp
 	  haiku_hash.cpp
 	  haiku_lock.cpp
 	  HaikuKernelFileSystem.cpp

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

@@ -24,6 +24,7 @@
 #include "FileSystem.h"
 #include "FSInfo.h"
 #include "haiku_block_cache_priv.h"
+#include "haiku_fs_cache.h"
 #include "HaikuKernelFileSystem.h"
 #include "RequestThread.h"
 #include "ServerDefs.h"
@@ -281,6 +282,11 @@ UserlandFSServer::_CreateHaikuKernelInterface(const char* fsName,
 	if (error != B_OK)
 		RETURN_ERROR(error);
 
+	// init file cache
+	error = UserlandFS::HaikuKernelEmu::file_cache_init();
+	if (error != B_OK)
+		RETURN_ERROR(error);
+
 	// init the FS
 	error = fileSystem->Init();
 	if (error != B_OK)

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

@@ -11,6 +11,9 @@
 
 
 namespace UserlandFS {
+
+class HaikuKernelVolume;
+
 namespace HaikuKernelEmu {
 
 /* transactions */
@@ -68,6 +71,11 @@ extern status_t file_cache_read(void *_cacheRef, off_t offset, void *bufferBase,
 extern status_t file_cache_write(void *_cacheRef, off_t offset,
 					const void *buffer, size_t *_size);
 
+// interface for the emulation layer
+status_t file_cache_init();
+status_t file_cache_register_volume(HaikuKernelVolume* volume);
+status_t file_cache_unregister_volume(HaikuKernelVolume* volume);
+
 }	// namespace HaikuKernelEmu
 }	// namespace UserlandFS
 

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

@@ -330,6 +330,81 @@ block_cache_put(void *_cache, off_t blockNumber)
 }
 
 
+// #pragma mark - File Cache
+
+// file_cache_create
+void *
+file_cache_create(mount_id mountID, vnode_id vnodeID, off_t size, int fd)
+{
+	return UserlandFS::HaikuKernelEmu::file_cache_create(mountID, vnodeID,
+		size, fd);
+}
+
+// file_cache_delete
+void
+file_cache_delete(void *_cacheRef)
+{
+	UserlandFS::HaikuKernelEmu::file_cache_delete(_cacheRef);
+}
+
+// file_cache_set_size
+status_t
+file_cache_set_size(void *_cacheRef, off_t size)
+{
+	return UserlandFS::HaikuKernelEmu::file_cache_set_size(_cacheRef, size);
+}
+
+// file_cache_sync
+status_t
+file_cache_sync(void *_cache)
+{
+	return UserlandFS::HaikuKernelEmu::file_cache_sync(_cache);
+}
+
+// file_cache_invalidate_file_map
+status_t
+file_cache_invalidate_file_map(void *_cacheRef, off_t offset, off_t size)
+{
+	return UserlandFS::HaikuKernelEmu::file_cache_invalidate_file_map(
+		_cacheRef, offset, size);
+}
+
+// file_cache_read_pages
+status_t
+file_cache_read_pages(void *_cacheRef, off_t offset, const iovec *vecs,
+	size_t count, size_t *_numBytes)
+{
+	return UserlandFS::HaikuKernelEmu::file_cache_read_pages(_cacheRef,
+		offset, vecs, count, _numBytes);
+}
+
+// file_cache_write_pages
+status_t
+file_cache_write_pages(void *_cacheRef, off_t offset, const iovec *vecs,
+	size_t count, size_t *_numBytes)
+{
+	return UserlandFS::HaikuKernelEmu::file_cache_write_pages(_cacheRef,
+		offset, vecs, count, _numBytes);
+}
+
+// file_cache_read
+status_t
+file_cache_read(void *_cacheRef, off_t offset, void *bufferBase, size_t *_size)
+{
+	return UserlandFS::HaikuKernelEmu::file_cache_read(_cacheRef, offset,
+		bufferBase, _size);
+}
+
+// file_cache_write
+status_t
+file_cache_write(void *_cacheRef, off_t offset, const void *buffer,
+	size_t *_size)
+{
+	return UserlandFS::HaikuKernelEmu::file_cache_write(_cacheRef, offset,
+		buffer, _size);
+}
+
+
 // #pragma mark - Misc