add notify_inval_inode and extend get_rootfs to return fs_idx for unmount

- Add notify_inval_inode method to fusedev to explicitly invalidate inode caches
  in the kernel, ensuring cache coherence when backend files change outside guest VFS.

- Extend get_rootfs to return both Arc<BackFileSystem> and u8 fs_idx.
  This is necessary for correct unmount handling and cache invalidation.

The implementation follows fuse kernel and libfuse protocols and maintains
compatibility with existing patterns like notify_inval_entry.

Signed-off-by: sidneychang <[email protected]>

Author: sidneychang

src/api/server/sync_io.rs

@@ -57,7 +57,36 @@ impl<F: FileSystem + Sync> Server<F> {
             .map_err(Error::FailedToWrite)?;
         buffer_writer.commit(None).map_err(Error::InvalidMessage)
     }
+    /// Notify the kernel that an inode's data has been invalidated.
+    #[cfg(feature = "fusedev")]
+    pub fn notify_inval_inode<S: BitmapSlice>(
+        &self,
+        mut w: FuseDevWriter<'_, S>,
+        ino: u64,
+        off: u64,
+        len: u64,
+    ) -> Result<usize> {
+        let mut buffer_writer = w.split_at(0).map_err(Error::FailedToSplitWriter)?;
+        let mut header = OutHeader::default();
+        let mut inode = NotifyInvalInodeOut::default();
+
+        header.unique = 0;
+        header.error = NotifyOpcode::InvalInode as i32;
+        header.len = std::mem::size_of::<OutHeader>() as u32
+            + std::mem::size_of::<NotifyInvalInodeOut>() as u32;
 
+        inode.ino = ino;
+        inode.off = off as i64;
+        inode.len = len as i64;
+
+        buffer_writer
+            .write_obj(header)
+            .map_err(Error::FailedToWrite)?;
+        buffer_writer
+            .write_obj(inode)
+            .map_err(Error::FailedToWrite)?;
+        buffer_writer.commit(None).map_err(Error::InvalidMessage)
+    }
     #[cfg(feature = "fusedev")]
     /// Send a resend notification message to the kernel via FUSE. This function should be invoked as part of
     /// the crash recovery routine. Given that FUSE initialization does not occur again during recovery,

src/api/vfs/mod.rs

@@ -499,8 +499,8 @@ impl Vfs {
         Ok((inode, parent))
     }
 
-    /// Get the mounted backend file system alongside the path if there's one.
-    pub fn get_rootfs(&self, path: &str) -> VfsResult<Option<Arc<BackFileSystem>>> {
+    /// Get the mounted backend file system and its fs_idx alongside the path if there's one.
+    pub fn get_rootfs(&self, path: &str) -> VfsResult<Option<(Arc<BackFileSystem>, u8)>> {
         // Serialize mount operations. Do not expect poisoned lock here.
         let _guard = self.lock.lock().unwrap();
         let inode = match self.root.path_walk(path).map_err(VfsError::PathWalk)? {
@@ -509,9 +509,10 @@ impl Vfs {
         };
 
         if let Some(mnt) = self.mountpoints.load().get(&inode) {
-            Ok(Some(self.get_fs_by_idx(mnt.fs_idx).map_err(|e| {
-                VfsError::NotFound(format!("fs index {}, {:?}", mnt.fs_idx, e))
-            })?))
+            let fs = self
+                .get_fs_by_idx(mnt.fs_idx)
+                .map_err(|e| VfsError::NotFound(format!("fs index {}, {:?}", mnt.fs_idx, e)))?;
+            Ok(Some((fs, mnt.fs_idx)))
         } else {
             // Pseudo fs dir inode exists, but that no backend is ever mounted
             // is a normal case.