fuser

https://docs.rs/fuser/latest/
Admin
A Rust userspace library implementation for FUSE (Filesystem in Userspace). It provides a low-level...
Tokens:102,506
Snippets:466
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Session::run

Source: https://docs.rs/fuser/latest/fuser/struct.Session.html

Starts the session loop to receive and dispatch kernel requests.

```APIDOC
## Session::run

### Description
Run the session loop that receives kernel requests and dispatches them to method calls into the filesystem. This read-dispatch-loop is non-concurrent to prevent having multiple buffers, but the filesystem methods may run concurrently.

### Signature
`pub fn run(self) -> Result<()>`

### Errors
Returns any final error when the session comes to an end.
```

--------------------------------

### create

Source: https://docs.rs/fuser/latest/src/fuser/lib.rs.html

Creates and opens a new file.

```APIDOC
## create

### Description
Create and open a file. If it does not exist, it is created with the specified mode.

### Parameters
- **parent** (INodeNo) - The parent directory inode.
- **name** (&OsStr) - The name of the file to create.
- **mode** (u32) - The file mode.
- **umask** (u32) - The umask.
- **flags** (i32) - Open flags.
- **reply** (ReplyCreate) - The response handler.
```

--------------------------------

### Extended Attribute Operations

Source: https://docs.rs/fuser/latest/src/fuser/lib.rs.html

Methods for managing extended attributes on inodes. These include setting, getting, listing, and removing attributes.

```rust
        ino: INodeNo,
        name: &OsStr,
        _value: &[u8],
        flags: i32,
        position: u32,
        reply: ReplyEmpty,
    ) {
        warn!(
            "[Not Implemented] setxattr(ino: {ino:#x?}, name: {name:?}, \
            flags: {flags:#x?}, position: {position})"
        );
        reply.error(Errno::ENOSYS);
    }

    /// Get an extended attribute.
    /// If `size` is 0, the size of the value should be sent with `reply.size()`.
    /// If `size` is not 0, and the value fits, send it with `reply.data()`, or
    /// `reply.error(ERANGE)` if it doesn't.
    fn getxattr(&self, _req: &Request, ino: INodeNo, name: &OsStr, size: u32, reply: ReplyXattr) {
        warn!("[Not Implemented] getxattr(ino: {ino:#x?}, name: {name:?}, size: {size})");
        reply.error(Errno::ENOSYS);
    }

    /// List extended attribute names.
    /// If `size` is 0, the size of the value should be sent with `reply.size()`.
    /// If `size` is not 0, and the value fits, send it with `reply.data()`, or
    /// `reply.error(ERANGE)` if it doesn't.
    fn listxattr(&self, _req: &Request, ino: INodeNo, size: u32, reply: ReplyXattr) {
        warn!("[Not Implemented] listxattr(ino: {ino:#x?}, size: {size})");
        reply.error(Errno::ENOSYS);
    }

    /// Remove an extended attribute.
    fn removexattr(&self, _req: &Request, ino: INodeNo, name: &OsStr, reply: ReplyEmpty) {
        warn!("[Not Implemented] removexattr(ino: {ino:#x?}, name: {name:?})");
        reply.error(Errno::ENOSYS);
    }
```

--------------------------------

### ReplyCreate Implementation

Source: https://docs.rs/fuser/latest/src/fuser/reply.rs.html

Initializes the structure for handling file creation replies.

```rust
impl Reply for ReplyCreate {
    fn new(unique: ll::RequestId, sender: ReplySender) -> ReplyCreate {
        ReplyCreate {
            reply: Reply::new(unique, sender),
        }
    }
}
```

--------------------------------

### GetXAttr Request Structure

Source: https://docs.rs/fuser/latest/src/fuser/ll/request.rs.html

Handles requests to get extended attributes, providing mechanisms to determine if the user is requesting size or data.

```rust
/// Get an extended attribute.
///
/// If the requested `XAttr` doesn't exist, return [`Err(Errno::NO_XATTR)`] which will
/// map to the right platform-specific error code.
#[derive(Debug)]
pub(crate) struct GetXAttr<'a> {
    #[expect(dead_code)]
    header: &'a fuse_in_header,
    arg: &'a fuse_getxattr_in,
    name: &'a OsStr,
}

/// Type for [`GetXAttrSizeEnum::GetSize`].
///
/// Represents a request from the user to get the size of the data stored in the `XAttr`.
#[derive(Debug)]
pub(crate) struct GetXAttrSize();

#[derive(Debug)]
/// Return type for [`GetXAttr::size`].
pub(crate) enum GetXAttrSizeEnum {
    /// User is requesting the size of the data stored in the `XAttr`
    GetSize(GetXAttrSize),
    /// User is requesting the data stored in the `XAttr`.  If the data will fit
    /// in this number of bytes it should be returned, otherwise return [`Err(Errno::ERANGE)`].
    #[allow(dead_code)]
    Size(NonZeroU32),
}
impl<'a> GetXAttr<'a> {
    /// Name of the `XAttr`
    pub(crate) fn name(&self) -> &'a OsStr {
        self.name
    }
    /// See [`GetXAttrSizeEnum`].
    ///
    /// You only need to check this value as an optimisation where there's a
    /// cost difference between checking the size of the data stored in an `XAttr`
    /// and actually providing the data.  Otherwise just call [`reply()`] with the
    /// data and it will do the right thing.
    pub(crate) fn size(&self) -> GetXAttrSizeEnum {
        let s: Result<NonZeroU32, _> = self.arg.size.try_into();
        match s {
            Ok(s) => GetXAttrSizeEnum::Size(s),
            Err(_) => GetXAttrSizeEnum::GetSize(GetXAttrSize()),
        }
    }
    /// The size of the buffer the user has allocated to store the `XAttr` value.
    pub(crate) fn size_u32(&self) -> u32 {
        self.arg.size
    }
}
```

--------------------------------

### Implement Filesystem Lifecycle and Lookup Methods

Source: https://docs.rs/fuser/latest/src/fuser/lib.rs.html

Methods for handling filesystem exit, inode lookups, and inode reference counting.

```rust
fn destroy(&mut self) {}

fn lookup(&self, _req: &Request, parent: INodeNo, name: &OsStr, reply: ReplyEntry) {
    warn!("[Not Implemented] lookup(parent: {parent:#x?}, name {name:?})");
    reply.error(Errno::ENOSYS);
}

fn forget(&self, _req: &Request, _ino: INodeNo, _nlookup: u64) {}

fn batch_forget(&self, req: &Request, nodes: &[ForgetOne]) {
    for node in nodes {
        self.forget(req, node.nodeid(), node.nlookup());
    }
}
```

--------------------------------

### Implement Node Creation and Manipulation

Source: https://docs.rs/fuser/latest/src/fuser/lib.rs.html

Methods for creating files, directories, symbolic links, and removing nodes.

```rust
fn readlink(&self, _req: &Request, ino: INodeNo, reply: ReplyData) {
    warn!("[Not Implemented] readlink(ino: {ino:#x?})");
    reply.error(Errno::ENOSYS);
}

fn mknod(
    &self,
    _req: &Request,
    parent: INodeNo,
    name: &OsStr,
    mode: u32,
    umask: u32,
    rdev: u32,
    reply: ReplyEntry,
) {
    warn!(
        "[Not Implemented] mknod(parent: {parent:#x?}, name: {name:?}, \
        mode: {mode}, umask: {umask:#x?}, rdev: {rdev})"
    );
    reply.error(Errno::ENOSYS);
}

fn mkdir(
    &self,
    _req: &Request,
    parent: INodeNo,
    name: &OsStr,
    mode: u32,
    umask: u32,
    reply: ReplyEntry,
) {
    warn!(
        "[Not Implemented] mkdir(parent: {parent:#x?}, name: {name:?}, mode: {mode}, umask: {umask:#x?})"
    );
    reply.error(Errno::ENOSYS);
}

fn unlink(&self, _req: &Request, parent: INodeNo, name: &OsStr, reply: ReplyEmpty) {
    warn!("[Not Implemented] unlink(parent: {parent:#x?}, name: {name:?})",);
    reply.error(Errno::ENOSYS);
}

fn rmdir(&self, _req: &Request, parent: INodeNo, name: &OsStr, reply: ReplyEmpty) {
    warn!("[Not Implemented] rmdir(parent: {parent:#x?}, name: {name:?})",);
    reply.error(Errno::ENOSYS);
}

fn symlink(
    &self,
    _req: &Request,
    parent: INodeNo,
    link_name: &OsStr,
    target: &Path,
    reply: ReplyEntry,
) {
    warn!(
        "[Not Implemented] symlink(parent: {parent:#x?}, link_name: {link_name:?}, target: {target:?})",
    );
    reply.error(Errno::EPERM);
}

fn rename(
    &self,
    _req: &Request,
    parent: INodeNo,
    name: &OsStr,
    newparent: INodeNo,
    newname: &OsStr,
    flags: RenameFlags,
    reply: ReplyEmpty,
) {
    warn!(
        "[Not Implemented] rename(parent: {parent:#x?}, name: {name:?}, \
        newparent: {newparent:#x?}, newname: {newname:?}, flags: {flags:?})"
    );
    reply.error(Errno::ENOSYS);
}
```

--------------------------------

### ReplyCreate Implementation

Source: https://docs.rs/fuser/latest/src/fuser/reply.rs.html

Handles file creation responses, including support for kernel passthrough via BackingId.

```rust
pub fn created(
        self,
        ttl: &Duration,
        attr: &FileAttr,
        generation: Generation,
        fh: ll::FileHandle,
        flags: FopenFlags,
    ) {
        assert!(!flags.contains(FopenFlags::FOPEN_PASSTHROUGH));
        self.reply.send_ll(&ll::ResponseStruct::new_create(
            ttl,
            &attr.into(),
            generation,
            fh,
            flags,
            0,
        ));
    }
```

```rust
pub fn created_passthrough(
        self,
        ttl: &Duration,
        attr: &FileAttr,
        generation: Generation,
        fh: ll::FileHandle,
        flags: FopenFlags,
        backing_id: &BackingId,
    ) {
        self.reply.send_ll(&ll::ResponseStruct::new_create(
            ttl,
            &attr.into(),
            generation,
            fh,
            flags | FopenFlags::FOPEN_PASSTHROUGH,
            backing_id.backing_id,
        ));
    }
```

--------------------------------

### Mount Struct and Initialization

Source: https://docs.rs/fuser/latest/src/fuser/mnt/mod.rs.html

The Mount struct and its constructor, which initializes the appropriate mount backend based on configuration.

```rust
93pub(crate) struct Mount {
94    mount_impl: Option<MountImpl>,
95    mount_point: PathBuf,
96}
97
98impl Mount {
99    pub(crate) fn new(
100        mountpoint: &Path,
101        options: &[MountOption],
102        acl: SessionACL,
103    ) -> io::Result<(Arc<DevFuse>, Mount)> {
104        #[cfg(fuser_mount_impl = "pure-rust")]
105        {
106            let (dev_fuse, mount) = fuse_pure::MountImpl::new(mountpoint, options, acl)?;
107            Ok((
108                dev_fuse,
109                Mount {
110                    mount_impl: Some(MountImpl::Pure(mount)),
111                    mount_point: mountpoint.to_path_buf(),
112                },
113            ))
114        }
115        #[cfg(fuser_mount_impl = "libfuse2")]
116        {
117            let (dev_fuse, mount) = fuse2::MountImpl::new(mountpoint, options, acl)?;
118            Ok((
119                dev_fuse,
120                Mount {
121                    mount_impl: Some(MountImpl::Fuse2(mount)),
122                    mount_point: mountpoint.to_path_buf(),
123                },
124            ))
125        }
126        #[cfg(fuser_mount_impl = "libfuse3")]
127        {
128            let (dev_fuse, mount) = fuse3::MountImpl::new(mountpoint, options, acl)?;
129            Ok((
130                dev_fuse,
131                Mount {
132                    mount_impl: Some(MountImpl::Fuse3(mount)),
133                    mount_point: mountpoint.to_path_buf(),
134                },
135            ))
136        }
137        #[cfg(fuser_mount_impl = "macos-no-mount")]
138        {
139            let _ = (mountpoint, options, acl);
140            Err(io::Error::other(
141                "Mount is not enabled; this is test-only configuration",
142            ))
143        }
144    }
145
146    pub(crate) fn umount(mut self) -> io::Result<()> {
147        match self.mount_impl.take() {
148            Some(mut mount) => {
149                info!("Unmounting {}", self.mount_point.display());
150                mount.umount_impl()
151            }
```

--------------------------------

### Implement open operation

Source: https://docs.rs/fuser/latest/src/fuser/lib.rs.html

Opens a file and returns a file handle. Filesystems may store an arbitrary handle in the reply.

```rust
fn open(&self, _req: &Request, _ino: INodeNo, _flags: OpenFlags, reply: ReplyOpen) {
        reply.opened(FileHandle(0), FopenFlags::empty());
    }
```

--------------------------------

### Implement opendir operation

Source: https://docs.rs/fuser/latest/src/fuser/lib.rs.html

Opens a directory and returns a file handle for subsequent directory operations.

```rust
fn opendir(&self, _req: &Request, _ino: INodeNo, _flags: OpenFlags, reply: ReplyOpen) {
        reply.opened(FileHandle(0), FopenFlags::empty());
    }
```

--------------------------------

### Implement ReplySender methods

Source: https://docs.rs/fuser/latest/src/fuser/reply.rs.html

These methods handle sending data, opening backing files, and wrapping backing file IDs through the underlying channel or test senders.

```rust
impl ReplySender {
    /// Send data.
    pub(crate) fn send(&self, data: &[IoSlice<'_>]) -> std::io::Result<()> {
        match self {
            ReplySender::Channel(sender) => sender.send(data),
            #[cfg(test)]
            ReplySender::Assert(sender) => sender.send(data),
            #[cfg(test)]
            ReplySender::Sync(sender) => {
                sender.send(()).unwrap();
                Ok(())
            }
        }
    }

    /// Open a backing file
    pub(crate) fn open_backing(&self, fd: BorrowedFd<'_>) -> std::io::Result<BackingId> {
        match self {
            ReplySender::Channel(sender) => sender.open_backing(fd),
            #[cfg(test)]
            ReplySender::Assert(_) => unreachable!(),
            #[cfg(test)]
            ReplySender::Sync(_) => unreachable!(),
        }
    }

    /// Wraps a raw backing file ID
    pub(crate) unsafe fn wrap_backing(&self, id: u32) -> BackingId {
        match self {
            ReplySender::Channel(sender) => unsafe { sender.wrap_backing(id) },
            #[cfg(test)]
            ReplySender::Assert(_) => unreachable!(),
            #[cfg(test)]
            ReplySender::Sync(_) => unreachable!(),
        }
    }
}
```

--------------------------------

### ReplyCreate

Source: https://docs.rs/fuser/latest/src/fuser/reply.rs.html

Methods for responding to file creation requests, including support for kernel passthrough.

```APIDOC
## ReplyCreate::created

### Description
Reply to a request with a newly created file entry and its newly open file handle.

### Parameters
- **ttl** (&Duration) - Time-to-live for the file attributes.
- **attr** (&FileAttr) - File attributes.
- **generation** (Generation) - Generation number.
- **fh** (ll::FileHandle) - File handle.
- **flags** (FopenFlags) - Open flags.

## ReplyCreate::created_passthrough

### Description
Reply to a request with an opened backing id for kernel passthrough.

### Parameters
- **ttl** (&Duration) - Time-to-live for the file attributes.
- **attr** (&FileAttr) - File attributes.
- **generation** (Generation) - Generation number.
- **fh** (ll::FileHandle) - File handle.
- **flags** (FopenFlags) - Open flags.
- **backing_id** (&BackingId) - The backing ID to use for passthrough.
```

--------------------------------

### Configure and Execute FUSE Mount

Source: https://docs.rs/fuser/latest/src/fuser/mnt/fuse_pure.rs.html

Constructs mount options and flags, then performs the platform-specific mount system call.

```rust
412        "fd={},rootmode={:o},user_id={},group_id={}",
413        file.as_raw_fd(),
414        mountpoint_mode,
415        nix::unistd::getuid(),
416        nix::unistd::getgid()
417    );
418
419    for option in options
420        .iter()
421        .filter(|x| option_group(x) == MountOptionGroup::KernelOption)
422    {
423        mount_options.push(',');
424        mount_options.push_str(&option_to_string(option));
425    }
426    if let Some(acl_option) = acl.to_mount_option() {
427        mount_options.push(',');
428        mount_options.push_str(acl_option);
429    }
430
431    #[cfg(target_os = "linux")]
432    let mut flags = nix::mount::MsFlags::empty();
433    #[cfg(target_os = "macos")]
434    let mut flags = nix::mount::MntFlags::empty();
435
436    if !options.contains(&MountOption::Dev) {
437        // Default to nodev
438        #[cfg(target_os = "linux")]
439        {
440            flags |= nix::mount::MsFlags::MS_NODEV;
441        }
442        #[cfg(target_os = "macos")]
443        {
444            flags |= nix::mount::MntFlags::MNT_NODEV;
445        }
446    }
447    if !options.contains(&MountOption::Suid) {
448        // Default to nosuid
449        #[cfg(target_os = "linux")]
450        {
451            flags |= nix::mount::MsFlags::MS_NOSUID;
452        }
453        #[cfg(target_os = "macos")]
454        {
455            flags |= nix::mount::MntFlags::MNT_NOSUID;
456        }
457    }
458    for flag in options
459        .iter()
460        .filter(|x| option_group(x) == MountOptionGroup::KernelFlag)
461    {
462        flags |= option_to_flag(flag)?;
463    }
464
465    // Default name is "/dev/fuse", then use the subtype, and lastly prefer the name
466    let mut source = DevFuse::PATH;
467    if let Some(MountOption::Subtype(subtype)) = options
468        .iter()
469        .find(|x| matches!(**x, MountOption::Subtype(_)))
470    {
471        source = subtype;
472    }
473    if let Some(MountOption::FSName(name)) = options
474        .iter()
475        .find(|x| matches!(**x, MountOption::FSName(_)))
476    {
477        source = name;
478    }
479
480    #[cfg(target_os = "linux")]
481    let result = nix::mount::mount(
482        Some(source),
483        mountpoint,
484        Some("fuse"),
485        flags,
486        Some(mount_options.as_str()),
487    );
488    #[cfg(target_os = "macos")]
489    let result = nix::mount::mount(source, mountpoint, flags, Some(mount_options.as_str()));
490
491    match result {
492        Ok(()) => Ok(Some(file)),
493        Err(nix::errno::Errno::EPERM) => Ok(None), // Retry with fusermount
494        Err(e) => Err(Error::new(
495            ErrorKind::Other,
496            format!(
497                "Error calling mount() at {mountpoint:?} with {mount_options:?} and flags={flags:?}: {e}"
498            ),
499        )),
500    }
501}
```

--------------------------------

### Create Request Structure

Source: https://docs.rs/fuser/latest/src/fuser/ll/request.rs.html

Handles file creation and opening, providing access to the file name, mode, and flags.

```rust
#[derive(Debug)]
pub(crate) struct Create<'a> {
    #[expect(dead_code)]
    header: &'a fuse_in_header,
    arg: &'a fuse_create_in,
    name: &'a Path,
}
impl<'a> Create<'a> {
    pub(crate) fn name(&self) -> &'a Path {
        self.name
    }
    pub(crate) fn mode(&self) -> u32 {
        self.arg.mode
    }
    /// Flags as passed to the `create()` call
    pub(crate) fn flags(&self) -> i32 {
        self.arg.flags
    }
    pub(crate) fn umask(&self) -> u32 {
        self.arg.umask
    }
}
```

--------------------------------

### Create a new FUSE session

Source: https://docs.rs/fuser/latest/src/fuser/session.rs.html

Initializes a new session by mounting a filesystem to a specified mountpoint with given configuration options.

```rust
pub fn new<P: AsRef<Path>>(
        filesystem: FS,
        mountpoint: P,
        options: &Config,
    ) -> io::Result<Session<FS>> {
        check_option_conflicts(options)?;

        let mountpoint = mountpoint.as_ref();
        info!("Mounting {}", mountpoint.display());
        // If AutoUnmount is requested, but not AllowRoot or AllowOther, return an error
        // because fusermount needs allow_root or allow_other to handle the auto_unmount option
        if options.mount_options.contains(&MountOption::AutoUnmount)
            && options.acl == SessionACL::Owner
        {
            return Err(io::Error::new(
                io::ErrorKind::InvalidInput,
                format!("auto_unmount requires acl != Owner, got: {:?}", options.acl),
            ));
        }
        let (file, mount) = Mount::new(mountpoint, &options.mount_options, options.acl)?;

        let ch = Channel::new(file);

        let mut session = Session {
            filesystem: FilesystemHolder {
                fs: Some(filesystem),
            },
            ch,
            mount: UmountOnDrop {
                mount: Arc::new(Mutex::new(Some(mount))),
            },
            allowed: options.acl,
            session_owner: geteuid(),
            proto_version: None,
            config: options.clone(),
        };

        session.handshake()?;

        Ok(session)
    }
```

--------------------------------

### join

Source: https://docs.rs/fuser/latest/fuser/struct.BackgroundSession.html

Joins the filesystem thread.

```APIDOC
### pub fn join(self) -> Result<()>

Join the filesystem thread.
```

--------------------------------

### fn mount<FS: Filesystem, P: AsRef<Path>>

Source: https://docs.rs/fuser/latest/fuser/fn.mount.html

Mounts the provided filesystem to the specified mountpoint. This function blocks until the filesystem is unmounted.

```APIDOC
## fn mount<FS: Filesystem, P: AsRef<Path>>(filesystem: FS, mountpoint: P, options: &Config) -> Result<()>

### Description
Mount the given filesystem to the given mountpoint. This function will not return until the filesystem is unmounted.

### Parameters
- **filesystem** (FS: Filesystem) - The filesystem implementation to mount.
- **mountpoint** (P: AsRef<Path>) - The path where the filesystem will be mounted.
- **options** (&Config) - Configuration options for the mount session.

### Errors
Returns an error if the options are incorrect, if the fuse device cannot be mounted, or if an error occurs when the session ends.
```

--------------------------------

### BackgroundSession::join

Source: https://docs.rs/fuser/latest/src/fuser/session.rs.html

Joins the filesystem background thread.

```APIDOC
## fn join(self) -> io::Result<()>

### Description
Blocks until the filesystem background thread has finished execution.

### Returns
- **io::Result<()>** - Returns Ok(()) if the thread finished successfully, or an io::Error if the thread panicked or encountered an error.
```

--------------------------------

### Implement CUSE initialization structure

Source: https://docs.rs/fuser/latest/src/fuser/ll/request.rs.html

Structure for handling CUSE (Character device in Userspace) initialization requests.

```rust
    #[derive(Debug)]
    pub(crate) struct CuseInit<'a> {
        #[expect(dead_code)]
        header: &'a fuse_in_header,
        #[expect(dead_code)]
        arg: &'a fuse_init_in,
    }
```

--------------------------------

### Init Request Structure

Source: https://docs.rs/fuser/latest/src/fuser/ll/request.rs.html

Manages the initialization handshake between the FUSE filesystem and the kernel.

```rust
#[derive(Debug)]
pub(crate) struct Init<'a> {
    #[expect(dead_code)]
    header: &'a fuse_in_header,
    /// Unlike other operation we put this in a box,
    /// because we memcopy prefix into it instead of casting.
    arg: Box<fuse_init_in>,
}
impl Init<'_> {
    pub(crate) fn capabilities(&self) -> InitFlags {
        let flags = InitFlags::from_bits_retain(u64::from(self.arg.flags));
        if flags.contains(InitFlags::FUSE_INIT_EXT) {
            return InitFlags::from_bits_retain(
                u64::from(self.arg.flags) | (u64::from(self.arg.flags2) << 32),
            );
        }
        flags
    }
    pub(crate) fn max_readahead(&self) -> u32 {
        self.arg.max_readahead
    }
    pub(crate) fn version(&self) -> super::Version {
        super::Version(self.arg.major, self.arg.minor)
    }

    pub(crate) fn reply(&self, config: &crate::KernelConfig) -> ResponseData {
        let flags = config.requested | InitFlags::FUSE_INIT_EXT;
        // use requested features and reported as capable
        let flags = flags & self.capabilities();

        let mut init = fuse_init_out {
            major: FUSE_KERNEL_VERSION,
            minor: FUSE_KERNEL_MINOR_VERSION,
            max_readahead: config.max_readahead,
            flags: flags.pair().0,
            max_background: config.max_background,
            congestion_threshold: config.congestion_threshold(),
            max_write: config.max_write,
            time_gran: config.time_gran.as_nanos() as u32,
            max_pages: config.max_pages(),
            unused2: 0,
            flags2: flags.pair().1,
            max_stack_depth: 0,
            reserved: [0; 6],
        };

        if flags.contains(InitFlags::FUSE_PASSTHROUGH) {
            init.max_stack_depth = config.max_stack_depth;
        }

        let init = init.as_bytes();
        let init = if self.arg.minor < 5 {
            &init[..FUSE_COMPAT_INIT_OUT_SIZE]
        } else if self.arg.minor < 23 {
            &init[..FUSE_COMPAT_22_INIT_OUT_SIZE]
        } else {
            init
        };
        ResponseData::new_data(init)
    }

    /// Reply with only our version, used when kernel major version > our major version.
    /// The kernel will then send a second INIT request with a compatible version.
    pub(crate) fn reply_version_only(&self) -> ResponseData {
        let init = fuse_init_out {
            major: FUSE_KERNEL_VERSION,
            minor: FUSE_KERNEL_MINOR_VERSION,
            max_readahead: 0,
            flags: 0,
            max_background: 0,
            congestion_threshold: 0,
            max_write: 0,
            time_gran: 0,
            max_pages: 0,
```

--------------------------------

### open

Source: https://docs.rs/fuser/latest/src/fuser/lib.rs.html

Opens a file for reading or writing.

```APIDOC
## open(ino, flags, reply)

### Description
Opens a file identified by `ino`. The filesystem may store a file handle in the reply to be used in subsequent operations.

### Parameters
- **ino** (INodeNo) - The inode number of the file to open.
- **flags** (OpenFlags) - File open flags.
- **reply** (ReplyOpen) - The reply object to return the file handle and flags.
```

--------------------------------

### Create raw backing file reference

Source: https://docs.rs/fuser/latest/fuser/struct.BackingId.html

Creates a raw backing ID without the managed wrapper. Use this only when manual lifetime management is required.

```rust
pub fn create_raw(fuse_dev: impl AsFd, fd: impl AsFd) -> Result<u32>
```

--------------------------------

### ReplyDirectory Implementation

Source: https://docs.rs/fuser/latest/src/fuser/reply.rs.html

Manages directory entry listing responses, allowing entries to be added to a buffer before sending.

```rust
impl ReplyDirectory {
    /// Creates a new `ReplyDirectory` with a specified buffer size.
    pub(crate) fn new(unique: ll::RequestId, sender: ReplySender, size: usize) -> ReplyDirectory {
        ReplyDirectory {
            reply: Reply::new(unique, sender),
            data: DirEntList::new(size),
        }
    }

    /// Add an entry to the directory reply buffer. Returns true if the buffer is full.
    /// A transparent offset value can be provided for each entry. The kernel uses these
    /// value to request the next entries in further readdir calls
    #[must_use]
    pub fn add<T: AsRef<OsStr>>(
        &mut self,
        ino: INodeNo,
        offset: u64,
        kind: FileType,
        name: T,
    ) -> bool {
        let name = name.as_ref();
        self.data
            .push(&DirEntry::new(ino, DirEntOffset(offset), kind, name))
    }

    /// Reply to a request with the filled directory buffer
    pub fn ok(self) {
        let response: ll::ResponseData = self.data.into();
        self.reply.send_ll(&response);
    }

    /// Reply to a request with the given error code
    pub fn error(self, err: Errno) {
        self.reply.error(err);
    }
}
```

--------------------------------

### System-Level FUSE Mount Initialization

Source: https://docs.rs/fuser/latest/src/fuser/mnt/fuse_pure.rs.html

Performs initial checks and opens the FUSE device for system-level mount operations on supported platforms.

```rust
#[cfg(any(target_os = "linux", target_os = "macos"))]
fn fuse_mount_sys(
    mountpoint: &OsStr,
    options: &[MountOption],
    acl: SessionACL,
) -> Result<Option<DevFuse>, Error> {
    use std::os::unix::fs::PermissionsExt;

    let mountpoint_mode = File::open(mountpoint)?.metadata()?.permissions().mode();

    // Auto unmount requests must be sent to fusermount binary
    assert!(!options.contains(&MountOption::AutoUnmount));

    let file = match DevFuse::open() {
        Ok(dev_fuse) => dev_fuse,
        Err(error) => {
            if error.kind() == ErrorKind::NotFound {
                error!("{} not found. Try 'modprobe fuse'", DevFuse::PATH);
            }
            return Err(error);
        }
    };
    assert!(
        file.as_raw_fd() > 2,
        "Conflict with stdin/stdout/stderr. fd={}",
        file.as_raw_fd()
    );

    let mut mount_options = format!(
```

--------------------------------

### Implement DirEntList

Source: https://docs.rs/fuser/latest/src/fuser/ll/reply.rs.html

Provides methods to push directory entries into a list and convert it to a response.

```rust
impl DirEntList {
    pub(crate) fn new(max_size: usize) -> Self {
        Self(EntListBuf::new(max_size))
    }
    /// Add an entry to the directory reply buffer. Returns true if the buffer is full.
    /// A transparent offset value can be provided for each entry. The kernel uses these
    /// value to request the next entries in further readdir calls
    #[must_use]
    pub(crate) fn push<T: AsRef<Path>>(&mut self, ent: &DirEntry<T>) -> bool {
        let name = ent.name.as_ref().as_os_str().as_bytes();
        let header = abi::fuse_dirent {
            ino: ent.ino.into(),
            off: ent.offset.0,
            namelen: name.len().try_into().expect("Name too long"),
            typ: mode_from_kind_and_perm(ent.kind, 0) >> 12,
        };
        self.0.push([header.as_bytes(), name])
    }
}
```

--------------------------------

### Implement testing utilities

Source: https://docs.rs/fuser/latest/src/fuser/ll/mod.rs.html

Provides alignment helpers and IO slice conversion utilities for unit testing.

```rust
    /// If we want to be able to cast bytes to our fuse C struct types we need it
    /// to be aligned.  This struct helps getting &[u8]s which are 8 byte aligned.
    #[cfg(test)]
    #[repr(align(8))]
    pub(crate) struct AlignedData<T>(pub T);
    impl<T> Deref for AlignedData<T> {
        type Target = T;

        fn deref(&self) -> &Self::Target {
            &self.0
        }
    }
    impl<T> DerefMut for AlignedData<T> {
        fn deref_mut(&mut self) -> &mut Self::Target {
            &mut self.0
        }
    }

    pub(crate) fn ioslice_to_vec(s: &[IoSlice<'_>]) -> Vec<u8> {
        let mut v = Vec::with_capacity(s.iter().map(|x| x.len()).sum());
        for x in s {
            v.extend_from_slice(x);
        }
        v
    }
```

--------------------------------

### Mount FUSE filesystem

Source: https://docs.rs/fuser/latest/src/fuser/mnt/fuse_pure.rs.html

Configures and executes the fusermount command with appropriate options and environment variables.

```rust
fn fuse_mount_fusermount(
    mountpoint: &OsStr,
    options: &[MountOption],
    acl: SessionACL,
) -> Result<(DevFuse, Option<UnixStream>), Error> {
    let fusermount_bin = detect_fusermount_bin();

    if fusermount_bin.ends_with(MOUNT_FUSEFS_BIN) {
        return fuse_mount_mount_fusefs(&fusermount_bin, mountpoint, options, acl);
    }

    let (child_socket, receive_socket) = UnixStream::pair()?;

    let mut builder = Command::new(&fusermount_bin);
    builder.stdout(Stdio::piped()).stderr(Stdio::piped());
    let mut options_strs: Vec<String> = options.iter().map(option_to_string).collect();
    options_strs.extend(acl.to_mount_option().map(|s| s.to_owned()));
    if !options_strs.is_empty() {
        builder.arg("-o");
        builder.arg(options_strs.join(","));
    }
    builder
        .arg("--")
        .arg(mountpoint)
        .env(FUSERMOUNT_COMM_ENV, child_socket.as_raw_fd().to_string());

    unsafe {
```

--------------------------------

### Mount a filesystem synchronously

Source: https://docs.rs/fuser/latest/src/fuser/lib.rs.html

Mounts a filesystem to a specified path and blocks until the session ends.

```rust
pub fn mount<FS: Filesystem, P: AsRef<Path>>(
    filesystem: FS,
    mountpoint: P,
    options: &Config,
) -> io::Result<()> {
    Session::new(filesystem, mountpoint.as_ref(), options).and_then(session::Session::run)
}
```

--------------------------------

### Session::new

Source: https://docs.rs/fuser/latest/fuser/struct.Session.html

Creates a new FUSE session by mounting a filesystem to a specified mountpoint.

```APIDOC
## Session::new

### Description
Creates a new session by mounting the given filesystem to the given mountpoint.

### Signature
`pub fn new<P: AsRef<Path>>(filesystem: FS, mountpoint: P, options: &Config) -> Result<Session<FS>>`

### Errors
Returns an error if the options are incorrect, or if the fuse device can’t be mounted.
```

--------------------------------

### Access Control and File Creation

Source: https://docs.rs/fuser/latest/src/fuser/lib.rs.html

Methods for checking file permissions and creating new files with specific flags.

```rust
    /// Check file access permissions.
    /// This will be called for the `access()` system call. If the `default_permissions`
    /// mount option is given, this method is not called. This method is not called
    /// under Linux kernel versions 2.4.x
    fn access(&self, _req: &Request, ino: INodeNo, mask: AccessFlags, reply: ReplyEmpty) {
        warn!("[Not Implemented] access(ino: {ino:#x?}, mask: {mask})");
        reply.error(Errno::ENOSYS);
    }

    /// Create and open a file.
    /// If the file does not exist, first create it with the specified mode, and then
    /// open it. You can use any open flags in the flags parameter except `O_NOCTTY`.
    /// The filesystem can store any type of file handle (such as a pointer or index)
    /// in fh, which can then be used across all subsequent file operations including
    /// read, write, flush, release, and fsync. Additionally, the filesystem may set
    /// certain flags like `direct_io` and `keep_cache` to change the way the file is
    /// opened. See `fuse_file_info` structure in <`fuse_common.h`> for more details. If
    /// this method is not implemented or under Linux kernel versions earlier than
    /// 2.6.15, the `mknod()` and `open()` methods will be called instead.
    fn create(
        &self,
        _req: &Request,
        parent: INodeNo,
        name: &OsStr,
        mode: u32,
        umask: u32,
        flags: i32,
        reply: ReplyCreate,
    ) {
        warn!(
            "[Not Implemented] create(parent: {parent:#x?}, name: {name:?}, mode: {mode}, \
            umask: {umask:#x?}, flags: {flags:#x?})"
        );
        reply.error(Errno::ENOSYS);
    }
```

--------------------------------

### Manage Directory Entry Buffers

Source: https://docs.rs/fuser/latest/src/fuser/ll/reply.rs.html

Handles the creation and population of directory entry buffers for FUSE readdir responses.

```rust
impl EntListBuf {
    pub(crate) fn new(max_size: usize) -> Self {
        Self {
            max_size,
            buf: ResponseBuf::new(),
        }
    }

    /// Add an entry to the directory reply buffer. Returns true if the buffer is full.
    /// A transparent offset value can be provided for each entry. The kernel uses these
    /// value to request the next entries in further readdir calls
    #[must_use]
    pub(crate) fn push(&mut self, ent: [&[u8]; 2]) -> bool {
        debug_assert!(self.buf.len() % size_of::<u64>() == 0);

        let entlen = ent[0].len() + ent[1].len();
        let entsize = entlen.next_multiple_of(size_of::<u64>()); // 64 bit align
        if self.buf.len() + entsize > self.max_size {
            return true;
        }
        self.buf.reserve(entsize);
        self.buf.extend_from_slice(ent[0]);
        self.buf.extend_from_slice(ent[1]);
        let padlen = entsize - entlen;
        self.buf.resize(self.buf.len() + padlen, 0);
        false
    }
}
```

--------------------------------

### Session::spawn

Source: https://docs.rs/fuser/latest/fuser/struct.Session.html

Runs the session loop in a background thread.

```APIDOC
## Session::spawn

### Description
Run the session loop in a background thread. If the returned handle is dropped, the filesystem is unmounted and the given session ends.

### Signature
`pub fn spawn(self) -> Result<BackgroundSession>`
```

--------------------------------

### ReplyOpen Implementation

Source: https://docs.rs/fuser/latest/src/fuser/reply.rs.html

Handles responses for open requests, including support for kernel passthrough via BackingId.

```rust
impl Reply for ReplyOpen {
    fn new(unique: ll::RequestId, sender: ReplySender) -> ReplyOpen {
        ReplyOpen {
            reply: Reply::new(unique, sender),
        }
    }
}

impl ReplyOpen {
    /// Reply to a request with the given open result
    /// # Panics
    /// When attempting to use kernel passthrough.
    /// Use [`opened_passthrough()`](Self::opened_passthrough) instead.
    pub fn opened(self, fh: ll::FileHandle, flags: FopenFlags) {
        assert!(!flags.contains(FopenFlags::FOPEN_PASSTHROUGH));
        self.reply
            .send_ll(&ll::ResponseStruct::new_open(fh, flags, 0));
    }

    /// Registers a fd for passthrough, returning a `BackingId`.  Once you have the backing ID,
    /// you can pass it as the 3rd parameter of [`ReplyOpen::opened_passthrough()`]. This is done in
    /// two separate steps because you must reuse backing IDs for the same inode for all open file handles.
    pub fn open_backing(&self, fd: impl std::os::fd::AsFd) -> std::io::Result<BackingId> {
        // TODO: assert passthrough capability is enabled.
        self.reply.sender.as_ref().unwrap().open_backing(fd.as_fd())
    }

    /// Wraps a raw FUSE `backing_id` value, returning a `BackingId`. Once you have the backing ID,
    /// you can pass it as the 3rd parameter of [`ReplyOpen::opened_passthrough()`]. This is done in
    /// two separate steps because you must reuse backing IDs for the same inode for all open file handles.
    ///
    /// This function takes ownership of the given backing ID value, automatically closing it once
    /// the returned `BackingId` is dropped. You may reobtain ownership of the backing ID by calling
    /// [`BackingId::into_raw()`].
    ///
    /// # Safety
    ///
    /// The given ID must be open and belong to this FUSE session, and may not be closed while the
    /// returned `BackingId` instance is still live.
    pub unsafe fn wrap_backing(&self, id: u32) -> BackingId {
        // TODO: assert passthrough capability is enabled.
        unsafe { self.reply.sender.as_ref().unwrap().wrap_backing(id) }
    }

    /// Reply to a request with an opened backing id. Call [`ReplyOpen::open_backing()`]
    /// to get one of these.
    ///
    /// Note that you must reuse the given `BackingId` for all future [`ReplyOpen::opened_passthrough()`]
    /// invocations as long as the passed file handle stays open!
    pub fn opened_passthrough(self, fh: ll::FileHandle, flags: FopenFlags, backing_id: &BackingId) {
        // TODO: assert passthrough capability is enabled.
        let flags = flags | FopenFlags::FOPEN_PASSTHROUGH;
        self.reply.send_ll(&ll::ResponseStruct::new_open(
            fh,
            flags,
            backing_id.backing_id,
        ));
    }

    /// Reply to a request with the given error code
    pub fn error(self, err: Errno) {
        self.reply.error(err);
    }
}
```

--------------------------------

### MkDir Request Structure

Source: https://docs.rs/fuser/latest/src/fuser/ll/request.rs.html

Represents a request to create a new directory.

```rust
/// Create a directory.
#[derive(Debug)]
pub(crate) struct MkDir<'a> {
    #[expect(dead_code)]
    header: &'a fuse_in_header,
    arg: &'a fuse_mkdir_in,
    name: &'a Path,
}
impl<'a> MkDir<'a> {
    pub(crate) fn name(&self) -> &'a Path {
        self.name
    }
    pub(crate) fn mode(&self) -> u32 {
        self.arg.mode
    }
    pub(crate) fn umask(&self) -> u32 {
        self.arg.umask
    }
}
```

--------------------------------

### spawn_mount

Source: https://docs.rs/fuser/latest/fuser/index.html

Mounts a given filesystem to a specified mountpoint in a background thread, allowing the main thread to continue execution.

```APIDOC
## spawn_mount

### Description
Mount the given filesystem to the given mountpoint. This function spawns a background thread to handle filesystem operations while being mounted and therefore returns immediately. The returned handle should be stored to reference the mounted filesystem. If it’s dropped, the filesystem will be unmounted.

### Signature
`pub fn spawn_mount<FS: Filesystem + Send + 'static, P: AsRef<Path>>(filesystem: FS, mountpoint: P, options: &[MountOption]) -> Result<BackgroundSession, Error>`
```
Tokens:
Raw