ptfs: make use of helpers from util

Make use of helpers from util.

Signed-off-by: Jiang Liu <gerry@linux.alibaba.com>

Author: jiangliu

src/passthrough/mod.rs

@@ -33,7 +33,7 @@ use self::inode_store::{InodeId, InodeStore};
 use self::mount_fd::MountFds;
 use self::statx::{statx, StatExt};
 use self::util::{
-    ebadf, einval, enosys, is_dir, is_safe_inode, openat, reopen_fd_through_proc, stat_fd,
+    ebadf, einval, enosys, eperm, is_dir, is_safe_inode, openat, reopen_fd_through_proc, stat_fd,
     UniqueInodeGenerator,
 };
 use crate::abi::fuse_abi as fuse;
@@ -581,16 +581,20 @@ impl<S: BitmapSlice + Send + Sync> PassthroughFs<S> {
     ) -> io::Result<(File, Option<FileHandle>, StatExt)> {
         let path_file = self.open_file_restricted(dir, name, libc::O_PATH, 0)?;
         let st = statx(&path_file, None)?;
-        let handle = FileHandle::from_fd(&path_file)?;
+        let handle = if self.cfg.inode_file_handles {
+            FileHandle::from_fd(&path_file)?
+        } else {
+            None
+        };
 
-        return Ok((path_file, handle, st));
+        Ok((path_file, handle, st))
     }
 
     fn to_openable_handle(&self, fh: FileHandle) -> io::Result<Arc<OpenableFileHandle>> {
         fh.into_openable(&self.mount_fds, |fd, flags, _mode| {
             reopen_fd_through_proc(&fd, flags, &self.proc_self_fd)
         })
-        .map(|v| Arc::new(v))
+        .map(Arc::new)
         .map_err(|e| {
             if !e.silent() {
                 error!("{}", e);
@@ -809,9 +813,7 @@ impl<S: BitmapSlice + Send + Sync> PassthroughFs<S> {
 
         match opcode {
             // write should not exceed the file size.
-            Opcode::Write if size + offset > file_size => {
-                Err(io::Error::from_raw_os_error(libc::EPERM))
-            }
+            Opcode::Write if size + offset > file_size => Err(eperm()),
 
             // fallocate operation should not allocate blocks exceed the file size.
             //
@@ -828,7 +830,7 @@ impl<S: BitmapSlice + Send + Sync> PassthroughFs<S> {
                     || (mode & libc::FALLOC_FL_COLLAPSE_RANGE != 0
                         || mode & libc::FALLOC_FL_INSERT_RANGE != 0) =>
             {
-                Err(io::Error::from_raw_os_error(libc::EPERM))
+                Err(eperm())
             }
 
             // setattr operation should be handled in setattr handler, other operations won't

src/passthrough/sync_io.rs

@@ -339,8 +339,8 @@ impl<S: BitmapSlice + Send + Sync> FileSystem for PassthroughFs<S> {
     }
 
     fn statfs(&self, _ctx: &Context, inode: Inode) -> io::Result<libc::statvfs64> {
-        let data = self.inode_map.get(inode)?;
         let mut out = MaybeUninit::<libc::statvfs64>::zeroed();
+        let data = self.inode_map.get(inode)?;
         let file = data.get_file()?;
 
         // Safe because this will only modify `out` and we check the return value.
@@ -381,7 +381,7 @@ impl<S: BitmapSlice + Send + Sync> FileSystem for PassthroughFs<S> {
     ) -> io::Result<(Option<Handle>, OpenOptions)> {
         if self.no_opendir.load(Ordering::Relaxed) {
             info!("fuse: opendir is not supported.");
-            Err(io::Error::from_raw_os_error(libc::ENOSYS))
+            Err(enosys())
         } else {
             self.do_open(inode, flags | (libc::O_DIRECTORY as u32), 0)
         }
@@ -507,7 +507,7 @@ impl<S: BitmapSlice + Send + Sync> FileSystem for PassthroughFs<S> {
     ) -> io::Result<(Option<Handle>, OpenOptions)> {
         if self.no_open.load(Ordering::Relaxed) {
             info!("fuse: open is not supported.");
-            Err(io::Error::from_raw_os_error(libc::ENOSYS))
+            Err(enosys())
         } else {
             self.do_open(inode, flags, fuse_flags)
         }
@@ -524,7 +524,7 @@ impl<S: BitmapSlice + Send + Sync> FileSystem for PassthroughFs<S> {
         _lock_owner: Option<u64>,
     ) -> io::Result<()> {
         if self.no_open.load(Ordering::Relaxed) {
-            Err(io::Error::from_raw_os_error(libc::ENOSYS))
+            Err(enosys())
         } else {
             self.do_release(inode, handle)
         }
@@ -764,13 +764,13 @@ impl<S: BitmapSlice + Send + Sync> FileSystem for PassthroughFs<S> {
                 attr.st_uid
             } else {
                 // Cannot use -1 here because these are unsigned values.
-                ::std::u32::MAX
+                u32::MAX
             };
             let gid = if valid.contains(SetattrValid::GID) {
                 attr.st_gid
             } else {
                 // Cannot use -1 here because these are unsigned values.
-                ::std::u32::MAX
+                u32::MAX
             };
 
             // Safe because this is a constant value and a valid C string.
@@ -1020,7 +1020,7 @@ impl<S: BitmapSlice + Send + Sync> FileSystem for PassthroughFs<S> {
         _lock_owner: u64,
     ) -> io::Result<()> {
         if self.no_open.load(Ordering::Relaxed) {
-            return Err(io::Error::from_raw_os_error(libc::ENOSYS));
+            return Err(enosys());
         }
 
         let data = self.handle_map.get(handle, inode)?;
@@ -1128,7 +1128,7 @@ impl<S: BitmapSlice + Send + Sync> FileSystem for PassthroughFs<S> {
         flags: u32,
     ) -> io::Result<()> {
         if !self.cfg.xattr {
-            return Err(io::Error::from_raw_os_error(libc::ENOSYS));
+            return Err(enosys());
         }
 
         let data = self.inode_map.get(inode)?;
@@ -1163,7 +1163,7 @@ impl<S: BitmapSlice + Send + Sync> FileSystem for PassthroughFs<S> {
         size: u32,
     ) -> io::Result<GetxattrReply> {
         if !self.cfg.xattr {
-            return Err(io::Error::from_raw_os_error(libc::ENOSYS));
+            return Err(enosys());
         }
 
         let data = self.inode_map.get(inode)?;
@@ -1198,7 +1198,7 @@ impl<S: BitmapSlice + Send + Sync> FileSystem for PassthroughFs<S> {
 
     fn listxattr(&self, _ctx: &Context, inode: Inode, size: u32) -> io::Result<ListxattrReply> {
         if !self.cfg.xattr {
-            return Err(io::Error::from_raw_os_error(libc::ENOSYS));
+            return Err(enosys());
         }
 
         let data = self.inode_map.get(inode)?;
@@ -1232,7 +1232,7 @@ impl<S: BitmapSlice + Send + Sync> FileSystem for PassthroughFs<S> {
 
     fn removexattr(&self, _ctx: &Context, inode: Inode, name: &CStr) -> io::Result<()> {
         if !self.cfg.xattr {
-            return Err(io::Error::from_raw_os_error(libc::ENOSYS));
+            return Err(enosys());
         }
 
         let data = self.inode_map.get(inode)?;

src/passthrough/util.rs

@@ -1,5 +1,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE-BSD-3-Clause file.
+// Copyright (C) 2023 Alibaba Cloud. All rights reserved.
 
 use std::collections::{btree_map, BTreeMap};
 use std::ffi::{CStr, CString};
@@ -160,7 +161,7 @@ pub fn openat(
 pub fn reopen_fd_through_proc(
     fd: &impl AsRawFd,
     flags: libc::c_int,
-    proc_self_fd: &File,
+    proc_self_fd: &impl AsRawFd,
 ) -> io::Result<File> {
     let name = CString::new(format!("{}", fd.as_raw_fd()).as_str())?;
     // Clear the `O_NOFOLLOW` flag if it is set since we need to follow the `/proc/self/fd` symlink
@@ -220,6 +221,10 @@ pub fn enosys() -> io::Error {
     io::Error::from_raw_os_error(libc::ENOSYS)
 }
 
+pub fn eperm() -> io::Error {
+    io::Error::from_raw_os_error(libc::EPERM)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;