Add FUSE_DEV_IOC_CLONE support for parallel request processing

Address review feedback on PR #636:

- Use existing fuse_dev_ioc_clone from ll/ioctl.rs instead of
  reimplementing the ioctl
- Make clone_fd opt-in via Config.clone_fd (default false)
- Add graceful fallback when FUSE_DEV_IOC_CLONE is not supported:
  detect ENOTTY/EINVAL and fall back to shared fd
- Remove separate test file (tests live in fuser-tests now)

When config.clone_fd is true and n_threads > 1, each worker thread
gets its own cloned fd via FUSE_DEV_IOC_CLONE. The kernel distributes
requests across all cloned fds, enabling true parallel processing.

Requires Linux 4.5+. Falls back gracefully on older kernels.

Author: ejc3

src/channel.rs

@@ -1,11 +1,13 @@
 use std::io;
 use std::os::fd::AsFd;
+use std::os::fd::AsRawFd;
 use std::os::fd::BorrowedFd;
 use std::sync::Arc;
 
 use nix::errno::Errno;
 
 use crate::dev_fuse::DevFuse;
+use crate::ll::ioctl::fuse_dev_ioc_clone;
 use crate::passthrough::BackingId;
 
 /// A raw communication channel to the FUSE kernel driver
@@ -55,6 +57,29 @@ impl Channel {
         // a sender by using the same file and use it in other threads.
         ChannelSender(self.0.clone())
     }
+
+    /// Clone the FUSE file descriptor using FUSE_DEV_IOC_CLONE.
+    ///
+    /// This creates a new /dev/fuse fd that shares the same FUSE connection,
+    /// allowing multiple threads to read requests in parallel. The kernel
+    /// distributes requests across all cloned fds.
+    ///
+    /// Requires Linux 4.5+. Returns an error on older kernels or non-Linux.
+    #[cfg(target_os = "linux")]
+    pub(crate) fn clone_fd(&self) -> io::Result<Self> {
+        // Open a new /dev/fuse fd
+        let new_dev = DevFuse::open()?;
+
+        // Clone the connection to the new fd
+        let mut source_fd = self.0.as_raw_fd() as u32;
+        // SAFETY: fuse_dev_ioc_clone is a valid ioctl for /dev/fuse
+        unsafe {
+            fuse_dev_ioc_clone(new_dev.as_raw_fd(), &mut source_fd)
+                .map_err(|e| io::Error::from_raw_os_error(e as i32))?;
+        }
+
+        Ok(Self(Arc::new(new_dev)))
+    }
 }
 
 #[derive(Clone, Debug)]

src/ll/ioctl.rs

@@ -6,7 +6,6 @@ pub(crate) struct fuse_backing_map {
 }
 
 pub(crate) const FUSE_DEV_IOC_MAGIC: u8 = 229;
-#[expect(dead_code)]
 pub(crate) const FUSE_DEV_IOC_CLONE: u8 = 0;
 pub(crate) const FUSE_DEV_IOC_BACKING_OPEN: u8 = 1;
 pub(crate) const FUSE_DEV_IOC_BACKING_CLOSE: u8 = 2;

src/mnt/mount_options.rs

@@ -15,6 +15,10 @@ pub struct Config {
     pub acl: SessionACL,
     /// Number of event loop threads. If unspecified, one thread is used.
     pub n_threads: Option<usize>,
+    /// Use FUSE_DEV_IOC_CLONE to give each worker thread its own fd.
+    /// This enables true parallel request processing from the kernel.
+    /// Requires Linux 4.5+. Falls back to shared fd on older kernels.
+    pub clone_fd: bool,
 }
 
 /// Mount options accepted by the FUSE filesystem type
@@ -210,6 +214,7 @@ pub(crate) fn parse_options_from_args(args: &[&OsStr]) -> io::Result<Config> {
         mount_options: out,
         acl,
         n_threads: None,
+        clone_fd: false,
     })
 }
 

src/session.rs

@@ -266,8 +266,32 @@ impl<FS: Filesystem> Session<FS> {
         let mut filesystem = Arc::new(filesystem);
 
         let mut channels = Vec::with_capacity(n_threads);
+        #[cfg(target_os = "linux")]
+        let mut use_clone_fd = config.clone_fd;
+        #[cfg(not(target_os = "linux"))]
+        let mut use_clone_fd = false;
+
         for _ in 0..n_threads_minus_one {
-            // TODO: fuse_dev_ioc_clone
+            if use_clone_fd {
+                match ch.clone_fd() {
+                    Ok(cloned) => {
+                        channels.push(cloned);
+                        continue;
+                    }
+                    Err(e) => {
+                        // ENOTTY/EINVAL indicate kernel doesn't support clone_fd
+                        // Fall back to shared fd for this and all remaining threads
+                        use_clone_fd = false;
+                        if e.raw_os_error() == Some(libc::ENOTTY)
+                            || e.raw_os_error() == Some(libc::EINVAL)
+                        {
+                            info!("FUSE_DEV_IOC_CLONE not supported, falling back to shared fd");
+                        } else {
+                            warn!("clone_fd failed: {e}, falling back to shared fd");
+                        }
+                    }
+                }
+            }
             channels.push(ch.clone());
         }
         channels.push(ch);