api/vfs: ensure entry attr st_ino consistency

Whenever we convert an entry, make sure the returned attribute st_ino
field is updated as well. Otherwise entry.inode and entry.attr.st_ino
are not consistent and it might confuse the kernel.

Signed-off-by: Peng Tao <[email protected]>

Author: bergwolf

src/api/vfs/async_io.rs

@@ -26,8 +26,7 @@ impl AsyncFileSystem for Vfs {
                 // parent is in an underlying rootfs
                 let mut entry = fs.async_lookup(ctx, idata.ino(), name).await?;
                 // lookup success, hash it to a real fuse inode
-                entry.inode = self.convert_inode(idata.fs_idx(), entry.inode)?;
-                Ok(entry)
+                self.convert_entry(idata.fs_idx(), entry.inode, &mut entry)
             }
         }
     }
@@ -96,7 +95,7 @@ impl AsyncFileSystem for Vfs {
                 fs.async_create(ctx, idata.ino(), name, args)
                     .await
                     .map(|(mut a, b, c)| {
-                        a.inode = self.convert_inode(idata.fs_idx(), a.inode)?;
+                        self.convert_entry(idata.fs_idx(), a.inode, &mut a)?;
                         Ok((a, b, c))
                     })?
             }

src/api/vfs/mod.rs

@@ -322,7 +322,7 @@ impl Vfs {
         let inode = self.root.mount(path)?;
         let real_root_ino = entry.inode;
 
-        entry.inode = self.convert_inode(fs_idx, entry.inode)?;
+        self.convert_entry(fs_idx, entry.inode, &mut entry)?;
 
         // Over mount would invalidate previous superblock inodes.
         if let Some(mnt) = mountpoints.get(&inode) {
@@ -454,6 +454,14 @@ impl Vfs {
         Ok(ino)
     }
 
+    fn convert_entry(&self, fs_idx: VfsIndex, inode: u64, entry: &mut Entry) -> Result<Entry> {
+        self.convert_inode(fs_idx, inode).map(|ino| {
+            entry.inode = ino;
+            entry.attr.st_ino = ino;
+            *entry
+        })
+    }
+
     fn allocate_fs_idx(&self) -> Result<VfsIndex> {
         let superblocks = self.superblocks.load().deref().deref().clone();
         let start = self.next_super.load(Ordering::SeqCst);
@@ -528,20 +536,18 @@ impl Vfs {
             Some(mnt) => {
                 // cross mountpoint, return mount root entry
                 entry = mnt.root_entry;
-                entry.inode = self.convert_inode(mnt.fs_idx, mnt.ino)?;
-                entry.attr.st_ino = entry.inode;
+                self.convert_entry(mnt.fs_idx, mnt.ino, &mut entry)?;
                 trace!(
                     "vfs lookup cross mountpoint, return new mount fs_idx {} inode 0x{:x} fuse inode 0x{:x}, attr inode 0x{:x}",
                     mnt.fs_idx,
                     mnt.ino,
                     entry.inode,
                     entry.attr.st_ino,
                 );
+                Ok(entry)
             }
-            None => entry.inode = self.convert_inode(idata.fs_idx(), entry.inode)?,
+            None => self.convert_entry(idata.fs_idx(), entry.inode, &mut entry),
         }
-
-        Ok(entry)
     }
 }
 

src/api/vfs/sync_io.rs

@@ -79,10 +79,7 @@ impl FileSystem for Vfs {
                 // parent is in an underlying rootfs
                 let mut entry = fs.lookup(ctx, idata.ino(), name)?;
                 // lookup success, hash it to a real fuse inode
-                let new_ino = self.convert_inode(idata.fs_idx(), entry.inode)?;
-                entry.inode = new_ino;
-                entry.attr.st_ino = new_ino;
-                Ok(entry)
+                self.convert_entry(idata.fs_idx(), entry.inode, &mut entry)
             }
         }
     }
@@ -155,10 +152,9 @@ impl FileSystem for Vfs {
 
         match self.get_real_rootfs(parent)? {
             (Left(fs), idata) => fs.symlink(ctx, linkname, idata.ino(), name),
-            (Right(fs), idata) => fs.symlink(ctx, linkname, idata.ino(), name).map(|mut e| {
-                e.inode = self.convert_inode(idata.fs_idx(), e.inode)?;
-                Ok(e)
-            })?,
+            (Right(fs), idata) => fs
+                .symlink(ctx, linkname, idata.ino(), name)
+                .map(|mut e| self.convert_entry(idata.fs_idx(), e.inode, &mut e))?,
         }
     }
 
@@ -175,13 +171,9 @@ impl FileSystem for Vfs {
 
         match self.get_real_rootfs(inode)? {
             (Left(fs), idata) => fs.mknod(ctx, idata.ino(), name, mode, rdev, umask),
-            (Right(fs), idata) => {
-                fs.mknod(ctx, idata.ino(), name, mode, rdev, umask)
-                    .map(|mut e| {
-                        e.inode = self.convert_inode(idata.fs_idx(), e.inode)?;
-                        Ok(e)
-                    })?
-            }
+            (Right(fs), idata) => fs
+                .mknod(ctx, idata.ino(), name, mode, rdev, umask)
+                .map(|mut e| self.convert_entry(idata.fs_idx(), e.inode, &mut e))?,
         }
     }
 
@@ -197,10 +189,9 @@ impl FileSystem for Vfs {
 
         match self.get_real_rootfs(parent)? {
             (Left(fs), idata) => fs.mkdir(ctx, idata.ino(), name, mode, umask),
-            (Right(fs), idata) => fs.mkdir(ctx, idata.ino(), name, mode, umask).map(|mut e| {
-                e.inode = self.convert_inode(idata.fs_idx(), e.inode)?;
-                Ok(e)
-            })?,
+            (Right(fs), idata) => fs
+                .mkdir(ctx, idata.ino(), name, mode, umask)
+                .map(|mut e| self.convert_entry(idata.fs_idx(), e.inode, &mut e))?,
         }
     }
 
@@ -281,10 +272,7 @@ impl FileSystem for Vfs {
             Left(fs) => fs.link(ctx, idata_old.ino(), idata_new.ino(), newname),
             Right(fs) => fs
                 .link(ctx, idata_old.ino(), idata_new.ino(), newname)
-                .map(|mut e| {
-                    e.inode = self.convert_inode(idata_new.fs_idx(), e.inode)?;
-                    Ok(e)
-                })?,
+                .map(|mut e| self.convert_entry(idata_new.fs_idx(), e.inode, &mut e))?,
         }
     }
 
@@ -321,7 +309,7 @@ impl FileSystem for Vfs {
             (Right(fs), idata) => {
                 fs.create(ctx, idata.ino(), name, args)
                     .map(|(mut a, b, c)| {
-                        a.inode = self.convert_inode(idata.fs_idx(), a.inode)?;
+                        self.convert_entry(idata.fs_idx(), a.inode, &mut a)?;
                         Ok((a, b, c))
                     })?
             }