bootc_internal_mount/

tempmount.rs

use std::os::fd::AsFd;
use std::path::Path;

use anyhow::{Context, Result};

use camino::Utf8Path;
use cap_std_ext::cap_std::{ambient_authority, fs::Dir};
use fn_error_context::context;
use rustix::mount::{
    MountFlags, MoveMountFlags, OpenTreeFlags, UnmountFlags, move_mount, open_tree, unmount,
};

/// RAII guard that synchronously unmounts a path on drop, flushing all writes.
///
/// Prefer this over `MNT_DETACH` when the mounted filesystem has received
/// writes (e.g. FAT ESP) and you need them flushed before the guard drops.
#[derive(Debug)]
pub struct MountGuard(std::path::PathBuf);

impl MountGuard {
    /// Mount `dev` at `path` and return a guard that will synchronously
    /// unmount it on drop.
    pub fn mount(
        dev: &str,
        path: std::path::PathBuf,
        fstype: &str,
        flags: MountFlags,
        data: Option<&std::ffi::CStr>,
    ) -> Result<Self> {
        rustix::mount::mount(dev, &path, fstype, flags, data)
            .with_context(|| format!("Mounting {} at {}", dev, path.display()))?;
        Ok(Self(path))
    }
}

impl std::ops::Deref for MountGuard {
    type Target = Path;
    fn deref(&self) -> &Path {
        &self.0
    }
}

impl Drop for MountGuard {
    fn drop(&mut self) {
        if let Err(e) = unmount(&self.0, UnmountFlags::empty()) {
            // Synchronous unmount failure may mean buffered writes were not
            // flushed to the underlying device (e.g. FAT ESP).  Treat this as
            // an error rather than a warning.
            tracing::error!("Failed to unmount {}: {e:?}", self.0.display());
        }
    }
}

/// Holds a tempdir with custom Drop impl
#[derive(Debug)]
pub struct MountpointTempdir(tempfile::TempDir);

impl std::ops::Deref for MountpointTempdir {
    type Target = tempfile::TempDir;
    fn deref(&self) -> &tempfile::TempDir {
        &self.0
    }
}

impl MountpointTempdir {
    fn new() -> Result<Self> {
        let mut tmpdir = tempfile::TempDir::new()?;
        tmpdir.disable_cleanup(true); // We will clean this ourselves
        Ok(Self(tmpdir))
    }
}

impl Drop for MountpointTempdir {
    fn drop(&mut self) {
        // Intentionally not using remove_dir_all so that we don't
        // accidentally end up deleting anything mounted at this path
        if let Err(e) = std::fs::remove_dir(self.path()) {
            tracing::warn!(
                "Failed to remove tmpdir at {}: {e:?}",
                self.path().display()
            )
        }
    }
}

/// RAII wrapper for a temporary mount that is automatically unmounted on drop.
#[derive(Debug)]
pub struct TempMount {
    /// The backing temporary directory.
    pub dir: MountpointTempdir,
    /// An open handle to the mounted directory.
    pub fd: Dir,
}

impl TempMount {
    /// Mount device/partition on a tempdir which will be automatically unmounted on drop
    #[context("Mounting {dev}")]
    pub fn mount_dev(
        dev: &str,
        fstype: &str,
        flags: MountFlags,
        data: Option<&std::ffi::CStr>,
    ) -> Result<Self> {
        let tempdir = MountpointTempdir::new()?;

        let utf8path = Utf8Path::from_path(tempdir.path())
            .ok_or(anyhow::anyhow!("Failed to convert path to UTF-8 Path"))?;

        rustix::mount::mount(dev, utf8path.as_std_path(), fstype, flags, data)?;

        let fd = Dir::open_ambient_dir(tempdir.path(), ambient_authority())
            .with_context(|| format!("Opening {:?}", tempdir.path()));

        let fd = match fd {
            Ok(fd) => fd,
            Err(e) => {
                unmount(tempdir.path(), UnmountFlags::DETACH)?;
                return Err(e)?;
            }
        };

        Ok(Self { dir: tempdir, fd })
    }

    /// Clone an existing mount into a tempdir via `open_tree(OPEN_TREE_CLONE)`
    /// + `move_mount(MOVE_MOUNT_F_EMPTY_PATH)`. The returned `TempMount`
    /// is a private view of the same filesystem — the source mount at
    /// `source_target` is untouched and remains visible to other processes.
    ///
    /// The clone inherits the source mount's attributes (rw/ro, nosuid,
    /// nodev, fmask/dmask, etc.). Callers that require specific mount
    /// options should use `mount_dev` and treat `EBUSY` as unrecoverable
    /// — this function is intended for read-only callers that can accept
    /// whatever the current mount happens to expose.
    #[context("Cloning existing mount at {source_target}")]
    pub fn clone_existing_mount(source_target: &Utf8Path) -> Result<Self> {
        let tempdir = MountpointTempdir::new()?;

        let cloned = open_tree(
            rustix::fs::CWD,
            source_target.as_std_path(),
            OpenTreeFlags::OPEN_TREE_CLOEXEC | OpenTreeFlags::OPEN_TREE_CLONE,
        )
        .with_context(|| format!("open_tree({source_target})"))?;
        move_mount(
            cloned.as_fd(),
            "",
            rustix::fs::CWD,
            tempdir.path(),
            MoveMountFlags::MOVE_MOUNT_F_EMPTY_PATH,
        )
        .context("move_mount")?;

        let fd = Dir::open_ambient_dir(tempdir.path(), ambient_authority())
            .with_context(|| format!("Opening {:?}", tempdir.path()));

        let fd = match fd {
            Ok(fd) => fd,
            Err(e) => {
                unmount(tempdir.path(), UnmountFlags::DETACH)?;
                return Err(e)?;
            }
        };

        Ok(Self { dir: tempdir, fd })
    }

    /// Mount and fd acquired with `open_tree` like syscall
    #[context("Mounting fd")]
    pub fn mount_fd(mnt_fd: impl AsFd) -> Result<Self> {
        let tempdir = MountpointTempdir::new()?;

        move_mount(
            mnt_fd.as_fd(),
            "",
            rustix::fs::CWD,
            tempdir.path(),
            MoveMountFlags::MOVE_MOUNT_F_EMPTY_PATH,
        )
        .context("move_mount")?;

        let fd = Dir::open_ambient_dir(tempdir.path(), ambient_authority())
            .with_context(|| format!("Opening {:?}", tempdir.path()));

        let fd = match fd {
            Ok(fd) => fd,
            Err(e) => {
                unmount(tempdir.path(), UnmountFlags::DETACH)?;
                return Err(e)?;
            }
        };

        Ok(Self { dir: tempdir, fd })
    }
}

impl Drop for TempMount {
    fn drop(&mut self) {
        match unmount(self.dir.path(), UnmountFlags::DETACH) {
            Ok(_) => {}
            Err(e) => tracing::warn!("Failed to unmount tempdir: {e:?}"),
        }
    }
}