ptfs: switch to new implementation from util.rs

1. switch to new implementation from util.rs.
2. move helpers into util.rs
3. split out config.rs for configuration information.
4. move os compatibility related data structs into os_compat.rs

Signed-off-by: Jiang Liu <[email protected]>

Author: jiangliu

src/passthrough/config.rs

@@ -0,0 +1,193 @@
+// Copyright (C) 2020-2022 Alibaba Cloud. All rights reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+use std::str::FromStr;
+use std::time::Duration;
+
+/// The caching policy that the file system should report to the FUSE client. By default the FUSE
+/// protocol uses close-to-open consistency. This means that any cached contents of the file are
+/// invalidated the next time that file is opened.
+#[derive(Debug, Default, Clone, Eq, PartialEq)]
+pub enum CachePolicy {
+    /// The client should never cache file data and all I/O should be directly forwarded to the
+    /// server. This policy must be selected when file contents may change without the knowledge of
+    /// the FUSE client (i.e., the file system does not have exclusive access to the directory).
+    Never,
+
+    /// The client is free to choose when and how to cache file data. This is the default policy and
+    /// uses close-to-open consistency as described in the enum documentation.
+    #[default]
+    Auto,
+
+    /// The client should always cache file data. This means that the FUSE client will not
+    /// invalidate any cached data that was returned by the file system the last time the file was
+    /// opened. This policy should only be selected when the file system has exclusive access to the
+    /// directory.
+    Always,
+}
+
+impl FromStr for CachePolicy {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "never" | "Never" | "NEVER" | "none" | "None" | "NONE" => Ok(CachePolicy::Never),
+            "auto" | "Auto" | "AUTO" => Ok(CachePolicy::Auto),
+            "always" | "Always" | "ALWAYS" => Ok(CachePolicy::Always),
+            _ => Err("invalid cache policy"),
+        }
+    }
+}
+
+/// Options that configure the behavior of the passthrough fuse file system.
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct Config {
+    /// How long the FUSE client should consider file and directory attributes to be valid. If the
+    /// attributes of a file or directory can only be modified by the FUSE client (i.e., the file
+    /// system has exclusive access), then this should be set to a large value.
+    ///
+    /// The default value for this option is 5 seconds.
+    pub attr_timeout: Duration,
+
+    /// How long the FUSE client should consider directory entries to be valid. If the contents of a
+    /// directory can only be modified by the FUSE client (i.e., the file system has exclusive
+    /// access), then this should be a large value.
+    ///
+    /// The default value for this option is 5 seconds.
+    pub entry_timeout: Duration,
+
+    /// Same as `attr_timeout`, override `attr_timeout` config, but only take effect on directories
+    /// when specified. This is useful to set different timeouts for directories and regular files.
+    pub dir_attr_timeout: Option<Duration>,
+
+    /// Same as `entry_timeout`, override `entry_timeout` config, but only take effect on
+    /// directories when specified. This is useful to set different timeouts for directories and
+    /// regular files.
+    pub dir_entry_timeout: Option<Duration>,
+
+    /// The caching policy the file system should use. See the documentation of `CachePolicy` for
+    /// more details.
+    pub cache_policy: CachePolicy,
+
+    /// Whether the file system should enable writeback caching. This can improve performance as it
+    /// allows the FUSE client to cache and coalesce multiple writes before sending them to the file
+    /// system. However, enabling this option can increase the risk of data corruption if the file
+    /// contents can change without the knowledge of the FUSE client (i.e., the server does **NOT**
+    /// have exclusive access). Additionally, the file system should have read access to all files
+    /// in the directory it is serving as the FUSE client may send read requests even for files
+    /// opened with `O_WRONLY`.
+    ///
+    /// Therefore callers should only enable this option when they can guarantee that: 1) the file
+    /// system has exclusive access to the directory and 2) the file system has read permissions for
+    /// all files in that directory.
+    ///
+    /// The default value for this option is `false`.
+    pub writeback: bool,
+
+    /// The path of the root directory.
+    ///
+    /// The default is `/`.
+    pub root_dir: String,
+
+    /// Whether the file system should support Extended Attributes (xattr). Enabling this feature may
+    /// have a significant impact on performance, especially on write parallelism. This is the result
+    /// of FUSE attempting to remove the special file privileges after each write request.
+    ///
+    /// The default value for this options is `false`.
+    pub xattr: bool,
+
+    /// To be compatible with Vfs and PseudoFs, PassthroughFs needs to prepare
+    /// root inode before accepting INIT request.
+    ///
+    /// The default value for this option is `true`.
+    pub do_import: bool,
+
+    /// Control whether no_open is allowed.
+    ///
+    /// The default value for this option is `false`.
+    pub no_open: bool,
+
+    /// Control whether no_opendir is allowed.
+    ///
+    /// The default value for this option is `false`.
+    pub no_opendir: bool,
+
+    /// Control whether kill_priv_v2 is enabled.
+    ///
+    /// The default value for this option is `false`.
+    pub killpriv_v2: bool,
+
+    /// Whether to use file handles to reference inodes.  We need to be able to open file
+    /// descriptors for arbitrary inodes, and by default that is done by storing an `O_PATH` FD in
+    /// `InodeData`.  Not least because there is a maximum number of FDs a process can have open
+    /// users may find it preferable to store a file handle instead, which we can use to open an FD
+    /// when necessary.
+    /// So this switch allows to choose between the alternatives: When set to `false`, `InodeData`
+    /// will store `O_PATH` FDs.  Otherwise, we will attempt to generate and store a file handle
+    /// instead.
+    ///
+    /// The default is `false`.
+    pub inode_file_handles: bool,
+
+    /// Control whether readdir/readdirplus requests return zero dirent to client, as if the
+    /// directory is empty even if it has children.
+    pub no_readdir: bool,
+
+    /// Control whether to refuse operations which modify the size of the file. For a share memory
+    /// file mounted from host, seal_size can prohibit guest to increase the size of
+    /// share memory file to attack the host.
+    pub seal_size: bool,
+
+    /// Whether count mount ID or not when comparing two inodes. By default we think two inodes
+    /// are same if their inode number and st_dev are the same. When `enable_mntid` is set as
+    /// 'true', inode's mount ID will be taken into account as well. For example, bindmount the
+    /// same file into virtiofs' source dir, the two bindmounted files will be identified as two
+    /// different inodes when this option is true, so the don't share pagecache.
+    ///
+    /// The default value for this option is `false`.
+    pub enable_mntid: bool,
+
+    /// What size file supports dax
+    /// * If dax_file_size == None, DAX will disable to all files.
+    /// * If dax_file_size == 0, DAX will enable all files.
+    /// * If dax_file_size == N, DAX will enable only when the file size is greater than or equal
+    /// to N Bytes.
+    pub dax_file_size: Option<u64>,
+
+    /// Reduce memory consumption by directly use host inode when possible.
+    ///
+    /// When set to false, a virtual inode number will be allocated for each file managed by
+    /// the passthroughfs driver. A map is used to maintain the relationship between virtual
+    /// inode numbers and host file objects.
+    /// When set to true, the host inode number will be directly used as virtual inode number
+    /// if it's less than the threshold (1 << 47), so reduce memory consumed by the map.
+    /// A virtual inode number will still be allocated and maintained if the host inode number
+    /// is bigger than the threshold.
+    /// The default value for this option is `false`.
+    pub use_host_ino: bool,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Config {
+            entry_timeout: Duration::from_secs(5),
+            attr_timeout: Duration::from_secs(5),
+            cache_policy: Default::default(),
+            writeback: false,
+            root_dir: String::from("/"),
+            xattr: false,
+            do_import: true,
+            no_open: false,
+            no_opendir: false,
+            killpriv_v2: false,
+            inode_file_handles: false,
+            no_readdir: false,
+            seal_size: false,
+            enable_mntid: false,
+            dax_file_size: None,
+            dir_entry_timeout: None,
+            dir_attr_timeout: None,
+            use_host_ino: false,
+        }
+    }
+}

src/passthrough/file_handle.rs

@@ -174,7 +174,7 @@ extern "C" {
 
 impl FileHandle {
     /// Create a file handle for the given file.
-    pub fn from_name_at(dir_fd: RawFd, path: &CStr) -> io::Result<Self> {
+    pub fn from_name_at(dir_fd: &impl AsRawFd, path: &CStr) -> io::Result<Self> {
         let mut mount_id: libc::c_int = 0;
         let mut c_fh = CFileHandle::new(0);
 
@@ -186,7 +186,7 @@ impl FileHandle {
         // structure of the correct size.
         let ret = unsafe {
             name_to_handle_at(
-                dir_fd,
+                dir_fd.as_raw_fd(),
                 path.as_ptr(),
                 c_fh.wrapper.as_mut_fam_struct_ptr(),
                 &mut mount_id,
@@ -214,7 +214,7 @@ impl FileHandle {
         // the automount can be triggered by adding a "/" to the end of the pathname.
         let ret = unsafe {
             name_to_handle_at(
-                dir_fd,
+                dir_fd.as_raw_fd(),
                 path.as_ptr(),
                 c_fh.wrapper.as_mut_fam_struct_ptr(),
                 &mut mount_id,
@@ -259,7 +259,7 @@ impl OpenableFileHandle {
     /// If `path` is empty, `reopen_dir` may be invoked to duplicate `dir` with custom
     /// `libc::open()` flags.
     pub fn from_name_at<F>(
-        dir_fd: RawFd,
+        dir_fd: &impl AsRawFd,
         path: &CStr,
         mount_fds: &MountFds,
         reopen_dir: F,
@@ -412,9 +412,8 @@ mod tests {
         let dir = File::open(topdir).unwrap();
         let filename = CString::new("build.rs").unwrap();
 
-        let dir_handle =
-            FileHandle::from_name_at(dir.as_raw_fd(), &CString::new("").unwrap()).unwrap();
-        let file_handle = FileHandle::from_name_at(dir.as_raw_fd(), &filename).unwrap();
+        let dir_handle = FileHandle::from_name_at(&dir, &CString::new("").unwrap()).unwrap();
+        let file_handle = FileHandle::from_name_at(&dir, &filename).unwrap();
 
         assert_eq!(dir_handle.mnt_id, file_handle.mnt_id);
         assert_ne!(
@@ -434,13 +433,11 @@ mod tests {
         let filename = CString::new("build.rs").unwrap();
         let mount_fds = MountFds::new(None).unwrap();
 
-        let file_handle = OpenableFileHandle::from_name_at(
-            dir.as_raw_fd(),
-            &filename,
-            &mount_fds,
-            |_fd, _flags, _mode| File::open(topdir),
-        )
-        .unwrap();
+        let file_handle =
+            OpenableFileHandle::from_name_at(&dir, &filename, &mount_fds, |_fd, _flags, _mode| {
+                File::open(topdir)
+            })
+            .unwrap();
         assert_eq!(file_handle.handle.mnt_id, file_handle.mount_id());
 
         let mut file = file_handle.open(libc::O_RDONLY).unwrap();

src/passthrough/inode_store.rs

@@ -102,6 +102,7 @@ mod test {
     use super::*;
 
     use std::ffi::CStr;
+    use std::mem::MaybeUninit;
     use std::os::unix::io::{AsRawFd, RawFd};
     use std::sync::atomic::Ordering;
     use vmm_sys_util::tempfile::TempFile;