Skip to content

A treemap for finding and removing what fills your disk, for Omarchy. Rust + GPUI.

Rust

Preserve independent mount data and allow external media cleanup

Tobi Lutke955108c13fec
diff --git a/crates/disktree-core/src/removal.rs b/crates/disktree-core/src/removal.rs
index b7bbc25..1fef87d 100644
--- a/crates/disktree-core/src/removal.rs
+++ b/crates/disktree-core/src/removal.rs
@@ -113,9 +113,10 @@ pub fn plan(targets: &[Target], root: &Path) -> Plan {
for target in targets {
let path = normalize(&target.path);
let reason =
- refuse(&path, &root, home.as_ref(), &mounts).or_else(|| {
- linked(&path, &root, real_root.as_deref(), home.as_ref())
- });
+ refuse(&path, &root, home.as_ref(), &mounts.points, &mounts.media)
+ .or_else(|| {
+ linked(&path, &root, real_root.as_deref(), home.as_ref())
+ });
if let Some(reason) = reason {
plan.blocked.push(Blocked {
path: target.path.clone(),
@@ -364,6 +365,7 @@ fn refuse(
root: &Path,
home: Option<&Home>,
mounts: &[PathBuf],
+ media: &[PathBuf],
) -> Option<String> {
let key = guard_key(path);
let root_key = guard_key(root);
@@ -414,7 +416,11 @@ fn refuse(
if !key.starts_with(&root_key) && !path.starts_with(root) {
return Some("outside the scanned root".into());
}
- if let Some(system) = system_tree(&key, home_key) {
+ if let Some(system) = system_tree(&key, home_key)
+ && !(system == "/run"
+ && on_media(&key, mounts, media)
+ && fs::canonicalize(path).is_ok_and(|real| real == path))
+ {
return Some(format!(
"part of the system under {system}: {SYSTEM_TOOLS}"
));
@@ -424,7 +430,7 @@ fn refuse(
"it contains {system}, which is part of the system"
));
}
- if is_mount_point(path) {
+ if mounts.contains(&key) || is_mount_point(path) {
return Some(
"a mount point: removing it would cross onto another filesystem"
.into(),
@@ -533,10 +539,78 @@ const fn identity(_path: &Path, _follow: bool) -> Option<(u64, u64)> {
/// mount boundary whatever the table said.
const MOUNTS_FRESH: std::time::Duration = std::time::Duration::from_secs(2);
+/// Paths and safe media exceptions must come from the same snapshot.
+#[derive(Default)]
+struct MountTable {
+ points: Vec<PathBuf>,
+ media: Vec<PathBuf>,
+}
+
+fn read_mount_table() -> MountTable {
+ if let Ok(table) = fs::read_to_string("/proc/self/mountinfo") {
+ let views = crate::space::parse_mountinfo(&table);
+ return MountTable {
+ points: views.iter().map(|mount| guard_key(&mount.point)).collect(),
+ media: media_roots(&views),
+ };
+ }
+ MountTable {
+ points: read_mount_points(),
+ media: Vec::new(),
+ }
+}
+
+/// Only real disks mounted by the desktop under /run/media qualify. A
+/// directory with that spelling, a bind of a system tree, and virtual
+/// filesystems retain the /run guard. Missing information fails closed.
+fn media_roots(mounts: &[crate::space::MountView]) -> Vec<PathBuf> {
+ mounts
+ .iter()
+ .filter(|mount| {
+ mount.point.starts_with("/run/media")
+ && mount.point != Path::new("/run/media")
+ && mount.fs_root == Path::new("/")
+ && mount.source.starts_with("/dev/")
+ && matches!(
+ mount.fstype.as_str(),
+ "ext2"
+ | "ext3"
+ | "ext4"
+ | "btrfs"
+ | "xfs"
+ | "f2fs"
+ | "vfat"
+ | "exfat"
+ | "ntfs"
+ | "ntfs3"
+ | "fuseblk"
+ | "fuse.ntfs-3g"
+ )
+ && !mounts.iter().any(|other| {
+ !other.point.starts_with("/run/media")
+ && (other.point == Path::new("/")
+ || system_tree(&other.point, None).is_some())
+ && (other.device == mount.device
+ || other.source == mount.source)
+ })
+ })
+ .map(|mount| mount.point.clone())
+ .collect()
+}
+
+fn on_media(key: &Path, mounts: &[PathBuf], media: &[PathBuf]) -> bool {
+ // Nested mounts do not inherit their parent's exception.
+ mounts
+ .iter()
+ .filter(|point| key.starts_with(point))
+ .max_by_key(|point| point.components().count())
+ .is_some_and(|point| key != point && media.contains(point))
+}
+
/// The last read of the mount table, and whether a read is under way.
struct MountCache {
read: Option<std::time::Instant>,
- mounts: Option<Arc<Vec<PathBuf>>>,
+ mounts: Option<Arc<MountTable>>,
refreshing: bool,
}
@@ -554,7 +628,7 @@ static MOUNTS: std::sync::Mutex<MountCache> =
/// its own thread and is used meanwhile; before the first read lands it is
/// empty, which is why the app primes it at start with
/// [`prime_mount_points`].
-fn mount_points() -> Arc<Vec<PathBuf>> {
+fn mount_points() -> Arc<MountTable> {
let mut cache = MOUNTS
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
@@ -564,7 +638,7 @@ fn mount_points() -> Arc<Vec<PathBuf>> {
let spawned = thread::Builder::new()
.name("disktree-mounts".into())
.spawn(|| {
- let mounts = Arc::new(read_mount_points());
+ let mounts = Arc::new(read_mount_table());
let mut cache = MOUNTS
.lock()
.unwrap_or_else(std::sync::PoisonError::into_inner);
@@ -919,7 +993,7 @@ fn run(
// The plan was judged against a mount table up to `MOUNTS_FRESH` old,
// or, right after start, not read yet. Judged again against a fresh
// read, here on the worker, before anything is touched.
- let mounts = read_mount_points();
+ let mounts = read_mount_table();
// Links too: one put on the way down since the plan was made would lead
// the trash out of the root. Permanent removal on Unix refuses that by
// itself; see [`open_parent`].
@@ -930,14 +1004,30 @@ fn run(
if cancel.load(Ordering::Relaxed) {
break;
}
- let reason = mounted(&target.path, &mounts).or_else(|| {
- linked(
- &target.path,
- &plan.root,
- real_root.as_deref(),
- home.as_ref(),
- )
- });
+ // The /run/media exception must still hold when removal starts;
+ // a disk may have been unmounted since the review was displayed.
+ let reason = target
+ .path
+ .starts_with("/run/media")
+ .then(|| {
+ refuse(
+ &target.path,
+ &plan.root,
+ home.as_ref(),
+ &mounts.points,
+ &mounts.media,
+ )
+ })
+ .flatten()
+ .or_else(|| mounted(&target.path, &mounts.points))
+ .or_else(|| {
+ linked(
+ &target.path,
+ &plan.root,
+ real_root.as_deref(),
+ home.as_ref(),
+ )
+ });
let outcome = if let Some(reason) = reason {
Err(io::Error::other(reason))
} else {
@@ -1469,6 +1559,129 @@ mod tests {
temp
}
+ #[cfg(target_os = "linux")]
+ #[test]
+ fn desktop_media_exception_requires_an_independent_disk() {
+ let views = crate::space::parse_mountinfo(
+ "1 0 8:1 / / rw - ext4 /dev/root rw\n\
+ 2 1 0:20 / /run rw - tmpfs tmpfs rw\n\
+ 3 2 8:2 / /run/media/user/Games rw - ext4 /dev/sdb rw\n\
+ 4 2 8:1 / /run/media/user/System rw - ext4 /dev/root rw\n\
+ 5 2 8:2 /folder /run/media/user/Bind rw - ext4 /dev/sdb rw\n\
+ 6 2 0:21 / /run/media/user/Virtual rw - tmpfs tmpfs rw\n\
+ 7 3 8:1 /etc /run/media/user/Games/nested rw - ext4 /dev/root rw\n",
+ );
+ let media = media_roots(&views);
+ assert_eq!(media, [PathBuf::from("/run/media/user/Games")]);
+ let points: Vec<_> =
+ views.iter().map(|view| view.point.clone()).collect();
+ assert!(on_media(
+ Path::new("/run/media/user/Games/game"),
+ &points,
+ &media
+ ));
+ for path in [
+ "/run/media/user/Games",
+ "/run/media/user/Games/nested/file",
+ "/run/media/user/System/etc",
+ "/run/media/user/Bind/file",
+ "/run/media/user/Virtual/file",
+ "/run/media/user/NotMounted/file",
+ "/run/user/1000/file",
+ ] {
+ assert!(!on_media(Path::new(path), &points, &media), "{path}");
+ }
+ assert!(media_roots(&[]).is_empty());
+ }
+
+ /// Run in a private mount namespace with the fixture described in
+ /// scripts/test-linux-mounts.sh. Never changes the host's mount table.
+ #[cfg(target_os = "linux")]
+ #[test]
+ #[ignore = "requires the isolated mount fixture"]
+ fn mounted_media_and_repeated_views() {
+ let table =
+ fs::read_to_string("/proc/self/mountinfo").expect("mountinfo");
+ assert!(
+ crate::space::parse_mountinfo(&table)
+ .iter()
+ .any(|mount| mount.point == Path::new("/run")
+ && mount.source == "disktree-test-run")
+ );
+ let root = Path::new("/run/media/disktree-test");
+ let mounts = read_mount_points();
+ // User namespaces cannot mount a block device. Supply the media
+ // classification separately; the table-policy test above covers it.
+ let media = vec![root.to_path_buf()];
+ let file = root.join("game");
+ fs::write(&file, b"game").expect("fixture");
+ assert_eq!(refuse(&file, root, None, &mounts, &media), None);
+ assert!(refuse(root, Path::new("/"), None, &mounts, &media).is_some());
+ assert!(refuse(&file, root, None, &mounts, &[]).is_some());
+ std::os::unix::fs::symlink("/etc", root.join("link")).expect("link");
+ assert!(
+ refuse(
+ &root.join("link/passwd"),
+ &root.join("link"),
+ None,
+ &mounts,
+ &media
+ )
+ .is_some()
+ );
+ fs::write(root.join("nested/keep"), b"keep").expect("nested");
+ assert!(
+ refuse(&root.join("nested/keep"), root, None, &mounts, &media)
+ .is_some()
+ );
+ remove_permanently(&file, root).expect("delete marked game");
+ assert!(!file.exists());
+ assert!(root.join("nested/keep").exists());
+
+ let scan_root = Path::new("/run/disktree-scan");
+ let options = crate::scan::ScanOptions {
+ apparent_size: true,
+ one_filesystem: false,
+ ..crate::scan::ScanOptions::default()
+ };
+ let tree = crate::scan::scan(scan_root, options.clone()).expect("scan");
+ for name in ["one", "two", "original"] {
+ assert!(
+ tree.children.iter().any(|child| &*child.name == name),
+ "{name}"
+ );
+ }
+ assert!(!tree.children.iter().any(|child| &*child.name == "alias"));
+ assert_eq!(tree.files, 3);
+ assert_eq!(tree.bytes, 12);
+ assert!(
+ std::process::Command::new("mount")
+ .args([
+ "-t",
+ "tmpfs",
+ "tmpfs",
+ "/run/disktree-scan/alias/nested"
+ ])
+ .status()
+ .expect("nested mount")
+ .success()
+ );
+ fs::write(scan_root.join("alias/nested/unique"), b"unique")
+ .expect("unique");
+ let tree = crate::scan::scan(scan_root, options).expect("rescan");
+ let alias = tree
+ .children
+ .iter()
+ .find(|child| &*child.name == "alias")
+ .expect("alias retained");
+ assert!(
+ alias
+ .children
+ .iter()
+ .any(|child| &*child.name == "nested" && child.files == 1)
+ );
+ }
+
#[test]
fn a_plan_keeps_only_the_outermost_targets() {
let temp = tree();
@@ -1515,13 +1728,19 @@ mod tests {
fn the_directories_above_home_are_refused() {
let home = Home::of(Path::new("/home/disktree-test-user"));
let reason =
- refuse(Path::new("/home"), Path::new("/"), Some(&home), &[]);
+ refuse(Path::new("/home"), Path::new("/"), Some(&home), &[], &[]);
assert!(
reason.is_some_and(|reason| reason.contains("home directory")),
"the home directory is inside it"
);
assert_eq!(
- refuse(Path::new("/home/other"), Path::new("/"), Some(&home), &[]),
+ refuse(
+ Path::new("/home/other"),
+ Path::new("/"),
+ Some(&home),
+ &[],
+ &[]
+ ),
None,
"a sibling of home is not above it"
);
@@ -1579,6 +1798,7 @@ mod tests {
Path::new("/"),
Some(&Home::of(home)),
&[],
+ &[],
)
.expect("refused");
assert!(reason.contains("home directory"), "{reason}");
@@ -1587,6 +1807,7 @@ mod tests {
Path::new("/Users/tobi/src"),
Path::new("/"),
Some(&Home::of(home)),
+ &[],
&[]
)
.is_none(),
@@ -1605,6 +1826,7 @@ mod tests {
Path::new("/"),
Some(&Home::of(home)),
&[],
+ &[],
)
.expect("refused");
assert!(reason.contains(inside), "{path}: {reason}");
@@ -1614,6 +1836,7 @@ mod tests {
Path::new("/opt/local"),
Path::new("/"),
Some(&Home::of(home)),
+ &[],
&[]
)
.is_none(),
@@ -1637,9 +1860,12 @@ mod tests {
"itself"
);
let reason =
- refuse(&root.join("a"), root, None, &mounts).expect("refused");
+ refuse(&root.join("a"), root, None, &mounts, &[]).expect("refused");
assert!(reason.contains("mounted inside"), "{reason}");
- assert_eq!(refuse(&root.join("a/one.bin"), root, None, &mounts), None);
+ assert_eq!(
+ refuse(&root.join("a/one.bin"), root, None, &mounts, &[]),
+ None
+ );
}
#[test]
@@ -1671,13 +1897,17 @@ mod tests {
// The first read lands on its own thread; wait for it, briefly.
let mut mounts = mount_points();
for _ in 0..500 {
- if !mounts.is_empty() {
+ if !mounts.points.is_empty() {
break;
}
thread::sleep(std::time::Duration::from_millis(10));
mounts = mount_points();
}
- assert_eq!(*mounts, read_mount_points(), "the same table, cached");
+ assert_eq!(
+ mounts.points,
+ read_mount_table().points,
+ "the same table, cached"
+ );
}
#[test]
@@ -1743,6 +1973,7 @@ mod tests {
&data.join("Users/tobi/src"),
data,
Some(&Home::of(home)),
+ &[],
&[]
)
.is_none(),
@@ -1753,6 +1984,7 @@ mod tests {
Path::new("/"),
Some(&Home::of(home)),
&[],
+ &[],
)
.expect("refused");
assert!(reason.contains("/Library"), "{reason}");
@@ -2190,6 +2422,7 @@ mod tests {
&drive,
Some(&Home::of(&home)),
&[],
+ &[],
);
assert!(
reason.is_some_and(|reason| reason
@@ -2220,7 +2453,7 @@ mod tests {
let public = crate::windows::user_profiles_dir()
.expect("profiles folder")
.join("Public");
- let reason = refuse(&public, &system_drive(), None, &[]);
+ let reason = refuse(&public, &system_drive(), None, &[], &[]);
assert!(reason.is_some_and(|reason| reason.contains("profile")));
}
@@ -2299,6 +2532,7 @@ mod tests {
Path::new("/"),
Some(&Home::of(home)),
&[],
+ &[],
);
assert!(reason.is_some_and(|reason| reason.contains("/etc")));
}
diff --git a/crates/disktree-core/src/scan.rs b/crates/disktree-core/src/scan.rs
index df59be9..191f280 100644
--- a/crates/disktree-core/src/scan.rs
+++ b/crates/disktree-core/src/scan.rs
@@ -750,10 +750,18 @@ fn scan_blocking(root: &Path, context: &Arc<WalkContext>) -> io::Result<Node> {
format!("{} is not a directory", root.display()),
));
}
-let resolved = root.canonicalize().ok();
+ let resolved = root.canonicalize().ok();
let canonical = resolved.as_deref().unwrap_or(root);
- let mut never = space::never_scanned(root, canonical);
- never.extend(space::repeated_mounts_for(root, canonical));
+ let mut never = crate::space::never_scanned(root, canonical);
+ // Hidden-entry and depth filters can leave an alias as the only route
+ // to files. Keep every mount view when either filter is active.
+ if context.options.include_hidden && context.options.max_depth.is_none() {
+ never.extend(crate::space::repeated_mounts_for(
+ root,
+ canonical,
+ context.options.one_filesystem,
+ ));
+ }
let _ = context.never_scanned.set(never.into_iter().collect());
if context.options.one_filesystem {
*lock(&context.root_device) = Some(device_of(&root_meta));
diff --git a/crates/disktree-core/src/space.rs b/crates/disktree-core/src/space.rs
index 3040721..010daeb 100644
--- a/crates/disktree-core/src/space.rs
+++ b/crates/disktree-core/src/space.rs
@@ -229,6 +229,8 @@ pub fn foreign_mounts_for(root: &Path) -> Option<Vec<PathBuf>> {
/// mount from the filesystem itself.
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct MountView {
+ /// Kernel filesystem identity; source names such as `tmpfs` repeat.
+ pub device: String,
pub source: String,
pub fstype: String,
pub point: PathBuf,
@@ -246,13 +248,15 @@ pub fn parse_mountinfo(table: &str) -> Vec<MountView> {
// Optional fields run up to a lone `-`; after it come the type
// and the source.
let (left, right) = line.split_once(" - ")?;
- let mut left = left.split_whitespace().skip(3);
+ let mut left = left.split_whitespace().skip(2);
+ let device = left.next()?.to_string();
let fs_root = PathBuf::from(unescape_octal(left.next()?));
let point = PathBuf::from(unescape_octal(left.next()?));
let mut right = right.split_whitespace();
let fstype = right.next()?.to_string();
let source = unescape_octal(right.next()?);
Some(MountView {
+ device,
source,
fstype,
point,
@@ -298,10 +302,40 @@ fn unescape_octal(field: &str) -> String {
/// is left out. The scanned root itself is never left out; if it is the
/// narrower view, its copy inside the wider one is.
pub fn repeated_mounts(mounts: &[MountView], root: &Path) -> Vec<PathBuf> {
+ repeated_mounts_excluding(mounts, root, &[])
+}
+
+fn same_filesystem(left: &MountView, right: &MountView) -> bool {
+ left.fstype == right.fstype
+ && (left.device == right.device
+ // Btrfs assigns device numbers per subvolume. Its block device
+ // identifies the filesystem shared by those different roots.
+ || (left.fstype == "btrfs"
+ && left.source.starts_with("/dev/")
+ && left.source == right.source))
+}
+
+fn covering_mount<'a>(
+ mounts: &'a [MountView],
+ path: &Path,
+) -> Option<&'a MountView> {
+ mounts
+ .iter()
+ .filter(|mount| path.starts_with(&mount.point))
+ .max_by_key(|mount| mount.point.components().count())
+}
+
+fn repeated_mounts_excluding(
+ mounts: &[MountView],
+ root: &Path,
+ excluded: &[PathBuf],
+) -> Vec<PathBuf> {
+ let own = covering_mount(mounts, root);
let mut visible: Vec<&MountView> = mounts
.iter()
.filter(|mount| {
- mount.point.starts_with(root) || root.starts_with(&mount.point)
+ (mount.point.starts_with(root) || Some(*mount) == own)
+ && !excluded.iter().any(|skip| mount.point.starts_with(skip))
})
.collect();
visible.sort_by_key(|mount| {
@@ -312,28 +346,49 @@ pub fn repeated_mounts(mounts: &[MountView], root: &Path) -> Vec<PathBuf> {
)
});
let mut kept: Vec<&MountView> = Vec::new();
- let mut repeated = Vec::new();
+ let mut repeated: Vec<PathBuf> = Vec::new();
for mount in visible {
- // Where this view's directory already appears through a kept one.
let elsewhere = kept.iter().find_map(|wider| {
- if wider.source != mount.source || wider.fstype != mount.fstype {
+ if !same_filesystem(wider, mount) {
return None;
}
let inside = mount.fs_root.strip_prefix(&wider.fs_root).ok()?;
let path = wider.point.join(inside);
- (path.starts_with(root) && path != mount.point).then_some(path)
+ if !path.starts_with(root)
+ || path == mount.point
+ || excluded
+ .iter()
+ .chain(&repeated)
+ .any(|skip| path.starts_with(skip))
+ {
+ return None;
+ }
+ // Another mount can hide the supposed original directory.
+ let covering = covering_mount(mounts, &path)?;
+ let relative = path.strip_prefix(&covering.point).ok()?;
+ (same_filesystem(covering, mount)
+ && covering.fs_root.join(relative) == mount.fs_root)
+ .then_some(path)
});
- match elsewhere {
- Some(_) if mount.point != root && mount.point.starts_with(root) => {
- repeated.push(mount.point.clone());
+ let skip = elsewhere.map(|copy| {
+ if mount.point != root && mount.point.starts_with(root) {
+ mount.point.clone()
+ } else {
+ copy
}
- Some(copy) => {
- if copy != root {
- repeated.push(copy);
- }
+ });
+ if let Some(skip) = skip
+ && !root.starts_with(&skip)
+ // A duplicate view can contain independently mounted data.
+ // Keep it rather than hiding that data with its parent.
+ && !mounts.iter().any(|child| child.point != skip && child.point.starts_with(&skip))
+ {
+ if skip != mount.point {
kept.push(mount);
}
- None => kept.push(mount),
+ repeated.push(skip);
+ } else {
+ kept.push(mount);
}
}
repeated
@@ -341,11 +396,20 @@ pub fn repeated_mounts(mounts: &[MountView], root: &Path) -> Vec<PathBuf> {
/// [`repeated_mounts`] for this machine, in `root`'s own spelling. Empty
/// where there is no `/proc/self/mountinfo`.
-pub fn repeated_mounts_for(root: &Path, canonical: &Path) -> Vec<PathBuf> {
+pub fn repeated_mounts_for(
+ root: &Path,
+ canonical: &Path,
+ one_filesystem: bool,
+) -> Vec<PathBuf> {
let Ok(table) = std::fs::read_to_string("/proc/self/mountinfo") else {
return Vec::new();
};
- repeated_mounts(&parse_mountinfo(&table), canonical)
+ let excluded = if one_filesystem {
+ foreign_mounts_for(canonical).unwrap_or_default()
+ } else {
+ Vec::new()
+ };
+ repeated_mounts_excluding(&parse_mountinfo(&table), canonical, &excluded)
.iter()
.filter_map(|path| path.strip_prefix(canonical).ok())
.map(|below| root.join(below))
@@ -703,6 +767,56 @@ portal /run/user/1000/doc fuse.portal rw 0 0
);
}
+ #[test]
+ fn unrelated_tmpfs_mounts_are_not_duplicates() {
+ let table = "1 0 8:1 / / rw - ext4 /dev/root rw\n\
+ 2 1 0:20 / /one rw - tmpfs tmpfs rw\n\
+ 3 1 0:21 / /two rw - tmpfs tmpfs rw\n";
+ assert!(repeated(table, "/").is_empty());
+ let alias =
+ format!("{table}4 1 0:20 / /three rw - tmpfs different-name rw\n");
+ assert_eq!(repeated(&alias, "/"), [PathBuf::from("/three")]);
+ }
+
+ #[test]
+ fn hidden_original_and_nested_mounts_are_preserved() {
+ let hidden = "1 0 8:1 / / rw - ext4 /dev/root rw\n\
+ 2 1 0:20 / /data rw - tmpfs tmpfs rw\n\
+ 3 2 8:1 /data/source /data/bind rw - ext4 /dev/root rw\n";
+ assert!(repeated(hidden, "/").is_empty());
+ let nested = "1 0 8:1 / / rw - ext4 /dev/root rw\n\
+ 2 1 8:1 /original /view rw - ext4 /dev/root rw\n\
+ 3 2 0:20 / /view/unique rw - tmpfs tmpfs rw\n";
+ assert!(repeated(nested, "/").is_empty());
+ }
+
+ #[test]
+ fn excluded_views_cannot_replace_visible_files() {
+ let mounts = parse_mountinfo(
+ "1 0 8:1 / / rw - ext4 /dev/root rw\n\
+ 2 1 8:1 /original /view rw - ext4 /dev/root rw\n",
+ );
+ assert!(
+ repeated_mounts_excluding(
+ &mounts,
+ Path::new("/"),
+ &[PathBuf::from("/original")]
+ )
+ .is_empty()
+ );
+ }
+
+ #[test]
+ fn btrfs_subvolume_devices_can_differ() {
+ let table = "1 0 0:20 /@ / rw - btrfs /dev/root rw\n\
+ 2 1 0:21 /@home /home rw - btrfs /dev/root rw\n\
+ 3 1 0:22 / /top rw - btrfs /dev/root rw\n";
+ assert_eq!(
+ repeated(table, "/"),
+ [PathBuf::from("/home"), PathBuf::from("/top/@")]
+ );
+ }
+
#[test]
fn mountinfo_escapes_are_decoded_once() {
let mounts = parse_mountinfo(
diff --git a/scripts/test-linux-mounts.sh b/scripts/test-linux-mounts.sh
new file mode 100644
index 0000000..b9af034
--- /dev/null
+++ b/scripts/test-linux-mounts.sh
@@ -0,0 +1,18 @@
+#!/bin/sh
+# Pass the compiled disktree-core unit test binary as the first argument.
+# All mounts and writes live in an isolated, temporary /run.
+set -eu
+exec unshare --user --map-root-user --mount sh -eu -c '
+ mount --make-rprivate /
+ mount -t tmpfs disktree-test-run /run
+ mkdir -p /run/media/disktree-test /run/disktree-scan
+ mount -t tmpfs tmpfs /run/media/disktree-test
+ mkdir /run/media/disktree-test/nested
+ mount -t tmpfs tmpfs /run/media/disktree-test/nested
+ for dir in original alias one two; do mkdir /run/disktree-scan/$dir; done
+ mkdir /run/disktree-scan/original/nested
+ mount --bind /run/disktree-scan/original /run/disktree-scan/alias
+ for dir in one two; do mount -t tmpfs tmpfs /run/disktree-scan/$dir; done
+ for dir in original one two; do printf data > /run/disktree-scan/$dir/file; done
+ "$1" --exact removal::tests::mounted_media_and_repeated_views --ignored --nocapture
+' sh "$1"