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

  • From: pdziepak-github.nfs4 <community@xxxxxxxxxxxx>
  • To: haiku-commits@xxxxxxxxxxxxx
  • Date: Wed, 8 Aug 2012 04:49:22 +0200 (CEST)

added 3 changesets to branch 'refs/remotes/pdziepak-github/nfs4'
old head: 224d602294491975618b856227b84120a5e1e0fc
new head: 3ae5e813c43fe9602bbc5a06ee3821887f9e17cb

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

49935f9: nfs4: Check if user is allowed to use open state

d8e2263: nfs4: Fix callback connection closing

3ae5e81: nfs4: Implement node monitoring

                                    [ Pawel Dziepak <pdziepak@xxxxxxxxxxx> ]

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

12 files changed, 214 insertions(+), 27 deletions(-)
.../kernel/file_systems/nfs4/Connection.cpp        |    2 +-
.../kernel/file_systems/nfs4/DirectoryCache.cpp    |   72 +++++++++++++++-
.../kernel/file_systems/nfs4/DirectoryCache.h      |    4 +
src/add-ons/kernel/file_systems/nfs4/Inode.cpp     |   28 +++++-
src/add-ons/kernel/file_systems/nfs4/Inode.h       |    9 +-
.../kernel/file_systems/nfs4/InodeRegular.cpp      |   28 +++---
.../kernel/file_systems/nfs4/MetadataCache.cpp     |   46 +++++++++-
.../kernel/file_systems/nfs4/MetadataCache.h       |   13 ++-
src/add-ons/kernel/file_systems/nfs4/NFS4Inode.cpp |   22 ++++-
src/add-ons/kernel/file_systems/nfs4/NFS4Inode.h   |    2 +-
.../kernel/file_systems/nfs4/RPCCallbackServer.cpp |   13 ++-
.../kernel/file_systems/nfs4/RPCCallbackServer.h   |    2 +

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

Commit:      49935f9b4f55bfad77098bf6e2652c8163760bd6

Author:      Pawel Dziepak <pdziepak@xxxxxxxxxxx>
Date:        Mon Aug  6 22:22:34 2012 UTC

nfs4: Check if user is allowed to use open state

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

diff --git a/src/add-ons/kernel/file_systems/nfs4/Inode.cpp 
b/src/add-ons/kernel/file_systems/nfs4/Inode.cpp
index 1121a6e..c86d104 100644
--- a/src/add-ons/kernel/file_systems/nfs4/Inode.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/Inode.cpp
@@ -805,13 +805,20 @@ Inode::ReturnDelegation(bool truncate)
 
        MutexLocker stateLocker(fStateLock);
        fOpenState->fDelegation = NULL;
+       ReleaseOpenState();
+
+       delete fDelegation;
+       fDelegation = NULL;
+}
+
+
+void
+Inode::ReleaseOpenState()
+{
        if (fOpenState->ReleaseReference() == 1) {
                fFileSystem->RemoveOpenFile(fOpenState);
                fOpenState = NULL;
        }
-
-       delete fDelegation;
-       fDelegation = NULL;
 }
 
 
diff --git a/src/add-ons/kernel/file_systems/nfs4/Inode.h 
b/src/add-ons/kernel/file_systems/nfs4/Inode.h
index 6dce7ba..b30f33f 100644
--- a/src/add-ons/kernel/file_systems/nfs4/Inode.h
+++ b/src/add-ons/kernel/file_systems/nfs4/Inode.h
@@ -93,6 +93,8 @@ public:
 protected:
                                                                Inode();
 
+                                       void            ReleaseOpenState();
+
                                        status_t        CreateState(const char* 
name, int mode,
                                                                        int 
perms, OpenState* state,
                                                                        
OpenDelegationData* data);
diff --git a/src/add-ons/kernel/file_systems/nfs4/InodeRegular.cpp 
b/src/add-ons/kernel/file_systems/nfs4/InodeRegular.cpp
index a4dcd76..a4f6967 100644
--- a/src/add-ons/kernel/file_systems/nfs4/InodeRegular.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/InodeRegular.cpp
@@ -130,13 +130,24 @@ Inode::Open(int mode, OpenFileCookie* cookie)
                        status_t result = OpenFile(fOpenState, O_RDWR, &data);
                        if (result != B_OK) {
                                locker.Lock();
-                               if (fOpenState->ReleaseReference() == 1) {
-                                       fFileSystem->RemoveOpenFile(fOpenState);
-                                       fOpenState = NULL;
-                               }
+                               ReleaseOpenState();
                                return result;
                        }
                        fOpenState->fMode = O_RDWR;
+               } else {
+                       int newMode = mode & O_RWMASK;
+                       uint32 allowed = 0;
+                       if (newMode == O_RDWR || newMode == O_RDONLY)
+                               allowed |= R_OK;
+                       if (newMode == O_RDWR || newMode == O_WRONLY)
+                               allowed |= W_OK;
+
+                       status_t result = Access(allowed);
+                       if (result != B_OK) {
+                               locker.Lock();
+                               ReleaseOpenState();
+                               return result;
+                       }
                }
        }
 
@@ -173,12 +184,7 @@ Inode::Close(OpenFileCookie* cookie)
        SyncAndCommit();
 
        MutexLocker _(fStateLock);
-       if (cookie->fOpenState != NULL) {
-               if (cookie->fOpenState->ReleaseReference() == 1) {
-                       fFileSystem->RemoveOpenFile(fOpenState);
-                       fOpenState = NULL;
-               }
-       }
+       ReleaseOpenState();
 
        return B_OK;
 }

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

Commit:      d8e2263f3b34a3ed39fdf96f96197e61abe3b3ad

Author:      Pawel Dziepak <pdziepak@xxxxxxxxxxx>
Date:        Mon Aug  6 22:56:15 2012 UTC

nfs4: Fix callback connection closing

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

diff --git a/src/add-ons/kernel/file_systems/nfs4/Connection.cpp 
b/src/add-ons/kernel/file_systems/nfs4/Connection.cpp
index 322ef47..cc4611b 100644
--- a/src/add-ons/kernel/file_systems/nfs4/Connection.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/Connection.cpp
@@ -163,7 +163,7 @@ ServerAddress::InAddr() const
 status_t
 ServerAddress::ResolveName(const char* name, ServerAddress* address)
 {
-       address->fProtocol = IPPROTO_UDP;
+       address->fProtocol = IPPROTO_TCP;
 
        // getaddrinfo() is very expensive when called from kernel, so we do not
        // want to call it unless there is no other choice.
diff --git a/src/add-ons/kernel/file_systems/nfs4/RPCCallbackServer.cpp 
b/src/add-ons/kernel/file_systems/nfs4/RPCCallbackServer.cpp
index 54fd3d3..4039c08 100644
--- a/src/add-ons/kernel/file_systems/nfs4/RPCCallbackServer.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/RPCCallbackServer.cpp
@@ -143,6 +143,10 @@ CallbackServer::StopServer()
                ConnectionEntry* entry = fConnectionList;
                fConnectionList = entry->fNext;
                entry->fConnection->Disconnect();
+
+               status_t result;
+               wait_for_thread(entry->fThread, &result);
+
                delete entry->fConnection;
                delete entry;
        }
@@ -163,6 +167,8 @@ CallbackServer::NewConnection(Connection* connection)
 
        MutexLocker locker(fConnectionLock);
        entry->fNext = fConnectionList;
+       if (fConnectionList != NULL)
+               fConnectionList->fPrev = entry;
        fConnectionList = entry;
        locker.Unlock();
 
@@ -177,13 +183,17 @@ CallbackServer::NewConnection(Connection* connection)
        thread = spawn_kernel_thread(&CallbackServer::ConnectionThreadLauncher,
                "NFSv4 Callback Connection", B_NORMAL_PRIORITY, arguments);
        if (thread < B_OK) {
+               ReleaseConnection(entry);
                free(arguments);
                return thread;
        }
 
+       entry->fThread = thread;
+
        status_t result = resume_thread(thread);
        if (result != B_OK) {
                kill_thread(thread);
+               ReleaseConnection(entry);
                free(arguments);
                return result;
        }
@@ -232,7 +242,8 @@ CallbackServer::ConnectionThread(ConnectionEntry* entry)
                void* buffer;
                status_t result = connection->Receive(&buffer, &size);
                if (result != B_OK) {
-                       ReleaseConnection(entry);
+                       if (result != ECONNABORTED)
+                               ReleaseConnection(entry);
                        return result;
                }
 
diff --git a/src/add-ons/kernel/file_systems/nfs4/RPCCallbackServer.h 
b/src/add-ons/kernel/file_systems/nfs4/RPCCallbackServer.h
index 9b22f20..d114c65 100644
--- a/src/add-ons/kernel/file_systems/nfs4/RPCCallbackServer.h
+++ b/src/add-ons/kernel/file_systems/nfs4/RPCCallbackServer.h
@@ -20,6 +20,8 @@ class Callback;
 
 struct ConnectionEntry {
        Connection*                     fConnection;
+       thread_id                       fThread;
+
        ConnectionEntry*        fNext;
        ConnectionEntry*        fPrev;
 };

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

Commit:      3ae5e813c43fe9602bbc5a06ee3821887f9e17cb

Author:      Pawel Dziepak <pdziepak@xxxxxxxxxxx>
Date:        Wed Aug  8 01:48:35 2012 UTC

nfs4: Implement node monitoring

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

diff --git a/src/add-ons/kernel/file_systems/nfs4/DirectoryCache.cpp 
b/src/add-ons/kernel/file_systems/nfs4/DirectoryCache.cpp
index dbb10f0..2e57166 100644
--- a/src/add-ons/kernel/file_systems/nfs4/DirectoryCache.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/DirectoryCache.cpp
@@ -175,7 +175,77 @@ DirectoryCache::Revalidate()
                return B_OK;
        }
 
+       DirectoryCacheSnapshot* oldSnapshot = fDirectoryCache;
+       oldSnapshot->AcquireReference();
+
        Trash();
-       return B_ERROR;
+
+       DirectoryCacheSnapshot* newSnapshot;
+       status_t result = fInode->GetDirSnapshot(&newSnapshot, NULL, &fChange);
+       if (result != B_OK) {
+               oldSnapshot->ReleaseReference();
+               return B_OK;
+       }
+       newSnapshot->AcquireReference();
+
+       SetSnapshot(newSnapshot);
+       fExpireTime = system_time() + kExpirationTime;
+       fTrashed = false;
+
+       NotifyChanges(oldSnapshot, newSnapshot);
+       oldSnapshot->ReleaseReference();
+       newSnapshot->ReleaseReference();
+
+       return B_OK;
+}
+
+
+void
+DirectoryCache::NotifyChanges(DirectoryCacheSnapshot* oldSnapshot,
+       DirectoryCacheSnapshot* newSnapshot)
+{
+       MutexLocker _(newSnapshot->fLock);
+
+       SinglyLinkedList<NameCacheEntry>::Iterator oldIt
+               = oldSnapshot->fEntries.GetIterator();
+       NameCacheEntry* oldCurrent;
+
+       SinglyLinkedList<NameCacheEntry>::Iterator newIt
+               = newSnapshot->fEntries.GetIterator();
+       NameCacheEntry* newCurrent = newIt.Next();
+       while (newCurrent != NULL) {
+               oldIt = oldSnapshot->fEntries.GetIterator();
+               oldCurrent = oldIt.Next();
+
+               bool found = false;
+               NameCacheEntry* prev = NULL;
+               while (oldCurrent != NULL) {
+                       if (oldCurrent->fNode == newCurrent->fNode &&
+                               strcmp(oldCurrent->fName, newCurrent->fName) == 
0) {
+                               found = true;
+                               break;
+                       }
+
+                       prev = oldCurrent;
+                       oldCurrent = oldIt.Next();
+               }
+
+               if (!found) {
+                       notify_entry_created(fInode->GetFileSystem()->DevId(),
+                               fInode->ID(), newCurrent->fName, 
newCurrent->fNode);
+               } else
+                       oldSnapshot->fEntries.Remove(prev, oldCurrent);
+
+               newCurrent = newIt.Next();
+       }
+
+       oldIt = oldSnapshot->fEntries.GetIterator();
+       oldCurrent = oldIt.Next();
+
+       while (oldCurrent != NULL) {
+               notify_entry_removed(fInode->GetFileSystem()->DevId(), 
fInode->ID(),
+                       oldCurrent->fName, oldCurrent->fNode);
+               oldCurrent = oldIt.Next();
+       }
 }
 
diff --git a/src/add-ons/kernel/file_systems/nfs4/DirectoryCache.h 
b/src/add-ons/kernel/file_systems/nfs4/DirectoryCache.h
index e558b16..3f22e47 100644
--- a/src/add-ons/kernel/file_systems/nfs4/DirectoryCache.h
+++ b/src/add-ons/kernel/file_systems/nfs4/DirectoryCache.h
@@ -65,6 +65,10 @@ public:
        inline  time_t                  ExpireTime();
 
        static  const bigtime_t kExpirationTime         = 15000000;
+protected:
+                       void                    
NotifyChanges(DirectoryCacheSnapshot* oldSnapshot,
+                                                               
DirectoryCacheSnapshot* newSnapshot);
+
 private:
                        SinglyLinkedList<NameCacheEntry>        fNameCache;
 
diff --git a/src/add-ons/kernel/file_systems/nfs4/Inode.cpp 
b/src/add-ons/kernel/file_systems/nfs4/Inode.cpp
index c86d104..be97c45 100644
--- a/src/add-ons/kernel/file_systems/nfs4/Inode.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/Inode.cpp
@@ -22,6 +22,7 @@
 
 Inode::Inode()
        :
+       fMetaCache(this),
        fCache(NULL),
        fDelegation(NULL),
        fFileCache(NULL),
@@ -248,6 +249,8 @@ Inode::Link(Inode* dir, const char* name)
                dir->fCache->Unlock();
        }
 
+       notify_entry_created(fFileSystem->DevId(), dir->ID(), name, ID());
+
        return B_OK;
 }
 
@@ -256,7 +259,8 @@ status_t
 Inode::Remove(const char* name, FileType type)
 {
        ChangeInfo changeInfo;
-       status_t result = NFS4Inode::RemoveObject(name, type, &changeInfo);
+       uint64 fileID;
+       status_t result = NFS4Inode::RemoveObject(name, type, &changeInfo, 
&fileID);
        if (result != B_OK)
                return result;
 
@@ -272,6 +276,9 @@ Inode::Remove(const char* name, FileType type)
 
        fFileSystem->Root()->MakeInfoInvalid();
 
+       notify_entry_removed(fFileSystem->DevId(), ID(), name,
+               FileIdToInoT(fileID));
+
        return B_OK;
 }
 
@@ -311,6 +318,9 @@ Inode::Rename(Inode* from, Inode* to, const char* fromName, 
const char* toName)
                to->fCache->Unlock();
        }
 
+       notify_entry_moved(from->fFileSystem->DevId(), from->ID(), fromName,
+               to->ID(), toName, FileIdToInoT(fileID));
+
        return B_OK;
 }
 
@@ -349,6 +359,9 @@ Inode::CreateObject(const char* name, const char* path, int 
mode, FileType type)
                fCache->Unlock();
        }
 
+       notify_entry_created(fFileSystem->DevId(), ID(), name,
+               FileIdToInoT(fileID));
+
        return B_OK;
 }
 
diff --git a/src/add-ons/kernel/file_systems/nfs4/Inode.h 
b/src/add-ons/kernel/file_systems/nfs4/Inode.h
index b30f33f..35dc4d8 100644
--- a/src/add-ons/kernel/file_systems/nfs4/Inode.h
+++ b/src/add-ons/kernel/file_systems/nfs4/Inode.h
@@ -90,6 +90,10 @@ public:
                                                                        const 
struct flock* lock);
                                        status_t        
ReleaseAllLocks(OpenFileCookie* cookie);
 
+                                       status_t        
GetDirSnapshot(DirectoryCacheSnapshot**
+                                                                       
_snapshot, OpenDirCookie* cookie,
+                                                                       uint64* 
_change);
+
 protected:
                                                                Inode();
 
@@ -105,9 +109,6 @@ protected:
                                                                        uint32 
size);
                                        status_t        FillDirEntry(struct 
dirent* de, ino_t id,
                                                                        const 
char* name, uint32 pos, uint32 size);
-                                       status_t        
GetDirSnapshot(DirectoryCacheSnapshot**
-                                                                       
_snapshot, OpenDirCookie* cookie,
-                                                                       uint64* 
_change);
 
                                        status_t        ChildAdded(const char* 
name, uint64 fileID,
                                                                        const 
FileHandle& fileHandle);
diff --git a/src/add-ons/kernel/file_systems/nfs4/InodeRegular.cpp 
b/src/add-ons/kernel/file_systems/nfs4/InodeRegular.cpp
index a4f6967..7bad21a 100644
--- a/src/add-ons/kernel/file_systems/nfs4/InodeRegular.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/InodeRegular.cpp
@@ -90,6 +90,8 @@ Inode::Create(const char* name, int mode, int perms, 
OpenFileCookie* cookie,
        fFileSystem->AddOpenFile(state);
        fFileSystem->Root()->MakeInfoInvalid();
 
+       notify_entry_created(fFileSystem->DevId(), ID(), name, *id);
+
        return B_OK;
 }
 
diff --git a/src/add-ons/kernel/file_systems/nfs4/MetadataCache.cpp 
b/src/add-ons/kernel/file_systems/nfs4/MetadataCache.cpp
index 058ce24..901021c 100644
--- a/src/add-ons/kernel/file_systems/nfs4/MetadataCache.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/MetadataCache.cpp
@@ -9,11 +9,17 @@
 
 #include "MetadataCache.h"
 
+#include <NodeMonitor.h>
 
-MetadataCache::MetadataCache()
+#include "Inode.h"
+
+
+MetadataCache::MetadataCache(Inode* inode)
        :
        fExpire(0),
-       fForceValid(false)
+       fForceValid(false),
+       fInode(inode),
+       fInited(false)
 {
        mutex_init(&fLock, NULL);
 }
@@ -52,8 +58,12 @@ void
 MetadataCache::SetStat(const struct stat& st)
 {
        MutexLocker _(fLock);
+       if (fInited)
+               NotifyChanges(&fStatCache, &st);
+
        fStatCache = st;
        fExpire = time(NULL) + kExpirationTime;
+       fInited = true;
 }
 
 
@@ -121,3 +131,35 @@ MetadataCache::UnlockValid()
 }
 
 
+void
+MetadataCache::NotifyChanges(const struct stat* oldStat,
+       const struct stat* newStat)
+{
+       uint32 flags = 0;
+       if (oldStat->st_size != newStat->st_size)
+               flags |= B_STAT_SIZE;
+       if (oldStat->st_mode != newStat->st_mode)
+               flags |= B_STAT_MODE;
+       if (oldStat->st_uid != newStat->st_uid)
+               flags |= B_STAT_UID;
+       if (oldStat->st_gid != newStat->st_gid)
+               flags |= B_STAT_GID;
+
+       if (memcmp(&oldStat->st_atim, &newStat->st_atim,
+               sizeof(struct timespec) == 0))
+               flags |= B_STAT_ACCESS_TIME;
+
+       if (memcmp(&oldStat->st_ctim, &newStat->st_ctim,
+               sizeof(struct timespec) == 0))
+               flags |= B_STAT_CHANGE_TIME;
+
+       if (memcmp(&oldStat->st_crtim, &newStat->st_crtim,
+               sizeof(struct timespec) == 0))
+               flags |= B_STAT_CREATION_TIME;
+
+       if (memcmp(&oldStat->st_mtim, &newStat->st_mtim,
+               sizeof(struct timespec) == 0))
+               flags |= B_STAT_MODIFICATION_TIME;
+
+       notify_stat_changed(fInode->GetFileSystem()->DevId(), fInode->ID(), 
flags);
+}
diff --git a/src/add-ons/kernel/file_systems/nfs4/MetadataCache.h 
b/src/add-ons/kernel/file_systems/nfs4/MetadataCache.h
index 4622c9e..26a5e97 100644
--- a/src/add-ons/kernel/file_systems/nfs4/MetadataCache.h
+++ b/src/add-ons/kernel/file_systems/nfs4/MetadataCache.h
@@ -9,12 +9,15 @@
 #define METADATACACHE_H
 
 
+#include <fs_interface.h>
 #include <lock.h>
 #include <SupportDefs.h>
 #include <util/AutoLock.h>
 #include <util/AVLTreeMap.h>
 
 
+class Inode;
+
 struct AccessEntry {
        time_t  fExpire;
        uint32  fAllowed;
@@ -22,7 +25,7 @@ struct AccessEntry {
 
 class MetadataCache {
 public:
-                                                               MetadataCache();
+                                                               
MetadataCache(Inode* inode);
                                                                
~MetadataCache();
 
                                        status_t        GetStat(struct stat* 
st);
@@ -41,11 +44,19 @@ public:
        inline                  void            Invalidate();
 
        static const    time_t          kExpirationTime = 60;
+
+protected:
+                                       void            NotifyChanges(const 
struct stat* oldStat,
+                                                                       const 
struct stat* newStat);
+
 private:
                                        struct stat     fStatCache;
                                        time_t          fExpire;
                                        bool            fForceValid;
 
+                                       Inode*          fInode;
+                                       bool            fInited;
+
                                        AVLTreeMap<uid_t, AccessEntry>  
fAccessCache;
 
                                        mutex           fLock;
diff --git a/src/add-ons/kernel/file_systems/nfs4/NFS4Inode.cpp 
b/src/add-ons/kernel/file_systems/nfs4/NFS4Inode.cpp
index a424350..24bb38d 100644
--- a/src/add-ons/kernel/file_systems/nfs4/NFS4Inode.cpp
+++ b/src/add-ons/kernel/file_systems/nfs4/NFS4Inode.cpp
@@ -736,7 +736,8 @@ NFS4Inode::CreateObject(const char* name, const char* path, 
int mode,
 
 
 status_t
-NFS4Inode::RemoveObject(const char* name, FileType type, ChangeInfo* 
changeInfo)
+NFS4Inode::RemoveObject(const char* name, FileType type, ChangeInfo* 
changeInfo,
+       uint64* fileID)
 {
        do {
                RPC::Server* serv = fFileSystem->Server();
@@ -755,6 +756,10 @@ NFS4Inode::RemoveObject(const char* name, FileType type, 
ChangeInfo* changeInfo)
                        req.Nverify(&attr, 1);
 
                req.PutFH(fInfo.fHandle);
+
+               Attribute idAttr[] = { FATTR4_FILEID };
+               req.GetAttr(idAttr, sizeof(idAttr) / sizeof(Attribute));
+
                req.Remove(name);
 
                status_t result = request.Send();
@@ -785,6 +790,18 @@ NFS4Inode::RemoveObject(const char* name, FileType type, 
ChangeInfo* changeInfo)
 
                reply.PutFH();
 
+               AttrValue* values;
+               uint32 count;
+               result = reply.GetAttr(&values, &count);
+               if (result != B_OK)
+                       return result;
+
+               if (count == 0)
+                       *fileID = fFileSystem->AllocFileId();
+               else
+                       *fileID = values[0].fData.fValue64;
+               delete[] values;
+
                return reply.Remove(&changeInfo->fBefore, &changeInfo->fAfter,
                        changeInfo->fAtomic);
        } while (true);
@@ -831,8 +848,7 @@ NFS4Inode::ReadDirOnce(DirEntry** dirents, uint32* count, 
OpenDirCookie* cookie,
                                return result;
                }
 
-               result = reply.ReadDir(dirCookie, dirCookieVerf, dirents,
-                       count, eof);
+               result = reply.ReadDir(dirCookie, dirCookieVerf, dirents, 
count, eof);
                if (result != B_OK) {
                        delete[] before;
                        return result;
diff --git a/src/add-ons/kernel/file_systems/nfs4/NFS4Inode.h 
b/src/add-ons/kernel/file_systems/nfs4/NFS4Inode.h
index 3e1bedb..f340a42 100644
--- a/src/add-ons/kernel/file_systems/nfs4/NFS4Inode.h
+++ b/src/add-ons/kernel/file_systems/nfs4/NFS4Inode.h
@@ -62,7 +62,7 @@ protected:
                                                        int mode, FileType 
type, ChangeInfo* changeInfo,
                                                        uint64* fileID, 
FileHandle* handle);
                        status_t        RemoveObject(const char* name, FileType 
type,
-                                                       ChangeInfo* changeInfo);
+                                                       ChangeInfo* changeInfo, 
uint64* fileID);
 
                        status_t        ReadDirOnce(DirEntry** dirents, uint32* 
count,
                                                        OpenDirCookie* cookie, 
bool* eof, uint64* change,


Other related posts: