Fix DeadLock in Kernel List Cache Feature

internal/fs/fs.go

@@ -2154,10 +2154,16 @@ func (fs *fileSystem) OpenDir(
 
 	// Enables kernel list-cache in case of non-zero kernelListCacheTTL.
 	if fs.kernelListCacheTTL > 0 {
+		// Following lock ordering rules: first taking dirInode.RLock() and then fs.lock().
+		fs.mu.Unlock()
 
 		// Taking RLock() since ShouldInvalidateKernelListCache only reads the DirInode
 		// properties, no modification.
 		in.RLock()
+
+		// Acquiring fs lock to use common defer function.
+		fs.mu.Lock()
+
 		// Invalidates the kernel list-cache once the last cached response is out of
 		// kernelListCacheTTL.
 		op.KeepCache = !in.ShouldInvalidateKernelListCache(fs.kernelListCacheTTL)

internal/fs/kernel_list_cache_test.go

@@ -26,6 +26,7 @@ package fs_test
 import (
 	"os"
 	"path"
+	"sync"
 	"testing"
 	"time"
 
@@ -120,6 +121,45 @@ func TestKernelListCacheTestWithPositiveTtlSuite(t *testing.T) {
 	suite.Run(t, new(KernelListCacheTestWithPositiveTtl))
 }
 
+// Test_Parallel_OpenDirAndLookUpInode helps in detecting the deadlock when
+// OpenDir() and LookUpInode() request for same directory comes in parallel.
+func (t *KernelListCacheTestWithPositiveTtl) Test_Parallel_OpenDirAndLookUpInode() {
+	var wg sync.WaitGroup
+	wg.Add(2)
+	// Fail if the operation takes more than timeout.
+	timeout := 5 * time.Second
+
+	go func() {
+		defer wg.Done()
+		for i := 0; i < 100; i++ {
+			f, err := os.Open(path.Join(mntDir, "explicitDir"))
+			assert.Nil(t.T(), err)
+
+			err = f.Close()
+			assert.Nil(t.T(), err)
+		}
+	}()
+	go func() {
+		defer wg.Done()
+		for i := 0; i < 100; i++ {
+			_, err := os.Stat(path.Join(mntDir, "explicitDir"))
+			assert.Nil(t.T(), err)
+		}
+	}()
+
+	done := make(chan bool, 1)
+	go func() {
+		wg.Wait()
+		done <- true
+	}()
+	select {
+	case <-done:
+		// Operation completed successfully before timeout.
+	case <-time.After(timeout):
+		assert.FailNow(t.T(), "Possible deadlock")
+	}
+}
+
 // (a) First ReadDir() will be served from GCSFuse filesystem.
 // (b) Second ReadDir() within ttl will be served from kernel page cache.
 func (t *KernelListCacheTestWithPositiveTtl) TestKernelListCache_CacheHit() {