passthroughfs: avoid extra lookup after readdirplus

The Sys_getdents64 in kernel will pad the name with '\0' bytes up to 8-byte
alignment, so @name of LinuxDirent64 may contain a few null terminators.

This causes an extra lookup from fuse kernel when called by readdirplus,
because kernel path walking only takes name without null terminators, the
dentry with more than 1 null terminators added by readdirplus doesn't
satisfy the path walking so that kernel has to issue another lookup to get
a valid dentry.

Signed-off-by: Liu Bo <bo.liu@linux.alibaba.com>

Author: liubogithub

src/api/server.rs

@@ -1394,7 +1394,8 @@ fn reply_error(err: io::Error, unique: u64, mut w: Writer) -> Result<usize> {
         .map_err(Error::EncodeMessage)
 }
 
-fn bytes_to_cstr(buf: &[u8]) -> Result<&CStr> {
+/// trim all trailing nul terminators.
+pub fn bytes_to_cstr(buf: &[u8]) -> Result<&CStr> {
     // There might be multiple 0s at the end of buf, find & use the first one and trim other zeros.
     let len = buf.len();
     let mut n: usize = 0;

src/passthrough/fs.rs

@@ -28,6 +28,7 @@ use crate::api::filesystem::{
     Context, DirEntry, Entry, FileSystem, FsOptions, GetxattrReply, ListxattrReply, OpenOptions,
     SetattrValid, ZeroCopyReader, ZeroCopyWriter,
 };
+use crate::api::server;
 use crate::api::{BackendFileSystem, VFS_MAX_INO};
 #[cfg(feature = "vhost-user-fs")]
 use crate::transport::FsCacheReqHandler;
@@ -584,6 +585,20 @@ impl PassthroughFs {
                 // break the loop so return `Ok` with a non-zero value instead.
                 Ok(1)
             } else {
+                // The Sys_getdents64 in kernel will pad the name with '\0'
+                // bytes up to 8-byte alignment, so @name may contain a few null
+                // terminators.  This causes an extra lookup from fuse when
+                // called by readdirplus, because kernel path walking only takes
+                // name without null terminators, the dentry with more than 1
+                // null terminators added by readdirplus doesn't satisfy the
+                // path walking.
+                let name = server::bytes_to_cstr(name)
+                    .map_err(|e| {
+                        error!("do_readdir: {:?}", e);
+                        io::Error::from_raw_os_error(libc::EINVAL)
+                    })?
+                    .to_bytes();
+
                 add_entry(DirEntry {
                     ino: dirent64.d_ino,
                     offset: dirent64.d_off as u64,
@@ -908,13 +923,14 @@ impl FileSystem for PassthroughFs {
         add_entry: &mut dyn FnMut(DirEntry, Entry) -> io::Result<usize>,
     ) -> io::Result<()> {
         self.do_readdir(inode, handle, size, offset, &mut |dir_entry| {
-            // Safe because the kernel guarantees that the buffer is nul-terminated. Additionally,
-            // the kernel will pad the name with '\0' bytes up to 8-byte alignment and there's no
-            // way for us to know exactly how many padding bytes there are. This would cause
-            // `CStr::from_bytes_with_nul` to return an error because it would think there are
-            // interior '\0' bytes. We trust the kernel to provide us with properly formatted data
-            // so we'll just skip the checks here.
-            let name = unsafe { CStr::from_bytes_with_nul_unchecked(dir_entry.name) };
+            // Safe because do_readdir() has ensured dir_entry.name is a
+            // valid [u8] generated by CStr::to_bytes().
+            let name = unsafe {
+                CStr::from_bytes_with_nul_unchecked(std::slice::from_raw_parts(
+                    &dir_entry.name[0],
+                    dir_entry.name.len() + 1,
+                ))
+            };
             let entry = self.do_lookup(inode, name)?;
             let ino = entry.inode;