Struct sys_mount::Mount

pub struct Mount { /* private fields */ }

Handle for managing a mounted file system.

Implementations

impl Mount

pub fn new<'a, S, T, F>(
    source: S,
    target: T,
    fstype: F,
    flags: MountFlags,
    data: Option<&str>
) -> Result<Self>where
    S: AsRef<Path>,
    T: AsRef<Path>,
    F: Into<FilesystemType<'a>>,

Mounts a file system at source to a target path in the system.

extern crate sys_mount;

use sys_mount::{
    Mount,
    MountFlags,
    SupportedFilesystems
};

fn main() {
    // Fetch a list of supported file systems.
    // When mounting, a file system will be selected from this.
    let supported = SupportedFilesystems::new().unwrap();

    // Attempt to mount the src device to the dest directory.
    let mount_result = Mount::new(
        "/imaginary/block/device",
        "/tmp/location",
        &supported,
        MountFlags::empty(),
        None
    );
}

Notes

The provided source device and target destinations must exist within the file system.

If the source is a file with an iso or squashfs extension, a loopback device will be created, and the file will be associated with the loopback device. The MountFlags will also be modified to ensure that the MountFlags::RDONLY flag is set before mounting.

The fstype parameter accepts either a &str or &SupportedFilesystem as input. If the input is a &str, then a particular file system will be used to mount the source with. If the input is a &SupportedFilesystems, then the file system will be selected automatically from the list.

The automatic variant of fstype works by attempting to mount the source with all supported device-based file systems until it succeeds, or fails after trying all possible options.

pub fn backing_loop_device(&self) -> Option<&Path>

If the device was associated with a loopback device, that device’s path can be retrieved here.

pub fn get_fstype(&self) -> &str

Describes the file system which this mount was mounted with.

This is useful in the event that the mounted device was mounted automatically.

Trait Implementations

impl Debug for Mount

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Unmount for Mount

fn unmount(&self, flags: UnmountFlags) -> Result<()>

Unmount this mount with the given flags.

fn into_unmount_drop(self, flags: UnmountFlags) -> UnmountDrop<Self>where
    Self: Sized,

Upgrades Self into an UnmountDrop, which will unmount the mount when it is dropped.