DragonOS-Community
diff --git a/‎kernel/src/filesystem/fuse/conn.rs‎
Lines changed: 7 additions & 0 deletions b/‎kernel/src/filesystem/fuse/conn.rs‎
Lines changed: 7 additions & 0 deletions
diff --git a/‎kernel/src/filesystem/fuse/inode.rs‎
Lines changed: 23 additions & 17 deletions b/‎kernel/src/filesystem/fuse/inode.rs‎
Lines changed: 23 additions & 17 deletions
@@ -1362,6 +1362,13 @@ impl FuseConn {
         !g.no_readdirplus && (g.init.flags & FUSE_DO_READDIRPLUS) != 0
     }
 
+    pub fn readdirplus_auto(&self) -> bool {
+        let g = self.inner.lock();
+        !g.no_readdirplus
+            && (g.init.flags & (FUSE_DO_READDIRPLUS | FUSE_READDIRPLUS_AUTO))
+                == (FUSE_DO_READDIRPLUS | FUSE_READDIRPLUS_AUTO)
+    }
+
     pub fn disable_readdirplus(&self) {
         let mut g = self.inner.lock();
         g.no_readdirplus = true;
 
@@ -8,8 +8,9 @@ use alloc::{
     sync::{Arc, Weak},
     vec::Vec,
 };
-use core::mem::size_of;
 use core::sync::atomic::{AtomicBool, AtomicU32, AtomicU64, AtomicUsize, Ordering};
+use core::{mem::size_of, num::NonZeroUsize};
+use lru::LruCache;
 
 use system_error::SystemError;
 
@@ -287,7 +288,11 @@ pub struct FuseNode {
     cached_metadata: Mutex<Option<Metadata>>,
     page_cache: Mutex<Option<Arc<PageCache>>>,
     writeback_handles: Mutex<Vec<Arc<FuseWritebackHandle>>>,
-    lookup_cache: Mutex<BTreeMap<String, FuseLookupCacheEntry>>,
+    lookup_cache: Mutex<LruCache<String, FuseLookupCacheEntry>>,
+    /// Linux FUSE_I_INIT_RDPLUS equivalent for the first cache use of a child.
+    readdirplus_init: AtomicBool,
+    /// Linux FUSE_I_ADVISE_RDPLUS equivalent for the next directory batch.
+    readdirplus_advised: AtomicBool,
     /// Serializes dirty-page admission against operations which must drain and
     /// invalidate the page cache (truncate and direct I/O).
     writeback_barrier: RwSem<()>,
@@ -330,6 +335,7 @@ struct FuseLookupCacheEntry {
 impl FuseNode {
     const FUSE_DIRENT_ALIGN: usize = 8;
     const LOOKUP_CACHE_MAX_ENTRIES: usize = 1024;
+    const LOOKUP_CACHE_PRUNE_BUDGET: usize = 64;
     const READDIR_BUFFER_SIZE: usize = 64 * 1024;
     const XATTR_SIZE_MAX: usize = 65536;
     const XATTR_LIST_MAX: usize = 65536;
@@ -370,7 +376,11 @@ impl FuseNode {
             cached_metadata: Mutex::new(cached),
             page_cache: Mutex::new(None),
             writeback_handles: Mutex::new(Vec::new()),
-            lookup_cache: Mutex::new(BTreeMap::new()),
+            lookup_cache: Mutex::new(LruCache::new(
+                NonZeroUsize::new(Self::LOOKUP_CACHE_MAX_ENTRIES).unwrap(),
+            )),
+            readdirplus_init: AtomicBool::new(false),
+            readdirplus_advised: AtomicBool::new(false),
             writeback_barrier: RwSem::new(()),
             dax_reclaim_serial: Mutex::new(()),
             dax_mappings: RwSem::new(DaxMappingTree::default()),
@@ -1174,10 +1184,6 @@ impl FuseNode {
         *self.name.lock() = Some(name.to_string());
     }
 
-    pub(crate) fn has_dname(&self, name: &str) -> bool {
-        self.name.lock().as_deref() == Some(name)
-    }
-
     pub(crate) fn clear_dname_if(&self, name: &str) {
         let mut dname = self.name.lock();
         if dname.as_deref() == Some(name) {
@@ -1374,21 +1380,21 @@ impl FuseNode {
         self.fs.upgrade()
     }
 
-    pub(crate) fn parent_fuse_nodeid(&self) -> u64 {
-        *self.parent_nodeid.lock()
-    }
-
     fn request_name(&self, opcode: u32, nodeid: u64, name: &str) -> Result<FuseReply, SystemError> {
-        self.check_not_stale()?;
-        let payload = Self::pack_name_payload(name);
-        self.conn().request(opcode, nodeid, &payload)
+        self.request_name_bytes(opcode, nodeid, name.as_bytes())
     }
 
-    fn pack_name_payload(name: &str) -> Vec<u8> {
+    fn request_name_bytes(
+        &self,
+        opcode: u32,
+        nodeid: u64,
+        name: &[u8],
+    ) -> Result<FuseReply, SystemError> {
+        self.check_not_stale()?;
         let mut payload = Vec::with_capacity(name.len() + 1);
-        payload.extend_from_slice(name.as_bytes());
+        payload.extend_from_slice(name);
         payload.push(0);
-        payload
+        self.conn().request(opcode, nodeid, &payload)
     }
 
     fn pack_struct_and_name_payload<T: Copy>(inarg: &T, name: &str) -> Vec<u8> {