From 2688d6dfb7bb8c9916bd2bbb57e7a7ef2df2bdc3 Mon Sep 17 00:00:00 2001
From: Vitaliy Filippov <vitalif@yourcmc.ru>
Date: Wed, 31 May 2023 12:27:10 +0300
Subject: [PATCH] Move LookUpCached to dir.go

---
 internal/dir.go    | 60 ++++++++++++++++++++++++++++++++++++++++++++
 internal/goofys.go | 62 +++-------------------------------------------
 2 files changed, 64 insertions(+), 58 deletions(-)

diff --git a/internal/dir.go b/internal/dir.go
index 24350f68..568f79ad 100644
--- a/internal/dir.go
+++ b/internal/dir.go
@@ -1711,6 +1711,66 @@ func (parent *Inode) findChildMaxTime() (maxMtime, maxCtime time.Time) {
 	return
 }
 
+func (parent *Inode) LookUpCached(name string) (inode *Inode, err error) {
+	parent.mu.Lock()
+	ok := false
+	inode = parent.findChildUnlocked(name)
+	if inode != nil {
+		ok = true
+		if expired(inode.AttrTime, parent.fs.flags.StatCacheTTL) {
+			ok = false
+			if inode.CacheState != ST_CACHED ||
+				inode.isDir() && atomic.LoadInt64(&inode.dir.ModifiedChildren) > 0 {
+				// we have an open file handle, object
+				// in S3 may not represent the true
+				// state of the file anyway, so just
+				// return what we know which is
+				// potentially more accurate
+				ok = true
+			} else {
+				inode.logFuse("lookup expired")
+			}
+		}
+	} else {
+		ok = false
+		if parent.dir.DeletedChildren != nil {
+			if _, ok := parent.dir.DeletedChildren[name]; ok {
+				// File is deleted locally
+				parent.mu.Unlock()
+				return nil, syscall.ENOENT
+			}
+		}
+		if !expired(parent.dir.DirTime, parent.fs.flags.StatCacheTTL) {
+			// Don't recheck from the server if directory cache is actual
+			parent.mu.Unlock()
+			return nil, syscall.ENOENT
+		}
+	}
+	parent.mu.Unlock()
+	if !ok {
+		inode, err = parent.recheckInode(inode, name)
+		err = mapAwsError(err)
+		if err != nil {
+			return nil, err
+		}
+		if inode == nil {
+			return nil, syscall.ENOENT
+		}
+	}
+	return inode, nil
+}
+
+func (parent *Inode) recheckInode(inode *Inode, name string) (newInode *Inode, err error) {
+	newInode, err = parent.LookUp(name, inode == nil)
+	if err != nil {
+		if inode != nil {
+			parent.removeChild(inode)
+		}
+		return nil, err
+	}
+	return newInode, nil
+}
+
 func (parent *Inode) LookUp(name string, doSlurp bool) (*Inode, error) {
 	_, parentKey := parent.cloud()
 	key := appendChildName(parentKey, name)
diff --git a/internal/goofys.go b/internal/goofys.go
index b0ba29c9..a7f88ed7 100644
--- a/internal/goofys.go
+++ b/internal/goofys.go
@@ -808,7 +808,7 @@ func (fs *Goofys) RefreshInodeCache(inode *Inode) error {
 		}
 		return mappedErr
 	}
-	inode, err := fs.recheckInode(parent, inode, name)
+	inode, err := parent.recheckInode(inode, name)
 	mappedErr = mapAwsError(err)
 	if fs.connection != nil {
 		// Send notifications from another goroutine to prevent deadlocks
@@ -1127,58 +1127,15 @@ func (fs *Goofys) LookUpInode(
 
 	atomic.AddInt64(&fs.stats.metadataReads, 1)
 
-	var inode *Inode
-	var ok bool
 	defer func() { fuseLog.Debugf("<-- LookUpInode %v %v %v", op.Parent, op.Name, err) }()
 
 	fs.mu.RLock()
 	parent := fs.getInodeOrDie(op.Parent)
 	fs.mu.RUnlock()
 
-	parent.mu.Lock()
-	inode = parent.findChildUnlocked(op.Name)
-	if inode != nil {
-		ok = true
-		if expired(inode.AttrTime, fs.flags.StatCacheTTL) {
-			ok = false
-			if inode.CacheState != ST_CACHED ||
-				inode.isDir() && atomic.LoadInt64(&inode.dir.ModifiedChildren) > 0 {
-				// we have an open file handle, object
-				// in S3 may not represent the true
-				// state of the file anyway, so just
-				// return what we know which is
-				// potentially more accurate
-				ok = true
-			} else {
-				inode.logFuse("lookup expired")
-			}
-		}
-	} else {
-		ok = false
-		if parent.dir.DeletedChildren != nil {
-			if _, ok := parent.dir.DeletedChildren[op.Name]; ok {
-				// File is deleted locally
-				parent.mu.Unlock()
-				return syscall.ENOENT
-			}
-		}
-		if !expired(parent.dir.DirTime, fs.flags.StatCacheTTL) {
-			// Don't recheck from the server if directory cache is actual
-			parent.mu.Unlock()
-			return syscall.ENOENT
-		}
-	}
-	parent.mu.Unlock()
-
-	if !ok {
-		inode, err = fs.recheckInode(parent, inode, op.Name)
-		err = mapAwsError(err)
-		if err != nil {
-			return
-		}
-		if inode == nil {
-			return syscall.ENOENT
-		}
+	inode, err := parent.LookUpCached(op.Name)
+	if err != nil {
+		return err
 	}
 
 	inode.Ref()
@@ -1190,17 +1147,6 @@ func (fs *Goofys) LookUpInode(
 	return
 }
 
-func (fs *Goofys) recheckInode(parent *Inode, inode *Inode, name string) (newInode *Inode, err error) {
-	newInode, err = parent.LookUp(name, inode == nil)
-	if err != nil {
-		if inode != nil {
-			parent.removeChild(inode)
-		}
-		return nil, err
-	}
-	return newInode, nil
-}
-
 // LOCKS_REQUIRED(parent.mu)
 // LOCKS_EXCLUDED(fs.mu)
 func (fs *Goofys) insertInode(parent *Inode, inode *Inode) {