[haiku-commits] BRANCH pdziepak-github.nfs4 - src/add-ons/kernel/file_systems/nfs4

  • From: pdziepak-github.nfs4 <community@xxxxxxxxxxxx>
  • To: haiku-commits@xxxxxxxxxxxxx
  • Date: Tue, 10 Jul 2012 19:49:15 +0200 (CEST)

added 3 changesets to branch 'refs/remotes/pdziepak-github/nfs4'
old head: 9054c96c17401b5ef4259cbba615ca8b8856473c
new head: 00a8558cc75d9aee84f6d9b34c28d6706952558c

----------------------------------------------------------------------------

92284dc: nfs4: Use semaphore to cancel threads instead of interrupt_thread()

fcb4139: dns_resolver: Remove accidentally added debug messages

00a8558: nfs4: Rename Filehandle to FileHandle and Filesystem to FileSystem

                                    [ Pawel Dziepak <pdziepak@xxxxxxxxxxx> ]

----------------------------------------------------------------------------

25 files changed, 259 insertions(+), 226 deletions(-)
headers/os/drivers/KernelExport.h                  |    1 -
.../kernel/file_systems/nfs4/Connection.cpp        |   44 ++++++++
src/add-ons/kernel/file_systems/nfs4/Connection.h  |    1 +
src/add-ons/kernel/file_systems/nfs4/Cookie.cpp    |    4 +-
src/add-ons/kernel/file_systems/nfs4/Cookie.h      |    4 +-
src/add-ons/kernel/file_systems/nfs4/FileInfo.cpp  |    4 +-
src/add-ons/kernel/file_systems/nfs4/FileInfo.h    |   44 ++++----
.../nfs4/{Filesystem.cpp => FileSystem.cpp}        |   36 +++----
.../nfs4/{Filesystem.h => FileSystem.h}            |   40 +++----
src/add-ons/kernel/file_systems/nfs4/Inode.cpp     |   86 ++++++++--------
src/add-ons/kernel/file_systems/nfs4/Inode.h       |   16 +--
src/add-ons/kernel/file_systems/nfs4/InodeDir.cpp  |   30 +++---
.../kernel/file_systems/nfs4/InodeRegular.cpp      |   54 +++++-----
src/add-ons/kernel/file_systems/nfs4/Jamfile       |    2 +-
.../kernel/file_systems/nfs4/NFS4Server.cpp        |   40 ++++---
src/add-ons/kernel/file_systems/nfs4/NFS4Server.h  |   11 +-
src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp |    6 +-
.../kernel/file_systems/nfs4/ReplyInterpreter.cpp  |    6 +-
.../kernel/file_systems/nfs4/ReplyInterpreter.h    |    2 +-
.../kernel/file_systems/nfs4/RequestBuilder.cpp    |    8 +-
.../kernel/file_systems/nfs4/RequestBuilder.h      |    2 +-
src/add-ons/kernel/file_systems/nfs4/RootInode.cpp |    6 +-
.../kernel/file_systems/nfs4/kernel_interface.cpp  |   20 ++--
.../dns_resolver/kernel_add_on/dns_resolver.cpp    |    4 +-
src/system/kernel/thread.cpp                       |   14 ---

############################################################################

Commit:      92284dcc2cc283de8cf553889891ae46aa2ba991

Author:      Pawel Dziepak <pdziepak@xxxxxxxxxxx>
Date:        Sun Jul  8 21:33:44 2012 UTC

nfs4: Use semaphore to cancel threads instead of interrupt_thread()

----------------------------------------------------------------------------

diff --git a/headers/os/drivers/KernelExport.h 
b/headers/os/drivers/KernelExport.h
index 14c707d..3e2e584 100644
--- a/headers/os/drivers/KernelExport.h
+++ b/headers/os/drivers/KernelExport.h
@@ -138,7 +138,6 @@ extern bool                 cancel_timer(timer *t);
 /* kernel threads */
 extern thread_id       spawn_kernel_thread(thread_func function,
                                                const char *name, int32 
priority, void *arg);
-extern status_t                interrupt_thread(thread_id id);
 
 /* signal functions */
 extern int                     send_signal_etc(pid_t thread, uint signal, 
uint32 flags);
diff --git a/src/add-ons/kernel/file_systems/nfs4/Connection.cpp 
b/src/add-ons/kernel/file_systems/nfs4/Connection.cpp
index 6a94ba7..f7381c7 100644
--- a/src/add-ons/kernel/file_systems/nfs4/Connection.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/Connection.cpp
@@ -88,6 +88,7 @@ ServerAddress::ResolveName(const char* name, ServerAddress* 
addr)
 
 Connection::Connection(const sockaddr_in& addr, Transport proto)
        :
+       fWaitCancel(create_sem(0, NULL)),
        fSock(-1),
        fProtocol(proto),
        fServerAddress(addr)
@@ -115,6 +116,7 @@ Connection::~Connection()
        if (fSock != -1)
                close(fSock);
        mutex_destroy(&fSockLock);
+       delete_sem(fWaitCancel);
 }
 
 
@@ -192,7 +194,25 @@ ConnectionStream::Receive(void** pbuffer, uint32* psize)
 
        int32 record_size;
        bool last_one;
+
+       object_wait_info object[2];
+       object[0].object = fWaitCancel;
+       object[0].type = B_OBJECT_TYPE_SEMAPHORE;
+       object[0].events = B_EVENT_ACQUIRE_SEMAPHORE;
+
+       object[1].object = fSock;
+       object[1].type = B_OBJECT_TYPE_FD;
+       object[1].events = B_EVENT_READ;
+
        do {
+               result = wait_for_objects(object, 2);
+               if (result < B_OK ||
+                       (object[0].events & B_EVENT_ACQUIRE_SEMAPHORE) != 0) {
+                       free(buffer);
+                       return ECONNABORTED;
+               } else if ((object[1].events & B_EVENT_READ) == 0)
+                       continue;
+
                // There is only one listener thread per connection. No need to 
lock.
                uint32 received = 0;
                do {
@@ -253,6 +273,26 @@ ConnectionPacket::Receive(void** pbuffer, uint32* psize)
        if (buffer == NULL)
                return B_NO_MEMORY;
 
+       object_wait_info object[2];
+       object[0].object = fWaitCancel;
+       object[0].type = B_OBJECT_TYPE_SEMAPHORE;
+       object[0].events = B_EVENT_ACQUIRE_SEMAPHORE;
+
+       object[1].object = fSock;
+       object[1].type = B_OBJECT_TYPE_FD;
+       object[1].events = B_EVENT_READ;
+
+       do {
+               result = wait_for_objects(object, 2);
+               if (result < B_OK ||
+                       (object[0].events & B_EVENT_ACQUIRE_SEMAPHORE) != 0) {
+                       free(buffer);
+                       return ECONNABORTED;
+               } else if ((object[1].events & B_EVENT_READ) == 0)
+                       continue;
+               break;
+       } while (true);
+
        // There is only one listener thread per connection. No need to lock.
        size = recv(fSock, buffer, size, 0);
        if (size < 0) {
@@ -333,7 +373,9 @@ Connection::_Connect()
 status_t
 Connection::Reconnect()
 {
+       release_sem(fWaitCancel);
        close(fSock);
+       acquire_sem(fWaitCancel);
        return _Connect();
 }
 
@@ -341,6 +383,8 @@ Connection::Reconnect()
 void
 Connection::Disconnect()
 {
+       release_sem(fWaitCancel);
+
        int sock = fSock;
        fSock = -1;
        close(sock);
diff --git a/src/add-ons/kernel/file_systems/nfs4/Connection.h 
b/src/add-ons/kernel/file_systems/nfs4/Connection.h
index 51d0323..eff2a66 100644
--- a/src/add-ons/kernel/file_systems/nfs4/Connection.h
+++ b/src/add-ons/kernel/file_systems/nfs4/Connection.h
@@ -53,6 +53,7 @@ protected:
                                                                        
Transport proto);
                        status_t                        _Connect();
 
+                       sem_id                          fWaitCancel;
                        int                                     fSock;
                        mutex                           fSockLock;
 
diff --git a/src/add-ons/kernel/file_systems/nfs4/NFS4Server.cpp 
b/src/add-ons/kernel/file_systems/nfs4/NFS4Server.cpp
index 49886ef..70757d3 100644
--- a/src/add-ons/kernel/file_systems/nfs4/NFS4Server.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/NFS4Server.cpp
@@ -16,6 +16,7 @@
 NFS4Server::NFS4Server(RPC::Server* serv)
        :
        fThreadCancel(true),
+       fWaitCancel(create_sem(1, NULL)),
        fLeaseTime(0),
        fClientIdLastUse(0),
        fUseCount(0),
@@ -31,10 +32,11 @@ NFS4Server::~NFS4Server()
 {
        fThreadCancel = true;
        fUseCount = 0;
-       interrupt_thread(fThread);
+       release_sem(fWaitCancel);
        status_t result;
        wait_for_thread(fThread, &result);
 
+       delete_sem(fWaitCancel);
        mutex_destroy(&fClientIdLock);
        mutex_destroy(&fFSLock);
 }
@@ -302,8 +304,12 @@ NFS4Server::_Renewal()
 {
        while (!fThreadCancel) {
                // TODO: operations like OPEN, READ, CLOSE, etc also renew 
leases
-               snooze_etc(sSecToBigTime(fLeaseTime - 2), B_SYSTEM_TIMEBASE,
-                       B_RELATIVE_TIMEOUT | B_CAN_INTERRUPT);
+               status_t result = acquire_sem_etc(fWaitCancel, 1,
+                       B_RELATIVE_TIMEOUT, sSecToBigTime(fLeaseTime - 2));
+               if (result != B_TIMED_OUT) {
+                       release_sem(fWaitCancel);
+                       return B_OK;
+               }
 
                uint64 clientId = fClientId;
 
diff --git a/src/add-ons/kernel/file_systems/nfs4/NFS4Server.h 
b/src/add-ons/kernel/file_systems/nfs4/NFS4Server.h
index 2979923..fdf61e8 100644
--- a/src/add-ons/kernel/file_systems/nfs4/NFS4Server.h
+++ b/src/add-ons/kernel/file_systems/nfs4/NFS4Server.h
@@ -45,6 +45,7 @@ private:
        static  status_t                _RenewalThreadStart(void* ptr);
                        thread_id               fThread;
                        bool                    fThreadCancel;
+                       sem_id                  fWaitCancel;
 
                        uint32                  fLeaseTime;
 
diff --git a/src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp 
b/src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp
index 3230caa..5e01714 100644
--- a/src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/RPCServer.cpp
@@ -89,12 +89,11 @@ Server::~Server()
 
        fThreadCancel = true;
        fConnection->Disconnect();
-       interrupt_thread(fThread);
-
-       delete fConnection;
 
        status_t result;
        wait_for_thread(fThread, &result);
+
+       delete fConnection;
 }
 
 
@@ -205,7 +204,6 @@ status_t
 Server::Repair()
 {
        fThreadCancel = true;
-       interrupt_thread(fThread);
 
        status_t result = fConnection->Reconnect();
        if (result != B_OK)
diff --git a/src/system/kernel/thread.cpp b/src/system/kernel/thread.cpp
index 022b8a1..6c95268 100644
--- a/src/system/kernel/thread.cpp
+++ b/src/system/kernel/thread.cpp
@@ -3008,20 +3008,6 @@ kill_thread(thread_id id)
 
 
 status_t
-interrupt_thread(thread_id id)
-{
-       Thread* thread = Thread::GetAndLock(id);
-       if (thread == NULL)
-               return B_BAD_THREAD_ID;
-       BReference<Thread> threadReference(thread, true);
-       ThreadLocker threadLocker(thread, true);
-
-       InterruptsSpinLocker schedulerLocker(gSchedulerLock);
-       return thread_interrupt(thread, false);
-}
-
-
-status_t
 send_data(thread_id thread, int32 code, const void *buffer, size_t bufferSize)
 {
        return send_data_etc(thread, code, buffer, bufferSize, 0);

############################################################################

Commit:      fcb41396a11ae546a4f1d1123468fe2c6a0f1891

Author:      Pawel Dziepak <pdziepak@xxxxxxxxxxx>
Date:        Sun Jul  8 21:35:05 2012 UTC

dns_resolver: Remove accidentally added debug messages

----------------------------------------------------------------------------

diff --git 
a/src/add-ons/kernel/network/dns_resolver/kernel_add_on/dns_resolver.cpp 
b/src/add-ons/kernel/network/dns_resolver/kernel_add_on/dns_resolver.cpp
index 40d2db4..eb58f5a 100644
--- a/src/add-ons/kernel/network/dns_resolver/kernel_add_on/dns_resolver.cpp
+++ b/src/add-ons/kernel/network/dns_resolver/kernel_add_on/dns_resolver.cpp
@@ -126,8 +126,6 @@ static status_t
 GetAddrInfo(const char* node, const char* service,
        const struct addrinfo* hints, struct addrinfo** res)
 {
-       dprintf("SENDING GETADDRINFO %s\n", node);
-
        uint32 nodeSize = node != NULL ? strlen(node) + 1 : 1;
        uint32 serviceSize = service != NULL ? strlen(service) + 1 : 1;
        uint32 size = nodeSize + serviceSize + sizeof(*hints);
@@ -157,7 +155,7 @@ GetAddrInfo(const char* node, const char* service,
                memset(nullHints, 0, sizeof(*nullHints));
                nullHints->ai_family = AF_UNSPEC;
        }
-       dprintf("SENDING BUFFER %s %d\n", buffer, (int)size);
+
        MutexLocker locker(gPortLock);
        do {
                status_t result = write_port(gPortRequest, MsgGetAddrInfo, 
buffer,

############################################################################

Commit:      00a8558cc75d9aee84f6d9b34c28d6706952558c

Author:      Pawel Dziepak <pdziepak@xxxxxxxxxxx>
Date:        Sun Jul  8 21:56:45 2012 UTC

nfs4: Rename Filehandle to FileHandle and Filesystem to FileSystem

----------------------------------------------------------------------------

diff --git a/src/add-ons/kernel/file_systems/nfs4/Cookie.cpp 
b/src/add-ons/kernel/file_systems/nfs4/Cookie.cpp
index 6c39b97..0102d68 100644
--- a/src/add-ons/kernel/file_systems/nfs4/Cookie.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/Cookie.cpp
@@ -124,7 +124,7 @@ Cookie::CancelAll()
        MutexLocker _(fRequestLock);
        RequestEntry* ent = fRequests;
        while (ent != NULL) {
-               fFilesystem->Server()->WakeCall(ent->fRequest);
+               fFileSystem->Server()->WakeCall(ent->fRequest);
                ent = ent->fNext;
        }
 
@@ -219,7 +219,7 @@ OpenFileCookie::DeleteLock(LockInfo* lock)
 status_t
 OpenFileCookie::_ReleaseLockOwner(LockOwner* owner)
 {
-       Request request(fFilesystem->Server());
+       Request request(fFileSystem->Server());
        RequestBuilder& req = request.Builder();
 
        req.ReleaseLockOwner(this, owner);
diff --git a/src/add-ons/kernel/file_systems/nfs4/Cookie.h 
b/src/add-ons/kernel/file_systems/nfs4/Cookie.h
index cda0791..364dc17c 100644
--- a/src/add-ons/kernel/file_systems/nfs4/Cookie.h
+++ b/src/add-ons/kernel/file_systems/nfs4/Cookie.h
@@ -11,7 +11,7 @@
 
 #include <SupportDefs.h>
 
-#include "Filesystem.h"
+#include "FileSystem.h"
 
 
 struct LockOwner {
@@ -55,7 +55,7 @@ struct Cookie {
                                RequestEntry*   fNext;
                        };
 
-                       Filesystem*             fFilesystem;
+                       FileSystem*             fFileSystem;
                        RequestEntry*   fRequests;
                        mutex                   fRequestLock;
 
diff --git a/src/add-ons/kernel/file_systems/nfs4/FileInfo.cpp 
b/src/add-ons/kernel/file_systems/nfs4/FileInfo.cpp
index 43bb3b4..22a86ec 100644
--- a/src/add-ons/kernel/file_systems/nfs4/FileInfo.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/FileInfo.cpp
@@ -9,7 +9,7 @@
 
 #include "FileInfo.h"
 
-#include "Filesystem.h"
+#include "FileSystem.h"
 #include "Request.h"
 
 
@@ -46,7 +46,7 @@ FileInfo::ParsePath(RequestBuilder& req, uint32& count, const 
char* _path)
 
 
 status_t
-FileInfo::UpdateFileHandles(Filesystem* fs)
+FileInfo::UpdateFileHandles(FileSystem* fs)
 {
        Request request(fs->Server());
        RequestBuilder& req = request.Builder();
diff --git a/src/add-ons/kernel/file_systems/nfs4/FileInfo.h 
b/src/add-ons/kernel/file_systems/nfs4/FileInfo.h
index 169967a..28b5412 100644
--- a/src/add-ons/kernel/file_systems/nfs4/FileInfo.h
+++ b/src/add-ons/kernel/file_systems/nfs4/FileInfo.h
@@ -17,27 +17,27 @@
 
 #define NFS4_FHSIZE    128
 
-struct Filehandle {
+struct FileHandle {
                        uint8           fSize;
-                       uint8           fFH[NFS4_FHSIZE];
+                       uint8           fData[NFS4_FHSIZE];
 
-       inline                          Filehandle();
-       inline                          Filehandle(const Filehandle& fh);
-       inline  Filehandle&     operator=(const Filehandle& fh);
+       inline                          FileHandle();
+       inline                          FileHandle(const FileHandle& fh);
+       inline  FileHandle&     operator=(const FileHandle& fh);
 };
 
 
-class Filesystem;
+class FileSystem;
 class RequestBuilder;
 
 // Complete information needed to identify a file in any situation.
-// Unfortunately just a filehandle is not enough even when they are persistent
-// since OPEN requires both parent filehandle and file name (just like LOOKUP).
+// Unfortunately just a FileHandle is not enough even when they are persistent
+// since OPEN requires both parent FileHandle and file name (just like LOOKUP).
 struct FileInfo {
                        uint64          fFileId;
-                       Filehandle      fHandle;
+                       FileHandle      fHandle;
 
-                       Filehandle      fParent;
+                       FileHandle      fParent;
                        const char*     fName;
                        const char*     fPath;
 
@@ -46,23 +46,23 @@ struct FileInfo {
        inline                          FileInfo(const FileInfo& fi);
        inline  FileInfo&       operator=(const FileInfo& fi);
 
-                       status_t        UpdateFileHandles(Filesystem* fs);
+                       status_t        UpdateFileHandles(FileSystem* fs);
 
        static status_t         ParsePath(RequestBuilder& req, uint32& count,
                                                        const char* _path);
 };
 
-struct FilesystemId {
+struct FileSystemId {
                        uint64          fMajor;
                        uint64          fMinor;
 
-       inline  bool            operator==(const FilesystemId& fsid) const;
-       inline  bool            operator!=(const FilesystemId& fsid) const;
+       inline  bool            operator==(const FileSystemId& fsid) const;
+       inline  bool            operator!=(const FileSystemId& fsid) const;
 };
 
 
 inline
-Filehandle::Filehandle()
+FileHandle::FileHandle()
        :
        fSize(0)
 {
@@ -70,19 +70,19 @@ Filehandle::Filehandle()
 
 
 inline
-Filehandle::Filehandle(const Filehandle& fh)
+FileHandle::FileHandle(const FileHandle& fh)
        :
        fSize(fh.fSize)
 {
-       memcpy(fFH, fh.fFH, fSize);
+       memcpy(fData, fh.fData, fSize);
 }
 
 
-inline Filehandle&
-Filehandle::operator=(const Filehandle& fh)
+inline FileHandle&
+FileHandle::operator=(const FileHandle& fh)
 {
        fSize = fh.fSize;
-       memcpy(fFH, fh.fFH, fSize);
+       memcpy(fData, fh.fData, fSize);
        return *this;
 }
 
@@ -135,14 +135,14 @@ FileInfo::operator=(const FileInfo& fi)
 
 
 inline bool
-FilesystemId::operator==(const FilesystemId& fsid) const
+FileSystemId::operator==(const FileSystemId& fsid) const
 {
        return fMajor == fsid.fMajor && fMinor == fsid.fMinor;
 }
 
 
 inline bool
-FilesystemId::operator!=(const FilesystemId& fsid) const
+FileSystemId::operator!=(const FileSystemId& fsid) const
 {
        return !operator==(fsid);
 }
diff --git a/src/add-ons/kernel/file_systems/nfs4/Filesystem.cpp 
b/src/add-ons/kernel/file_systems/nfs4/FileSystem.cpp
similarity index 88%
rename from src/add-ons/kernel/file_systems/nfs4/Filesystem.cpp
rename to src/add-ons/kernel/file_systems/nfs4/FileSystem.cpp
index b128718..a8ab9d4 100644
--- a/src/add-ons/kernel/file_systems/nfs4/Filesystem.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/FileSystem.cpp
@@ -7,7 +7,7 @@
  */
 
 
-#include "Filesystem.h"
+#include "FileSystem.h"
 
 #include <string.h>
 
@@ -21,7 +21,7 @@ extern RPC::ServerManager* gRPCServerManager;
 extern RPC::ProgramData* CreateNFS4Server(RPC::Server* serv);
 
 
-Filesystem::Filesystem()
+FileSystem::FileSystem()
        :
        fNext(NULL),
        fPrev(NULL),
@@ -35,9 +35,9 @@ Filesystem::Filesystem()
 }
 
 
-Filesystem::~Filesystem()
+FileSystem::~FileSystem()
 {
-       NFSServer()->RemoveFilesystem(this);
+       NFSServer()->RemoveFileSystem(this);
 
        mutex_destroy(&fOpenLock);
 
@@ -63,7 +63,7 @@ sGetPath(const char* root, const char* path)
 
 
 status_t
-Filesystem::Mount(Filesystem** pfs, RPC::Server* serv, const char* fsPath,
+FileSystem::Mount(FileSystem** pfs, RPC::Server* serv, const char* fsPath,
        dev_t id)
 {
        Request request(serv);
@@ -94,7 +94,7 @@ Filesystem::Mount(Filesystem** pfs, RPC::Server* serv, const 
char* fsPath,
        for (uint32 i = 0; i < lookupCount; i++)
                reply.LookUp();
 
-       Filehandle fh;
+       FileHandle fh;
        reply.GetFH(&fh);
 
        uint32 allowed;
@@ -111,7 +111,7 @@ Filesystem::Mount(Filesystem** pfs, RPC::Server* serv, 
const char* fsPath,
        if (result != B_OK || count < 2)
                return result;
 
-       Filesystem* fs = new(std::nothrow) Filesystem;
+       FileSystem* fs = new(std::nothrow) FileSystem;
        if (fs == NULL)
                return B_NO_MEMORY;
 
@@ -122,8 +122,8 @@ Filesystem::Mount(Filesystem** pfs, RPC::Server* serv, 
const char* fsPath,
        fs->fExpireType = values[1].fData.fValue32;
 
        // FATTR4_FSID is mandatory
-       FilesystemId* fsid =
-               reinterpret_cast<FilesystemId*>(values[2].fData.fPointer);
+       FileSystemId* fsid =
+               reinterpret_cast<FileSystemId*>(values[2].fData.fPointer);
 
        if (count == 4 && values[3].fAttribute == FATTR4_FS_LOCATIONS) {
                FSLocations* locs =
@@ -168,7 +168,7 @@ Filesystem::Mount(Filesystem** pfs, RPC::Server* serv, 
const char* fsPath,
 
        fs->fRoot = reinterpret_cast<RootInode*>(inode);
 
-       fs->NFSServer()->AddFilesystem(fs);
+       fs->NFSServer()->AddFileSystem(fs);
        *pfs = fs;
 
        return B_OK;
@@ -176,7 +176,7 @@ Filesystem::Mount(Filesystem** pfs, RPC::Server* serv, 
const char* fsPath,
 
 
 status_t
-Filesystem::GetInode(ino_t id, Inode** _inode)
+FileSystem::GetInode(ino_t id, Inode** _inode)
 {
        FileInfo fi;
        status_t result = fInoIdMap.GetFileInfo(&fi, id);
@@ -197,7 +197,7 @@ Filesystem::GetInode(ino_t id, Inode** _inode)
 
 
 status_t
-Filesystem::Migrate(const RPC::Server* serv)
+FileSystem::Migrate(const RPC::Server* serv)
 {
        MutexLocker _(fOpenLock);
        if (serv != fServer)
@@ -250,8 +250,8 @@ Filesystem::Migrate(const RPC::Server* serv)
        }
 
        NFS4Server* old = reinterpret_cast<NFS4Server*>(server->PrivateData());
-       old->RemoveFilesystem(this);
-       NFSServer()->AddFilesystem(this);
+       old->RemoveFileSystem(this);
+       NFSServer()->AddFileSystem(this);
 
        gRPCServerManager->Release(server);
 
@@ -260,7 +260,7 @@ Filesystem::Migrate(const RPC::Server* serv)
 
 
 OpenFileCookie*
-Filesystem::OpenFilesLock()
+FileSystem::OpenFilesLock()
 {
        mutex_lock(&fOpenLock);
        return fOpenFiles;
@@ -268,14 +268,14 @@ Filesystem::OpenFilesLock()
 
 
 void
-Filesystem::OpenFilesUnlock()
+FileSystem::OpenFilesUnlock()
 {
        mutex_unlock(&fOpenLock);
 }
 
 
 void
-Filesystem::AddOpenFile(OpenFileCookie* cookie)
+FileSystem::AddOpenFile(OpenFileCookie* cookie)
 {
        MutexLocker _(fOpenLock);
 
@@ -289,7 +289,7 @@ Filesystem::AddOpenFile(OpenFileCookie* cookie)
 
 
 void
-Filesystem::RemoveOpenFile(OpenFileCookie* cookie)
+FileSystem::RemoveOpenFile(OpenFileCookie* cookie)
 {
        MutexLocker _(fOpenLock);
        if (cookie == fOpenFiles)
diff --git a/src/add-ons/kernel/file_systems/nfs4/Filesystem.h 
b/src/add-ons/kernel/file_systems/nfs4/FileSystem.h
similarity index 76%
rename from src/add-ons/kernel/file_systems/nfs4/Filesystem.h
rename to src/add-ons/kernel/file_systems/nfs4/FileSystem.h
index 9073e67..1099f27 100644
--- a/src/add-ons/kernel/file_systems/nfs4/Filesystem.h
+++ b/src/add-ons/kernel/file_systems/nfs4/FileSystem.h
@@ -17,11 +17,11 @@
 class Inode;
 class RootInode;
 
-class Filesystem {
+class FileSystem {
 public:
-       static  status_t                        Mount(Filesystem** pfs, 
RPC::Server* serv,
+       static  status_t                        Mount(FileSystem** pfs, 
RPC::Server* serv,
                                                                        const 
char* path, dev_t id);
-                                                               ~Filesystem();
+                                                               ~FileSystem();
 
                        status_t                        GetInode(ino_t id, 
Inode** inode);
        inline  Inode*                          Root();
@@ -41,17 +41,17 @@ public:
        inline  NFS4Server*                     NFSServer();
 
        inline  const char*                     Path() const;
-       inline  const FilesystemId&     FsId() const;
+       inline  const FileSystemId&     FsId() const;
 
        inline  uint64                          AllocFileId();
 
        inline  dev_t                           DevId() const;
        inline  InodeIdMap*                     InoIdMap();
 
-                       Filesystem*                     fNext;
-                       Filesystem*                     fPrev;
+                       FileSystem*                     fNext;
+                       FileSystem*                     fPrev;
 private:
-                                                               Filesystem();
+                                                               FileSystem();
 
                        OpenFileCookie*         fOpenFiles;
                        uint32                          fOpenCount;
@@ -60,7 +60,7 @@ private:
                        uint32                          fExpireType;
                        uint32                          fSupAttrs[2];
 
-                       FilesystemId            fFsId;
+                       FileSystemId            fFsId;
                        const char*                     fPath;
 
                        RootInode*                      fRoot;
@@ -75,77 +75,77 @@ private:
 
 
 inline Inode*
-Filesystem::Root()
+FileSystem::Root()
 {
        return reinterpret_cast<Inode*>(fRoot);
 }
 
 
 inline uint32
-Filesystem::OpenFilesCount()
+FileSystem::OpenFilesCount()
 {
        return fOpenCount;
 }
 
 
 inline bool
-Filesystem::IsAttrSupported(Attribute attr) const
+FileSystem::IsAttrSupported(Attribute attr) const
 {
        return sIsAttrSet(attr, fSupAttrs, 2);
 }
 
 
 inline uint32
-Filesystem::ExpireType() const
+FileSystem::ExpireType() const
 {
        return fExpireType;
 }
 
 
 inline RPC::Server*
-Filesystem::Server()
+FileSystem::Server()
 {
        return fServer;
 }
 
 
 inline NFS4Server*
-Filesystem::NFSServer()
+FileSystem::NFSServer()
 {
        return reinterpret_cast<NFS4Server*>(fServer->PrivateData());
 }
 
 
 inline const char*
-Filesystem::Path() const
+FileSystem::Path() const
 {
        return fPath;
 }
 
 
-inline const FilesystemId&
-Filesystem::FsId() const
+inline const FileSystemId&
+FileSystem::FsId() const
 {
        return fFsId;
 }
 
 
 inline uint64
-Filesystem::AllocFileId()
+FileSystem::AllocFileId()
 {
        return atomic_add64(&fId, 1);
 }
 
 
 inline dev_t
-Filesystem::DevId() const
+FileSystem::DevId() const
 {
        return fDevId;
 }
 
 
 inline InodeIdMap*
-Filesystem::InoIdMap()
+FileSystem::InoIdMap()
 {
        return &fInoIdMap;
 }
diff --git a/src/add-ons/kernel/file_systems/nfs4/Inode.cpp 
b/src/add-ons/kernel/file_systems/nfs4/Inode.cpp
index e6ef4f7..5650947 100644
--- a/src/add-ons/kernel/file_systems/nfs4/Inode.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/Inode.cpp
@@ -25,7 +25,7 @@ Inode::Inode()
 
 
 status_t
-Inode::CreateInode(Filesystem* fs, const FileInfo &fi, Inode** _inode)
+Inode::CreateInode(FileSystem* fs, const FileInfo &fi, Inode** _inode)
 {
        Inode* inode = NULL;
        if (fs->Root() == NULL)
@@ -37,7 +37,7 @@ Inode::CreateInode(Filesystem* fs, const FileInfo &fi, 
Inode** _inode)
                return B_NO_MEMORY;
 
        inode->fInfo = fi;
-       inode->fFilesystem = fs;
+       inode->fFileSystem = fs;
 
        do {
                RPC::Server* serv = fs->Server();
@@ -78,8 +78,8 @@ Inode::CreateInode(Filesystem* fs, const FileInfo &fi, 
Inode** _inode)
                inode->fType = values[0].fData.fValue32;
 
                // FATTR4_FSID is mandatory
-               FilesystemId* fsid =
-                       
reinterpret_cast<FilesystemId*>(values[1].fData.fPointer);
+               FileSystemId* fsid =
+                       
reinterpret_cast<FileSystemId*>(values[1].fData.fPointer);
                if (*fsid != fs->FsId()) {
                        delete[] values;
                        return B_ENTRY_NOT_FOUND;
@@ -111,7 +111,7 @@ Inode::LookUp(const char* name, ino_t* id)
        }
 
        do {
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -144,7 +144,7 @@ Inode::LookUp(const char* name, ino_t* id)
                if (result != B_OK)
                        return result;
 
-               Filehandle fh;
+               FileHandle fh;
                reply.GetFH(&fh);
 
                AttrValue* values;
@@ -154,16 +154,16 @@ Inode::LookUp(const char* name, ino_t* id)
                        return result;
 
                // FATTR4_FSID is mandatory
-               FilesystemId* fsid =
-                       
reinterpret_cast<FilesystemId*>(values[0].fData.fPointer);
-               if (*fsid != fFilesystem->FsId()) {
+               FileSystemId* fsid =
+                       
reinterpret_cast<FileSystemId*>(values[0].fData.fPointer);
+               if (*fsid != fFileSystem->FsId()) {
                        delete[] values;
                        return B_ENTRY_NOT_FOUND;
                }
 
                uint64 fileId;
                if (count < 2 || values[1].fAttribute != FATTR4_FILEID)
-                       fileId = fFilesystem->AllocFileId();
+                       fileId = fFileSystem->AllocFileId();
                else
                        fileId = values[1].fData.fValue64;
                delete[] values;
@@ -188,7 +188,7 @@ Inode::LookUp(const char* name, ino_t* id)
                strcat(path, name);
                fi.fPath = path;
 
-               fFilesystem->InoIdMap()->AddEntry(fi, *id);
+               fFileSystem->InoIdMap()->AddEntry(fi, *id);
 
                return B_OK;
        } while (true);
@@ -199,7 +199,7 @@ status_t
 Inode::Link(Inode* dir, const char* name)
 {
        do {
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -214,16 +214,16 @@ Inode::Link(Inode* dir, const char* name)
 
                ReplyInterpreter& reply = request.Reply();
 
-               // filehandle has expired
+               // FileHandle has expired
                if (reply.NFS4Error() == NFS4ERR_FHEXPIRED) {
-                       fInfo.UpdateFileHandles(fFilesystem);
-                       dir->fInfo.UpdateFileHandles(dir->fFilesystem);
+                       fInfo.UpdateFileHandles(fFileSystem);
+                       dir->fInfo.UpdateFileHandles(dir->fFileSystem);
                        continue;
                }
 
                // filesystem has been moved
                if (reply.NFS4Error() == NFS4ERR_MOVED) {
-                       fFilesystem->Migrate(serv);
+                       fFileSystem->Migrate(serv);
                        continue;
                }
 
@@ -237,13 +237,13 @@ Inode::Link(Inode* dir, const char* name)
 
 
 // May cause problem similar to Rename (described below). When node's is has
-// more than one hard link and we delete the name it stores for filehandle
+// more than one hard link and we delete the name it stores for FileHandle
 // restoration node will inocorectly become unavailable.
 status_t
 Inode::Remove(const char* name, FileType type)
 {
        do {
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -293,18 +293,18 @@ Inode::Remove(const char* name, FileType type)
 }
 
 
-// Rename may cause some problems if filehandles are volatile and local Inode
+// Rename may cause some problems if FileHandles are volatile and local Inode
 // object exists for renamed node. It's stored filename will become invalid
-// and, consequnetly, filehandle restoration will fail. Probably, it will
+// and, consequnetly, FileHandle restoration will fail. Probably, it will
 // be much easier to solve this problem if more metadata is cached.
 status_t
 Inode::Rename(Inode* from, Inode* to, const char* fromName, const char* toName)
 {
-       if (from->fFilesystem != to->fFilesystem)
+       if (from->fFileSystem != to->fFileSystem)
                return B_DONT_DO_THAT;
 
        do {
-               RPC::Server* serv = from->fFilesystem->Server();
+               RPC::Server* serv = from->fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -319,16 +319,16 @@ Inode::Rename(Inode* from, Inode* to, const char* 
fromName, const char* toName)
 
                ReplyInterpreter& reply = request.Reply();
 
-               // filehandle has expired
+               // FileHandle has expired
                if (reply.NFS4Error() == NFS4ERR_FHEXPIRED) {
-                       from->fInfo.UpdateFileHandles(from->fFilesystem);
-                       to->fInfo.UpdateFileHandles(to->fFilesystem);
+                       from->fInfo.UpdateFileHandles(from->fFileSystem);
+                       to->fInfo.UpdateFileHandles(to->fFileSystem);
                        continue;
                }
 
                // filesystem has been moved
                if (reply.NFS4Error() == NFS4ERR_MOVED) {
-                       from->fFilesystem->Migrate(serv);
+                       from->fFileSystem->Migrate(serv);
                        continue;
                }
 
@@ -347,7 +347,7 @@ Inode::CreateLink(const char* name, const char* path, int 
mode)
        bool badOwner = false;
 
        do {
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -360,14 +360,14 @@ Inode::CreateLink(const char* name, const char* path, int 
mode)
                cattr[i].fData.fValue32 = mode;
                i++;
 
-               if (!badOwner && fFilesystem->IsAttrSupported(FATTR4_OWNER)) {
+               if (!badOwner && fFileSystem->IsAttrSupported(FATTR4_OWNER)) {
                        cattr[i].fAttribute = FATTR4_OWNER;
                        cattr[i].fFreePointer = true;
                        cattr[i].fData.fPointer = gIdMapper->GetOwner(getuid());
                        i++;
                }
 
-               if (!badOwner && 
fFilesystem->IsAttrSupported(FATTR4_OWNER_GROUP)) {
+               if (!badOwner && 
fFileSystem->IsAttrSupported(FATTR4_OWNER_GROUP)) {
                        cattr[i].fAttribute = FATTR4_OWNER_GROUP;
                        cattr[i].fFreePointer = true;
                        cattr[i].fData.fPointer = 
gIdMapper->GetOwnerGroup(getgid());
@@ -403,7 +403,7 @@ Inode::ReadLink(void* buffer, size_t* length)
                return B_BAD_VALUE;
 
        do {
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -434,7 +434,7 @@ status_t
 Inode::Access(int mode)
 {
        do {
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -482,7 +482,7 @@ status_t
 Inode::Stat(struct stat* st)
 {
        do {
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -671,7 +671,7 @@ Inode::WriteStat(const struct stat* st, uint32 mask)
        }
 
        do {
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -742,7 +742,7 @@ Inode::TestLock(OpenFileCookie* cookie, struct flock* lock)
                return result;
 
        do {
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -812,7 +812,7 @@ Inode::AcquireLock(OpenFileCookie* cookie, const struct 
flock* lock,
        do {
                MutexLocker ownerLocker(linfo->fOwner->fLock);
 
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -881,7 +881,7 @@ Inode::ReleaseLock(OpenFileCookie* cookie, const struct 
flock* lock)
        do {
                MutexLocker ownerLocker(linfo->fOwner->fLock);
 
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -926,7 +926,7 @@ Inode::ReleaseAllLocks(OpenFileCookie* cookie)
                do {
                        MutexLocker ownerLocker(linfo->fOwner->fLock);
 
-                       RPC::Server* serv = fFilesystem->Server();
+                       RPC::Server* serv = fFileSystem->Server();
                        Request request(serv);
                        RequestBuilder& req = request.Builder();
 
@@ -989,7 +989,7 @@ Inode::_HandleErrors(uint32 nfs4Error, RPC::Server* serv,
 
                // server is in grace period, we need to wait
                case NFS4ERR_GRACE:
-                       leaseTime = fFilesystem->NFSServer()->LeaseTime();
+                       leaseTime = fFileSystem->NFSServer()->LeaseTime();
                        if (cookie == NULL) {
                                snooze_etc(sSecToBigTime(leaseTime) / 3, 
B_SYSTEM_TIMEBASE,
                                        B_RELATIVE_TIMEOUT);
@@ -1008,25 +1008,25 @@ Inode::_HandleErrors(uint32 nfs4Error, RPC::Server* 
serv,
                // server has rebooted, reclaim share and try again
                case NFS4ERR_STALE_CLIENTID:
                case NFS4ERR_STALE_STATEID:
-                       
fFilesystem->NFSServer()->ServerRebooted(cookie->fClientId);
+                       
fFileSystem->NFSServer()->ServerRebooted(cookie->fClientId);
                        return true;
 
-               // filehandle has expired
+               // FileHandle has expired
                case NFS4ERR_FHEXPIRED:
-                       if (fInfo.UpdateFileHandles(fFilesystem) == B_OK)
+                       if (fInfo.UpdateFileHandles(fFileSystem) == B_OK)
                                return true;
                        return false;
 
                // filesystem has been moved
                case NFS4ERR_LEASE_MOVED:
                case NFS4ERR_MOVED:
-                       fFilesystem->Migrate(serv);
+                       fFileSystem->Migrate(serv);
                        return true;
 
                // lease has expired
                case NFS4ERR_EXPIRED:
                        if (cookie != NULL) {
-                               
fFilesystem->NFSServer()->ClientId(cookie->fClientId, true);
+                               
fFileSystem->NFSServer()->ClientId(cookie->fClientId, true);
                                return true;
                        }
                        return false;
diff --git a/src/add-ons/kernel/file_systems/nfs4/Inode.h 
b/src/add-ons/kernel/file_systems/nfs4/Inode.h
index 76445e7..91751bb 100644
--- a/src/add-ons/kernel/file_systems/nfs4/Inode.h
+++ b/src/add-ons/kernel/file_systems/nfs4/Inode.h
@@ -14,21 +14,21 @@
 #include <SupportDefs.h>
 
 #include "Cookie.h"
-#include "Filesystem.h"
+#include "FileSystem.h"
 #include "NFS4Defs.h"
 #include "ReplyInterpreter.h"
 
 
 class Inode {
 public:
-       static                  status_t        CreateInode(Filesystem* fs, 
const FileInfo& fi,
+       static                  status_t        CreateInode(FileSystem* fs, 
const FileInfo& fi,
                                                                        Inode** 
inode);
                                                                ~Inode();
 
        inline                  ino_t           ID() const;
        inline                  mode_t          Type() const;
        inline                  const char*     Name() const;
-       inline                  Filesystem*     FileSystem() const;
+       inline                  FileSystem*     GetFileSystem() const;
 
                                        status_t        LookUp(const char* 
name, ino_t* id);
 
@@ -75,7 +75,7 @@ protected:
                                                                        
RPC::Server* serv,
                                                                        
OpenFileCookie* cookie = NULL);
 
-                                       status_t        _ConfirmOpen(const 
Filehandle& fh,
+                                       status_t        _ConfirmOpen(const 
FileHandle& fh,
                                                                        
OpenFileCookie* cookie);
 
                                        status_t        _ReadDirOnce(DirEntry** 
dirents, uint32* count,
@@ -92,7 +92,7 @@ protected:
                                        uint32          fType;
 
                                        FileInfo        fInfo;
-                                       Filesystem*     fFilesystem;
+                                       FileSystem*     fFileSystem;
 };
 
 
@@ -128,10 +128,10 @@ Inode::Name() const
 }
 
 
-inline Filesystem*
-Inode::FileSystem() const
+inline FileSystem*
+Inode::GetFileSystem() const
 {
-       return fFilesystem;
+       return fFileSystem;
 }
 
 
diff --git a/src/add-ons/kernel/file_systems/nfs4/InodeDir.cpp 
b/src/add-ons/kernel/file_systems/nfs4/InodeDir.cpp
index 19b2743..5f3c25c 100644
--- a/src/add-ons/kernel/file_systems/nfs4/InodeDir.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/InodeDir.cpp
@@ -23,7 +23,7 @@ Inode::CreateDir(const char* name, int mode)
        bool badOwner = false;
 
        do {
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -36,14 +36,14 @@ Inode::CreateDir(const char* name, int mode)
                cattr[i].fData.fValue32 = mode;
                i++;
 
-               if (!badOwner && fFilesystem->IsAttrSupported(FATTR4_OWNER)) {
+               if (!badOwner && fFileSystem->IsAttrSupported(FATTR4_OWNER)) {
                        cattr[i].fAttribute = FATTR4_OWNER;
                        cattr[i].fFreePointer = true;
                        cattr[i].fData.fPointer = gIdMapper->GetOwner(getuid());
                        i++;
                }
 
-               if (!badOwner && 
fFilesystem->IsAttrSupported(FATTR4_OWNER_GROUP)) {
+               if (!badOwner && 
fFileSystem->IsAttrSupported(FATTR4_OWNER_GROUP)) {
                        cattr[i].fAttribute = FATTR4_OWNER_GROUP;
                        cattr[i].fFreePointer = true;
                        cattr[i].fData.fPointer = 
gIdMapper->GetOwnerGroup(getgid());
@@ -79,7 +79,7 @@ Inode::OpenDir(OpenDirCookie* cookie)
                return B_NOT_A_DIRECTORY;
 
        do {
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -105,7 +105,7 @@ Inode::OpenDir(OpenDirCookie* cookie)
                if (allowed & ACCESS4_READ != ACCESS4_READ)
                        return B_PERMISSION_DENIED;
 
-               cookie->fFilesystem = fFilesystem;
+               cookie->fFileSystem = fFileSystem;
                cookie->fCookie = 0;
                cookie->fCookieVerf = 2;
 
@@ -119,7 +119,7 @@ Inode::_ReadDirOnce(DirEntry** dirents, uint32* count, 
OpenDirCookie* cookie,
        bool* eof)
 {
        do {
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -155,7 +155,7 @@ Inode::_FillDirEntry(struct dirent* de, ino_t id, const 
char* name, uint32 pos,
        if (pos + entSize + nameSize > size)
                return B_BUFFER_OVERFLOW;
 
-       de->d_dev = fFilesystem->DevId();
+       de->d_dev = fFileSystem->DevId();
        de->d_ino = id;
        de->d_reclen = entSize + nameSize;
        if (de->d_reclen % 8 != 0)
@@ -171,7 +171,7 @@ status_t
 Inode::_ReadDirUp(struct dirent* de, uint32 pos, uint32 size)
 {
        do {
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -179,7 +179,7 @@ Inode::_ReadDirUp(struct dirent* de, uint32 pos, uint32 
size)
                req.LookUpUp();
                req.GetFH();
 
-               if (fFilesystem->IsAttrSupported(FATTR4_FILEID)) {
+               if (fFileSystem->IsAttrSupported(FATTR4_FILEID)) {
                        Attribute attr[] = { FATTR4_FILEID };
                        req.GetAttr(attr, sizeof(attr) / sizeof(Attribute));
                }
@@ -198,11 +198,11 @@ Inode::_ReadDirUp(struct dirent* de, uint32 pos, uint32 
size)
                if (result != B_OK)
                        return result;
 
-               Filehandle fh;
+               FileHandle fh;
                reply.GetFH(&fh);
 
                uint64 fileId;
-               if (fFilesystem->IsAttrSupported(FATTR4_FILEID)) {
+               if (fFileSystem->IsAttrSupported(FATTR4_FILEID)) {
                        AttrValue* values;
                        uint32 count;
                        reply.GetAttr(&values, &count);
@@ -212,7 +212,7 @@ Inode::_ReadDirUp(struct dirent* de, uint32 pos, uint32 
size)
                        fileId = values[0].fData.fValue64;
                        delete[] values;
                } else
-                       fileId = fFilesystem->AllocFileId();
+                       fileId = fFileSystem->AllocFileId();
 
                return _FillDirEntry(de, _FileIdToInoT(fileId), "..", pos, 
size);
        } while (true);
@@ -273,15 +273,15 @@ Inode::ReadDir(void* _buffer, uint32 size, uint32* _count,
 
                        // FATTR4_FSID is mandatory
                        void* data = dirents[i].fAttrs[0].fData.fPointer;
-                       FilesystemId* fsid = 
reinterpret_cast<FilesystemId*>(data);
-                       if (*fsid != fFilesystem->FsId())
+                       FileSystemId* fsid = 
reinterpret_cast<FileSystemId*>(data);
+                       if (*fsid != fFileSystem->FsId())
                                continue;
 
                        ino_t id;
                        if (dirents[i].fAttrCount == 2)
                                id = 
_FileIdToInoT(dirents[i].fAttrs[1].fData.fValue64);
                        else
-                               id = _FileIdToInoT(fFilesystem->AllocFileId());
+                               id = _FileIdToInoT(fFileSystem->AllocFileId());
 
                        const char* name = dirents[i].fName;
                        if (_FillDirEntry(de, id, name, pos, size) == 
B_BUFFER_OVERFLOW) {
diff --git a/src/add-ons/kernel/file_systems/nfs4/InodeRegular.cpp 
b/src/add-ons/kernel/file_systems/nfs4/InodeRegular.cpp
index 2b37035..9ecb03a 100644
--- a/src/add-ons/kernel/file_systems/nfs4/InodeRegular.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/InodeRegular.cpp
@@ -18,10 +18,10 @@
 
 
 status_t
-Inode::_ConfirmOpen(const Filehandle& fh, OpenFileCookie* cookie)
+Inode::_ConfirmOpen(const FileHandle& fh, OpenFileCookie* cookie)
 {
        do {
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
 
                RequestBuilder& req = request.Builder();
@@ -32,7 +32,7 @@ Inode::_ConfirmOpen(const Filehandle& fh, OpenFileCookie* 
cookie)
 
                status_t result = request.Send();
                if (result != B_OK) {
-                       fFilesystem->RemoveOpenFile(cookie);
+                       fFileSystem->RemoveOpenFile(cookie);
                        return result;
                }
 
@@ -44,7 +44,7 @@ Inode::_ConfirmOpen(const Filehandle& fh, OpenFileCookie* 
cookie)
                reply.PutFH();
                result = reply.OpenConfirm(&cookie->fStateSeq);
                if (result != B_OK) {
-                       fFilesystem->RemoveOpenFile(cookie);
+                       fFileSystem->RemoveOpenFile(cookie);
                        return result;
                }
 
@@ -67,11 +67,11 @@ Inode::Create(const char* name, int mode, int perms, 
OpenFileCookie* cookie,
        cookie->fLocks = NULL;
 
        bool badOwner = false;
-       Filehandle fh;
+       FileHandle fh;
        do {
-               cookie->fClientId = fFilesystem->NFSServer()->ClientId();
+               cookie->fClientId = fFileSystem->NFSServer()->ClientId();
 
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -92,14 +92,14 @@ Inode::Create(const char* name, int mode, int perms, 
OpenFileCookie* cookie,
                cattr[i].fData.fValue32 = perms;
                i++;
 
-               if (!badOwner && fFilesystem->IsAttrSupported(FATTR4_OWNER)) {
+               if (!badOwner && fFileSystem->IsAttrSupported(FATTR4_OWNER)) {
                        cattr[i].fAttribute = FATTR4_OWNER;
                        cattr[i].fFreePointer = true;
                        cattr[i].fData.fPointer = gIdMapper->GetOwner(getuid());
                        i++;
                }
 
-               if (!badOwner && 
fFilesystem->IsAttrSupported(FATTR4_OWNER_GROUP)) {
+               if (!badOwner && 
fFileSystem->IsAttrSupported(FATTR4_OWNER_GROUP)) {
                        cattr[i].fAttribute = FATTR4_OWNER_GROUP;
                        cattr[i].fFreePointer = true;
                        cattr[i].fData.fPointer = 
gIdMapper->GetOwnerGroup(getgid());
@@ -112,7 +112,7 @@ Inode::Create(const char* name, int mode, int perms, 
OpenFileCookie* cookie,
 
                req.GetFH();
 
-               if (fFilesystem->IsAttrSupported(FATTR4_FILEID)) {
+               if (fFileSystem->IsAttrSupported(FATTR4_FILEID)) {
                        Attribute attr[] = { FATTR4_FILEID };
                        req.GetAttr(attr, sizeof(attr) / sizeof(Attribute));
                }
@@ -135,7 +135,7 @@ Inode::Create(const char* name, int mode, int perms, 
OpenFileCookie* cookie,
                reply.GetFH(&fh);
 
                uint64 fileId;
-               if (fFilesystem->IsAttrSupported(FATTR4_FILEID)) {
+               if (fFileSystem->IsAttrSupported(FATTR4_FILEID)) {
                        AttrValue* values;
                        uint32 count;
                        result = reply.GetAttr(&values, &count);
@@ -146,7 +146,7 @@ Inode::Create(const char* name, int mode, int perms, 
OpenFileCookie* cookie,
 
                        delete[] values;
                } else
-                       fileId = fFilesystem->AllocFileId();
+                       fileId = fFileSystem->AllocFileId();
 
                *id = _FileIdToInoT(fileId);
 
@@ -163,15 +163,15 @@ Inode::Create(const char* name, int mode, int perms, 
OpenFileCookie* cookie,
                strcat(path, name);
                fi.fPath = path;
 
-               fFilesystem->InoIdMap()->AddEntry(fi, *id);
+               fFileSystem->InoIdMap()->AddEntry(fi, *id);
 
-               cookie->fFilesystem = fFilesystem;
+               cookie->fFileSystem = fFileSystem;
                cookie->fInfo = fi;
 
                break;
        } while (true);
 
-       fFilesystem->AddOpenFile(cookie);
+       fFileSystem->AddOpenFile(cookie);
 
        if (confirm)
                return _ConfirmOpen(fh, cookie);
@@ -186,16 +186,16 @@ Inode::Open(int mode, OpenFileCookie* cookie)
        bool confirm;
        status_t result;
 
-       cookie->fFilesystem = fFilesystem;
+       cookie->fFileSystem = fFileSystem;
        cookie->fInfo = fInfo;
        cookie->fMode = mode;
        cookie->fSequence = 0;
        cookie->fLocks = NULL;
 
        do {
-               cookie->fClientId = fFilesystem->NFSServer()->ClientId();
+               cookie->fClientId = fFileSystem->NFSServer()->ClientId();
 
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -203,7 +203,7 @@ Inode::Open(int mode, OpenFileCookie* cookie)
 
                // Since we are opening the file using a pair (parentFH, name) 
we
                // need to check for race conditions.
-               if (fFilesystem->IsAttrSupported(FATTR4_FILEID)) {
+               if (fFileSystem->IsAttrSupported(FATTR4_FILEID)) {
                        req.PutFH(fInfo.fParent);
                        req.LookUp(fInfo.fName);
                        AttrValue attr;
@@ -211,7 +211,7 @@ Inode::Open(int mode, OpenFileCookie* cookie)
                        attr.fFreePointer = false;
                        attr.fData.fValue64 = fInfo.fFileId;
                        req.Verify(&attr, 1);
-               } else if (fFilesystem->ExpireType() == FH4_PERSISTENT) {
+               } else if (fFileSystem->ExpireType() == FH4_PERSISTENT) {
                        req.PutFH(fInfo.fParent);
                        req.LookUp(fInfo.fName);
                        AttrValue attr;
@@ -246,8 +246,8 @@ Inode::Open(int mode, OpenFileCookie* cookie)
 
                // Verify if the file we want to open is the file this Inode
                // represents.
-               if (fFilesystem->IsAttrSupported(FATTR4_FILEID) ||
-                       fFilesystem->ExpireType() == FH4_PERSISTENT) {
+               if (fFileSystem->IsAttrSupported(FATTR4_FILEID) ||
+                       fFileSystem->ExpireType() == FH4_PERSISTENT) {
                        reply.PutFH();
                        result = reply.LookUp();
                        if (result != B_OK)
@@ -267,7 +267,7 @@ Inode::Open(int mode, OpenFileCookie* cookie)
                break;
        } while (true);
 
-       fFilesystem->AddOpenFile(cookie);
+       fFileSystem->AddOpenFile(cookie);
 
        if (confirm)
                return _ConfirmOpen(fInfo.fHandle, cookie);
@@ -279,10 +279,10 @@ Inode::Open(int mode, OpenFileCookie* cookie)
 status_t
 Inode::Close(OpenFileCookie* cookie)
 {
-       fFilesystem->RemoveOpenFile(cookie);
+       fFileSystem->RemoveOpenFile(cookie);
 
        do {
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -320,7 +320,7 @@ Inode::Read(OpenFileCookie* cookie, off_t pos, void* 
buffer, size_t* _length)
 
        while (size < *_length && !eof) {
                do {
-                       RPC::Server* serv = fFilesystem->Server();
+                       RPC::Server* serv = fFileSystem->Server();
                        Request request(serv);
                        RequestBuilder& req = request.Builder();
 
@@ -366,7 +366,7 @@ Inode::Write(OpenFileCookie* cookie, off_t pos, const void* 
_buffer,
 
        while (size < *_length) {
                do {
-                       RPC::Server* serv = fFilesystem->Server();
+                       RPC::Server* serv = fFileSystem->Server();
                        Request request(serv);
                        RequestBuilder& req = request.Builder();
 
diff --git a/src/add-ons/kernel/file_systems/nfs4/Jamfile 
b/src/add-ons/kernel/file_systems/nfs4/Jamfile
index 822bf41..5350ac5 100644
--- a/src/add-ons/kernel/file_systems/nfs4/Jamfile
+++ b/src/add-ons/kernel/file_systems/nfs4/Jamfile
@@ -7,7 +7,7 @@ KernelAddon nfs4 :
        Cookie.cpp
        Connection.cpp
        FileInfo.cpp
-       Filesystem.cpp
+       FileSystem.cpp
        IdMap.cpp
        Inode.cpp
        InodeDir.cpp
diff --git a/src/add-ons/kernel/file_systems/nfs4/NFS4Server.cpp 
b/src/add-ons/kernel/file_systems/nfs4/NFS4Server.cpp
index 70757d3..2ed4035 100644
--- a/src/add-ons/kernel/file_systems/nfs4/NFS4Server.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/NFS4Server.cpp
@@ -7,7 +7,7 @@
  */
 
 
-#include "Filesystem.h"
+#include "FileSystem.h"
 #include "Inode.h"
 #include "NFS4Server.h"
 #include "Request.h"
@@ -20,7 +20,7 @@ NFS4Server::NFS4Server(RPC::Server* serv)
        fLeaseTime(0),
        fClientIdLastUse(0),
        fUseCount(0),
-       fFilesystems(NULL),
+       fFileSystems(NULL),
        fServer(serv)
 {
        mutex_init(&fClientIdLock, NULL);
@@ -52,7 +52,7 @@ NFS4Server::ServerRebooted(uint64 clientId)
 
        // reclaim all opened files and held locks from all filesystems
        MutexLocker _(fFSLock);
-       Filesystem* fs = fFilesystems;
+       FileSystem* fs = fFileSystems;
        while (fs != NULL) {
                OpenFileCookie* current = fs->OpenFilesLock();
                while (current != NULL) {
@@ -157,14 +157,14 @@ NFS4Server::_ReclaimLocks(OpenFileCookie* cookie)
 
 
 void
-NFS4Server::AddFilesystem(Filesystem* fs)
+NFS4Server::AddFileSystem(FileSystem* fs)
 {
        MutexLocker _(fFSLock);
        fs->fPrev = NULL;
-       fs->fNext = fFilesystems;
-       if (fFilesystems != NULL)
-               fFilesystems->fPrev = fs;
-       fFilesystems = fs;
+       fs->fNext = fFileSystems;
+       if (fFileSystems != NULL)
+               fFileSystems->fPrev = fs;
+       fFileSystems = fs;
        fUseCount += fs->OpenFilesCount();
        if (fs->OpenFilesCount() > 0 && fThreadCancel)
                _StartRenewing();
@@ -172,11 +172,11 @@ NFS4Server::AddFilesystem(Filesystem* fs)
 
 
 void
-NFS4Server::RemoveFilesystem(Filesystem* fs)
+NFS4Server::RemoveFileSystem(FileSystem* fs)
 {
        MutexLocker _(fFSLock);
-       if (fs == fFilesystems)
-               fFilesystems = fs->fNext;
+       if (fs == fFileSystems)
+               fFileSystems = fs->fNext;
 
        if (fs->fNext)
                fs->fNext->fPrev = fs->fPrev;
@@ -223,11 +223,11 @@ NFS4Server::ClientId(uint64 prevId, bool forceNew)
 
 
 status_t
-NFS4Server::FilesystemMigrated()
+NFS4Server::FileSystemMigrated()
 {
        // reclaim all opened files and held locks from all filesystems
        MutexLocker _(fFSLock);
-       Filesystem* fs = fFilesystems;
+       FileSystem* fs = fFileSystems;
        while (fs != NULL) {
                fs->Migrate(fServer);
                fs = fs->fNext;
@@ -330,7 +330,7 @@ NFS4Server::_Renewal()
                                ServerRebooted(clientId);
                                break;
                        case NFS4ERR_LEASE_MOVED:
-                               FilesystemMigrated();
+                               FileSystemMigrated();
                                break;
                }
        }
diff --git a/src/add-ons/kernel/file_systems/nfs4/NFS4Server.h 
b/src/add-ons/kernel/file_systems/nfs4/NFS4Server.h
index fdf61e8..210e3fa 100644
--- a/src/add-ons/kernel/file_systems/nfs4/NFS4Server.h
+++ b/src/add-ons/kernel/file_systems/nfs4/NFS4Server.h
@@ -14,7 +14,7 @@
 #include "RPCServer.h"
 
 
-class Filesystem;
+class FileSystem;
 class OpenFileCookie;
 
 class NFS4Server : public RPC::ProgramData {
@@ -23,10 +23,10 @@ public:
        virtual                                 ~NFS4Server();
 
                        uint64                  ServerRebooted(uint64 clientId);
-                       status_t                FilesystemMigrated();
+                       status_t                FileSystemMigrated();
 
-                       void                    AddFilesystem(Filesystem* fs);
-                       void                    RemoveFilesystem(Filesystem* 
fs);
+                       void                    AddFileSystem(FileSystem* fs);
+                       void                    RemoveFileSystem(FileSystem* 
fs);
 
        inline  void                    IncUsage();
        inline  void                    DecUsage();
@@ -55,7 +55,7 @@ private:
                        mutex                   fClientIdLock;
 
                        uint32                  fUseCount;
-                       Filesystem*             fFilesystems;
+                       FileSystem*             fFileSystems;
                        mutex                   fFSLock;
 
                        RPC::Server*    fServer;
diff --git a/src/add-ons/kernel/file_systems/nfs4/ReplyInterpreter.cpp 
b/src/add-ons/kernel/file_systems/nfs4/ReplyInterpreter.cpp
index 43755b2..8306a58 100644
--- a/src/add-ons/kernel/file_systems/nfs4/ReplyInterpreter.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/ReplyInterpreter.cpp
@@ -166,7 +166,7 @@ ReplyInterpreter::GetAttr(AttrValue** attrs, uint32* count)
 
 
 status_t
-ReplyInterpreter::GetFH(Filehandle* fh)
+ReplyInterpreter::GetFH(FileHandle* fh)
 {
        status_t res = _OperationError(OpGetFH);
        if (res != B_OK)
@@ -179,7 +179,7 @@ ReplyInterpreter::GetFH(Filehandle* fh)
 
        if (fh != NULL) {
                fh->fSize = size;
-               memcpy(fh->fFH, ptr, size);
+               memcpy(fh->fData, ptr, size);
        }
 
        return fReply->Stream().IsEOF() ? B_BAD_VALUE : B_OK;
@@ -538,7 +538,7 @@ ReplyInterpreter::_DecodeAttrs(XDR::ReadStream& str, 
AttrValue** attrs,
                values[current].fAttribute = FATTR4_FSID;
                values[current].fFreePointer = true;
 
-               FilesystemId fsid;
+               FileSystemId fsid;
                fsid.fMajor = stream.GetUHyper();
                fsid.fMinor = stream.GetUHyper();
                
diff --git a/src/add-ons/kernel/file_systems/nfs4/ReplyInterpreter.h 
b/src/add-ons/kernel/file_systems/nfs4/ReplyInterpreter.h
index 8e99e9e..eedd9ea 100644
--- a/src/add-ons/kernel/file_systems/nfs4/ReplyInterpreter.h
+++ b/src/add-ons/kernel/file_systems/nfs4/ReplyInterpreter.h
@@ -71,7 +71,7 @@ public:
                        status_t        Close();
                        status_t        Create();
                        status_t        GetAttr(AttrValue** attrs, uint32* 
count);
-                       status_t        GetFH(Filehandle* fh);
+                       status_t        GetFH(FileHandle* fh);
                        status_t        Link();
                        status_t        Lock(LockInfo* linfo);
                        status_t        LockT(uint64* pos, uint64* len, 
LockType* type);
diff --git a/src/add-ons/kernel/file_systems/nfs4/RequestBuilder.cpp 
b/src/add-ons/kernel/file_systems/nfs4/RequestBuilder.cpp
index 81cade2..e9007fa 100644
--- a/src/add-ons/kernel/file_systems/nfs4/RequestBuilder.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/RequestBuilder.cpp
@@ -402,7 +402,7 @@ RequestBuilder::OpenConfirm(uint32 seq, const uint32* id, 
uint32 stateSeq)
 
 
 status_t
-RequestBuilder::PutFH(const Filehandle& fh)
+RequestBuilder::PutFH(const FileHandle& fh)
 {
        if (fProcedure != ProcCompound)
                return B_BAD_VALUE;
@@ -410,7 +410,7 @@ RequestBuilder::PutFH(const Filehandle& fh)
                return B_NO_MEMORY;
 
        fRequest->Stream().AddUInt(OpPutFH);
-       fRequest->Stream().AddOpaque(fh.fFH, fh.fSize);
+       fRequest->Stream().AddOpaque(fh.fData, fh.fSize);
        fOpCount++;
 
        return B_OK;
@@ -761,8 +761,8 @@ RequestBuilder::_EncodeAttrs(XDR::WriteStream& stream, 
AttrValue* attr,
        }
 
        if (i < count && attr[i].fAttribute == FATTR4_FILEHANDLE) {
-               Filehandle* fh = 
reinterpret_cast<Filehandle*>(attr[i].fData.fPointer);
-               str.AddOpaque(fh->fFH, fh->fSize);
+               FileHandle* fh = 
reinterpret_cast<FileHandle*>(attr[i].fData.fPointer);
+               str.AddOpaque(fh->fData, fh->fSize);
                i++;
        }
 
diff --git a/src/add-ons/kernel/file_systems/nfs4/RequestBuilder.h 
b/src/add-ons/kernel/file_systems/nfs4/RequestBuilder.h
index f59aac7..753a837 100644
--- a/src/add-ons/kernel/file_systems/nfs4/RequestBuilder.h
+++ b/src/add-ons/kernel/file_systems/nfs4/RequestBuilder.h
@@ -54,7 +54,7 @@ public:
                                                                                
uint32 count = 0, bool excl = false);
                        status_t                                
OpenConfirm(uint32 seq, const uint32* id,
                                                                                
uint32 stateSeq);
-                       status_t                                PutFH(const 
Filehandle& fh);
+                       status_t                                PutFH(const 
FileHandle& fh);
                        status_t                                PutRootFH();
                        status_t                                Read(const 
uint32* id, uint32 stateSeq,
                                                                                
uint64 pos, uint32 len);
diff --git a/src/add-ons/kernel/file_systems/nfs4/RootInode.cpp 
b/src/add-ons/kernel/file_systems/nfs4/RootInode.cpp
index 4b8ed2e..d5830ce 100644
--- a/src/add-ons/kernel/file_systems/nfs4/RootInode.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/RootInode.cpp
@@ -18,7 +18,7 @@ status_t
 RootInode::ReadInfo(struct fs_info* info)
 {
        do {
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -97,7 +97,7 @@ bool
 RootInode::ProbeMigration()
 {
        do {
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
@@ -126,7 +126,7 @@ status_t
 RootInode::GetLocations(AttrValue** attrv)
 {
        do {
-               RPC::Server* serv = fFilesystem->Server();
+               RPC::Server* serv = fFileSystem->Server();
                Request request(serv);
                RequestBuilder& req = request.Builder();
 
diff --git a/src/add-ons/kernel/file_systems/nfs4/kernel_interface.cpp 
b/src/add-ons/kernel/file_systems/nfs4/kernel_interface.cpp
index 2edac96..223bb62 100644
--- a/src/add-ons/kernel/file_systems/nfs4/kernel_interface.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/kernel_interface.cpp
@@ -12,7 +12,7 @@
 #include <fs_interface.h>
 
 #include "Connection.h"
-#include "Filesystem.h"
+#include "FileSystem.h"
 #include "IdMap.h"
 #include "Inode.h"
 #include "NFS4Defs.h"
@@ -86,8 +86,8 @@ nfs4_mount(fs_volume* volume, const char* device, uint32 
flags,
        if (result != B_OK)
                return result;
        
-       Filesystem* fs;
-       result = Filesystem::Mount(&fs, server, path, volume->id);
+       FileSystem* fs;
+       result = FileSystem::Mount(&fs, server, path, volume->id);
        if (result != B_OK) {
                gRPCServerManager->Release(server);
                return result;
@@ -119,7 +119,7 @@ static status_t
 nfs4_get_vnode(fs_volume* volume, ino_t id, fs_vnode* vnode, int* _type,
        uint32* _flags, bool reenter)
 {
-       Filesystem* fs = reinterpret_cast<Filesystem*>(volume->private_volume);
+       FileSystem* fs = reinterpret_cast<FileSystem*>(volume->private_volume);
        Inode* inode;   
        status_t result = fs->GetInode(id, &inode);
        if (result != B_OK)
@@ -138,7 +138,7 @@ nfs4_get_vnode(fs_volume* volume, ino_t id, fs_vnode* 
vnode, int* _type,
 static status_t
 nfs4_unmount(fs_volume* volume)
 {
-       Filesystem* fs = reinterpret_cast<Filesystem*>(volume->private_volume);
+       FileSystem* fs = reinterpret_cast<FileSystem*>(volume->private_volume);
        RPC::Server* server = fs->Server();
 
        delete fs;
@@ -151,7 +151,7 @@ nfs4_unmount(fs_volume* volume)
 static status_t
 nfs4_read_fs_info(fs_volume* volume, struct fs_info* info)
 {
-       Filesystem* fs = reinterpret_cast<Filesystem*>(volume->private_volume);
+       FileSystem* fs = reinterpret_cast<FileSystem*>(volume->private_volume);
        RootInode* inode = reinterpret_cast<RootInode*>(fs->Root());
        return inode->ReadInfo(info);
 }
@@ -183,12 +183,12 @@ nfs4_get_vnode_name(fs_volume* volume, fs_vnode* vnode, 
char* buffer,
 static status_t
 nfs4_put_vnode(fs_volume* volume, fs_vnode* vnode, bool reenter)
 {
-       Filesystem* fs = reinterpret_cast<Filesystem*>(volume->private_volume);
+       FileSystem* fs = reinterpret_cast<FileSystem*>(volume->private_volume);
        Inode* inode = reinterpret_cast<Inode*>(vnode->private_node);
        if (fs->Root() == inode)
                return B_OK;
 
-       inode->FileSystem()->InoIdMap()->RemoveEntry(inode->ID());
+       inode->GetFileSystem()->InoIdMap()->RemoveEntry(inode->ID());
        delete inode;
 
        return B_OK;
@@ -202,12 +202,12 @@ nfs4_remove_vnode(fs_volume* volume, fs_vnode* vnode, 
bool reenter)
        // side are only an attempt to simulate local filesystem. Hence,
        // this hook is the same as put_vnode().
 
-       Filesystem* fs = reinterpret_cast<Filesystem*>(volume->private_volume);
+       FileSystem* fs = reinterpret_cast<FileSystem*>(volume->private_volume);
        Inode* inode = reinterpret_cast<Inode*>(vnode->private_node);
        if (fs->Root() == inode)
                return B_OK;
 
-       inode->FileSystem()->InoIdMap()->RemoveEntry(inode->ID());
+       inode->GetFileSystem()->InoIdMap()->RemoveEntry(inode->ID());
        delete inode;
 
        return B_OK;


Other related posts: