diff --git a/Cargo.lock b/Cargo.lock
index 8dd26aba..3879426d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1511,6 +1511,7 @@ dependencies = [
  "uu_lsmem",
  "uu_mcookie",
  "uu_mesg",
+ "uu_mount",
  "uu_mountpoint",
  "uu_nologin",
  "uu_renice",
@@ -1669,6 +1670,16 @@ dependencies = [
  "uucore 0.2.2",
 ]
 
+[[package]]
+name = "uu_mount"
+version = "0.0.1"
+dependencies = [
+ "clap",
+ "libc",
+ "thiserror",
+ "uucore 0.2.2",
+]
+
 [[package]]
 name = "uu_mountpoint"
 version = "0.0.1"
diff --git a/Cargo.toml b/Cargo.toml
index b05af895..9eb55459 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -40,6 +40,7 @@ feat_common_core = [
   "lsmem",
   "mcookie",
   "mesg",
+  "mount",
   "mountpoint",
   "nologin",
   "renice",
@@ -108,6 +109,7 @@ lslocks = { optional = true, version = "0.0.1", package = "uu_lslocks", path = "
 lsmem = { optional = true, version = "0.0.1", package = "uu_lsmem", path = "src/uu/lsmem" }
 mcookie = { optional = true, version = "0.0.1", package = "uu_mcookie", path = "src/uu/mcookie" }
 mesg = { optional = true, version = "0.0.1", package = "uu_mesg", path = "src/uu/mesg" }
+mount = { optional = true, version = "0.0.1", package = "uu_mount", path = "src/uu/mount" }
 mountpoint = { optional = true, version = "0.0.1", package = "uu_mountpoint", path = "src/uu/mountpoint" }
 nologin = { optional = true, version = "0.0.1", package = "uu_nologin", path = "src/uu/nologin" }
 renice = { optional = true, version = "0.0.1", package = "uu_renice", path = "src/uu/renice" }
@@ -121,6 +123,7 @@ ctor = "0.6.0"
 # dmesg test require fixed-boot-time feature turned on.
 dmesg = { version = "0.0.1", package = "uu_dmesg", path = "src/uu/dmesg", features = ["fixed-boot-time"] }
 libc = { workspace = true }
+mount = { version = "0.0.1", package = "uu_mount", path = "src/uu/mount" }
 pretty_assertions = "1"
 rand = { workspace = true }
 regex = { workspace = true }
diff --git a/src/uu/mount/Cargo.toml b/src/uu/mount/Cargo.toml
new file mode 100644
index 00000000..98088242
--- /dev/null
+++ b/src/uu/mount/Cargo.toml
@@ -0,0 +1,17 @@
+[package]
+name = "uu_mount"
+version = "0.0.1"
+edition = "2021"
+
+[lib]
+path = "src/mount.rs"
+
+[[bin]]
+name = "mount"
+path = "src/main.rs"
+
+[dependencies]
+clap = { workspace = true }
+libc = { workspace = true }
+thiserror = { workspace = true }
+uucore = { workspace = true }
diff --git a/src/uu/mount/mount.md b/src/uu/mount/mount.md
new file mode 100644
index 00000000..3399590a
--- /dev/null
+++ b/src/uu/mount/mount.md
@@ -0,0 +1,109 @@
+# mount
+
+```
+mount [options]
+mount [options] <source> <directory>
+mount [options] <source> | <directory>
+mount [options] --source <source> [--target <directory>]
+mount [options] [--source <source>] --target <directory>
+mount [options] --make-{shared,slave,private,unbindable} <mountpoint>
+mount [options] --make-{rshared,rslave,rprivate,runbindable} <mountpoint>
+```
+
+Mount a filesystem, or show all currently mounted filesystems.
+
+When called without arguments, or with `-t` but no source and target, mount
+prints all currently mounted filesystems (read from `/proc/mounts` on Linux).
+The `-t` option filters the listing to entries of the given type. `-l` requests
+labels in listing output when they can be discovered from `/dev/disk/by-label`.
+
+When called with a source device and a target directory, mount attaches the
+filesystem found on the source to the target directory.
+
+When called with a single positional argument, mount resolves that argument via
+`/etc/fstab`. The argument may be either a source specifier or a mount point.
+`--source` and `--target` can be used to disambiguate that lookup.
+
+When called with `--make-*`, mount applies mount-propagation changes to the
+specified mountpoint. If a normal mount is also requested in the same command,
+the propagation changes are applied after the mount succeeds.
+
+## Supported contract
+
+This implementation currently targets **Linux** and is intended to provide a
+strong baseline `mount` with the core operational semantics in place:
+
+- no-argument listing from `/proc/mounts`
+- direct mounts plus `--bind`, `--rbind`, and `--move`
+- `--all` with already-mounted skipping, `-t` filtering, `-O` filtering, and
+  optional `--fork`
+- `/etc/fstab`-driven single-argument resolution, including alternate files via
+  `-T`
+- label/UUID/PARTLABEL/PARTUUID resolution
+- merged `fstab` + CLI `-o` options for fstab-derived mounts
+- optional mountpoint creation via `-m`
+- propagation changes via `--make-*`
+
+This command is **not yet a full upstream-compatible replacement** for every
+advanced `mount(8)` feature. The supported behavior is intentionally explicit so
+reviewers can evaluate the current contract clearly.
+
+## Options
+
+- `-a`, `--all` — mount all filesystems listed in `/etc/fstab` (respects `noauto`
+  and `-t` / `-O` filters)
+- `-B`, `--bind` — bind-mount a subtree at another location (`MS_BIND`)
+- `-R`, `--rbind` — recursively bind-mount a subtree (`MS_BIND | MS_REC`)
+- `-M`, `--move` — atomically move a mounted subtree to a new location
+  (`MS_MOVE`)
+- `--make-shared` — mark a subtree as shared
+- `--make-slave` — mark a subtree as slave
+- `--make-private` — mark a subtree as private
+- `--make-unbindable` — mark a subtree as unbindable
+- `--make-rshared` — recursively mark a whole subtree as shared
+- `--make-rslave` — recursively mark a whole subtree as slave
+- `--make-rprivate` — recursively mark a whole subtree as private
+- `--make-runbindable` — recursively mark a whole subtree as unbindable
+- `-f`, `--fake` — dry run; parse arguments and resolve devices but skip the
+  actual `mount(2)` syscall
+- `-F`, `--fork` — with `--all`, mount matching filesystems in separate worker
+  processes
+- `-T`, `--fstab PATH` — use an alternate fstab file instead of `/etc/fstab`
+- `-l`, `--show-labels` — show filesystem labels in listing output when
+  available
+- `-m`, `--mkdir` — create the target mountpoint if it does not already exist
+- `-n`, `--no-mtab` — do not write an entry to `/etc/mtab`
+- `-o`, `--options LIST` — comma-separated list of mount options (e.g.
+  `ro,noatime,uid=1000`); for `/etc/fstab`-resolved mounts, CLI options are
+  appended after `fstab` options so later values win
+- `-O`, `--test-opts LIST` — with `--all`, limit mounts to fstab entries whose
+  option field matches `LIST`
+- `-r`, `--read-only` — mount read-only (same as `-o ro`)
+- `-w`, `--read-write` — mount read-write, overriding a `ro` option from fstab
+- `-t`, `--types LIST` — filesystem type filter; prefix a type with `no` to
+  exclude it (e.g. `-t noext4`)
+- `-v`, `--verbose` — print a diagnostic line for each mount operation
+- `-L`, `--label LABEL` — mount the device with the given filesystem label
+- `-U`, `--uuid UUID` — mount the device with the given filesystem UUID
+- `--partlabel LABEL` — mount the partition with the given partition label
+  (`PARTLABEL=`)
+- `--partuuid UUID` — mount the partition with the given partition UUID
+  (`PARTUUID=`)
+- `--source SOURCE` — explicitly specify the source side of the mount or the
+  single-argument fstab lookup key
+- `--target DIRECTORY` — explicitly specify the target side of the mount or the
+  single-argument fstab lookup key
+
+## Notes
+
+- `--make-*` propagation operations are not combined with `--all`.
+- Propagation changes do not read `/etc/fstab`; provide the target mountpoint
+  explicitly when using them directly.
+
+## Deferred features
+
+Notable items that remain outside the current supported contract include:
+
+- alternate `--options-mode` handling beyond the current append-style merge
+- helper-specific behaviors outside this in-process Linux implementation
+- additional advanced `mount(8)` compatibility options not yet implemented
diff --git a/src/uu/mount/src/errors.rs b/src/uu/mount/src/errors.rs
new file mode 100644
index 00000000..4a205501
--- /dev/null
+++ b/src/uu/mount/src/errors.rs
@@ -0,0 +1,66 @@
+// This file is part of the uutils util-linux package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use thiserror::Error;
+use uucore::error::UError;
+
+pub const EXIT_MOUNT_FAILED: i32 = 32;
+
+#[derive(Error, Debug)]
+pub enum MountError {
+    #[error("cannot open /proc/mounts: {0}")]
+    ProcMounts(std::io::Error),
+
+    #[error("cannot read {0}: {1}")]
+    FstabRead(String, std::io::Error),
+
+    #[error("I/O error: {0}")]
+    Fstab(#[from] std::io::Error),
+
+    #[error("cannot find device with label {0:?}")]
+    LabelNotFound(String),
+
+    #[error("cannot find device with UUID {0:?}")]
+    UuidNotFound(String),
+
+    #[error("cannot find mount entry for {0:?} in fstab")]
+    FstabEntryNotFound(String),
+
+    #[error("no mount point specified and none found in fstab for {0}")]
+    NoMountPoint(String),
+
+    #[error("cannot create mount point {0}: {1}")]
+    CreateMountPoint(String, std::io::Error),
+
+    #[error("cannot fork mount worker: {0}")]
+    Fork(std::io::Error),
+
+    #[error("cannot wait for mount worker: {0}")]
+    Wait(std::io::Error),
+
+    #[error("invalid source path: {0}")]
+    InvalidSource(std::ffi::NulError),
+
+    #[error("invalid target path: {0}")]
+    InvalidTarget(std::ffi::NulError),
+
+    #[error("invalid filesystem type: {0}")]
+    InvalidFSType(std::ffi::NulError),
+
+    #[error("invalid mount options: {0}")]
+    InvalidOptions(std::ffi::NulError),
+
+    #[error("mount: {1} on {2}: {0}")]
+    MountFailed(std::io::Error, String, String),
+}
+
+impl UError for MountError {
+    fn code(&self) -> i32 {
+        match self {
+            MountError::MountFailed(_, _, _) => EXIT_MOUNT_FAILED,
+            _ => 1,
+        }
+    }
+}
diff --git a/src/uu/mount/src/escape.rs b/src/uu/mount/src/escape.rs
new file mode 100644
index 00000000..43239fb1
--- /dev/null
+++ b/src/uu/mount/src/escape.rs
@@ -0,0 +1,32 @@
+// This file is part of the uutils util-linux package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+/// Expand octal escape sequences of the form `\NNN` used in mount-table style
+/// files to encode whitespace and other special characters.
+pub(crate) fn unescape_octal(s: &str) -> String {
+    let mut result: Vec<u8> = Vec::with_capacity(s.len());
+    let bytes = s.as_bytes();
+    let mut i = 0;
+    while i < bytes.len() {
+        if bytes[i] == b'\\' && i + 3 < bytes.len() {
+            let (a, b, c) = (bytes[i + 1], bytes[i + 2], bytes[i + 3]);
+            if a.is_ascii_digit()
+                && a < b'8'
+                && b.is_ascii_digit()
+                && b < b'8'
+                && c.is_ascii_digit()
+                && c < b'8'
+            {
+                let value = (a - b'0') * 64 + (b - b'0') * 8 + (c - b'0');
+                result.push(value);
+                i += 4;
+                continue;
+            }
+        }
+        result.push(bytes[i]);
+        i += 1;
+    }
+    String::from_utf8_lossy(&result).into_owned()
+}
diff --git a/src/uu/mount/src/fstab.rs b/src/uu/mount/src/fstab.rs
new file mode 100644
index 00000000..7d17eb62
--- /dev/null
+++ b/src/uu/mount/src/fstab.rs
@@ -0,0 +1,419 @@
+// This file is part of the uutils util-linux package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use crate::errors::MountError;
+use crate::escape::unescape_octal;
+#[cfg(target_os = "linux")]
+use std::path::Path;
+
+/// Case-insensitive prefix strip that preserves the original case of the
+/// remaining slice (the prefix must be ASCII-only for correctness).
+fn strip_ci_prefix<'a>(s: &'a str, prefix: &str) -> Option<&'a str> {
+    if s.len() >= prefix.len() && s[..prefix.len()].eq_ignore_ascii_case(prefix) {
+        Some(&s[prefix.len()..])
+    } else {
+        None
+    }
+}
+
+/// A parsed entry from `/etc/fstab`.
+#[derive(Debug, PartialEq, Clone)]
+pub struct FsTabEntry {
+    /// Device or remote filesystem (e.g. `/dev/sda1`, `UUID=...`, `LABEL=...`).
+    pub fs_spec: String,
+    /// Mount point (e.g. `/`, `/boot`).
+    pub fs_file: String,
+    /// Filesystem type (e.g. `ext4`, `tmpfs`).
+    pub fs_vfstype: String,
+    /// Mount options (e.g. `defaults`, `ro,noatime`).
+    pub fs_mntops: String,
+    /// Dump frequency (0 = never backed up).
+    pub fs_freq: i32,
+    /// `fsck` pass order (0 = skip).
+    pub fs_passno: i32,
+}
+
+/// The parameters needed to perform a mount, as resolved from a label or UUID.
+#[derive(Debug, PartialEq)]
+pub struct ResolvedMount {
+    /// Actual block device path (e.g. `/dev/sda1`).
+    pub source: String,
+    /// Mount point (e.g. `/boot`).
+    pub target: String,
+    /// Filesystem type, if known.
+    pub fs_type: Option<String>,
+    /// Mount options string.
+    pub options: String,
+}
+
+/// Parse the contents of an `/etc/fstab`-formatted string into a list of
+/// entries.
+///
+/// - Lines beginning with `#` and blank lines are ignored.
+/// - Fields are separated by any amount of whitespace (spaces or tabs).
+/// - Octal escape sequences (`\040`, `\011`, …) in field values are expanded.
+/// - The `fs_freq` and `fs_passno` fields are optional and default to `0`.
+/// - Lines with fewer than four fields are silently skipped.
+pub fn parse_fstab_contents(contents: &str) -> Vec<FsTabEntry> {
+    let mut entries = Vec::new();
+    for line in contents.lines() {
+        let line = line.trim();
+        if line.is_empty() || line.starts_with('#') {
+            continue;
+        }
+        let fields: Vec<&str> = line.split_whitespace().collect();
+        if fields.len() < 4 {
+            continue;
+        }
+        let fs_freq = fields.get(4).and_then(|s| s.parse().ok()).unwrap_or(0);
+        let fs_passno = fields.get(5).and_then(|s| s.parse().ok()).unwrap_or(0);
+        entries.push(FsTabEntry {
+            fs_spec: unescape_octal(fields[0]),
+            fs_file: unescape_octal(fields[1]),
+            fs_vfstype: fields[2].to_string(),
+            fs_mntops: fields[3].to_string(),
+            fs_freq,
+            fs_passno,
+        });
+    }
+    entries
+}
+
+/// Read and parse an fstab-formatted file.
+#[cfg(target_os = "linux")]
+pub fn parse_fstab_path(path: &Path) -> Result<Vec<FsTabEntry>, MountError> {
+    let contents = std::fs::read_to_string(path)
+        .map_err(|err| MountError::FstabRead(path.display().to_string(), err))?;
+    Ok(parse_fstab_contents(&contents))
+}
+
+// ── Label / UUID resolution ──────────────────────────────────────────────────
+
+/// Build a [`ResolvedMount`] from a set of fstab `entries` where `fs_spec`
+/// matches `spec` (compared case-insensitively).
+///
+/// `display` is used in error messages (e.g. `"LABEL=boot"`).
+fn resolve_from_entries(
+    spec: &str,
+    display: &str,
+    cli_target: Option<&str>,
+    entries: &[FsTabEntry],
+    not_found_err: MountError,
+) -> Result<ResolvedMount, MountError> {
+    let entry = entries
+        .iter()
+        .find(|e| e.fs_spec.eq_ignore_ascii_case(spec))
+        .cloned()
+        .ok_or(not_found_err)?;
+
+    let target = match cli_target {
+        Some(t) => t.to_string(),
+        None => entry.fs_file.clone(),
+    };
+
+    // Guard against accidentally trying to "mount" a swap entry with no
+    // meaningful mount point (fs_file is "none").
+    if target == "none" && cli_target.is_none() {
+        return Err(MountError::NoMountPoint(display.to_string()));
+    }
+
+    Ok(ResolvedMount {
+        source: entry.fs_spec.clone(),
+        target,
+        fs_type: Some(entry.fs_vfstype.clone()),
+        options: entry.fs_mntops.clone(),
+    })
+}
+
+/// Resolve a filesystem **label** to mount parameters using the supplied
+/// pre-loaded fstab `entries`.
+///
+/// Resolution order:
+/// 1. `/dev/disk/by-label/<label>` symlink (udev-maintained, most reliable).
+/// 2. A fstab entry whose `fs_spec` is `LABEL=<label>` (case-insensitive).
+///
+/// `cli_target`, when provided, overrides the mount point found in fstab.
+pub fn resolve_label_from(
+    label: &str,
+    cli_target: Option<&str>,
+    entries: &[FsTabEntry],
+) -> Result<ResolvedMount, MountError> {
+    let by_label = std::path::Path::new("/dev/disk/by-label").join(label);
+
+    if by_label.exists() {
+        // Canonicalize the symlink to get the real block device path.
+        let source = by_label
+            .canonicalize()
+            .map_err(MountError::Fstab)?
+            .to_string_lossy()
+            .into_owned();
+
+        // Also check fstab for the mount point and options.
+        let spec = format!("LABEL={label}");
+        let entry = entries
+            .iter()
+            .find(|e| e.fs_spec.eq_ignore_ascii_case(spec.as_str()))
+            .cloned();
+
+        let target = match cli_target {
+            Some(t) => t.to_string(),
+            None => entry
+                .as_ref()
+                .map(|e| e.fs_file.clone())
+                .ok_or_else(|| MountError::NoMountPoint(spec.clone()))?,
+        };
+
+        return Ok(ResolvedMount {
+            source,
+            target,
+            fs_type: entry.as_ref().map(|e| e.fs_vfstype.clone()),
+            options: entry
+                .as_ref()
+                .map(|e| e.fs_mntops.clone())
+                .unwrap_or_else(|| "defaults".to_string()),
+        });
+    }
+
+    // Fall back to a fstab LABEL= entry.
+    let spec = format!("LABEL={label}");
+    resolve_from_entries(
+        &spec,
+        &spec,
+        cli_target,
+        entries,
+        MountError::LabelNotFound(label.to_string()),
+    )
+}
+
+/// Resolve a **UUID** to mount parameters using the supplied pre-loaded fstab
+/// `entries`.
+///
+/// Resolution order:
+/// 1. `/dev/disk/by-uuid/<uuid>` symlink.
+/// 2. A fstab entry whose `fs_spec` is `UUID=<uuid>` (case-insensitive).
+///
+/// `cli_target`, when provided, overrides the mount point found in fstab.
+pub fn resolve_uuid_from(
+    uuid: &str,
+    cli_target: Option<&str>,
+    entries: &[FsTabEntry],
+) -> Result<ResolvedMount, MountError> {
+    let by_uuid = std::path::Path::new("/dev/disk/by-uuid").join(uuid);
+
+    if by_uuid.exists() {
+        let source = by_uuid
+            .canonicalize()
+            .map_err(MountError::Fstab)?
+            .to_string_lossy()
+            .into_owned();
+
+        let spec = format!("UUID={uuid}");
+        let entry = entries
+            .iter()
+            .find(|e| e.fs_spec.eq_ignore_ascii_case(spec.as_str()))
+            .cloned();
+
+        let target = match cli_target {
+            Some(t) => t.to_string(),
+            None => entry
+                .as_ref()
+                .map(|e| e.fs_file.clone())
+                .ok_or_else(|| MountError::NoMountPoint(spec.clone()))?,
+        };
+
+        return Ok(ResolvedMount {
+            source,
+            target,
+            fs_type: entry.as_ref().map(|e| e.fs_vfstype.clone()),
+            options: entry
+                .as_ref()
+                .map(|e| e.fs_mntops.clone())
+                .unwrap_or_else(|| "defaults".to_string()),
+        });
+    }
+
+    // Fall back to a fstab UUID= entry.
+    let spec = format!("UUID={uuid}");
+    resolve_from_entries(
+        &spec,
+        &spec,
+        cli_target,
+        entries,
+        MountError::UuidNotFound(uuid.to_string()),
+    )
+}
+
+// ── PARTLABEL / PARTUUID resolution ─────────────────────────────────────────
+
+/// Resolve a **partition label** (`PARTLABEL=`) to mount parameters using
+/// `/dev/disk/by-partlabel/<label>` and/or a matching fstab entry.
+pub fn resolve_partlabel_from(
+    label: &str,
+    cli_target: Option<&str>,
+    entries: &[FsTabEntry],
+) -> Result<ResolvedMount, MountError> {
+    let by_partlabel = std::path::Path::new("/dev/disk/by-partlabel").join(label);
+
+    if by_partlabel.exists() {
+        let source = by_partlabel
+            .canonicalize()
+            .map_err(MountError::Fstab)?
+            .to_string_lossy()
+            .into_owned();
+
+        let spec = format!("PARTLABEL={label}");
+        let entry = entries
+            .iter()
+            .find(|e| e.fs_spec.eq_ignore_ascii_case(spec.as_str()))
+            .cloned();
+
+        let target = match cli_target {
+            Some(t) => t.to_string(),
+            None => entry
+                .as_ref()
+                .map(|e| e.fs_file.clone())
+                .ok_or_else(|| MountError::NoMountPoint(spec.clone()))?,
+        };
+
+        return Ok(ResolvedMount {
+            source,
+            target,
+            fs_type: entry.as_ref().map(|e| e.fs_vfstype.clone()),
+            options: entry
+                .as_ref()
+                .map(|e| e.fs_mntops.clone())
+                .unwrap_or_else(|| "defaults".to_string()),
+        });
+    }
+
+    let spec = format!("PARTLABEL={label}");
+    resolve_from_entries(
+        &spec,
+        &spec,
+        cli_target,
+        entries,
+        MountError::LabelNotFound(label.to_string()),
+    )
+}
+
+/// Resolve a **partition UUID** (`PARTUUID=`) to mount parameters using
+/// `/dev/disk/by-partuuid/<uuid>` and/or a matching fstab entry.
+pub fn resolve_partuuid_from(
+    uuid: &str,
+    cli_target: Option<&str>,
+    entries: &[FsTabEntry],
+) -> Result<ResolvedMount, MountError> {
+    let by_partuuid = std::path::Path::new("/dev/disk/by-partuuid").join(uuid);
+
+    if by_partuuid.exists() {
+        let source = by_partuuid
+            .canonicalize()
+            .map_err(MountError::Fstab)?
+            .to_string_lossy()
+            .into_owned();
+
+        let spec = format!("PARTUUID={uuid}");
+        let entry = entries
+            .iter()
+            .find(|e| e.fs_spec.eq_ignore_ascii_case(spec.as_str()))
+            .cloned();
+
+        let target = match cli_target {
+            Some(t) => t.to_string(),
+            None => entry
+                .as_ref()
+                .map(|e| e.fs_file.clone())
+                .ok_or_else(|| MountError::NoMountPoint(spec.clone()))?,
+        };
+
+        return Ok(ResolvedMount {
+            source,
+            target,
+            fs_type: entry.as_ref().map(|e| e.fs_vfstype.clone()),
+            options: entry
+                .as_ref()
+                .map(|e| e.fs_mntops.clone())
+                .unwrap_or_else(|| "defaults".to_string()),
+        });
+    }
+
+    let spec = format!("PARTUUID={uuid}");
+    resolve_from_entries(
+        &spec,
+        &spec,
+        cli_target,
+        entries,
+        MountError::UuidNotFound(uuid.to_string()),
+    )
+}
+
+fn resolved_mount_from_entry(
+    entry: &FsTabEntry,
+    display: &str,
+) -> Result<ResolvedMount, MountError> {
+    if entry.fs_file == "none" {
+        return Err(MountError::NoMountPoint(display.to_string()));
+    }
+
+    Ok(ResolvedMount {
+        source: resolve_spec(&entry.fs_spec).unwrap_or_else(|| entry.fs_spec.clone()),
+        target: entry.fs_file.clone(),
+        fs_type: Some(entry.fs_vfstype.clone()),
+        options: entry.fs_mntops.clone(),
+    })
+}
+
+/// Resolve a single positional mount argument through `/etc/fstab`.
+///
+/// The argument may name either a mount point or a source specifier. If the
+/// fstab entry uses `LABEL=`, `UUID=`, `PARTLABEL=`, or `PARTUUID=`, the source
+/// is resolved to its canonical device path when possible.
+pub fn resolve_single_argument_from(
+    arg: &str,
+    entries: &[FsTabEntry],
+) -> Result<ResolvedMount, MountError> {
+    if let Some(entry) = entries.iter().find(|entry| entry.fs_file == arg) {
+        return resolved_mount_from_entry(entry, arg);
+    }
+
+    if let Some(entry) = entries.iter().find(|entry| {
+        entry.fs_spec.eq_ignore_ascii_case(arg)
+            || resolve_spec(&entry.fs_spec).as_deref() == Some(arg)
+    }) {
+        return resolved_mount_from_entry(entry, &entry.fs_spec);
+    }
+
+    Err(MountError::FstabEntryNotFound(arg.to_string()))
+}
+
+/// Attempt to resolve a device specifier that may use a `LABEL=`, `UUID=`,
+/// `PARTLABEL=`, or `PARTUUID=` prefix to a real block device path via the
+/// corresponding `/dev/disk/by-*` symlink.
+///
+/// Returns the canonicalised device path on success, or `None` if the
+/// specifier does not use a recognised prefix or the symlink does not exist.
+/// Callers should fall back to using the original `spec` string unchanged.
+pub fn resolve_spec(spec: &str) -> Option<String> {
+    let (disk_dir, value) = if let Some(v) = strip_ci_prefix(spec, "LABEL=") {
+        ("/dev/disk/by-label", v)
+    } else if let Some(v) = strip_ci_prefix(spec, "UUID=") {
+        ("/dev/disk/by-uuid", v)
+    } else if let Some(v) = strip_ci_prefix(spec, "PARTLABEL=") {
+        ("/dev/disk/by-partlabel", v)
+    } else if let Some(v) = strip_ci_prefix(spec, "PARTUUID=") {
+        ("/dev/disk/by-partuuid", v)
+    } else {
+        return None;
+    };
+
+    let path = std::path::Path::new(disk_dir).join(value);
+    if path.exists() {
+        path.canonicalize()
+            .ok()
+            .map(|p| p.to_string_lossy().into_owned())
+    } else {
+        None
+    }
+}
diff --git a/src/uu/mount/src/main.rs b/src/uu/mount/src/main.rs
new file mode 100644
index 00000000..0e1eea83
--- /dev/null
+++ b/src/uu/mount/src/main.rs
@@ -0,0 +1,6 @@
+// This file is part of the uutils util-linux package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+uucore::bin!(uu_mount);
diff --git a/src/uu/mount/src/mount.rs b/src/uu/mount/src/mount.rs
new file mode 100644
index 00000000..414abc24
--- /dev/null
+++ b/src/uu/mount/src/mount.rs
@@ -0,0 +1,1180 @@
+// This file is part of the uutils util-linux package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+#[cfg(target_os = "linux")]
+use clap::ArgMatches;
+use clap::{crate_version, Arg, ArgAction, ArgGroup, Command};
+#[cfg(target_os = "linux")]
+use std::collections::HashMap;
+use std::collections::HashSet;
+#[cfg(target_os = "linux")]
+use uucore::error::UError;
+use uucore::{error::UResult, format_usage, help_about, help_usage};
+
+mod errors;
+mod escape;
+mod fstab;
+#[cfg(target_os = "linux")]
+mod mtab;
+#[cfg(target_os = "linux")]
+use errors::MountError;
+use escape::unescape_octal;
+pub use fstab::{
+    parse_fstab_contents, resolve_label_from, resolve_partlabel_from, resolve_partuuid_from,
+    resolve_single_argument_from, resolve_spec, resolve_uuid_from, FsTabEntry, ResolvedMount,
+};
+#[cfg(target_os = "linux")]
+pub use mtab::write_mtab_to;
+
+const ABOUT: &str = help_about!("mount.md");
+const USAGE: &str = help_usage!("mount.md");
+
+mod options {
+    pub const ALL: &str = "all";
+    pub const BIND: &str = "bind";
+    pub const FAKE: &str = "fake";
+    pub const FORK: &str = "fork";
+    pub const ALT_FSTAB: &str = "fstab";
+    pub const MKDIR: &str = "mkdir";
+    pub const NO_MTAB: &str = "no-mtab";
+    pub const VERBOSE: &str = "verbose";
+    pub const READ_ONLY: &str = "read-only";
+    pub const READ_WRITE: &str = "read-write";
+    pub const FSTYPE: &str = "types";
+    pub const OPTIONS: &str = "options";
+    pub const TEST_OPTS: &str = "test-opts";
+    pub const LABEL: &str = "label";
+    pub const UUID: &str = "uuid";
+    pub const PARTLABEL: &str = "partlabel";
+    pub const PARTUUID: &str = "partuuid";
+    pub const POSITIONAL_SOURCE: &str = "positional-source";
+    pub const POSITIONAL_TARGET: &str = "positional-target";
+    pub const SOURCE: &str = "source";
+    pub const TARGET: &str = "target";
+    pub const RBIND: &str = "rbind";
+    pub const MOVE: &str = "move";
+    pub const MAKE_SHARED: &str = "make-shared";
+    pub const MAKE_SLAVE: &str = "make-slave";
+    pub const MAKE_PRIVATE: &str = "make-private";
+    pub const MAKE_UNBINDABLE: &str = "make-unbindable";
+    pub const MAKE_RSHARED: &str = "make-rshared";
+    pub const MAKE_RSLAVE: &str = "make-rslave";
+    pub const MAKE_RPRIVATE: &str = "make-rprivate";
+    pub const MAKE_RUNBINDABLE: &str = "make-runbindable";
+    pub const SHOW_LABELS: &str = "show-labels";
+}
+
+/// A parsed entry from `/proc/mounts` (Linux) or equivalent.
+#[derive(Debug, PartialEq)]
+pub struct MountEntry {
+    pub source: String,
+    pub target: String,
+    pub fs_type: String,
+    pub options: String,
+}
+
+impl MountEntry {
+    pub fn new(source: &str, target: &str, fs_type: &str, options: &str) -> Self {
+        Self {
+            source: source.to_string(),
+            target: target.to_string(),
+            fs_type: fs_type.to_string(),
+            options: options.to_string(),
+        }
+    }
+}
+
+impl std::fmt::Display for MountEntry {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(&format_mount_listing(self, None))
+    }
+}
+
+pub fn format_mount_listing(entry: &MountEntry, label: Option<&str>) -> String {
+    let mut rendered = format!(
+        "{} on {} type {} ({})",
+        entry.source, entry.target, entry.fs_type, entry.options
+    );
+    if let Some(label) = label.filter(|label| !label.is_empty()) {
+        rendered.push_str(" [");
+        rendered.push_str(label);
+        rendered.push(']');
+    }
+    rendered
+}
+
+/// Parse mount entries from the contents of `/proc/mounts`.
+pub fn parse_mount_entries(contents: &str) -> Vec<MountEntry> {
+    contents
+        .lines()
+        .filter_map(|line| {
+            let mut fields = line.split_whitespace();
+            let source = fields.next()?;
+            let target = fields.next()?;
+            let fs_type = fields.next()?;
+            let options = fields.next()?;
+
+            // The next two fields are optional (dump and fsck).
+            let _dump = fields.next();
+            let _passno = fields.next();
+
+            // If there are more fields, the line is malformed.
+            if fields.next().is_some() {
+                return None;
+            }
+
+            Some(MountEntry::new(
+                &unescape_octal(source),
+                &unescape_octal(target),
+                &unescape_octal(fs_type),
+                &unescape_octal(options),
+            ))
+        })
+        .collect()
+}
+
+/// Read currently mounted filesystems.
+#[cfg(target_os = "linux")]
+fn read_mounts() -> Result<Vec<MountEntry>, MountError> {
+    let contents = std::fs::read_to_string("/proc/mounts").map_err(MountError::ProcMounts)?;
+    Ok(parse_mount_entries(&contents))
+}
+
+/// Convert a comma-separated options string into mount flags and a remaining
+/// options string for `libc::mount`.
+///
+/// Returns `(flags_to_set, flags_to_clear, extra_data)`.  The caller should
+/// compute the effective flags as `(base | flags_to_set) & !flags_to_clear`.
+/// For a fresh mount `base` is typically `0`; for a remount it should be the
+/// flags already in effect so that positive options (e.g. `exec`) can undo
+/// previously set negative ones (e.g. `noexec`).
+#[cfg(target_os = "linux")]
+pub fn options_to_flags(opts: &str) -> (libc::c_ulong, libc::c_ulong, String) {
+    let mut set_flags: libc::c_ulong = 0;
+    let mut clear_flags: libc::c_ulong = 0;
+    let mut extra: Vec<&str> = Vec::new();
+
+    for opt in opts.split(',') {
+        match opt.trim() {
+            // ── flags to set ─────────────────────────────────────────────────
+            "ro" => set_flags |= libc::MS_RDONLY,
+            "rw" => clear_flags |= libc::MS_RDONLY,
+            "noexec" => set_flags |= libc::MS_NOEXEC,
+            "nosuid" => set_flags |= libc::MS_NOSUID,
+            "nodev" => set_flags |= libc::MS_NODEV,
+            "sync" => set_flags |= libc::MS_SYNCHRONOUS,
+            "remount" => set_flags |= libc::MS_REMOUNT,
+            "mand" => set_flags |= libc::MS_MANDLOCK,
+            "dirsync" => set_flags |= libc::MS_DIRSYNC,
+            "noatime" => set_flags |= libc::MS_NOATIME,
+            "nodiratime" => set_flags |= libc::MS_NODIRATIME,
+            "relatime" => set_flags |= libc::MS_RELATIME,
+            "strictatime" => set_flags |= libc::MS_STRICTATIME,
+            "lazytime" => set_flags |= libc::MS_LAZYTIME,
+            "bind" => set_flags |= libc::MS_BIND,
+            "rbind" => set_flags |= libc::MS_BIND | libc::MS_REC,
+            "shared" => set_flags |= libc::MS_SHARED,
+            "slave" => set_flags |= libc::MS_SLAVE,
+            "private" => set_flags |= libc::MS_PRIVATE,
+            "unbindable" => set_flags |= libc::MS_UNBINDABLE,
+            // ── flags to clear (positive counterparts) ────────────────────────
+            "exec" => clear_flags |= libc::MS_NOEXEC,
+            "suid" => clear_flags |= libc::MS_NOSUID,
+            "dev" => clear_flags |= libc::MS_NODEV,
+            "atime" => clear_flags |= libc::MS_NOATIME,
+            "diratime" => clear_flags |= libc::MS_NODIRATIME,
+            "" => {}
+            o => extra.push(o),
+        }
+    }
+
+    (set_flags, clear_flags, extra.join(","))
+}
+
+pub fn merge_mount_options(fstab_opts: &str, cli_opts: &str) -> String {
+    [fstab_opts, cli_opts]
+        .into_iter()
+        .flat_map(|opts| opts.split(','))
+        .map(str::trim)
+        .filter(|opt| !opt.is_empty())
+        .collect::<Vec<_>>()
+        .join(",")
+}
+
+pub fn fstab_entry_matches_test_opts(entry: &FsTabEntry, filter: &str) -> bool {
+    let entry_options: HashSet<&str> = entry
+        .fs_mntops
+        .split(',')
+        .map(str::trim)
+        .filter(|opt| !opt.is_empty())
+        .collect();
+
+    filter
+        .split(',')
+        .map(str::trim)
+        .filter(|opt| !opt.is_empty())
+        .all(|required| match required.strip_prefix("no_") {
+            Some(excluded) => !entry_options.contains(excluded),
+            None => entry_options.contains(required),
+        })
+}
+
+/// Determine whether `fs_type` matches the `-t`/`--types` filter string.
+///
+/// The filter is a comma-separated list of filesystem types. A leading `no`
+/// prefix excludes that type (e.g. `noext4`). Rules (matching GNU mount):
+/// - If the list contains only exclusions, all types match *except* those
+///   listed.
+/// - If the list contains any inclusions, only those types match (and any
+///   simultaneously excluded types are removed).
+#[cfg(target_os = "linux")]
+pub fn fstype_matches_filter(fs_type: &str, filter: &str) -> bool {
+    let parts: Vec<&str> = filter
+        .split(',')
+        .map(str::trim)
+        .filter(|s| !s.is_empty())
+        .collect();
+    let (included, excluded): (Vec<&str>, Vec<&str>) = parts
+        .iter()
+        .partition(|&&t| !t.starts_with("no") || t.len() <= 2);
+    let excluded_types: Vec<&str> = excluded.iter().map(|t| &t[2..]).collect();
+
+    if excluded_types.contains(&fs_type) {
+        return false;
+    }
+    if included.is_empty() {
+        return true;
+    }
+    included.contains(&fs_type)
+}
+
+#[cfg(target_os = "linux")]
+fn canonical_device_path(path: &str) -> Option<String> {
+    let path = std::path::Path::new(path);
+    if !path.exists() {
+        return None;
+    }
+    path.canonicalize()
+        .ok()
+        .map(|resolved| resolved.to_string_lossy().into_owned())
+}
+
+#[cfg(target_os = "linux")]
+fn source_match_candidates(source: &str) -> HashSet<String> {
+    let mut candidates = HashSet::from([source.to_string()]);
+    if let Some(resolved) = resolve_spec(source) {
+        candidates.insert(resolved.clone());
+        if let Some(canonical) = canonical_device_path(&resolved) {
+            candidates.insert(canonical);
+        }
+    }
+    if let Some(canonical) = canonical_device_path(source) {
+        candidates.insert(canonical);
+    }
+    candidates
+}
+
+#[cfg(target_os = "linux")]
+pub fn is_already_mounted(entry: &FsTabEntry, mounts: &[MountEntry]) -> bool {
+    let expected_sources = source_match_candidates(&entry.fs_spec);
+    mounts.iter().any(|mount| {
+        mount.target == entry.fs_file
+            && !expected_sources.is_disjoint(&source_match_candidates(&mount.source))
+    })
+}
+
+#[cfg(target_os = "linux")]
+fn read_mount_labels() -> HashMap<String, String> {
+    let mut labels = HashMap::new();
+    let Ok(entries) = std::fs::read_dir("/dev/disk/by-label") else {
+        return labels;
+    };
+
+    for entry in entries.flatten() {
+        let label = entry.file_name().to_string_lossy().into_owned();
+        if let Ok(device) = entry.path().canonicalize() {
+            labels.insert(device.to_string_lossy().into_owned(), label);
+        }
+    }
+
+    labels
+}
+
+#[cfg(target_os = "linux")]
+fn mount_label<'a>(entry: &MountEntry, labels: &'a HashMap<String, String>) -> Option<&'a str> {
+    source_match_candidates(&entry.source)
+        .into_iter()
+        .find_map(|source| labels.get(&source).map(String::as_str))
+}
+
+#[cfg(target_os = "linux")]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct PropagationChange {
+    pub name: &'static str,
+    pub flags: libc::c_ulong,
+}
+
+#[cfg(target_os = "linux")]
+pub fn collect_propagation_changes(enabled: &[&str]) -> Vec<PropagationChange> {
+    enabled
+        .iter()
+        .filter_map(|name| match *name {
+            options::MAKE_SHARED => Some(PropagationChange {
+                name: options::MAKE_SHARED,
+                flags: libc::MS_SHARED,
+            }),
+            options::MAKE_SLAVE => Some(PropagationChange {
+                name: options::MAKE_SLAVE,
+                flags: libc::MS_SLAVE,
+            }),
+            options::MAKE_PRIVATE => Some(PropagationChange {
+                name: options::MAKE_PRIVATE,
+                flags: libc::MS_PRIVATE,
+            }),
+            options::MAKE_UNBINDABLE => Some(PropagationChange {
+                name: options::MAKE_UNBINDABLE,
+                flags: libc::MS_UNBINDABLE,
+            }),
+            options::MAKE_RSHARED => Some(PropagationChange {
+                name: options::MAKE_RSHARED,
+                flags: libc::MS_SHARED | libc::MS_REC,
+            }),
+            options::MAKE_RSLAVE => Some(PropagationChange {
+                name: options::MAKE_RSLAVE,
+                flags: libc::MS_SLAVE | libc::MS_REC,
+            }),
+            options::MAKE_RPRIVATE => Some(PropagationChange {
+                name: options::MAKE_RPRIVATE,
+                flags: libc::MS_PRIVATE | libc::MS_REC,
+            }),
+            options::MAKE_RUNBINDABLE => Some(PropagationChange {
+                name: options::MAKE_RUNBINDABLE,
+                flags: libc::MS_UNBINDABLE | libc::MS_REC,
+            }),
+            _ => None,
+        })
+        .collect()
+}
+
+#[cfg(target_os = "linux")]
+fn selected_propagation_changes(matches: &ArgMatches) -> Vec<PropagationChange> {
+    let mut enabled = Vec::new();
+    for option in [
+        options::MAKE_SHARED,
+        options::MAKE_SLAVE,
+        options::MAKE_PRIVATE,
+        options::MAKE_UNBINDABLE,
+        options::MAKE_RSHARED,
+        options::MAKE_RSLAVE,
+        options::MAKE_RPRIVATE,
+        options::MAKE_RUNBINDABLE,
+    ] {
+        if matches.get_flag(option) {
+            enabled.push(option);
+        }
+    }
+    collect_propagation_changes(&enabled)
+}
+
+#[cfg(target_os = "linux")]
+#[derive(Clone, Copy)]
+struct MountInvocation<'a> {
+    source: Option<&'a str>,
+    target: Option<&'a str>,
+    lookup_arg: Option<&'a str>,
+}
+
+#[cfg(target_os = "linux")]
+fn resolve_mount_invocation<'a>(matches: &'a ArgMatches) -> UResult<MountInvocation<'a>> {
+    let source_opt = matches
+        .get_one::<String>(options::SOURCE)
+        .map(String::as_str);
+    let target_opt = matches
+        .get_one::<String>(options::TARGET)
+        .map(String::as_str);
+    let arg1 = matches
+        .get_one::<String>(options::POSITIONAL_SOURCE)
+        .map(String::as_str);
+    let arg2 = matches
+        .get_one::<String>(options::POSITIONAL_TARGET)
+        .map(String::as_str);
+
+    let invocation = match (source_opt, target_opt, arg1, arg2) {
+        (Some(source), Some(target), None, None) => MountInvocation {
+            source: Some(source),
+            target: Some(target),
+            lookup_arg: None,
+        },
+        (Some(source), None, Some(target), None) => MountInvocation {
+            source: Some(source),
+            target: Some(target),
+            lookup_arg: None,
+        },
+        (None, Some(target), Some(source), None) => MountInvocation {
+            source: Some(source),
+            target: Some(target),
+            lookup_arg: None,
+        },
+        (None, None, Some(source), Some(target)) => MountInvocation {
+            source: Some(source),
+            target: Some(target),
+            lookup_arg: None,
+        },
+        (Some(source), None, None, None) => MountInvocation {
+            source: None,
+            target: None,
+            lookup_arg: Some(source),
+        },
+        (None, Some(target), None, None) => MountInvocation {
+            source: None,
+            target: None,
+            lookup_arg: Some(target),
+        },
+        (None, None, Some(arg), None) => MountInvocation {
+            source: None,
+            target: None,
+            lookup_arg: Some(arg),
+        },
+        (None, None, None, None) => MountInvocation {
+            source: None,
+            target: None,
+            lookup_arg: None,
+        },
+        _ => {
+            return Err(uucore::error::USimpleError::new(
+                1,
+                "invalid combination of source/target arguments",
+            ));
+        }
+    };
+
+    Ok(invocation)
+}
+
+#[cfg(target_os = "linux")]
+fn ensure_mount_point(target: &str) -> Result<(), MountError> {
+    use std::os::unix::fs::DirBuilderExt;
+
+    let path = std::path::Path::new(target);
+    if path.is_dir() {
+        return Ok(());
+    }
+
+    std::fs::DirBuilder::new()
+        .recursive(true)
+        .mode(0o755)
+        .create(path)
+        .map_err(|err| MountError::CreateMountPoint(target.to_string(), err))
+}
+
+#[cfg(target_os = "linux")]
+fn apply_propagation_change(
+    target: &str,
+    change: PropagationChange,
+    verbose: bool,
+    fake: bool,
+) -> Result<(), MountError> {
+    use std::ffi::CString;
+
+    let c_target = CString::new(target).map_err(MountError::InvalidTarget)?;
+
+    if verbose {
+        eprintln!("mount: applying --{} to {}", change.name, target);
+    }
+
+    if fake {
+        return Ok(());
+    }
+
+    let ret = unsafe {
+        libc::mount(
+            std::ptr::null(),
+            c_target.as_ptr(),
+            std::ptr::null(),
+            change.flags,
+            std::ptr::null(),
+        )
+    };
+
+    if ret != 0 {
+        return Err(MountError::MountFailed(
+            std::io::Error::last_os_error(),
+            format!("--{}", change.name),
+            target.to_string(),
+        ));
+    }
+
+    Ok(())
+}
+
+/// Perform the actual mount syscall on Linux.
+#[cfg(target_os = "linux")]
+#[allow(clippy::too_many_arguments)]
+fn do_mount(
+    source: &str,
+    target: &str,
+    fs_type: Option<&str>,
+    opts: &str,
+    extra_flags: libc::c_ulong,
+    extra_clear_flags: libc::c_ulong,
+    verbose: bool,
+    fake: bool,
+    mkdir: bool,
+    no_mtab: bool,
+) -> Result<(), MountError> {
+    use std::ffi::CString;
+
+    macro_rules! to_cstring {
+        ($s:expr, $e:expr) => {
+            CString::new($s).map_err($e)
+        };
+    }
+
+    let (set_flags, clear_flags, data) = options_to_flags(opts);
+    let flags = (set_flags | extra_flags) & !(clear_flags | extra_clear_flags);
+
+    let c_source = to_cstring!(source, MountError::InvalidSource)?;
+    let c_target = to_cstring!(target, MountError::InvalidTarget)?;
+    let c_fstype = fs_type
+        .map(|t| to_cstring!(t, MountError::InvalidFSType))
+        .transpose()?;
+    let c_data = to_cstring!(data.as_str(), MountError::InvalidOptions)?;
+
+    if mkdir {
+        ensure_mount_point(target)?;
+    }
+
+    if verbose {
+        eprintln!(
+            "mount: mounting {} on {} with options \"{}\"",
+            source, target, opts
+        );
+    }
+
+    if fake {
+        return Ok(());
+    }
+
+    let fstype_ptr = c_fstype
+        .as_ref()
+        .map(|s| s.as_ptr())
+        .unwrap_or(std::ptr::null());
+
+    let ret = unsafe {
+        libc::mount(
+            c_source.as_ptr(),
+            c_target.as_ptr(),
+            fstype_ptr,
+            flags,
+            c_data.as_ptr() as *const libc::c_void,
+        )
+    };
+
+    if ret != 0 {
+        let err = std::io::Error::last_os_error();
+        let hint = if err.kind() == std::io::ErrorKind::PermissionDenied {
+            " (must be run as root)"
+        } else {
+            ""
+        };
+        return Err(MountError::MountFailed(
+            err,
+            format!("{source}{hint}"),
+            target.to_string(),
+        ));
+    }
+
+    if !no_mtab {
+        let fstype_str = fs_type.unwrap_or("none");
+        let effective_opts = if opts.is_empty() { "defaults" } else { opts };
+        if let Err(e) = mtab::write_mtab(source, target, fstype_str, effective_opts) {
+            eprintln!("mount: warning: failed to write to /etc/mtab: {e}");
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(target_os = "linux")]
+#[allow(clippy::too_many_arguments)]
+fn mount_fstab_entry(
+    entry: &FsTabEntry,
+    user_opts: &str,
+    extra_flags: libc::c_ulong,
+    extra_clear_flags: libc::c_ulong,
+    verbose: bool,
+    fake: bool,
+    mkdir: bool,
+    no_mtab: bool,
+) -> Result<MountEntry, MountError> {
+    let device = fstab::resolve_spec(&entry.fs_spec).unwrap_or_else(|| entry.fs_spec.clone());
+    let effective_opts = merge_mount_options(&entry.fs_mntops, user_opts);
+    do_mount(
+        &device,
+        &entry.fs_file,
+        Some(&entry.fs_vfstype),
+        &effective_opts,
+        extra_flags,
+        extra_clear_flags,
+        verbose,
+        fake,
+        mkdir,
+        no_mtab,
+    )?;
+
+    Ok(MountEntry::new(
+        &device,
+        &entry.fs_file,
+        &entry.fs_vfstype,
+        &effective_opts,
+    ))
+}
+
+#[cfg(target_os = "linux")]
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let matches = uu_app().try_get_matches_from(args)?;
+
+    let verbose = matches.get_flag(options::VERBOSE);
+    let fake = matches.get_flag(options::FAKE);
+    let fork = matches.get_flag(options::FORK);
+    let mkdir = matches.get_flag(options::MKDIR);
+    let no_mtab = matches.get_flag(options::NO_MTAB);
+    let read_only = matches.get_flag(options::READ_ONLY);
+    let read_write = matches.get_flag(options::READ_WRITE);
+    let bind = matches.get_flag(options::BIND);
+    let rbind = matches.get_flag(options::RBIND);
+    let move_mount = matches.get_flag(options::MOVE);
+    let show_labels = matches.get_flag(options::SHOW_LABELS);
+    let fstab_path = matches
+        .get_one::<String>(options::ALT_FSTAB)
+        .map(String::as_str)
+        .unwrap_or("/etc/fstab");
+    let fstype_filter = matches
+        .get_one::<String>(options::FSTYPE)
+        .map(String::as_str);
+    let test_opts_filter = matches
+        .get_one::<String>(options::TEST_OPTS)
+        .map(String::as_str);
+    let user_opts = matches
+        .get_one::<String>(options::OPTIONS)
+        .map(String::as_str)
+        .unwrap_or("");
+    let invocation = resolve_mount_invocation(&matches)?;
+    let propagation_changes = selected_propagation_changes(&matches);
+
+    // Compute extra kernel flags from flag arguments.
+    let mut extra_flags: libc::c_ulong = 0;
+    if read_only {
+        extra_flags |= libc::MS_RDONLY;
+    }
+    if bind {
+        extra_flags |= libc::MS_BIND;
+    } else if rbind {
+        extra_flags |= libc::MS_BIND | libc::MS_REC;
+    } else if move_mount {
+        extra_flags |= libc::MS_MOVE;
+    }
+
+    // -w/--read-write explicitly clears MS_RDONLY (useful when fstab says ro).
+    let extra_clear_flags: libc::c_ulong = if read_write { libc::MS_RDONLY } else { 0 };
+
+    if matches.get_flag(options::ALL) && !propagation_changes.is_empty() {
+        return Err(uucore::error::USimpleError::new(
+            1,
+            "--make-* propagation operations cannot be combined with --all",
+        ));
+    }
+
+    // ── mount --all ──────────────────────────────────────────────────────────
+    if matches.get_flag(options::ALL) {
+        let fstab_entries = fstab::parse_fstab_path(std::path::Path::new(fstab_path))?;
+        let mut current_mounts = read_mounts()?;
+        let mut had_error = false;
+        let mut child_pids = Vec::new();
+        for entry in fstab_entries {
+            // Skip entries explicitly marked as not auto-mountable.
+            if entry.fs_mntops.split(',').any(|o| o.trim() == "noauto") {
+                continue;
+            }
+            // Apply -t filter when specified.
+            if let Some(filter) = fstype_filter {
+                if !fstype_matches_filter(&entry.fs_vfstype, filter) {
+                    continue;
+                }
+            }
+            if let Some(filter) = test_opts_filter {
+                if !fstab_entry_matches_test_opts(&entry, filter) {
+                    continue;
+                }
+            }
+            if is_already_mounted(&entry, &current_mounts) {
+                continue;
+            }
+            if fork {
+                let pid = unsafe { libc::fork() };
+                if pid < 0 {
+                    return Err(MountError::Fork(std::io::Error::last_os_error()).into());
+                }
+                if pid == 0 {
+                    let exit_code = match mount_fstab_entry(
+                        &entry,
+                        user_opts,
+                        extra_flags,
+                        extra_clear_flags,
+                        verbose,
+                        fake,
+                        mkdir,
+                        no_mtab,
+                    ) {
+                        Ok(_) => 0,
+                        Err(e) => {
+                            eprintln!("mount: {e}");
+                            e.code()
+                        }
+                    };
+                    std::process::exit(exit_code);
+                }
+                child_pids.push(pid);
+            } else {
+                match mount_fstab_entry(
+                    &entry,
+                    user_opts,
+                    extra_flags,
+                    extra_clear_flags,
+                    verbose,
+                    fake,
+                    mkdir,
+                    no_mtab,
+                ) {
+                    Ok(mount_entry) => current_mounts.push(mount_entry),
+                    Err(e) => {
+                        eprintln!("mount: {e}");
+                        had_error = true;
+                    }
+                }
+            }
+        }
+        for pid in child_pids {
+            let mut status = 0;
+            if unsafe { libc::waitpid(pid, &mut status, 0) } < 0 {
+                return Err(MountError::Wait(std::io::Error::last_os_error()).into());
+            }
+            if !libc::WIFEXITED(status) || libc::WEXITSTATUS(status) != 0 {
+                had_error = true;
+            }
+        }
+        if had_error {
+            return Err(uucore::error::USimpleError::new(
+                errors::EXIT_MOUNT_FAILED,
+                "some mounts failed",
+            ));
+        }
+        return Ok(());
+    }
+
+    let source = invocation.source;
+    let target = invocation.target;
+    let lookup_arg = invocation.lookup_arg;
+
+    if matches.contains_id(options::SOURCE)
+        && (matches.contains_id(options::LABEL)
+            || matches.contains_id(options::UUID)
+            || matches.contains_id(options::PARTLABEL)
+            || matches.contains_id(options::PARTUUID))
+    {
+        return Err(uucore::error::USimpleError::new(
+            1,
+            "cannot combine --source with --label/--uuid/--partlabel/--partuuid",
+        ));
+    }
+
+    // ── mount --label / --uuid / --partlabel / --partuuid ────────────────────
+    let label = matches
+        .get_one::<String>(options::LABEL)
+        .map(String::as_str);
+    let uuid = matches.get_one::<String>(options::UUID).map(String::as_str);
+    let partlabel = matches
+        .get_one::<String>(options::PARTLABEL)
+        .map(String::as_str);
+    let partuuid = matches
+        .get_one::<String>(options::PARTUUID)
+        .map(String::as_str);
+
+    if !propagation_changes.is_empty()
+        && (label.is_some() || uuid.is_some() || partlabel.is_some() || partuuid.is_some())
+    {
+        return Err(uucore::error::USimpleError::new(
+            1,
+            "--make-* propagation operations require an explicit source and target mount",
+        ));
+    }
+
+    if label.is_some() || uuid.is_some() || partlabel.is_some() || partuuid.is_some() {
+        let fstab_entries = fstab::parse_fstab_path(std::path::Path::new(fstab_path))?;
+        let cli_target = target.or(lookup_arg);
+
+        let resolved = match (label, uuid, partlabel, partuuid) {
+            (Some(lbl), None, None, None) => {
+                fstab::resolve_label_from(lbl, cli_target, &fstab_entries)?
+            }
+            (None, Some(id), None, None) => {
+                fstab::resolve_uuid_from(id, cli_target, &fstab_entries)?
+            }
+            (None, None, Some(lbl), None) => {
+                fstab::resolve_partlabel_from(lbl, cli_target, &fstab_entries)?
+            }
+            (None, None, None, Some(id)) => {
+                fstab::resolve_partuuid_from(id, cli_target, &fstab_entries)?
+            }
+            _ => unreachable!("clap only permits one device-identifier flag"),
+        };
+
+        let effective_opts = merge_mount_options(&resolved.options, user_opts);
+        let effective_fstype = fstype_filter.or(resolved.fs_type.as_deref());
+
+        do_mount(
+            &resolved.source,
+            &resolved.target,
+            effective_fstype,
+            &effective_opts,
+            extra_flags,
+            extra_clear_flags,
+            verbose,
+            fake,
+            mkdir,
+            no_mtab,
+        )?;
+        for change in &propagation_changes {
+            apply_propagation_change(&resolved.target, *change, verbose, fake)?;
+        }
+        return Ok(());
+    }
+
+    // ── mount SOURCE TARGET (explicit) / list mounts ─────────────────────────
+    match (source, target) {
+        (Some(src), Some(tgt)) => {
+            do_mount(
+                src,
+                tgt,
+                fstype_filter,
+                user_opts,
+                extra_flags,
+                extra_clear_flags,
+                verbose,
+                fake,
+                mkdir,
+                no_mtab,
+            )?;
+            for change in &propagation_changes {
+                apply_propagation_change(tgt, *change, verbose, fake)?;
+            }
+        }
+        _ if lookup_arg.is_some() => {
+            if propagation_changes.is_empty() {
+                let entries = fstab::parse_fstab_path(std::path::Path::new(fstab_path))?;
+                let resolved = fstab::resolve_single_argument_from(lookup_arg.unwrap(), &entries)?;
+                let effective_opts = merge_mount_options(&resolved.options, user_opts);
+                let effective_fstype = fstype_filter.or(resolved.fs_type.as_deref());
+
+                do_mount(
+                    &resolved.source,
+                    &resolved.target,
+                    effective_fstype,
+                    &effective_opts,
+                    extra_flags,
+                    extra_clear_flags,
+                    verbose,
+                    fake,
+                    mkdir,
+                    no_mtab,
+                )?;
+            } else {
+                for change in &propagation_changes {
+                    apply_propagation_change(lookup_arg.unwrap(), *change, verbose, fake)?;
+                }
+            }
+        }
+        _ => {
+            if !propagation_changes.is_empty() {
+                return Err(uucore::error::USimpleError::new(
+                    1,
+                    "--make-* propagation operations require a target mountpoint",
+                ));
+            }
+            // No source/target: list mounts.
+            let entries = read_mounts()?;
+            let labels = if show_labels {
+                Some(read_mount_labels())
+            } else {
+                None
+            };
+            for entry in entries {
+                // Apply -t filter to listing output when specified.
+                if let Some(filter) = fstype_filter {
+                    if !fstype_matches_filter(&entry.fs_type, filter) {
+                        continue;
+                    }
+                }
+                let label = labels
+                    .as_ref()
+                    .and_then(|labels| mount_label(&entry, labels));
+                println!("{}", format_mount_listing(&entry, label));
+            }
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(not(target_os = "linux"))]
+#[uucore::main]
+pub fn uumain(args: impl uucore::Args) -> UResult<()> {
+    let _matches = uu_app().try_get_matches_from(args)?;
+    Err(uucore::error::USimpleError::new(
+        1,
+        "`mount` is currently only supported on Linux.",
+    ))
+}
+
+pub fn uu_app() -> Command {
+    Command::new(uucore::util_name())
+        .version(crate_version!())
+        .about(ABOUT)
+        .override_usage(format_usage(USAGE))
+        .infer_long_args(true)
+        .arg(
+            Arg::new(options::ALL)
+                .short('a')
+                .long("all")
+                .help("mount all filesystems mentioned in fstab")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::BIND)
+                .short('B')
+                .long("bind")
+                .help("mount a subtree somewhere else (like bind)")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::RBIND)
+                .short('R')
+                .long("rbind")
+                .help("mount a subtree and all submounts somewhere else")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::MOVE)
+                .short('M')
+                .long("move")
+                .help("move a subtree to some other place")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::MAKE_SHARED)
+                .long("make-shared")
+                .help("mark a subtree as shared")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::MAKE_SLAVE)
+                .long("make-slave")
+                .help("mark a subtree as slave")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::MAKE_PRIVATE)
+                .long("make-private")
+                .help("mark a subtree as private")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::MAKE_UNBINDABLE)
+                .long("make-unbindable")
+                .help("mark a subtree as unbindable")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::MAKE_RSHARED)
+                .long("make-rshared")
+                .help("recursively mark a whole subtree as shared")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::MAKE_RSLAVE)
+                .long("make-rslave")
+                .help("recursively mark a whole subtree as slave")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::MAKE_RPRIVATE)
+                .long("make-rprivate")
+                .help("recursively mark a whole subtree as private")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::MAKE_RUNBINDABLE)
+                .long("make-runbindable")
+                .help("recursively mark a whole subtree as unbindable")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::FAKE)
+                .short('f')
+                .long("fake")
+                .help("dry run; skip the mount(2) syscall")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::FORK)
+                .short('F')
+                .long("fork")
+                .help("fork off a new mount process for each device (use with --all)")
+                .requires(options::ALL)
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::ALT_FSTAB)
+                .short('T')
+                .long("fstab")
+                .value_name("PATH")
+                .help("use an alternative fstab file")
+                .action(ArgAction::Set),
+        )
+        .arg(
+            Arg::new(options::MKDIR)
+                .short('m')
+                .long("mkdir")
+                .help("create the target mountpoint if it does not exist")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::NO_MTAB)
+                .short('n')
+                .long("no-mtab")
+                .help("don't write to /etc/mtab")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::READ_ONLY)
+                .short('r')
+                .long("read-only")
+                .help("mount the filesystem read-only (same as -o ro)")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::READ_WRITE)
+                .short('w')
+                .long("read-write")
+                .help("mount the filesystem read-write (default)")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::VERBOSE)
+                .short('v')
+                .long("verbose")
+                .help("say what is being done")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::FSTYPE)
+                .short('t')
+                .long("types")
+                .value_name("LIST")
+                .help("filesystem type")
+                .action(ArgAction::Set),
+        )
+        .arg(
+            Arg::new(options::OPTIONS)
+                .short('o')
+                .long("options")
+                .value_name("LIST")
+                .help("comma-separated list of mount options")
+                .action(ArgAction::Set),
+        )
+        .arg(
+            Arg::new(options::TEST_OPTS)
+                .short('O')
+                .long("test-opts")
+                .value_name("LIST")
+                .help("limit --all to fstab entries whose option field matches LIST")
+                .requires(options::ALL)
+                .action(ArgAction::Set),
+        )
+        .arg(
+            Arg::new(options::LABEL)
+                .short('L')
+                .long("label")
+                .value_name("LABEL")
+                .help("synonym for LABEL=<label>")
+                .action(ArgAction::Set),
+        )
+        .arg(
+            Arg::new(options::UUID)
+                .short('U')
+                .long("uuid")
+                .value_name("UUID")
+                .help("synonym for UUID=<uuid>")
+                .action(ArgAction::Set),
+        )
+        .arg(
+            Arg::new(options::PARTLABEL)
+                .long("partlabel")
+                .value_name("LABEL")
+                .help("synonym for PARTLABEL=<label>")
+                .action(ArgAction::Set),
+        )
+        .arg(
+            Arg::new(options::PARTUUID)
+                .long("partuuid")
+                .value_name("UUID")
+                .help("synonym for PARTUUID=<uuid>")
+                .action(ArgAction::Set),
+        )
+        .arg(
+            Arg::new(options::SHOW_LABELS)
+                .short('l')
+                .long("show-labels")
+                .help("show filesystem labels in listing output")
+                .action(ArgAction::SetTrue),
+        )
+        .arg(
+            Arg::new(options::SOURCE)
+                .long("source")
+                .value_name("SOURCE")
+                .help("explicitly specifies the mount source")
+                .action(ArgAction::Set),
+        )
+        .arg(
+            Arg::new(options::TARGET)
+                .long("target")
+                .value_name("DIRECTORY")
+                .help("explicitly specifies the mountpoint")
+                .action(ArgAction::Set),
+        )
+        .arg(
+            Arg::new(options::POSITIONAL_SOURCE)
+                .value_name("SOURCE")
+                .help("special device or remote filesystem to mount")
+                .index(1),
+        )
+        .arg(
+            Arg::new(options::POSITIONAL_TARGET)
+                .value_name("DIRECTORY")
+                .help("mount point for the filesystem")
+                .index(2),
+        )
+        .group(
+            ArgGroup::new("mount-action")
+                .args([options::BIND, options::RBIND, options::MOVE])
+                .required(false),
+        )
+        .group(
+            ArgGroup::new("rw-mode")
+                .args([options::READ_ONLY, options::READ_WRITE])
+                .required(false),
+        )
+}
diff --git a/src/uu/mount/src/mtab.rs b/src/uu/mount/src/mtab.rs
new file mode 100644
index 00000000..90a77f64
--- /dev/null
+++ b/src/uu/mount/src/mtab.rs
@@ -0,0 +1,86 @@
+// This file is part of the uutils util-linux package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use std::io::{self, Write};
+use std::os::unix::io::AsRawFd;
+use std::path::Path;
+
+/// Append a mount entry to the file at `path`.
+///
+/// If `path` is a symbolic link the function returns `Ok(())` without writing
+/// anything. On modern Linux systems `/etc/mtab` is typically a symlink to
+/// `/proc/mounts`, so the kernel already maintains the mount list and there is
+/// nothing to update.
+///
+/// When the file is a real file an exclusive `flock(2)` lock is acquired
+/// before appending so that concurrent `mount` invocations cannot corrupt it.
+///
+/// The entry is written in the same whitespace-separated format used by
+/// `/proc/mounts`:
+/// ```text
+/// <source> <target> <fstype> <options> 0 0
+/// ```
+pub fn write_mtab_to(
+    path: &Path,
+    source: &str,
+    target: &str,
+    fs_type: &str,
+    opts: &str,
+) -> io::Result<()> {
+    // Use symlink_metadata so that we inspect the link itself, not its target.
+    let meta = match std::fs::symlink_metadata(path) {
+        Ok(m) => m,
+        // If the file doesn't exist there is nothing to update.
+        Err(e) if e.kind() == io::ErrorKind::NotFound => return Ok(()),
+        Err(e) => return Err(e),
+    };
+
+    if meta.file_type().is_symlink() {
+        return Ok(());
+    }
+
+    let file = std::fs::OpenOptions::new().append(true).open(path)?;
+
+    // Hold an exclusive lock for the duration of the write to prevent races
+    // with other concurrent mount processes.
+    let lock_result = unsafe { libc::flock(file.as_raw_fd(), libc::LOCK_EX) };
+    if lock_result != 0 {
+        return Err(io::Error::last_os_error());
+    }
+
+    let entry = format!(
+        "{} {} {} {} 0 0\n",
+        escape_octal(source),
+        escape_octal(target),
+        escape_octal(fs_type),
+        escape_octal(opts)
+    );
+    (&file).write_all(entry.as_bytes())?;
+
+    // The exclusive lock is released automatically when `file` drops here.
+    Ok(())
+}
+
+fn escape_octal(s: &str) -> String {
+    let mut escaped = String::with_capacity(s.len());
+    for byte in s.bytes() {
+        match byte {
+            b' ' => escaped.push_str(r"\040"),
+            b'\t' => escaped.push_str(r"\011"),
+            b'\n' => escaped.push_str(r"\012"),
+            b'\\' => escaped.push_str(r"\134"),
+            _ => escaped.push(byte as char),
+        }
+    }
+    escaped
+}
+
+/// Append a mount entry to `/etc/mtab`.
+///
+/// This is a convenience wrapper around [`write_mtab_to`] that uses the
+/// standard path `/etc/mtab`.
+pub fn write_mtab(source: &str, target: &str, fs_type: &str, opts: &str) -> io::Result<()> {
+    write_mtab_to(Path::new("/etc/mtab"), source, target, fs_type, opts)
+}
diff --git a/tests/by-util/test_mount.rs b/tests/by-util/test_mount.rs
new file mode 100644
index 00000000..b736fdb1
--- /dev/null
+++ b/tests/by-util/test_mount.rs
@@ -0,0 +1,1439 @@
+// This file is part of the uutils util-linux package.
+//
+// For the full copyright and license information, please view the LICENSE
+// file that was distributed with this source code.
+
+use uutests::new_ucmd;
+
+// ── CLI / argument parsing tests ────────────────────────────────────────────
+
+#[test]
+fn test_invalid_arg() {
+    new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
+}
+
+/// `mount --help` should succeed and mention "mount".
+#[test]
+fn test_help() {
+    new_ucmd!()
+        .arg("--help")
+        .succeeds()
+        .stdout_contains("mount");
+}
+
+/// `mount --version` should succeed.
+#[test]
+fn test_version() {
+    new_ucmd!().arg("--version").succeeds();
+}
+
+/// `mount --help` should advertise the major compatibility features.
+#[test]
+fn test_help_mentions_phase4_features() {
+    new_ucmd!()
+        .arg("--help")
+        .succeeds()
+        .stdout_contains("--fstab")
+        .stdout_contains("--source")
+        .stdout_contains("--target")
+        .stdout_contains("--mkdir")
+        .stdout_contains("--test-opts")
+        .stdout_contains("--make-shared");
+}
+
+// ── Listing mounts (no arguments) ───────────────────────────────────────────
+
+/// On Linux, `mount` with no arguments reads `/proc/mounts` and prints every
+/// entry in the form:  <source> on <target> type <fstype> (<options>)
+#[test]
+#[cfg(target_os = "linux")]
+fn test_list_mounts_no_args() {
+    let result = new_ucmd!().succeeds();
+    let stdout = result.stdout_str();
+    // There is always at least the rootfs or sysfs entry on Linux.
+    assert!(
+        !stdout.is_empty(),
+        "expected at least one mount entry, got empty output"
+    );
+    // Every line must match the expected format.
+    for line in stdout.lines() {
+        assert!(
+            line.contains(" on ") && line.contains(" type "),
+            "unexpected mount line format: {line:?}"
+        );
+    }
+}
+
+/// The output of `mount` (no args) must be consistent with `/proc/mounts`.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_list_mounts_matches_proc_mounts() {
+    use std::fs;
+
+    let proc_contents = fs::read_to_string("/proc/mounts").unwrap();
+    let result = new_ucmd!().succeeds();
+    let stdout = result.stdout_str();
+
+    // Every source device listed in /proc/mounts should appear in the output.
+    for line in proc_contents.lines() {
+        let mut fields = line.split_whitespace();
+        if let (Some(src), Some(tgt)) = (fields.next(), fields.next()) {
+            assert!(
+                stdout.contains(src) && stdout.contains(tgt),
+                "expected source '{src}' and target '{tgt}' in mount output"
+            );
+        }
+    }
+}
+
+/// `--fake --no-mtab` should succeed without touching /etc/mtab.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_fake_no_mtab() {
+    use tempfile::TempDir;
+    let dir = TempDir::new().unwrap();
+    new_ucmd!()
+        .args(&[
+            "--fake",
+            "--no-mtab",
+            "--types",
+            "tmpfs",
+            "tmpfs",
+            dir.path().to_str().unwrap(),
+        ])
+        .succeeds();
+}
+
+/// `mount --all --fake --no-mtab` should succeed.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_all_fake_no_mtab() {
+    if !std::path::Path::new("/etc/fstab").exists() {
+        return;
+    }
+    new_ucmd!()
+        .args(&["--all", "--fake", "--no-mtab"])
+        .succeeds();
+}
+
+// ── `mount --fake` (dry-run) ─────────────────────────────────────────────────
+
+/// `mount --fake` with a source and target should succeed without performing
+/// the actual syscall (no root privileges needed).
+#[test]
+#[cfg(target_os = "linux")]
+fn test_fake_mount_succeeds() {
+    use tempfile::TempDir;
+    let dir = TempDir::new().unwrap();
+    new_ucmd!()
+        .args(&[
+            "--fake",
+            "--types",
+            "tmpfs",
+            "tmpfs",
+            dir.path().to_str().unwrap(),
+        ])
+        .succeeds();
+}
+
+/// `--fake --verbose` should print a diagnostic message to stderr.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_fake_verbose_mount() {
+    use tempfile::TempDir;
+    let dir = TempDir::new().unwrap();
+    new_ucmd!()
+        .args(&[
+            "--fake",
+            "--verbose",
+            "--types",
+            "tmpfs",
+            "tmpfs",
+            dir.path().to_str().unwrap(),
+        ])
+        .succeeds()
+        .stderr_contains("mounting");
+}
+
+/// `--fake` with `-o ro` should succeed.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_fake_read_only_option() {
+    use tempfile::TempDir;
+    let dir = TempDir::new().unwrap();
+    new_ucmd!()
+        .args(&[
+            "--fake",
+            "-o",
+            "ro",
+            "--types",
+            "tmpfs",
+            "tmpfs",
+            dir.path().to_str().unwrap(),
+        ])
+        .succeeds();
+}
+
+/// `--fake --read-only` should succeed.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_fake_read_only_flag() {
+    use tempfile::TempDir;
+    let dir = TempDir::new().unwrap();
+    new_ucmd!()
+        .args(&[
+            "--fake",
+            "--read-only",
+            "--types",
+            "tmpfs",
+            "tmpfs",
+            dir.path().to_str().unwrap(),
+        ])
+        .succeeds();
+}
+
+/// `--fake --bind` should succeed.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_fake_bind_flag() {
+    use tempfile::TempDir;
+    let src = TempDir::new().unwrap();
+    let dst = TempDir::new().unwrap();
+    new_ucmd!()
+        .args(&[
+            "--fake",
+            "--bind",
+            src.path().to_str().unwrap(),
+            dst.path().to_str().unwrap(),
+        ])
+        .succeeds();
+}
+
+/// `--fake --rbind` should succeed.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_fake_rbind_flag() {
+    use tempfile::TempDir;
+    let src = TempDir::new().unwrap();
+    let dst = TempDir::new().unwrap();
+    new_ucmd!()
+        .args(&[
+            "--fake",
+            "--rbind",
+            src.path().to_str().unwrap(),
+            dst.path().to_str().unwrap(),
+        ])
+        .succeeds();
+}
+
+/// `--fake --move` should succeed.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_fake_move_flag() {
+    use tempfile::TempDir;
+    let src = TempDir::new().unwrap();
+    let dst = TempDir::new().unwrap();
+    new_ucmd!()
+        .args(&[
+            "--fake",
+            "--move",
+            src.path().to_str().unwrap(),
+            dst.path().to_str().unwrap(),
+        ])
+        .succeeds();
+}
+
+/// `mount --all --fake` should succeed when `/etc/fstab` is present (skips
+/// syscall so no root privileges are needed).
+#[test]
+#[cfg(target_os = "linux")]
+fn test_all_fake_succeeds() {
+    // Only run this test when /etc/fstab exists.
+    if !std::path::Path::new("/etc/fstab").exists() {
+        return;
+    }
+    new_ucmd!().args(&["--all", "--fake"]).succeeds();
+}
+
+/// `--fstab` should allow single-argument resolution from an alternate file.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_alt_fstab_single_argument_resolution() {
+    use std::fs;
+    use tempfile::TempDir;
+
+    let dir = TempDir::new().unwrap();
+    let target = dir.path().join("mnt");
+    fs::create_dir(&target).unwrap();
+    let fstab = dir.path().join("test.fstab");
+    fs::write(
+        &fstab,
+        format!("tmpfs {} tmpfs defaults 0 0\n", target.display()),
+    )
+    .unwrap();
+
+    new_ucmd!()
+        .args(&[
+            "--fake",
+            "--fstab",
+            fstab.to_str().unwrap(),
+            target.to_str().unwrap(),
+        ])
+        .succeeds();
+}
+
+/// `--target` should disambiguate a single-argument mountpoint lookup.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_explicit_target_single_argument_resolution() {
+    use std::fs;
+    use tempfile::TempDir;
+
+    let dir = TempDir::new().unwrap();
+    let target = dir.path().join("mnt");
+    fs::create_dir(&target).unwrap();
+    let fstab = dir.path().join("test.fstab");
+    fs::write(
+        &fstab,
+        format!("tmpfs {} tmpfs defaults 0 0\n", target.display()),
+    )
+    .unwrap();
+
+    new_ucmd!()
+        .args(&[
+            "--fake",
+            "--fstab",
+            fstab.to_str().unwrap(),
+            "--target",
+            target.to_str().unwrap(),
+        ])
+        .succeeds();
+}
+
+/// Explicit `--source` and `--target` should work for direct mounts.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_explicit_source_target_mount() {
+    use tempfile::TempDir;
+
+    let dir = TempDir::new().unwrap();
+    new_ucmd!()
+        .args(&[
+            "--fake",
+            "--types",
+            "tmpfs",
+            "--source",
+            "tmpfs",
+            "--target",
+            dir.path().to_str().unwrap(),
+        ])
+        .succeeds();
+}
+
+/// `--source` should disambiguate a single-argument source lookup through fstab.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_explicit_source_single_argument_resolution() {
+    use std::fs;
+    use tempfile::TempDir;
+
+    let dir = TempDir::new().unwrap();
+    let target = dir.path().join("mnt");
+    fs::create_dir(&target).unwrap();
+    let fstab = dir.path().join("test.fstab");
+    fs::write(
+        &fstab,
+        format!("tmpfs {} tmpfs defaults 0 0\n", target.display()),
+    )
+    .unwrap();
+
+    new_ucmd!()
+        .args(&[
+            "--fake",
+            "--fstab",
+            fstab.to_str().unwrap(),
+            "--source",
+            "tmpfs",
+        ])
+        .succeeds();
+}
+
+/// `--mkdir` should create a missing mountpoint before the mount attempt.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_mkdir_creates_missing_target() {
+    use tempfile::TempDir;
+
+    let dir = TempDir::new().unwrap();
+    let target = dir.path().join("missing").join("mountpoint");
+
+    new_ucmd!()
+        .args(&[
+            "--fake",
+            "--mkdir",
+            "--types",
+            "tmpfs",
+            "tmpfs",
+            target.to_str().unwrap(),
+        ])
+        .succeeds();
+
+    assert!(
+        target.is_dir(),
+        "--mkdir should create the target directory"
+    );
+}
+
+/// `--test-opts` should filter `--all` entries using options from the chosen fstab.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_all_test_opts_filters_entries() {
+    use std::fs;
+    use tempfile::TempDir;
+
+    let dir = TempDir::new().unwrap();
+    let target1 = dir.path().join("mnt1");
+    let target2 = dir.path().join("mnt2");
+    fs::create_dir(&target1).unwrap();
+    fs::create_dir(&target2).unwrap();
+    let fstab = dir.path().join("test.fstab");
+    fs::write(
+        &fstab,
+        format!(
+            "tmpfs {} tmpfs defaults,noatime 0 0\ntmpfs {} tmpfs defaults 0 0\n",
+            target1.display(),
+            target2.display()
+        ),
+    )
+    .unwrap();
+
+    new_ucmd!()
+        .args(&[
+            "--all",
+            "--fake",
+            "--verbose",
+            "--fstab",
+            fstab.to_str().unwrap(),
+            "--test-opts",
+            "noatime",
+        ])
+        .succeeds()
+        .stderr_contains(target1.to_str().unwrap())
+        .stderr_does_not_contain(target2.to_str().unwrap());
+}
+
+/// `--all` can create missing mountpoints when `--mkdir` is requested.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_all_with_mkdir_creates_missing_target() {
+    use std::fs;
+    use tempfile::TempDir;
+
+    let dir = TempDir::new().unwrap();
+    let target = dir.path().join("missing").join("mnt");
+    let fstab = dir.path().join("test.fstab");
+    fs::write(
+        &fstab,
+        format!("tmpfs {} tmpfs defaults 0 0\n", target.display()),
+    )
+    .unwrap();
+
+    new_ucmd!()
+        .args(&[
+            "--all",
+            "--fake",
+            "--mkdir",
+            "--fstab",
+            fstab.to_str().unwrap(),
+        ])
+        .succeeds();
+
+    assert!(
+        target.is_dir(),
+        "--all --mkdir should create the target directory"
+    );
+}
+
+/// `--fork` should be accepted with `--all` and still mount all matching entries.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_all_fork_fake_succeeds() {
+    use std::fs;
+    use tempfile::TempDir;
+
+    let dir = TempDir::new().unwrap();
+    let target1 = dir.path().join("mnt1");
+    let target2 = dir.path().join("mnt2");
+    fs::create_dir(&target1).unwrap();
+    fs::create_dir(&target2).unwrap();
+    let fstab = dir.path().join("test.fstab");
+    fs::write(
+        &fstab,
+        format!(
+            "tmpfs {} tmpfs defaults 0 0\ntmpfs {} tmpfs defaults 0 0\n",
+            target1.display(),
+            target2.display()
+        ),
+    )
+    .unwrap();
+
+    let result = new_ucmd!()
+        .args(&[
+            "--all",
+            "--fake",
+            "--fork",
+            "--verbose",
+            "--fstab",
+            fstab.to_str().unwrap(),
+        ])
+        .succeeds();
+
+    let stderr = result.stderr_str();
+    assert!(stderr.contains(target1.to_str().unwrap()));
+    assert!(stderr.contains(target2.to_str().unwrap()));
+}
+
+/// A pure propagation operation should work in fake mode on an explicit target.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_make_shared_fake_succeeds() {
+    use tempfile::TempDir;
+
+    let dir = TempDir::new().unwrap();
+    new_ucmd!()
+        .args(&["--fake", "--make-shared", dir.path().to_str().unwrap()])
+        .succeeds();
+}
+
+/// Recursive propagation operations should be accepted by the parser.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_make_rprivate_fake_succeeds() {
+    use tempfile::TempDir;
+
+    let dir = TempDir::new().unwrap();
+    new_ucmd!()
+        .args(&[
+            "--fake",
+            "--make-rprivate",
+            "--target",
+            dir.path().to_str().unwrap(),
+        ])
+        .succeeds();
+}
+
+/// A direct mount can be followed by propagation operations in the same command.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_mount_with_propagation_fake_succeeds() {
+    use tempfile::TempDir;
+
+    let dir = TempDir::new().unwrap();
+    let result = new_ucmd!()
+        .args(&[
+            "--fake",
+            "--verbose",
+            "--make-private",
+            "--make-unbindable",
+            "--types",
+            "tmpfs",
+            "tmpfs",
+            dir.path().to_str().unwrap(),
+        ])
+        .succeeds();
+
+    let stderr = result.stderr_str();
+    assert!(stderr.contains("applying --make-private"));
+    assert!(stderr.contains("applying --make-unbindable"));
+}
+
+/// Propagation operations must not be combined with `--all`.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_make_shared_conflicts_with_all() {
+    new_ucmd!()
+        .args(&["--all", "--fake", "--make-shared", "/tmp"])
+        .fails()
+        .code_is(1);
+}
+
+/// `--label` with an unknown label should fail.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_label_not_found_fails() {
+    new_ucmd!()
+        .args(&["--fake", "--label", "this-label-does-not-exist-xyz"])
+        .fails()
+        .code_is(1);
+}
+
+/// `--uuid` with an unknown UUID should fail.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_uuid_not_found_fails() {
+    new_ucmd!()
+        .args(&["--fake", "--uuid", "00000000-0000-0000-0000-000000000000"])
+        .fails()
+        .code_is(1);
+}
+
+/// `--uuid` arg must be accepted by the parser (no "unexpected argument" error).
+#[test]
+fn test_uuid_arg_is_recognised() {
+    // We just check the flag is parsed; actual resolution will fail without a
+    // matching device, which is expected in CI.
+    let out = new_ucmd!()
+        .args(&["--fake", "--uuid", "any-uuid", "/tmp"])
+        .run();
+    // Either succeeds (device found) or fails with exit code 1 (not found),
+    // but must NOT fail with exit code 64 (clap usage error).
+    assert_ne!(out.code(), 64, "--uuid should be a recognised argument");
+}
+
+/// `--partlabel` arg must be accepted by the parser.
+#[test]
+fn test_partlabel_arg_is_recognised() {
+    let out = new_ucmd!()
+        .args(&["--fake", "--partlabel", "some-part-label", "/tmp"])
+        .run();
+    assert_ne!(
+        out.code(),
+        64,
+        "--partlabel should be a recognised argument"
+    );
+}
+
+/// `--partuuid` arg must be accepted by the parser.
+#[test]
+fn test_partuuid_arg_is_recognised() {
+    let out = new_ucmd!()
+        .args(&[
+            "--fake",
+            "--partuuid",
+            "00000000-0000-0000-0000-000000000000",
+            "/tmp",
+        ])
+        .run();
+    assert_ne!(out.code(), 64, "--partuuid should be a recognised argument");
+}
+
+/// `-l`/`--show-labels` with no other args should list mounted filesystems.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_show_labels_flag_shows_mounts() {
+    let result = new_ucmd!().arg("-l").succeeds();
+    let stdout = result.stdout_str();
+    assert!(!stdout.is_empty(), "-l should produce output");
+    for line in stdout.lines() {
+        assert!(
+            line.contains(" on ") && line.contains(" type "),
+            "unexpected line format: {line:?}"
+        );
+    }
+}
+
+/// `-r` and `-w` are mutually exclusive.
+#[test]
+fn test_read_only_and_read_write_are_mutually_exclusive() {
+    new_ucmd!().args(&["--read-only", "--read-write"]).fails();
+}
+
+/// `-t` filters the listing output.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_types_filter_in_list_mode() {
+    // tmpfs is present on every Linux system; filter for it.
+    let result = new_ucmd!().args(&["-t", "tmpfs"]).succeeds();
+    let stdout = result.stdout_str();
+    // Every printed line must be of type tmpfs.
+    for line in stdout.lines() {
+        assert!(
+            line.contains(" type tmpfs "),
+            "expected only tmpfs entries, got: {line:?}"
+        );
+    }
+}
+
+/// `-t notmpfs` should exclude tmpfs entries.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_types_filter_exclusion_in_list_mode() {
+    let result = new_ucmd!().args(&["-t", "notmpfs"]).succeeds();
+    let stdout = result.stdout_str();
+    for line in stdout.lines() {
+        assert!(
+            !line.contains(" type tmpfs "),
+            "expected no tmpfs entries, got: {line:?}"
+        );
+    }
+}
+
+// ── Unit tests for internal helpers ─────────────────────────────────────────
+
+#[cfg(target_os = "linux")]
+mod unit {
+    use mount::{
+        collect_propagation_changes, format_mount_listing, fstab_entry_matches_test_opts,
+        fstype_matches_filter, is_already_mounted, merge_mount_options, options_to_flags,
+        parse_fstab_contents, parse_mount_entries, resolve_label_from, resolve_partlabel_from,
+        resolve_partuuid_from, resolve_single_argument_from, resolve_uuid_from, write_mtab_to,
+        FsTabEntry, MountEntry,
+    };
+
+    // ── parse_mount_entries ──────────────────────────────────────────────────
+
+    #[test]
+    fn test_parse_empty() {
+        assert!(parse_mount_entries("").is_empty());
+    }
+
+    #[test]
+    fn test_parse_single_entry() {
+        let input = "sysfs /sys sysfs rw,nosuid,nodev,noexec,relatime 0 0\n";
+        let entries = parse_mount_entries(input);
+        assert_eq!(entries.len(), 1);
+        assert_eq!(
+            entries[0],
+            MountEntry::new("sysfs", "/sys", "sysfs", "rw,nosuid,nodev,noexec,relatime")
+        );
+    }
+
+    #[test]
+    fn test_parse_single_entry_unescapes_fields() {
+        let input = r"/dev/disk/by-label/My\040Drive /mount\040point ext4 rw\011errors=remount-ro 0 0
+";
+        let entries = parse_mount_entries(input);
+        assert_eq!(entries.len(), 1);
+        assert_eq!(entries[0].source, "/dev/disk/by-label/My Drive");
+        assert_eq!(entries[0].target, "/mount point");
+        assert_eq!(entries[0].options, "rw\terrors=remount-ro");
+    }
+
+    #[test]
+    fn test_parse_multiple_entries() {
+        let input = "\
+sysfs /sys sysfs rw,nosuid 0 0
+proc /proc proc rw,nosuid 0 0
+tmpfs /run tmpfs rw,noexec 0 0
+";
+        let entries = parse_mount_entries(input);
+        assert_eq!(entries.len(), 3);
+        assert_eq!(entries[0].source, "sysfs");
+        assert_eq!(entries[1].source, "proc");
+        assert_eq!(entries[2].source, "tmpfs");
+    }
+
+    #[test]
+    fn test_parse_skips_malformed_lines() {
+        let input = "\
+good /mnt ext4 rw 0 0
+bad_line_with_only_one_field
+also /mnt2 ext4 ro 0 0
+";
+        let entries = parse_mount_entries(input);
+        // Lines with fewer than 4 fields are skipped.
+        assert_eq!(entries.len(), 2);
+    }
+
+    #[test]
+    fn test_mount_entry_display() {
+        let entry = MountEntry::new("tmpfs", "/run", "tmpfs", "rw,noexec");
+        assert_eq!(entry.to_string(), "tmpfs on /run type tmpfs (rw,noexec)");
+    }
+
+    #[test]
+    fn test_format_mount_listing_with_label() {
+        let entry = MountEntry::new("/dev/sda1", "/", "ext4", "rw,relatime");
+        assert_eq!(
+            format_mount_listing(&entry, Some("rootfs")),
+            "/dev/sda1 on / type ext4 (rw,relatime) [rootfs]"
+        );
+    }
+
+    // ── options_to_flags ─────────────────────────────────────────────────────
+    // options_to_flags returns (set_flags, clear_flags, extra_data).
+
+    #[test]
+    fn test_flags_ro() {
+        let (set_flags, _, extra) = options_to_flags("ro");
+        assert!(set_flags & libc::MS_RDONLY != 0);
+        assert!(extra.is_empty());
+    }
+
+    #[test]
+    fn test_flags_rw_clears_rdonly() {
+        let (set_flags, clear_flags, extra) = options_to_flags("rw");
+        assert_eq!(set_flags, 0);
+        assert!(clear_flags & libc::MS_RDONLY != 0);
+        assert!(extra.is_empty());
+    }
+
+    #[test]
+    fn test_flags_noexec() {
+        let (set_flags, _, _) = options_to_flags("noexec");
+        assert!(set_flags & libc::MS_NOEXEC != 0);
+    }
+
+    #[test]
+    fn test_flags_nosuid() {
+        let (set_flags, _, _) = options_to_flags("nosuid");
+        assert!(set_flags & libc::MS_NOSUID != 0);
+    }
+
+    #[test]
+    fn test_flags_nodev() {
+        let (set_flags, _, _) = options_to_flags("nodev");
+        assert!(set_flags & libc::MS_NODEV != 0);
+    }
+
+    #[test]
+    fn test_flags_noatime() {
+        let (set_flags, _, _) = options_to_flags("noatime");
+        assert!(set_flags & libc::MS_NOATIME != 0);
+    }
+
+    #[test]
+    fn test_flags_relatime() {
+        let (set_flags, _, _) = options_to_flags("relatime");
+        assert!(set_flags & libc::MS_RELATIME != 0);
+    }
+
+    #[test]
+    fn test_flags_remount() {
+        let (set_flags, _, _) = options_to_flags("remount");
+        assert!(set_flags & libc::MS_REMOUNT != 0);
+    }
+
+    #[test]
+    fn test_flags_exec_clears_noexec() {
+        let (set_flags, clear_flags, _) = options_to_flags("exec");
+        assert_eq!(set_flags & libc::MS_NOEXEC, 0);
+        assert!(clear_flags & libc::MS_NOEXEC != 0);
+    }
+
+    #[test]
+    fn test_flags_suid_clears_nosuid() {
+        let (_, clear_flags, _) = options_to_flags("suid");
+        assert!(clear_flags & libc::MS_NOSUID != 0);
+    }
+
+    #[test]
+    fn test_flags_dev_clears_nodev() {
+        let (_, clear_flags, _) = options_to_flags("dev");
+        assert!(clear_flags & libc::MS_NODEV != 0);
+    }
+
+    #[test]
+    fn test_flags_atime_clears_noatime() {
+        let (_, clear_flags, _) = options_to_flags("atime");
+        assert!(clear_flags & libc::MS_NOATIME != 0);
+    }
+
+    #[test]
+    fn test_flags_diratime_clears_nodiratime() {
+        let (_, clear_flags, _) = options_to_flags("diratime");
+        assert!(clear_flags & libc::MS_NODIRATIME != 0);
+    }
+
+    #[test]
+    fn test_flags_bind() {
+        let (set_flags, _, _) = options_to_flags("bind");
+        assert!(set_flags & libc::MS_BIND != 0);
+    }
+
+    #[test]
+    fn test_flags_rbind() {
+        let (set_flags, _, _) = options_to_flags("rbind");
+        assert!(set_flags & libc::MS_BIND != 0);
+        assert!(set_flags & libc::MS_REC != 0);
+    }
+
+    #[test]
+    fn test_flags_shared() {
+        let (set_flags, _, _) = options_to_flags("shared");
+        assert!(set_flags & libc::MS_SHARED != 0);
+    }
+
+    #[test]
+    fn test_flags_slave() {
+        let (set_flags, _, _) = options_to_flags("slave");
+        assert!(set_flags & libc::MS_SLAVE != 0);
+    }
+
+    #[test]
+    fn test_flags_private() {
+        let (set_flags, _, _) = options_to_flags("private");
+        assert!(set_flags & libc::MS_PRIVATE != 0);
+    }
+
+    #[test]
+    fn test_flags_unbindable() {
+        let (set_flags, _, _) = options_to_flags("unbindable");
+        assert!(set_flags & libc::MS_UNBINDABLE != 0);
+    }
+
+    #[test]
+    fn test_flags_combined() {
+        let (set_flags, _, extra) = options_to_flags("ro,nosuid,nodev,noexec");
+        assert!(set_flags & libc::MS_RDONLY != 0);
+        assert!(set_flags & libc::MS_NOSUID != 0);
+        assert!(set_flags & libc::MS_NODEV != 0);
+        assert!(set_flags & libc::MS_NOEXEC != 0);
+        assert!(extra.is_empty());
+    }
+
+    #[test]
+    fn test_flags_unknown_option_passed_through() {
+        let (_, _, extra) = options_to_flags("uid=1000,gid=1000");
+        assert!(extra.contains("uid=1000"));
+        assert!(extra.contains("gid=1000"));
+    }
+
+    #[test]
+    fn test_flags_mixed_known_and_unknown() {
+        let (set_flags, _, extra) = options_to_flags("ro,uid=1000,noexec");
+        assert!(set_flags & libc::MS_RDONLY != 0);
+        assert!(set_flags & libc::MS_NOEXEC != 0);
+        assert_eq!(extra, "uid=1000");
+    }
+
+    #[test]
+    fn test_merge_mount_options_keeps_order() {
+        assert_eq!(
+            merge_mount_options("defaults,noexec", "ro,exec"),
+            "defaults,noexec,ro,exec"
+        );
+    }
+
+    #[test]
+    fn test_merge_mount_options_skips_empty_segments() {
+        assert_eq!(merge_mount_options("", "ro"), "ro");
+        assert_eq!(merge_mount_options("defaults", ""), "defaults");
+    }
+
+    #[test]
+    fn test_fstab_entry_matches_test_opts_positive_match() {
+        let entry = FsTabEntry {
+            fs_spec: "/dev/sda1".into(),
+            fs_file: "/data".into(),
+            fs_vfstype: "ext4".into(),
+            fs_mntops: "defaults,noatime".into(),
+            fs_freq: 0,
+            fs_passno: 0,
+        };
+        assert!(fstab_entry_matches_test_opts(&entry, "noatime"));
+        assert!(!fstab_entry_matches_test_opts(&entry, "nodev"));
+    }
+
+    #[test]
+    fn test_fstab_entry_matches_test_opts_negative_match() {
+        let entry = FsTabEntry {
+            fs_spec: "/dev/sda1".into(),
+            fs_file: "/data".into(),
+            fs_vfstype: "ext4".into(),
+            fs_mntops: "defaults,netdev".into(),
+            fs_freq: 0,
+            fs_passno: 0,
+        };
+        assert!(!fstab_entry_matches_test_opts(&entry, "no_netdev"));
+        assert!(fstab_entry_matches_test_opts(&entry, "no_noatime"));
+    }
+
+    #[test]
+    fn test_collect_propagation_changes_basic_and_recursive() {
+        let changes = collect_propagation_changes(&["make-shared", "make-rprivate"]);
+        assert_eq!(changes.len(), 2);
+        assert_eq!(changes[0].name, "make-shared");
+        assert_eq!(changes[0].flags, libc::MS_SHARED);
+        assert_eq!(changes[1].name, "make-rprivate");
+        assert_eq!(changes[1].flags, libc::MS_PRIVATE | libc::MS_REC);
+    }
+
+    // ── parse_fstab_contents ─────────────────────────────────────────────────
+
+    #[test]
+    fn test_fstab_empty() {
+        assert!(parse_fstab_contents("").is_empty());
+    }
+
+    #[test]
+    fn test_fstab_skips_comments() {
+        let input = "# This is a comment\n# Another comment\n";
+        assert!(parse_fstab_contents(input).is_empty());
+    }
+
+    #[test]
+    fn test_fstab_skips_blank_lines() {
+        let input = "\n   \n\t\n";
+        assert!(parse_fstab_contents(input).is_empty());
+    }
+
+    #[test]
+    fn test_fstab_basic_entry() {
+        let input = "/dev/sda1 / ext4 defaults 1 1\n";
+        let entries = parse_fstab_contents(input);
+        assert_eq!(entries.len(), 1);
+        assert_eq!(
+            entries[0],
+            FsTabEntry {
+                fs_spec: "/dev/sda1".into(),
+                fs_file: "/".into(),
+                fs_vfstype: "ext4".into(),
+                fs_mntops: "defaults".into(),
+                fs_freq: 1,
+                fs_passno: 1,
+            }
+        );
+    }
+
+    #[test]
+    fn test_fstab_tab_separated() {
+        let input = "/dev/sda1\t/\text4\tdefaults\t0\t0\n";
+        let entries = parse_fstab_contents(input);
+        assert_eq!(entries.len(), 1);
+        assert_eq!(entries[0].fs_spec, "/dev/sda1");
+        assert_eq!(entries[0].fs_file, "/");
+        assert_eq!(entries[0].fs_vfstype, "ext4");
+    }
+
+    #[test]
+    fn test_fstab_multiple_spaces() {
+        let input = "/dev/sda1   /boot   ext4   defaults   0   2\n";
+        let entries = parse_fstab_contents(input);
+        assert_eq!(entries.len(), 1);
+        assert_eq!(entries[0].fs_passno, 2);
+    }
+
+    #[test]
+    fn test_fstab_optional_freq_passno() {
+        // Only 4 fields (freq and passno omitted) → default to 0.
+        let input = "tmpfs /tmp tmpfs defaults\n";
+        let entries = parse_fstab_contents(input);
+        assert_eq!(entries.len(), 1);
+        assert_eq!(entries[0].fs_freq, 0);
+        assert_eq!(entries[0].fs_passno, 0);
+    }
+
+    #[test]
+    fn test_fstab_optional_passno_only() {
+        // 5 fields (passno omitted) → fs_passno defaults to 0.
+        let input = "tmpfs /tmp tmpfs defaults 1\n";
+        let entries = parse_fstab_contents(input);
+        assert_eq!(entries.len(), 1);
+        assert_eq!(entries[0].fs_freq, 1);
+        assert_eq!(entries[0].fs_passno, 0);
+    }
+
+    #[test]
+    fn test_fstab_skips_malformed_lines() {
+        let input = "\
+/dev/sda1 / ext4 defaults 1 1
+too_few_fields
+/dev/sdb1 /data ext4 defaults 0 0
+";
+        let entries = parse_fstab_contents(input);
+        assert_eq!(entries.len(), 2);
+        assert_eq!(entries[0].fs_spec, "/dev/sda1");
+        assert_eq!(entries[1].fs_spec, "/dev/sdb1");
+    }
+
+    #[test]
+    fn test_fstab_octal_space_in_path() {
+        // \040 is the octal escape for a space character.
+        let input = r"/dev/sda1 /mount\040point ext4 defaults 0 0";
+        let entries = parse_fstab_contents(input);
+        assert_eq!(entries.len(), 1);
+        assert_eq!(entries[0].fs_file, "/mount point");
+    }
+
+    #[test]
+    fn test_fstab_octal_tab_in_spec() {
+        // \011 is the octal escape for a tab character.
+        let input = r"/dev/sd\011a1 / ext4 defaults 0 0";
+        let entries = parse_fstab_contents(input);
+        assert_eq!(entries.len(), 1);
+        assert_eq!(entries[0].fs_spec, "/dev/sd\ta1");
+    }
+
+    #[test]
+    fn test_fstab_comment_after_data() {
+        let input = "\
+# /etc/fstab
+# <fs>   <mount>  <type>  <opts>    <dump>  <pass>
+/dev/sda1  /       ext4    defaults  1       1
+tmpfs      /tmp    tmpfs   noauto    0       0
+";
+        let entries = parse_fstab_contents(input);
+        assert_eq!(entries.len(), 2);
+        assert_eq!(entries[0].fs_vfstype, "ext4");
+        assert_eq!(entries[1].fs_mntops, "noauto");
+    }
+
+    #[test]
+    fn test_fstab_swap_entry() {
+        let input = "/dev/sda2 none swap sw 0 0\n";
+        let entries = parse_fstab_contents(input);
+        assert_eq!(entries.len(), 1);
+        assert_eq!(entries[0].fs_file, "none");
+        assert_eq!(entries[0].fs_vfstype, "swap");
+    }
+
+    // ── write_mtab_to ────────────────────────────────────────────────────────
+
+    #[test]
+    fn test_write_mtab_appends_entry() {
+        use std::io::Write;
+        use tempfile::NamedTempFile;
+
+        let mut f = NamedTempFile::new().unwrap();
+        writeln!(f, "existing /mnt ext4 defaults 0 0").unwrap();
+
+        write_mtab_to(f.path(), "tmpfs", "/tmp", "tmpfs", "rw,nodev").unwrap();
+
+        let contents = std::fs::read_to_string(f.path()).unwrap();
+        assert!(contents.contains("existing /mnt ext4 defaults 0 0"));
+        assert!(contents.contains("tmpfs /tmp tmpfs rw,nodev 0 0"));
+    }
+
+    #[test]
+    fn test_write_mtab_entry_format() {
+        use tempfile::NamedTempFile;
+
+        let f = NamedTempFile::new().unwrap();
+        write_mtab_to(f.path(), "/dev/sda1", "/boot", "ext4", "ro").unwrap();
+
+        let contents = std::fs::read_to_string(f.path()).unwrap();
+        assert_eq!(contents.trim(), "/dev/sda1 /boot ext4 ro 0 0");
+    }
+
+    #[test]
+    fn test_write_mtab_escapes_whitespace() {
+        use tempfile::NamedTempFile;
+
+        let f = NamedTempFile::new().unwrap();
+        write_mtab_to(
+            f.path(),
+            "/dev/disk/by-label/My Drive",
+            "/mnt/my mount",
+            "ext4",
+            "rw",
+        )
+        .unwrap();
+
+        let contents = std::fs::read_to_string(f.path()).unwrap();
+        assert_eq!(
+            contents.trim(),
+            r"/dev/disk/by-label/My\040Drive /mnt/my\040mount ext4 rw 0 0"
+        );
+    }
+
+    #[test]
+    fn test_write_mtab_skips_symlink() {
+        use tempfile::TempDir;
+
+        let dir = TempDir::new().unwrap();
+        let target = dir.path().join("real_file");
+        std::fs::write(&target, "").unwrap();
+        let link = dir.path().join("mtab_link");
+        std::os::unix::fs::symlink(&target, &link).unwrap();
+
+        write_mtab_to(&link, "tmpfs", "/tmp", "tmpfs", "defaults").unwrap();
+
+        let contents = std::fs::read_to_string(&target).unwrap();
+        assert!(contents.is_empty(), "symlink target should not be modified");
+    }
+
+    #[test]
+    fn test_write_mtab_missing_file_is_ok() {
+        let result = write_mtab_to(
+            std::path::Path::new("/nonexistent/mtab"),
+            "x",
+            "/y",
+            "z",
+            "rw",
+        );
+        assert!(result.is_ok());
+    }
+
+    // ── resolve_label_from ───────────────────────────────────────────────────
+
+    fn make_entries(specs: &[(&str, &str, &str, &str)]) -> Vec<FsTabEntry> {
+        specs
+            .iter()
+            .map(|&(spec, file, vfs, opts)| FsTabEntry {
+                fs_spec: spec.to_string(),
+                fs_file: file.to_string(),
+                fs_vfstype: vfs.to_string(),
+                fs_mntops: opts.to_string(),
+                fs_freq: 0,
+                fs_passno: 0,
+            })
+            .collect()
+    }
+
+    #[test]
+    fn test_resolve_label_from_fstab() {
+        let entries = make_entries(&[
+            ("LABEL=boot", "/boot", "ext4", "defaults"),
+            ("/dev/sda2", "/", "ext4", "defaults"),
+        ]);
+        let r = resolve_label_from("boot", None, &entries).unwrap();
+        assert_eq!(r.target, "/boot");
+        assert_eq!(r.fs_type.as_deref(), Some("ext4"));
+        assert_eq!(r.options, "defaults");
+    }
+
+    #[test]
+    fn test_resolve_label_case_insensitive() {
+        let entries = make_entries(&[("LABEL=Boot", "/boot", "ext4", "ro")]);
+        // Lookup with different case should still find it.
+        let r = resolve_label_from("boot", None, &entries).unwrap();
+        assert_eq!(r.target, "/boot");
+    }
+
+    #[test]
+    fn test_resolve_label_cli_target_overrides_fstab() {
+        let entries = make_entries(&[("LABEL=data", "/data", "ext4", "defaults")]);
+        let r = resolve_label_from("data", Some("/mnt/override"), &entries).unwrap();
+        assert_eq!(r.target, "/mnt/override");
+    }
+
+    #[test]
+    fn test_resolve_label_not_found() {
+        let entries = make_entries(&[("LABEL=other", "/other", "ext4", "defaults")]);
+        let err = resolve_label_from("missing", None, &entries).unwrap_err();
+        assert!(err.to_string().contains("missing"));
+    }
+
+    #[test]
+    fn test_resolve_label_swap_has_no_mount_point() {
+        // "none" target means it's a swap entry – should fail without cli_target.
+        let entries = make_entries(&[("LABEL=swap0", "none", "swap", "sw")]);
+        let err = resolve_label_from("swap0", None, &entries).unwrap_err();
+        assert!(err.to_string().contains("no mount point"));
+    }
+
+    // ── resolve_uuid_from ────────────────────────────────────────────────────
+
+    #[test]
+    fn test_resolve_uuid_from_fstab() {
+        let uuid = "550e8400-e29b-41d4-a716-446655440000";
+        let entries = make_entries(&[(&format!("UUID={uuid}"), "/data", "ext4", "noatime")]);
+        let r = resolve_uuid_from(uuid, None, &entries).unwrap();
+        assert_eq!(r.target, "/data");
+        assert_eq!(r.options, "noatime");
+    }
+
+    #[test]
+    fn test_resolve_uuid_case_insensitive() {
+        let entries = make_entries(&[("UUID=ABCD-EF01", "/usb", "vfat", "defaults")]);
+        let r = resolve_uuid_from("abcd-ef01", None, &entries).unwrap();
+        assert_eq!(r.target, "/usb");
+    }
+
+    #[test]
+    fn test_resolve_uuid_cli_target_overrides_fstab() {
+        let entries = make_entries(&[("UUID=1234-5678", "/home", "ext4", "defaults")]);
+        let r = resolve_uuid_from("1234-5678", Some("/mnt/usb"), &entries).unwrap();
+        assert_eq!(r.target, "/mnt/usb");
+    }
+
+    #[test]
+    fn test_resolve_uuid_not_found() {
+        let entries: Vec<FsTabEntry> = vec![];
+        let err = resolve_uuid_from("dead-beef", None, &entries).unwrap_err();
+        assert!(err.to_string().contains("dead-beef"));
+    }
+
+    // ── resolve_partlabel_from ───────────────────────────────────────────────
+
+    #[test]
+    fn test_resolve_partlabel_from_fstab() {
+        let entries = make_entries(&[("PARTLABEL=efi", "/boot/efi", "vfat", "defaults")]);
+        let r = resolve_partlabel_from("efi", None, &entries).unwrap();
+        assert_eq!(r.target, "/boot/efi");
+        assert_eq!(r.fs_type.as_deref(), Some("vfat"));
+    }
+
+    #[test]
+    fn test_resolve_partlabel_case_insensitive() {
+        let entries = make_entries(&[("PARTLABEL=EFI", "/boot/efi", "vfat", "ro")]);
+        let r = resolve_partlabel_from("efi", None, &entries).unwrap();
+        assert_eq!(r.target, "/boot/efi");
+    }
+
+    #[test]
+    fn test_resolve_partlabel_not_found() {
+        let entries: Vec<FsTabEntry> = vec![];
+        let err = resolve_partlabel_from("missing-part", None, &entries).unwrap_err();
+        assert!(err.to_string().contains("missing-part"));
+    }
+
+    // ── resolve_partuuid_from ────────────────────────────────────────────────
+
+    #[test]
+    fn test_resolve_partuuid_from_fstab() {
+        let uuid = "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee";
+        let entries = make_entries(&[(&format!("PARTUUID={uuid}"), "/data", "ext4", "noatime")]);
+        let r = resolve_partuuid_from(uuid, None, &entries).unwrap();
+        assert_eq!(r.target, "/data");
+        assert_eq!(r.options, "noatime");
+    }
+
+    #[test]
+    fn test_resolve_partuuid_case_insensitive() {
+        let entries = make_entries(&[("PARTUUID=ABCD-EF01", "/usb", "vfat", "defaults")]);
+        let r = resolve_partuuid_from("abcd-ef01", None, &entries).unwrap();
+        assert_eq!(r.target, "/usb");
+    }
+
+    #[test]
+    fn test_resolve_partuuid_not_found() {
+        let entries: Vec<FsTabEntry> = vec![];
+        let err = resolve_partuuid_from("dead-beef", None, &entries).unwrap_err();
+        assert!(err.to_string().contains("dead-beef"));
+    }
+
+    // ── resolve_single_argument_from ─────────────────────────────────────────
+
+    #[test]
+    fn test_resolve_single_argument_from_mountpoint() {
+        let entries = make_entries(&[("/dev/sda1", "/data", "ext4", "defaults")]);
+        let resolved = resolve_single_argument_from("/data", &entries).unwrap();
+        assert_eq!(resolved.source, "/dev/sda1");
+        assert_eq!(resolved.target, "/data");
+    }
+
+    #[test]
+    fn test_resolve_single_argument_from_source() {
+        let entries = make_entries(&[("/dev/sda1", "/data", "ext4", "defaults")]);
+        let resolved = resolve_single_argument_from("/dev/sda1", &entries).unwrap();
+        assert_eq!(resolved.source, "/dev/sda1");
+        assert_eq!(resolved.target, "/data");
+    }
+
+    #[test]
+    fn test_resolve_single_argument_from_swap_has_no_mount_point() {
+        let entries = make_entries(&[("/dev/sda2", "none", "swap", "sw")]);
+        let err = resolve_single_argument_from("/dev/sda2", &entries).unwrap_err();
+        assert!(err.to_string().contains("no mount point"));
+    }
+
+    #[test]
+    fn test_resolve_single_argument_from_missing_entry() {
+        let entries = make_entries(&[("/dev/sda1", "/data", "ext4", "defaults")]);
+        let err = resolve_single_argument_from("/missing", &entries).unwrap_err();
+        assert!(err.to_string().contains("/missing"));
+    }
+
+    #[test]
+    fn test_is_already_mounted_matches_exact_source_and_target() {
+        let entry = FsTabEntry {
+            fs_spec: "/dev/sda1".into(),
+            fs_file: "/data".into(),
+            fs_vfstype: "ext4".into(),
+            fs_mntops: "defaults".into(),
+            fs_freq: 0,
+            fs_passno: 0,
+        };
+        let mounts = vec![MountEntry::new("/dev/sda1", "/data", "ext4", "rw")];
+        assert!(is_already_mounted(&entry, &mounts));
+    }
+
+    #[test]
+    fn test_is_already_mounted_matches_canonicalised_source() {
+        use tempfile::TempDir;
+
+        let dir = TempDir::new().unwrap();
+        let device = dir.path().join("device");
+        let symlink = dir.path().join("device-link");
+        std::fs::write(&device, "").unwrap();
+        std::os::unix::fs::symlink(&device, &symlink).unwrap();
+
+        let entry = FsTabEntry {
+            fs_spec: symlink.to_string_lossy().into_owned(),
+            fs_file: "/data".into(),
+            fs_vfstype: "ext4".into(),
+            fs_mntops: "defaults".into(),
+            fs_freq: 0,
+            fs_passno: 0,
+        };
+        let mounts = vec![MountEntry::new(
+            &device.to_string_lossy(),
+            "/data",
+            "ext4",
+            "rw",
+        )];
+        assert!(is_already_mounted(&entry, &mounts));
+    }
+
+    #[test]
+    fn test_is_already_mounted_requires_matching_target() {
+        let entry = FsTabEntry {
+            fs_spec: "/dev/sda1".into(),
+            fs_file: "/data".into(),
+            fs_vfstype: "ext4".into(),
+            fs_mntops: "defaults".into(),
+            fs_freq: 0,
+            fs_passno: 0,
+        };
+        let mounts = vec![MountEntry::new("/dev/sda1", "/other", "ext4", "rw")];
+        assert!(!is_already_mounted(&entry, &mounts));
+    }
+
+    // ── fstype_matches_filter ────────────────────────────────────────────────
+
+    #[test]
+    fn test_fstype_filter_simple_inclusion() {
+        assert!(fstype_matches_filter("ext4", "ext4"));
+        assert!(!fstype_matches_filter("tmpfs", "ext4"));
+    }
+
+    #[test]
+    fn test_fstype_filter_multiple_inclusions() {
+        assert!(fstype_matches_filter("ext4", "ext4,vfat"));
+        assert!(fstype_matches_filter("vfat", "ext4,vfat"));
+        assert!(!fstype_matches_filter("tmpfs", "ext4,vfat"));
+    }
+
+    #[test]
+    fn test_fstype_filter_exclusion_only() {
+        // "notmpfs" → include everything except tmpfs.
+        assert!(fstype_matches_filter("ext4", "notmpfs"));
+        assert!(!fstype_matches_filter("tmpfs", "notmpfs"));
+    }
+
+    #[test]
+    fn test_fstype_filter_exclusion_multiple() {
+        assert!(fstype_matches_filter("ext4", "notmpfs,nodevtmpfs"));
+        assert!(!fstype_matches_filter("tmpfs", "notmpfs,nodevtmpfs"));
+        assert!(!fstype_matches_filter("devtmpfs", "notmpfs,nodevtmpfs"));
+    }
+
+    #[test]
+    fn test_fstype_filter_mixed_inclusion_exclusion() {
+        // Include ext4 and vfat, but exclude vfat → only ext4 matches.
+        assert!(fstype_matches_filter("ext4", "ext4,novfat"));
+        assert!(!fstype_matches_filter("vfat", "ext4,novfat"));
+        assert!(!fstype_matches_filter("tmpfs", "ext4,novfat"));
+    }
+
+    #[test]
+    fn test_fstype_filter_empty_string_matches_all() {
+        // An empty filter string (no inclusions, no exclusions) → all types match.
+        assert!(fstype_matches_filter("ext4", ""));
+        assert!(fstype_matches_filter("tmpfs", ""));
+    }
+}
+
+/// An unmatched single positional argument should be treated as an fstab lookup
+/// failure rather than falling back to listing mounted filesystems.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_single_positional_unknown_fails() {
+    new_ucmd!()
+        .arg("/copilot-mount-missing-entry-9876f2ab")
+        .fails()
+        .code_is(1)
+        .stderr_contains("in fstab");
+}
diff --git a/tests/tests.rs b/tests/tests.rs
index 8f94a09a..c185b4bb 100644
--- a/tests/tests.rs
+++ b/tests/tests.rs
@@ -31,6 +31,10 @@ mod test_lslocks;
 #[path = "by-util/test_mesg.rs"]
 mod test_mesg;
 
+#[cfg(feature = "mount")]
+#[path = "by-util/test_mount.rs"]
+mod test_mount;
+
 #[cfg(feature = "mountpoint")]
 #[path = "by-util/test_mountpoint.rs"]
 mod test_mountpoint;