func (fs *flushFS) LookUpInode(
op *fuseops.LookUpInodeOp) (err error) {
fs.mu.Lock()
defer fs.mu.Unlock()
// Sanity check.
if op.Parent != fuseops.RootInodeID {
err = fuse.ENOENT
return
}
// Set up the entry.
switch op.Name {
case "foo":
op.Entry = fuseops.ChildInodeEntry{
Child: fooID,
Attributes: fs.fooAttributes(),
}
case "bar":
op.Entry = fuseops.ChildInodeEntry{
Child: barID,
Attributes: fs.barAttributes(),
}
default:
err = fuse.ENOENT
return
}
return
}
func (fs *fsImpl) LookUpInode(
ctx context.Context,
op *fuseops.LookUpInodeOp) (err error) {
fs.mu.Lock()
defer fs.mu.Unlock()
// Make sure the parent exists and has not been forgotten.
_ = fs.findInodeByID(op.Parent)
// Handle the names we support.
var childID fuseops.InodeID
switch {
case op.Parent == cannedID_Root && op.Name == "foo":
childID = cannedID_Foo
case op.Parent == cannedID_Root && op.Name == "bar":
childID = cannedID_Bar
default:
err = fuse.ENOENT
return
}
// Look up the child.
child := fs.findInodeByID(childID)
child.IncrementLookupCount()
// Return an appropriate entry.
op.Entry = fuseops.ChildInodeEntry{
Child: childID,
Attributes: child.attributes,
}
return
}
// LOCKS_EXCLUDED(fs.mu)
func (fs *fileSystem) LookUpInode(
op *fuseops.LookUpInodeOp) (err error) {
// Find the parent directory in question.
fs.mu.Lock()
parent := fs.inodes[op.Parent].(inode.DirInode)
fs.mu.Unlock()
// Find or create the child inode.
child, err := fs.lookUpOrCreateChildInode(op.Context(), parent, op.Name)
if err != nil {
return
}
defer fs.unlockAndMaybeDisposeOfInode(child, &err)
// Fill out the response.
op.Entry.Child = child.ID()
if op.Entry.Attributes, err = child.Attributes(op.Context()); err != nil {
return
}
return
}
func (s *GoofysTest) TestRenameCache(t *C) {
root := s.getRoot(t)
s.fs.flags.StatCacheTTL = 60 * 1000 * 1000 * 1000
lookupOp1 := fuseops.LookUpInodeOp{
Parent: root.Id,
Name: "file1",
}
lookupOp2 := lookupOp1
lookupOp2.Name = "newfile"
err := s.fs.LookUpInode(nil, &lookupOp1)
t.Assert(err, IsNil)
err = s.fs.LookUpInode(nil, &lookupOp2)
t.Assert(err, Equals, fuse.ENOENT)
renameOp := fuseops.RenameOp{
OldParent: root.Id,
NewParent: root.Id,
OldName: "file1",
NewName: "newfile",
}
err = s.fs.Rename(nil, &renameOp)
t.Assert(err, IsNil)
lookupOp1.Entry = fuseops.ChildInodeEntry{}
lookupOp2.Entry = fuseops.ChildInodeEntry{}
err = s.fs.LookUpInode(nil, &lookupOp1)
t.Assert(err, Equals, fuse.ENOENT)
err = s.fs.LookUpInode(nil, &lookupOp2)
t.Assert(err, IsNil)
}