Experimental ZFS support

anylinuxfs/Cargo.toml

@@ -30,6 +30,7 @@ if-addrs = "0.13.4"
 crossterm = "0.29.0"
 objc2-system-configuration = "0.3.1"
 os_socketaddr = "0.2.5"
+rayon = "1.11.0"
 
 [patch.crates-io]
 libblkid-rs = { git = 'https://github.com/stratis-storage/libblkid-rs.git', rev = "5c08342" }

anylinuxfs/src/diskutil.rs

@@ -156,6 +156,7 @@ pub const LINUX_LABELS: Labels = Labels {
         "Linux_LVM",
         "Linux_RAID",
         "Linux",
+        "ZFS",
     ]),
     fs_types: FsTypes(&[
         "btrfs",
@@ -168,6 +169,7 @@ pub const LINUX_LABELS: Labels = Labels {
         "zfs",
         "crypto_LUKS",
         "LVM2_member",
+        "zfs_member",
     ]),
 };
 

anylinuxfs/src/fsutil.rs

@@ -1,15 +1,20 @@
+use anyhow::anyhow;
+use common_utils::host_println;
+use rayon::prelude::*;
 use std::{
     collections::HashSet,
     ffi::{CStr, CString, OsStr, OsString},
     io, mem,
     os::unix::ffi::OsStrExt,
     path::{Path, PathBuf},
+    process::Command,
     ptr::null_mut,
 };
 
 #[derive(Debug, Clone)]
 pub struct MountTable {
     disks: HashSet<OsString>,
+    mount_points: HashSet<OsString>,
 }
 
 impl MountTable {
@@ -32,6 +37,7 @@ impl MountTable {
         }
 
         let mut disks = HashSet::new();
+        let mut mount_points = HashSet::new();
         for buf in mounts_raw {
             let mntfromname = os_str_from_c_chars(&buf.f_mntfromname).to_owned();
             let mntonname = os_str_from_c_chars(&buf.f_mntonname).to_owned();
@@ -40,15 +46,23 @@ impl MountTable {
 
             if !mntfromname.is_empty() && !mntonname.is_empty() {
                 disks.insert(mntfromname);
+                mount_points.insert(mntonname);
             }
         }
-        Ok(MountTable { disks })
+        Ok(MountTable {
+            disks,
+            mount_points,
+        })
     }
 
     pub fn is_mounted(&self, path: impl AsRef<Path>) -> bool {
         let path = path.as_ref();
         self.disks.contains(path.as_os_str())
     }
+
+    pub fn mount_points(&self) -> impl Iterator<Item = &OsString> {
+        self.mount_points.iter()
+    }
 }
 
 pub fn mounted_from(path: impl AsRef<Path>) -> io::Result<PathBuf> {
@@ -81,3 +95,144 @@ fn os_str_from_c_chars(chars: &[i8]) -> &OsStr {
     let cstr = unsafe { CStr::from_ptr(chars.as_ptr()) };
     OsStr::from_bytes(cstr.to_bytes())
 }
+
+mod dirtrie {
+    use std::{collections::BTreeMap, ffi::OsString, fmt::Display, path::Path};
+
+    #[derive(Debug, Default)]
+    pub struct Node {
+        pub paths: Option<(OsString, String)>,
+        pub children: BTreeMap<OsString, Node>,
+    }
+
+    impl Node {
+        pub fn insert(&mut self, path: &Path, full_path: &str) {
+            let mut current = self;
+            for segment in path.components() {
+                let segment = segment.as_os_str().to_owned();
+                current = current.children.entry(segment).or_default();
+            }
+            current.paths = Some((path.as_os_str().to_owned(), full_path.to_owned()));
+        }
+    }
+
+    impl Display for Node {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            fn fmt_node(
+                node: &Node,
+                f: &mut std::fmt::Formatter<'_>,
+                prefix: &str,
+            ) -> std::fmt::Result {
+                for (segment, child) in &node.children {
+                    write!(
+                        f,
+                        "{}{} ({})\r\n",
+                        prefix,
+                        segment.to_string_lossy(),
+                        child
+                            .paths
+                            .as_ref()
+                            .map(|(_, p)| p.clone())
+                            .unwrap_or("".to_owned())
+                    )?;
+                    fmt_node(child, f, &format!("{}--", prefix))?;
+                }
+                Ok(())
+            }
+            fmt_node(self, f, "")
+        }
+    }
+}
+
+fn parallel_mount_recursive(
+    mnt_point_base: PathBuf,
+    trie: &dirtrie::Node,
+    elevate: bool,
+) -> anyhow::Result<()> {
+    if let Some((rel_path, nfs_path)) = &trie.paths {
+        let shell_script = format!(
+            "mount -t nfs \"localhost:{}\" \"{}\"",
+            nfs_path,
+            mnt_point_base.join(rel_path).display()
+        );
+        // host_println!("Running NFS mount command: `{}`", &shell_script);
+
+        // elevate if needed (e.g. mounting image under /Volumes)
+        let cmdline = ["sudo", "-S", "sh", "-c", &shell_script];
+        let cmdline = if elevate { &cmdline[..] } else { &cmdline[2..] };
+        let status = Command::new(cmdline[0]).args(&cmdline[1..]).status()?;
+
+        if !status.success() {
+            return Err(anyhow!(
+                "mount failed with exit code {}",
+                status
+                    .code()
+                    .map(|c| c.to_string())
+                    .unwrap_or("unknown".to_owned())
+            ));
+        }
+        host_println!(
+            "Mounted subdirectory: {}",
+            mnt_point_base.join(rel_path).display()
+        );
+    }
+    trie.children.par_iter().try_for_each(|(_, child)| {
+        parallel_mount_recursive(mnt_point_base.clone(), child, elevate)
+    })?;
+
+    Ok(())
+}
+
+pub fn mount_nfs_subdirs<'a>(
+    share_path_base: &str,
+    subdirs: impl Iterator<Item = &'a str>,
+    mnt_point_base: impl AsRef<Path>,
+    elevate: bool,
+) -> anyhow::Result<()> {
+    let mut trie = dirtrie::Node::default();
+
+    for subdir in subdirs {
+        let subdir_relative = subdir
+            .trim_start_matches(share_path_base)
+            .trim_start_matches('/');
+
+        trie.insert(Path::new(subdir_relative), subdir);
+    }
+
+    parallel_mount_recursive(mnt_point_base.as_ref().into(), &trie, elevate)?;
+    // host_println!("Mounted NFS subdirectories:\r\n{}", trie);
+    Ok(())
+}
+
+fn parallel_unmount_recursive(trie: &dirtrie::Node) -> anyhow::Result<()> {
+    trie.children
+        .par_iter()
+        .try_for_each(|(_, child)| parallel_unmount_recursive(child))?;
+
+    if let Some((_, mount_path)) = &trie.paths {
+        let shell_script = format!("diskutil unmount \"{}\"", mount_path);
+        // host_println!("Running NFS unmount command: `{}`", &shell_script);
+        // exit status ignored, we don't want to exit early if one unmount fails
+        let _ = Command::new("sh").arg("-c").arg(&shell_script).status()?;
+    }
+    Ok(())
+}
+
+pub fn unmount_nfs_subdirs<'a>(
+    subdirs: impl Iterator<Item = &'a OsStr>,
+    mnt_point_base: impl AsRef<Path>,
+) -> anyhow::Result<()> {
+    let mut trie = dirtrie::Node::default();
+
+    for subdir in subdirs {
+        let subdir = subdir.to_string_lossy();
+        let subdir_relative = subdir
+            .trim_start_matches(&*mnt_point_base.as_ref().to_string_lossy())
+            .trim_start_matches('/');
+
+        trie.insert(Path::new(subdir_relative), &subdir);
+    }
+
+    parallel_unmount_recursive(&trie)?;
+    Ok(())
+}