A treemap for finding and removing what fills your disk, for Omarchy. Rust + GPUI.
Rust
core: list, measure and remove on Windows
Oleg Shevchukf3741c1a5174
diff --git a/Cargo.lock b/Cargo.lockindex 4047a24..832669d 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -1439,6 +1439,9 @@ dependencies = ["rustc-hash 2.1.3","rustix","tempfile",+ "trash",+ "winapi-util",+ "windows-sys 0.61.2",][[package]]@@ -7071,6 +7074,23 @@ dependencies = ["tracing-log",]+[[package]]+name = "trash"+version = "5.2.9"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "be89b3fe156965d29ac4f8522f3a640c655affdd9f21cb4f36857f0c92c00317"+dependencies = [+ "libc",+ "log",+ "objc2 0.6.4",+ "objc2-foundation 0.3.2",+ "once_cell",+ "percent-encoding",+ "scopeguard",+ "urlencoding",+ "windows 0.62.2",+]+[[package]]name = "triomphe"version = "0.1.16"@@ -7228,6 +7248,12 @@ dependencies = ["serde",]+[[package]]+name = "urlencoding"+version = "2.1.3"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "daf8dba3b7eb870caf1ddeed7bc9d2a049f3cfdfae7cb521b087cc33ae4c49da"+[[package]]name = "usvg"version = "0.45.1"diff --git a/crates/disktree-core/Cargo.toml b/crates/disktree-core/Cargo.tomlindex 21ac328..9647cb8 100644--- a/crates/disktree-core/Cargo.toml+++ b/crates/disktree-core/Cargo.toml@@ -12,8 +12,17 @@ workspace = true[dependencies]chrono = { version = "0.4.45", default-features = false, features = ["clock", "std"] }rayon = { workspace = true }-rustix = { version = "1.1", features = ["fs"] }rustc-hash = { workspace = true }+# rustix has no filesystem calls on Windows; `windows.rs` covers them there.+[target.'cfg(not(windows))'.dependencies]+rustix = { version = "1.1", features = ["fs"] }++[target.'cfg(windows)'.dependencies]+# The Recycle Bin, through the shell's own file operation.+trash = { version = "5.2.9", default-features = false, features = ["coinit_apartmentthreaded"] }+winapi-util = "0.1.11"+windows-sys = { version = "0.61", features = ["Win32_Foundation", "Win32_Storage_FileSystem"] }+[dev-dependencies]tempfile = "3"diff --git a/crates/disktree-core/src/lib.rs b/crates/disktree-core/src/lib.rsindex d7cdb24..aa2dfce 100644--- a/crates/disktree-core/src/lib.rs+++ b/crates/disktree-core/src/lib.rs@@ -14,3 +14,5 @@ pub mod size;pub mod space;pub mod tree;pub mod treemap;+#[cfg(windows)]+mod windows;diff --git a/crates/disktree-core/src/removal.rs b/crates/disktree-core/src/removal.rsindex c15ad04..08b4b58 100644--- a/crates/disktree-core/src/removal.rs+++ b/crates/disktree-core/src/removal.rs@@ -10,8 +10,9 @@//! standard library rather than by shelling out, so no path ever reaches a//! shell and no filename can be misread as an option.//! * [`RemovalMode::Trash`] — move to the desktop trash, using `trash-put`,-//! then `gio trash`, then a built-in XDG implementation. The backend is-//! detected once and named in the UI so the user knows what actually happens.+//! then `gio trash`, then a built-in XDG implementation; on Windows, the+//! Recycle Bin. The backend is detected once and named in the UI so the+//! user knows what actually happens.use std::fs;use std::io;@@ -22,6 +23,9 @@ use std::sync::atomic::{AtomicBool, Ordering};use std::sync::mpsc::{self, Receiver};use std::thread;+#[cfg(windows)]+use crate::windows::{same, within};+/// One path the user asked to remove.#[derive(Clone, Debug, PartialEq, Eq)]pub struct Target {@@ -92,7 +96,7 @@ impl Plan {/// looking at is the only thing they consented to act on.pub fn plan(targets: &[Target], root: &Path) -> Plan {let root = normalize(root);- let home = std::env::var_os("HOME").map(PathBuf::from);+ let home = std::env::home_dir();let mut plan = Plan::default();let mut accepted: Vec<Target> = Vec::new();@@ -118,7 +122,7 @@ pub fn plan(targets: &[Target], root: &Path) -> Plan {for target in accepted {if outer.iter()- .any(|candidate| target.path.starts_with(&candidate.path))+ .any(|candidate| within(&target.path, &candidate.path)){plan.covered.push(target);} else {@@ -135,6 +139,7 @@ pub fn plan(targets: &[Target], root: &Path) -> Plan {/// and removing them by hand breaks the system; pacman, paccache and/// `journalctl --vacuum` are the right tools. Refused even where/// permissions would allow it, and even inside them.+#[cfg(not(windows))]const SYSTEM_TREES: [&str; 14] = ["/bin","/boot",@@ -152,8 +157,13 @@ const SYSTEM_TREES: [&str; 14] = ["/efi",];+/// What to use instead, said when a system tree is refused.+#[cfg(not(windows))]+const SYSTEM_TOOLS: &str = "use the package manager";+/// The system tree `path` is in, if any. The home directory is never/// system, wherever it lives.+#[cfg(not(windows))]fn system_tree(path: &Path, home: Option<&Path>) -> Option<&'static str> {if home.is_some_and(|home| path.starts_with(normalize(home))) {return None;@@ -164,22 +174,83 @@ fn system_tree(path: &Path, home: Option<&Path>) -> Option<&'static str> {.copied()}+/// [`SYSTEM_TREES`] on Windows: Windows itself, installed programs and+/// their machine-wide data, and what Windows keeps at the top of its drive+/// for restore points, recovery and booting. Taken from the environment, so+/// a system elsewhere is still recognized, and the usual places on the+/// system drive besides.+#[cfg(windows)]+fn system_trees() -> Vec<PathBuf> {+ let drive = system_drive();+ let mut trees: Vec<PathBuf> = [+ "SystemRoot",+ "ProgramFiles",+ "ProgramFiles(x86)",+ "ProgramW6432",+ "ProgramData",+ ]+ .into_iter()+ .filter_map(std::env::var_os)+ .map(PathBuf::from)+ // An empty or relative value would match too much or nothing at all.+ .filter(|tree| tree.is_absolute())+ .collect();+ trees.extend(+ [+ "Windows",+ "Program Files",+ "Program Files (x86)",+ "ProgramData",+ "System Volume Information",+ "Recovery",+ "Boot",+ "bootmgr",+ ]+ .map(|name| drive.join(name)),+ );+ trees+}++/// The root of the drive Windows runs from, such as `C:\`.+#[cfg(windows)]+fn system_drive() -> PathBuf {+ let mut drive =+ std::env::var_os("SystemDrive").unwrap_or_else(|| "C:".into());+ // `C:` alone is the current directory on C:, not its root.+ drive.push(r"\");+ PathBuf::from(drive)+}++#[cfg(windows)]+const SYSTEM_TOOLS: &str = "use Settings, or the program's own uninstaller";++#[cfg(windows)]+fn system_tree(path: &Path, home: Option<&Path>) -> Option<String> {+ if home.is_some_and(|home| within(path, &normalize(home))) {+ return None;+ }+ system_trees()+ .into_iter()+ .find(|tree| within(path, tree))+ .map(|tree| tree.display().to_string())+}+fn refuse(path: &Path, root: &Path, home: Option<&Path>) -> Option<String> {if path.parent().is_none() {return Some("the filesystem root cannot be removed".into());}- if path == root {+ if same(path, root) {return Some("the scanned root cannot be removed".into());}- if home.is_some_and(|home| path == normalize(home)) {+ if home.is_some_and(|home| same(path, &normalize(home))) {return Some("the home directory cannot be removed".into());}- if !path.starts_with(root) {+ if !within(path, root) {return Some("outside the scanned root".into());}if let Some(system) = system_tree(path, home) {return Some(format!(- "part of the system under {system}: use the package manager"+ "part of the system under {system}: {SYSTEM_TOOLS}"));}if is_mount_point(path) {@@ -191,6 +262,17 @@ fn refuse(path: &Path, root: &Path, home: Option<&Path>) -> Option<String> {None}+/// `path` is `base` or inside it, by whole components.+#[cfg(not(windows))]+fn within(path: &Path, base: &Path) -> bool {+ path.starts_with(base)+}++#[cfg(not(windows))]+fn same(left: &Path, right: &Path) -> bool {+ left == right+}+/// Whether `path` sits on a different device than its parent, i.e. is a/// mount point. Descending into one would delete data the user never marked.#[cfg(unix)]@@ -212,7 +294,13 @@ pub fn is_mount_point(path: &Path) -> bool {}}-#[cfg(not(unix))]+/// Whether `path` is a folder another volume is mounted on.+#[cfg(windows)]+pub fn is_mount_point(path: &Path) -> bool {+ crate::windows::is_mount_point(path)+}++#[cfg(not(any(unix, windows)))]pub fn is_mount_point(_path: &Path) -> bool {false}@@ -256,6 +344,8 @@ pub enum TrashBackend {Gio,/// The XDG trash directory, implemented here.XdgHome,+ /// The Windows Recycle Bin, through the shell's own file operation.+ RecycleBin,/// No way to move files to a trash on this machine.#[default]Unavailable,@@ -264,7 +354,9 @@ pub enum TrashBackend {impl TrashBackend {pub const fn is_available(self) -> bool {match self {- Self::TrashPut | Self::Gio | Self::XdgHome => true,+ Self::TrashPut | Self::Gio | Self::XdgHome | Self::RecycleBin => {+ true+ }Self::Unavailable => false,}}@@ -274,6 +366,7 @@ impl TrashBackend {Self::TrashPut => "trash-put",Self::Gio => "gio trash",Self::XdgHome => "XDG trash",+ Self::RecycleBin => "the Recycle Bin",Self::Unavailable => "no trash tool found",}}@@ -287,6 +380,7 @@ impl TrashBackend {Self::XdgHome => {"moves into ~/.local/share/Trash on the same volume"}+ Self::RecycleBin => "the same Recycle Bin as File Explorer",Self::Unavailable => {"install trash-cli or keep deleting permanently"}@@ -294,7 +388,15 @@ impl TrashBackend {}}+/// Detect the best available trash backend for this machine. Windows+/// always has its Recycle Bin.+#[cfg(windows)]+pub const fn detect_trash_backend() -> TrashBackend {+ TrashBackend::RecycleBin+}+/// Detect the best available trash backend for this machine.+#[cfg(not(windows))]pub fn detect_trash_backend() -> TrashBackend {if which("trash-put") {TrashBackend::TrashPut@@ -307,6 +409,7 @@ pub fn detect_trash_backend() -> TrashBackend {}}+#[cfg(not(windows))]fn which(program: &str) -> bool {let Some(path) = std::env::var_os("PATH") else {return false;@@ -445,23 +548,53 @@ pub fn remove_permanently(path: &Path) -> io::Result<()> {let meta = fs::symlink_metadata(path)?;if meta.is_dir() {fs::remove_dir_all(path)+ } else if is_dir_link(&meta) {+ // Windows removes a link to a directory, a junction or a directory+ // symlink, as a directory: `RemoveDirectoryW` takes the link and+ // leaves its target alone.+ fs::remove_dir(path)} else {fs::remove_file(path)}}+#[cfg(windows)]+fn is_dir_link(meta: &fs::Metadata) -> bool {+ use std::os::windows::fs::FileTypeExt as _;+ meta.file_type().is_symlink_dir()+}++#[cfg(not(windows))]+const fn is_dir_link(_meta: &fs::Metadata) -> bool {+ false+}+/// Move one path to the desktop trash.pub fn move_to_trash(path: &Path, backend: TrashBackend) -> io::Result<()> {match backend {TrashBackend::TrashPut => run_tool(Path::new("trash-put"), &[], path),TrashBackend::Gio => run_tool(Path::new("gio"), &["trash"], path),TrashBackend::XdgHome => trash_via_xdg(path),+ TrashBackend::RecycleBin => recycle(path),TrashBackend::Unavailable => Err(io::Error::other("no trash tool is installed; use permanent deletion instead",)),}}+/// Hand `path` to the Recycle Bin. `trash` asks the shell to warn before it+/// destroys anything rather than recycling it (`FOF_WANTNUKEWARNING`), so+/// the reversible path cannot turn into a permanent one silently.+#[cfg(windows)]+fn recycle(path: &Path) -> io::Result<()> {+ trash::delete(path).map_err(io::Error::other)+}++#[cfg(not(windows))]+fn recycle(_path: &Path) -> io::Result<()> {+ Err(io::Error::other("the Recycle Bin is only on Windows"))+}+/// Run one trash tool on one path.////// `--` is passed before the path so that a file named `-rf` is read as a path@@ -547,6 +680,7 @@ pub fn trash_into(_path: &Path, _trash: &Path) -> io::Result<()> {}/// `name`, or `name.1`, `name.2`, … until the name is free in `dir`.+#[cfg(unix)]fn unique_name(dir: &Path, name: &str) -> (PathBuf, String) {let first = dir.join(name);if !first.exists() {@@ -579,6 +713,7 @@ pub fn percent_encode(input: &str) -> String {out}+#[cfg(unix)]fn deletion_date() -> String {// The specification wants ISO 8601 in local time; chrono is already in the// dependency graph, so use it rather than approximating the offset.@@ -631,7 +766,7 @@ mod tests {fn the_root_and_home_are_refused() {let temp = tree();let root = temp.path();- let home = std::env::var_os("HOME").map(PathBuf::from);+ let home = std::env::home_dir();let mut targets = vec![target(Path::new("/"), 0), target(root, 0)];if let Some(home) = &home {targets.push(target(home, 0));@@ -699,19 +834,54 @@ mod tests {assert!(temp.path().join("a/c.bin").exists());}+ /// A link to a directory: a symbolic link on Unix, a junction on+ /// Windows, which needs no privilege to make.+ fn link_dir(target: &Path, link: &Path) {+ #[cfg(unix)]+ std::os::unix::fs::symlink(target, link).expect("symlink");+ #[cfg(windows)]+ assert!(crate::windows::make_junction(link, target), "junction");+ }+#[test]fn permanent_removal_unlinks_a_symlink_instead_of_following_it() {let temp = tree();let keep = TempDir::new().expect("tempdir");fs::write(keep.path().join("precious.bin"), b"data").expect("write");let link = temp.path().join("link");- std::os::unix::fs::symlink(keep.path(), &link).expect("symlink");+ link_dir(keep.path(), &link);remove_permanently(&link).expect("remove link");- assert!(!link.exists());+ assert!(fs::symlink_metadata(&link).is_err(), "the link is gone");assert!(keep.path().join("precious.bin").exists());}+ /// Git keeps its objects read-only, which on Windows stops a plain+ /// delete; clearing an old checkout must still work.+ #[test]+ fn read_only_files_are_removed_too() {+ let temp = tree();+ let objects = temp.path().join("a/b/objects");+ fs::create_dir_all(&objects).expect("mkdir");+ let object = objects.join("pack.idx");+ fs::write(&object, b"x").expect("write");+ let mut permissions =+ fs::metadata(&object).expect("stat").permissions();+ permissions.set_readonly(true);+ fs::set_permissions(&object, permissions).expect("read-only");+ let lone = temp.path().join("a/lone.idx");+ fs::write(&lone, b"x").expect("write");+ let mut permissions = fs::metadata(&lone).expect("stat").permissions();+ permissions.set_readonly(true);+ fs::set_permissions(&lone, permissions).expect("read-only");++ remove_permanently(&lone).expect("a read-only file");+ remove_permanently(&temp.path().join("a/b")).expect("a directory");+ assert!(!lone.exists());+ assert!(!temp.path().join("a/b").exists());+ assert!(temp.path().join("a/c.bin").exists());+ }+#[test]fn a_missing_target_reports_not_found() {let temp = tree();@@ -728,6 +898,7 @@ mod tests {assert_eq!(percent_encode("/a\nb"), "/a%0Ab");}+ #[cfg(unix)]#[test]fn trash_names_avoid_collisions() {let temp = TempDir::new().expect("tempdir");@@ -740,6 +911,7 @@ mod tests {assert_ne!(first, second);}+ #[cfg(unix)]#[test]fn the_xdg_trash_moves_a_file_and_records_where_it_came_from() {// A private trash directory keeps the test out of the real trash can.@@ -762,6 +934,7 @@ mod tests {assert!(info.contains("DeletionDate="));}+ #[cfg(unix)]#[test]fn a_trash_info_path_is_restorable() {let trash = TempDir::new().expect("tempdir");@@ -830,6 +1003,7 @@ mod tests {assert!(root.join("a/one.bin").exists());}+ #[cfg(unix)]#[test]fn a_trash_tool_is_called_with_the_path_after_a_separator() {use std::os::unix::fs::PermissionsExt as _;@@ -858,6 +1032,7 @@ mod tests {assert!(doomed.exists(), "the real tool would have moved it");}+ #[cfg(unix)]#[test]fn a_failing_trash_tool_reports_its_stderr() {use std::os::unix::fs::PermissionsExt as _;@@ -872,6 +1047,7 @@ mod tests {assert!(error.to_string().contains("no trash here"), "{error}");}+ #[cfg(not(windows))]#[test]fn detection_prefers_a_tool_this_machine_has() {let backend = detect_trash_backend();@@ -881,6 +1057,45 @@ mod tests {assert!(backend.is_available());}+ #[cfg(windows)]+ #[test]+ fn windows_trashes_into_the_recycle_bin() {+ let backend = detect_trash_backend();+ assert_eq!(backend, TrashBackend::RecycleBin);+ assert!(backend.is_available());+ }++ #[cfg(windows)]+ #[test]+ fn windows_system_trees_are_refused_in_a_whole_disk_scan() {+ let drive = system_drive();+ let home = drive.join(r"Users\tobi");+ let system = |relative: &str| {+ system_tree(&drive.join(relative), Some(&home))+ .map(|tree| tree.to_lowercase())+ };+ let windows = drive.join("Windows").display().to_string();+ assert!(+ system(r"WINDOWS\System32\drivers\etc\hosts").is_some(),+ "without regard to case"+ );+ assert!(system(r"Program Files\App\app.exe").is_some());+ assert!(system(r"Program Files (x86)\App").is_some());+ assert!(system(r"ProgramData\Vendor\state.db").is_some());+ assert!(system("System Volume Information").is_some());+ assert_eq!(system("Windows.old"), None, "components, not prefixes");+ assert_eq!(system(r"Users\tobi\AppData\Local\Temp"), None);+ assert_eq!(system("Games"), None);+ let reason = refuse(&drive.join(r"Windows\Temp"), &drive, Some(&home));+ assert!(+ reason.is_some_and(|reason| reason+ .to_lowercase()+ .contains(&windows.to_lowercase())),+ "refused as part of {windows}"+ );+ }++ #[cfg(not(windows))]#[test]fn system_trees_are_refused_in_a_whole_disk_scan() {let home = Path::new("/home/tobi");diff --git a/crates/disktree-core/src/scan.rs b/crates/disktree-core/src/scan.rsindex be5f2ff..fb9fb50 100644--- a/crates/disktree-core/src/scan.rs+++ b/crates/disktree-core/src/scan.rs@@ -15,7 +15,9 @@//! poll without locking, and cooperative cancellation so a re-scan can abandon//! a walk of a large home directory instead of queueing behind it.-use std::fs::{self, DirEntry, Metadata};+#[cfg(not(windows))]+use std::fs::DirEntry;+use std::fs::{self, Metadata};use std::io;use std::path::{Path, PathBuf};use std::sync::atomic::{AtomicBool, AtomicU64, AtomicUsize, Ordering};@@ -274,77 +276,77 @@ impl WalkContext {}/// Decide what to do with an entry, and account for the work it implies.- fn classify(&self, entry: &DirEntry) -> Classified {- let path = entry.path();- let file_type = match entry.file_type() {- Ok(file_type) => file_type,+ fn classify(&self, entry: &impl Listed) -> Classified {+ let path = entry.entry_path();+ let listing = match entry.listing() {+ Ok(listing) => listing,Err(error) => {self.progress.record_error(&path, &error);return Classified::Skipped;}};- // Non-UTF-8 names are lossy for display. The scan still measures them- // correctly; only the reported name is approximate.- let name: Box<str> =- entry.file_name().to_string_lossy().into_owned().into();+ let name = entry.display_name();if !self.options.include_hidden && name.starts_with('.') {return Classified::Skipped;}- if file_type.is_symlink() {- return self.classify_symlink(&path, name);+ let kind = match listing {+ Listing::Symlink => return self.classify_symlink(&path, name),+ Listing::Directory => return self.classify_dir(entry, path, name),+ Listing::Leaf(kind) => kind,+ };+ match entry.facts(self.options.apparent_size) {+ Ok(facts) => self.leaf(name, kind, &facts),+ Err(error) => {+ self.progress.record_error(&path, &error);+ Classified::Skipped+ }}+ }- if file_type.is_dir() {- // Memoized: the subtree a narrower scan already measured is- // taken whole, before any volume rule, since it was measured- // under the same rules.- if let Some(known) = &self.known- && known.path == path- {- let tree = (*known.tree).clone();- self.progress.files.fetch_add(tree.files, Ordering::Relaxed);- self.progress.bytes.fetch_add(tree.bytes, Ordering::Relaxed);- self.progress.dirs.fetch_add(tree.dirs, Ordering::Relaxed);- let mut tree = tree;- tree.name = name;- return Classified::Entry(tree);+ fn classify_dir(+ &self,+ entry: &impl Listed,+ path: PathBuf,+ name: Box<str>,+ ) -> Classified {+ // Memoized: the subtree a narrower scan already measured is taken+ // whole, before any volume rule, since it was measured under the same+ // rules.+ if let Some(known) = &self.known+ && known.path == path+ {+ let tree = (*known.tree).clone();+ self.progress.files.fetch_add(tree.files, Ordering::Relaxed);+ self.progress.bytes.fetch_add(tree.bytes, Ordering::Relaxed);+ self.progress.dirs.fetch_add(tree.dirs, Ordering::Relaxed);+ let mut tree = tree;+ tree.name = name;+ return Classified::Entry(tree);+ }+ if self.options.one_filesystem+ && let Some(foreign) = self.foreign_mounts.get()+ {+ // Checked by path before anything reads the directory, so an+ // automount point is never triggered.+ if foreign.contains(&path) {+ return Classified::Skipped;}- if self.options.one_filesystem- && let Some(foreign) = self.foreign_mounts.get()- {- // Checked by path before anything reads the directory, so an- // automount point is never triggered.- if foreign.contains(&path) {+ } else if self.options.one_filesystem {+ match (entry.device(), self.root_device(&path)) {+ (Ok(device), Some(root_device)) if device != root_device => {return Classified::Skipped;}- } else if self.options.one_filesystem {- let device = entry.metadata().map(|meta| device_of(&meta));- match (device, self.root_device(&path)) {- (Ok(device), Some(root_device))- if device != root_device =>- {- return Classified::Skipped;- }- (Err(error), _) => {- self.progress.record_error(&path, &error);- return Classified::Skipped;- }- _ => {}+ (Err(error), _) => {+ self.progress.record_error(&path, &error);+ return Classified::Skipped;}- }- self.progress.count_dir();- return Classified::Subdirectory(path);- }-- match entry.metadata() {- Ok(meta) => self.leaf(name, kind_of(&meta, file_type), &meta),- Err(error) => {- self.progress.record_error(&path, &error);- Classified::Skipped+ _ => {}}}+ self.progress.count_dir();+ Classified::Subdirectory(path)}fn classify_symlink(&self, path: &Path, name: Box<str>) -> Classified {@@ -353,13 +355,12 @@ impl WalkContext {// `du` reports as a handful of bytes or nothing at all.return match fs::symlink_metadata(path) {Ok(meta) => {- let size = measure(&meta, self.options.apparent_size);- self.progress.count_file(size);+ let facts = Facts::of(&meta, self.options.apparent_size);+ self.progress.count_file(facts.size);Classified::Entry(leaf_node(name,NodeKind::Symlink,- size,- &meta,+ &facts,))}Err(error) => {@@ -381,7 +382,7 @@ impl WalkContext {};if meta.is_dir() {- if let Some(key) = file_identity(&meta)+ if let Some(key) = identity_of(path, &meta)&& !lock(&self.visited_dirs).insert(key){return Classified::Skipped;@@ -390,21 +391,147 @@ impl WalkContext {return Classified::Subdirectory(path.to_path_buf());}- self.leaf(name, kind_of(&meta, meta.file_type()), &meta)+ let mut facts = Facts::of(&meta, self.options.apparent_size);+ // What the link leads to, so a file that is also reached directly is+ // charged once.+ facts.identity = identity_of(path, &meta);+ self.leaf(name, kind_of(&meta, meta.file_type()), &facts)}fn leaf(&self,name: Box<str>,kind: NodeKind,- meta: &Metadata,+ facts: &Facts,) -> Classified {- let size = measure(meta, self.options.apparent_size);- self.progress.count_file(size);- Classified::Entry(leaf_node(name, kind, size, meta))+ self.progress.count_file(facts.size);+ Classified::Entry(leaf_node(name, kind, facts))+ }+}++/// What the walk reads about one directory entry.+///+/// `std::fs::DirEntry` everywhere but Windows. There the standard listing+/// has neither the allocated size nor a file id, so measuring like `du`+/// would cost an open per file; [`crate::windows`] lists a directory with+/// both instead.+trait Listed {+ fn entry_path(&self) -> PathBuf;+ /// Non-UTF-8 names are lossy for display. The scan still measures them+ /// correctly; only the reported name is approximate.+ fn display_name(&self) -> Box<str>;+ fn listing(&self) -> io::Result<Listing>;+ /// Size, identity and age of a leaf.+ fn facts(&self, apparent_size: bool) -> io::Result<Facts>;+ /// The device a directory is on, for staying on one volume when the+ /// mount table cannot be read.+ fn device(&self) -> io::Result<u64>;+}++/// What an entry is, as far as the walk is concerned.+enum Listing {+ Directory,+ Symlink,+ Leaf(NodeKind),+}++/// What a leaf contributes.+struct Facts {+ size: u64,+ identity: Option<(u64, u64)>,+ modified: i64,+}++impl Facts {+ fn of(meta: &Metadata, apparent_size: bool) -> Self {+ Self {+ size: measure(meta, apparent_size),+ identity: file_identity(meta),+ modified: modified_seconds(meta),+ }}}+#[cfg(not(windows))]+impl Listed for DirEntry {+ fn entry_path(&self) -> PathBuf {+ self.path()+ }++ fn display_name(&self) -> Box<str> {+ self.file_name().to_string_lossy().into_owned().into()+ }++ fn listing(&self) -> io::Result<Listing> {+ let file_type = self.file_type()?;+ Ok(if file_type.is_symlink() {+ Listing::Symlink+ } else if file_type.is_dir() {+ Listing::Directory+ } else if file_type.is_file() {+ Listing::Leaf(NodeKind::File)+ } else {+ Listing::Leaf(NodeKind::Other)+ })+ }++ fn facts(&self, apparent_size: bool) -> io::Result<Facts> {+ self.metadata().map(|meta| Facts::of(&meta, apparent_size))+ }++ fn device(&self) -> io::Result<u64> {+ self.metadata().map(|meta| device_of(&meta))+ }+}++#[cfg(windows)]+impl Listed for crate::windows::Entry {+ fn entry_path(&self) -> PathBuf {+ self.path()+ }++ fn display_name(&self) -> Box<str> {+ self.file_name().to_string_lossy().into_owned().into()+ }++ fn listing(&self) -> io::Result<Listing> {+ Ok(match self.kind() {+ crate::windows::Kind::Link => Listing::Symlink,+ crate::windows::Kind::Directory => Listing::Directory,+ crate::windows::Kind::File => Listing::Leaf(NodeKind::File),+ })+ }++ fn facts(&self, apparent_size: bool) -> io::Result<Facts> {+ Ok(Facts {+ size: if apparent_size {+ self.apparent()+ } else {+ self.allocated()+ },+ identity: self.identity(),+ modified: self.modified(),+ })+ }++ /// Never consulted: see [`crate::space::foreign_mounts_for`]. The same+ /// answer as [`device_of`], so the two could only ever agree.+ fn device(&self) -> io::Result<u64> {+ Ok(0)+ }+}++/// List a directory the way [`Listed`] describes.+#[cfg(not(windows))]+fn list(path: &Path) -> io::Result<fs::ReadDir> {+ fs::read_dir(path)+}++#[cfg(windows)]+fn list(path: &Path) -> io::Result<crate::windows::ReadDir> {+ crate::windows::read_dir(path)+}+/// What a directory entry turned out to be.enum Classified {/// Descend into this directory on a new task.@@ -486,7 +613,7 @@ fn scan_blocking(root: &Path, context: &Arc<WalkContext>) -> io::Result<Node> {}}if context.options.follow_links- && let Some(key) = file_identity(&root_meta)+ && let Some(key) = identity_of(root, &root_meta){lock(&context.visited_dirs).insert(key);}@@ -508,7 +635,7 @@ fn walk(scope: &Scope<'_>, dir: &Arc<PendingDir>, context: &Arc<WalkContext>) {let mut subdirs: Vec<Arc<PendingDir>> = Vec::new();let mut leaves: Vec<Node> = Vec::new();- match fs::read_dir(&dir.path) {+ match list(&dir.path) {Ok(entries) => {for entry in entries {if context.cancelled() {@@ -607,15 +734,10 @@ fn mark_duplicate_hardlinks(node: &mut Node, seen: &mut FxHashSet<(u64, u64)>) {}}-fn leaf_node(- name: Box<str>,- kind: NodeKind,- size: u64,- meta: &Metadata,-) -> Node {- let mut node = Node::entry(name, kind, size);- node.inode = file_identity(meta);- node.modified = modified_seconds(meta);+fn leaf_node(name: Box<str>, kind: NodeKind, facts: &Facts) -> Node {+ let mut node = Node::entry(name, kind, facts.size);+ node.inode = facts.identity;+ node.modified = facts.modified;node}@@ -654,7 +776,7 @@ fn allocated_bytes(meta: &Metadata) -> Option<u64> {}#[cfg(not(unix))]-fn allocated_bytes(_meta: &Metadata) -> Option<u64> {+const fn allocated_bytes(_meta: &Metadata) -> Option<u64> {None}@@ -665,13 +787,15 @@ fn device_of(meta: &Metadata) -> u64 {}#[cfg(not(unix))]-fn device_of(_meta: &Metadata) -> u64 {+const fn device_of(_meta: &Metadata) -> u64 {0}/// `(device, inode)`, or `None` where the platform does not expose them./// Hardlink de-duplication and symlink loop detection both depend on this, so-/// they are simply unavailable rather than silently wrong elsewhere.+/// they are simply unavailable rather than silently wrong elsewhere. Windows+/// has no file id in `Metadata` on stable Rust; its listing carries one+/// instead (see [`crate::windows`]).#[allow(clippy::unnecessary_wraps,reason = "the Option is the non-Unix answer, so both arms must agree"@@ -683,10 +807,23 @@ fn file_identity(meta: &Metadata) -> Option<(u64, u64)> {}#[cfg(not(unix))]-fn file_identity(_meta: &Metadata) -> Option<(u64, u64)> {+const fn file_identity(_meta: &Metadata) -> Option<(u64, u64)> {None}+/// The identity of what `path` leads to, `meta` being its followed+/// metadata: how a walk that follows links recognizes a directory it has+/// entered before, and a file it has already charged.+#[cfg(not(windows))]+fn identity_of(_path: &Path, meta: &Metadata) -> Option<(u64, u64)> {+ file_identity(meta)+}++#[cfg(windows)]+fn identity_of(path: &Path, _meta: &Metadata) -> Option<(u64, u64)> {+ crate::windows::identity(path)+}+fn kind_of(meta: &Metadata, file_type: fs::FileType) -> NodeKind {if meta.is_dir() || file_type.is_dir() {NodeKind::Directory@@ -838,6 +975,20 @@ mod tests {assert_eq!(without.bytes, 100);}+ /// A link to a directory: a symbolic link on Unix, a junction on+ /// Windows, which needs no privilege to make. `false` if it could not be+ /// made.+ fn link_dir(target: &Path, link: &Path) -> bool {+ #[cfg(unix)]+ {+ std::os::unix::fs::symlink(target, link).is_ok()+ }+ #[cfg(windows)]+ {+ crate::windows::make_junction(link, target)+ }+ }+#[test]fn symlinks_are_not_followed_by_default() {let temp = TempDir::new().expect("tempdir");@@ -845,8 +996,7 @@ mod tests {write(outside.path(), "elsewhere.bin", 5000);let root = temp.path();write(root, "real.bin", 100);- std::os::unix::fs::symlink(outside.path(), root.join("link"))- .expect("symlink");+ assert!(link_dir(outside.path(), &root.join("link")), "a link");let tree = scan_dir(root, &options());// Only the real file's bytes; the link itself holds just its target@@ -862,8 +1012,7 @@ mod tests {let temp = TempDir::new().expect("tempdir");let root = temp.path();write(root, "sub/leaf.bin", 42);- std::os::unix::fs::symlink(root, root.join("sub/loop"))- .expect("symlink");+ assert!(link_dir(root, &root.join("sub/loop")), "a link");let tree = scan_dir(root,@@ -875,6 +1024,29 @@ mod tests {assert_eq!(tree.bytes, 42);}+ /// Disk usage is what the volume allocated, not the length: whole+ /// blocks, so it covers the data and ends on a block boundary.+ #[test]+ fn disk_usage_is_whole_allocation_units() {+ let temp = TempDir::new().expect("tempdir");+ // Noise, so a compressing filesystem cannot store it in less.+ let mut state = 0x2545_f491_4f6c_dd1d_u64;+ let noise: Vec<u8> = (0..100_000)+ .map(|_| {+ state ^= state << 13;+ state ^= state >> 7;+ state ^= state << 17;+ state.to_le_bytes()[0]+ })+ .collect();+ fs::write(temp.path().join("data.bin"), noise).expect("write");+ let tree = scan_dir(temp.path(), &ScanOptions::default());+ assert!(tree.bytes >= 100_000, "{}", tree.bytes);+ assert_eq!(tree.bytes % 512, 0, "{}", tree.bytes);+ let apparent = scan_dir(temp.path(), &options());+ assert_eq!(apparent.bytes, 100_000);+ }+#[test]fn max_depth_stops_descending_but_keeps_direct_files() {let temp = TempDir::new().expect("tempdir");@@ -927,6 +1099,7 @@ mod tests {assert_eq!(by_files.children[0].files, 5);}+ #[cfg(unix)]#[test]fn an_unreadable_directory_is_recorded_not_fatal() {use std::os::unix::fs::PermissionsExt as _;@@ -1040,7 +1213,7 @@ mod tests {#[test]#[ignore = "walks the whole disk"]fn whole_disk_smoke() {- let home = std::env::var_os("HOME").map(PathBuf::from).expect("HOME");+ let home = std::env::home_dir().expect("a home directory");let root = crate::space::volume_root_for(&home).expect("a volume root");let started = std::time::Instant::now();let tree = scan(&root, ScanOptions::default()).expect("scan");diff --git a/crates/disktree-core/src/space.rs b/crates/disktree-core/src/space.rsindex 008eec3..74a4ae9 100644--- a/crates/disktree-core/src/space.rs+++ b/crates/disktree-core/src/space.rs@@ -49,6 +49,13 @@ impl SpaceInfo {}/// Read the space on the volume containing `path`.+#[cfg(windows)]+pub fn space_info(path: &Path) -> io::Result<SpaceInfo> {+ crate::windows::space_info(path)+}++/// Read the space on the volume containing `path`.+#[cfg(not(windows))]pub fn space_info(path: &Path) -> io::Result<SpaceInfo> {let stat = rustix::fs::statvfs(path)?;// `f_frsize` is the fragment size the block counts are expressed in;@@ -66,9 +73,17 @@ pub fn space_info(path: &Path) -> io::Result<SpaceInfo> {})}+/// The volume a path is on, as Windows names it: `C:\`, a share, or the+/// folder a volume is mounted on.+#[cfg(windows)]+pub fn device_for(path: &Path) -> Option<String> {+ crate::windows::volume_root(path).map(|root| root.display().to_string())+}+/// The device a path's filesystem is mounted from, such as/// `/dev/nvme0n1p2`: the mount with the longest prefix of `path` in/// `/proc/self/mounts`. `None` where that table cannot be read.+#[cfg(not(windows))]pub fn device_for(path: &Path) -> Option<String> {let table = std::fs::read_to_string("/proc/self/mounts").ok()?;let path = path.canonicalize().unwrap_or_else(|_| path.to_path_buf());@@ -186,19 +201,42 @@ pub fn volume_root(mounts: &[Mount], path: &Path) -> Option<PathBuf> {}/// [`volume_root`] for this machine.+#[cfg(not(windows))]pub fn volume_root_for(path: &Path) -> Option<PathBuf> {let table = std::fs::read_to_string("/proc/self/mounts").ok()?;let path = path.canonicalize().unwrap_or_else(|_| path.to_path_buf());volume_root(&parse_mounts(&table), &path)}+/// The top of the volume `path` lives on: its drive, such as `C:\`.+#[cfg(windows)]+pub fn volume_root_for(path: &Path) -> Option<PathBuf> {+ crate::windows::volume_root(path)+}+/// [`foreign_mounts`] for this machine; `None` when the mount table cannot/// be read, so the caller can fall back to comparing devices.+#[cfg(not(windows))]pub fn foreign_mounts_for(root: &Path) -> Option<Vec<PathBuf>> {let table = std::fs::read_to_string("/proc/self/mounts").ok()?;Some(foreign_mounts(&parse_mounts(&table), root))}+/// Nothing to leave out by path on Windows.+///+/// There, the only way into another volume below `root` is a folder that+/// volume is mounted on, which is a reparse point the walk treats as a link+/// and does not enter unless links are followed; other drives are separate+/// trees altogether.+#[cfg(windows)]+#[allow(+ clippy::unnecessary_wraps,+ reason = "the Option is the Unix answer when the mount table is missing"+)]+pub const fn foreign_mounts_for(_root: &Path) -> Option<Vec<PathBuf>> {+ Some(Vec::new())+}+#[cfg(test)]mod tests {use super::*;diff --git a/crates/disktree-core/src/windows.rs b/crates/disktree-core/src/windows.rsnew file mode 100644index 0000000..e834239--- /dev/null+++ b/crates/disktree-core/src/windows.rs@@ -0,0 +1,727 @@+//! What a walk on Windows needs beyond the standard library.+//!+//! `std::fs::read_dir` lists a directory with `FindNextFileW`, whose records+//! carry neither the space a file occupies nor a file id. Asking for them+//! file by file costs an open per file: on a home directory of 1.3 million+//! files that made the walk seven times slower. `GetFileInformationByHandleEx`+//! with `FileIdExtdDirectoryInfo` returns both for a whole buffer of entries,+//! for what the listing costs anyway.+//!+//! The rest is small: the volume a path is on, its free space, and comparing+//! paths the way Windows does.++#![allow(+ unsafe_code,+ reason = "Win32 calls std does not wrap; each block says why it is sound"+)]++use std::ffi::{OsStr, OsString};+use std::fs::{self, File, OpenOptions};+use std::io;+use std::mem::offset_of;+use std::os::windows::ffi::{OsStrExt as _, OsStringExt as _};+use std::os::windows::fs::{MetadataExt as _, OpenOptionsExt as _};+use std::os::windows::io::AsRawHandle as _;+use std::path::{Component, Path, PathBuf, Prefix};+use std::sync::Arc;++use windows_sys::Win32::Foundation::{+ ERROR_INVALID_FUNCTION, ERROR_INVALID_LEVEL, ERROR_INVALID_PARAMETER,+ ERROR_NO_MORE_FILES, ERROR_NOT_SUPPORTED,+};+use windows_sys::Win32::Storage::FileSystem::{+ FILE_ATTRIBUTE_DIRECTORY, FILE_ATTRIBUTE_REPARSE_POINT,+ FILE_FLAG_BACKUP_SEMANTICS, FILE_ID_EXTD_DIR_INFO, FILE_LIST_DIRECTORY,+ FILE_READ_ATTRIBUTES, FileIdExtdDirectoryInfo, GetDiskFreeSpaceExW,+ GetFileInformationByHandleEx, GetVolumePathNameW, SYNCHRONIZE,+};++use crate::space::SpaceInfo;++/// Bytes the file system fills per call: some hundreds of entries.+const BUFFER_BYTES: usize = 64 * 1024;++/// Where a record's name starts; everything before it has a fixed size.+const NAME_AT: usize = offset_of!(FILE_ID_EXTD_DIR_INFO, FileName);++/// Reparse tags with this bit stand for another path: symbolic links,+/// junctions and mounted folders. These are exactly what the standard+/// library calls symlinks, so this listing agrees with `std::fs::FileType`.+const NAME_SURROGATE: u32 = 0x2000_0000;++/// A `FILETIME` counts 100 ns ticks from 1601; this many precede 1970.+const EPOCH_TICKS: i64 = 116_444_736_000_000_000;+const TICKS_PER_SECOND: i64 = 10_000_000;++/// What an entry is.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub enum Kind {+ Directory,+ /// A symbolic link, a junction or a mounted folder.+ Link,+ File,+}++/// One directory entry, with what a measurement needs.+#[derive(Debug)]+pub struct Entry {+ dir: Arc<Path>,+ name: OsString,+ kind: Kind,+ apparent: u64,+ allocated: u64,+ modified: i64,+ identity: Option<(u64, u64)>,+}++impl Entry {+ pub fn path(&self) -> PathBuf {+ self.dir.join(&self.name)+ }++ pub fn file_name(&self) -> &OsStr {+ &self.name+ }++ pub const fn kind(&self) -> Kind {+ self.kind+ }++ /// The length, in bytes.+ pub const fn apparent(&self) -> u64 {+ self.apparent+ }++ /// Bytes the volume has allocated to the file, in whole clusters: less+ /// than the length for a compressed or sparse file, and zero for one+ /// whose data is kept in its file record. Where the listing could not say+ /// (see [`read_dir`]), the length.+ pub const fn allocated(&self) -> u64 {+ self.allocated+ }++ /// Last write, in Unix seconds; `0` when earlier or unknown.+ pub const fn modified(&self) -> i64 {+ self.modified+ }++ /// `(volume serial, file id)`: the same for two names of one file.+ pub const fn identity(&self) -> Option<(u64, u64)> {+ self.identity+ }++ fn from_std(dir: &Arc<Path>, entry: &fs::DirEntry) -> io::Result<Self> {+ let meta = entry.metadata()?;+ let file_type = meta.file_type();+ let kind = if file_type.is_symlink() {+ Kind::Link+ } else if file_type.is_dir() {+ Kind::Directory+ } else {+ Kind::File+ };+ Ok(Self {+ dir: Arc::clone(dir),+ name: entry.file_name(),+ kind,+ apparent: meta.len(),+ allocated: meta.len(),+ modified: unix_seconds(+ i64::try_from(meta.last_write_time()).unwrap_or(0),+ ),+ identity: None,+ })+ }+}++/// A directory being listed; like `std::fs::ReadDir`, it leaves out `.`+/// and `..`.+#[derive(Debug)]+pub struct ReadDir {+ dir: Arc<Path>,+ source: Source,+}++#[derive(Debug)]+enum Source {+ Records(Records),+ /// A file system or network share that does not implement the listing+ /// with ids: the standard one, which has lengths but not allocations.+ /// Boxed, being ten times the size of the common case.+ Std(Box<fs::ReadDir>),+}++#[derive(Debug)]+struct Records {+ handle: File,+ /// Serial number of the directory's volume, which with a file id names+ /// a file. `None` when it cannot be read; nothing is de-duplicated then.+ volume: Option<u64>,+ /// `u64`s for the eight-byte alignment the records are laid out in.+ buffer: Box<[u64]>,+ /// Where the next record starts, or `None` once the buffer is used up.+ next: Option<usize>,+ done: bool,+}++/// List `dir`, with each entry's allocation and file id.+pub fn read_dir(dir: &Path) -> io::Result<ReadDir> {+ let handle = OpenOptions::new()+ .access_mode(FILE_LIST_DIRECTORY | FILE_READ_ATTRIBUTES | SYNCHRONIZE)+ // Needed to open a directory at all. Without+ // `FILE_FLAG_OPEN_REPARSE_POINT` a link is followed, which is what+ // a walk that chose to enter one wants.+ .custom_flags(FILE_FLAG_BACKUP_SEMANTICS)+ .open(dir)?;+ let volume = winapi_util::file::information(&handle)+ .ok()+ .map(|info| info.volume_serial_number());+ let mut records = Records {+ handle,+ volume,+ buffer: vec![0; BUFFER_BYTES / 8].into_boxed_slice(),+ next: None,+ done: false,+ };+ let dir: Arc<Path> = Arc::from(dir);+ // The first fill shows whether the file system implements this listing,+ // before any entry has been handed out.+ let source = match records.fill() {+ Ok(()) => Source::Records(records),+ Err(error) if unsupported(&error) => {+ Source::Std(Box::new(fs::read_dir(&dir)?))+ }+ Err(error) => return Err(error),+ };+ Ok(ReadDir { dir, source })+}++impl Iterator for ReadDir {+ type Item = io::Result<Entry>;++ fn next(&mut self) -> Option<Self::Item> {+ let records = match &mut self.source {+ Source::Std(listing) => {+ return listing.next().map(|entry| {+ entry.and_then(|entry| Entry::from_std(&self.dir, &entry))+ });+ }+ Source::Records(records) => records,+ };+ loop {+ if records.done {+ return None;+ }+ let Some(offset) = records.next else {+ if let Err(error) = records.fill() {+ records.done = true;+ return Some(Err(error));+ }+ continue;+ };+ match records.record(&self.dir, offset) {+ Ok((entry, next)) => {+ records.next = next;+ if let Some(entry) = entry {+ return Some(Ok(entry));+ }+ }+ Err(error) => {+ records.done = true;+ return Some(Err(error));+ }+ }+ }+ }+}++impl Records {+ /// Ask the file system for the next buffer of records.+ fn fill(&mut self) -> io::Result<()> {+ // SAFETY: the handle is an open directory handle owned by `self`;+ // the pointer and length describe `self.buffer`, which is writable+ // for that many bytes and not otherwise borrowed during the call;+ // and the class is the one the records are read as.+ let filled = unsafe {+ GetFileInformationByHandleEx(+ self.handle.as_raw_handle(),+ FileIdExtdDirectoryInfo,+ self.buffer.as_mut_ptr().cast(),+ BUFFER_BYTES as u32,+ )+ };+ if filled != 0 {+ self.next = Some(0);+ return Ok(());+ }+ let error = io::Error::last_os_error();+ if code(&error) == Some(ERROR_NO_MORE_FILES) {+ self.done = true;+ return Ok(());+ }+ Err(error)+ }++ /// The buffer as the bytes the file system wrote.+ fn bytes(&self) -> &[u8] {+ // SAFETY: `[u64]` can be read as `u8`s of eight times its length:+ // one allocation, no alignment requirement for `u8`, and every byte+ // initialized, since the buffer starts zeroed.+ unsafe {+ std::slice::from_raw_parts(+ self.buffer.as_ptr().cast::<u8>(),+ size_of_val(&*self.buffer),+ )+ }+ }++ /// The entry at `offset`, or `None` for `.` and `..`, and where the next+ /// record starts. Every length the file system wrote is checked against+ /// the buffer before it is used.+ fn record(+ &self,+ dir: &Arc<Path>,+ offset: usize,+ ) -> io::Result<(Option<Entry>, Option<usize>)> {+ let malformed =+ || io::Error::other("the file system returned a malformed record");+ let bytes = self.bytes();+ let header =+ bytes.get(offset..offset + NAME_AT).ok_or_else(malformed)?;+ let field = |at: usize| {+ u32::from_ne_bytes(header[at..at + 4].try_into().expect("four"))+ };+ let signed = |at: usize| {+ i64::from_ne_bytes(header[at..at + 8].try_into().expect("eight"))+ };+ let name_len =+ field(offset_of!(FILE_ID_EXTD_DIR_INFO, FileNameLength)) as usize;+ let name_bytes = bytes+ .get(offset + NAME_AT..offset + NAME_AT + name_len)+ .filter(|name| name.len() % 2 == 0)+ .ok_or_else(malformed)?;+ let next =+ match field(offset_of!(FILE_ID_EXTD_DIR_INFO, NextEntryOffset)) {+ 0 => None,+ step if step as usize >= NAME_AT + name_len => {+ Some(offset + step as usize)+ }+ _ => return Err(malformed()),+ };++ let name: Vec<u16> = name_bytes+ .chunks_exact(2)+ .map(|pair| u16::from_ne_bytes([pair[0], pair[1]]))+ .collect();+ if name == [u16::from(b'.')] || name == [u16::from(b'.'); 2] {+ return Ok((None, next));+ }++ let attributes =+ field(offset_of!(FILE_ID_EXTD_DIR_INFO, FileAttributes));+ let tag = field(offset_of!(FILE_ID_EXTD_DIR_INFO, ReparsePointTag));+ let kind = if attributes & FILE_ATTRIBUTE_REPARSE_POINT != 0+ && tag & NAME_SURROGATE != 0+ {+ Kind::Link+ } else if attributes & FILE_ATTRIBUTE_DIRECTORY != 0 {+ Kind::Directory+ } else {+ Kind::File+ };+ let id_at = offset_of!(FILE_ID_EXTD_DIR_INFO, FileId);+ let id = u128::from_le_bytes(+ header[id_at..id_at + 16].try_into().expect("sixteen"),+ );+ let entry = Entry {+ dir: Arc::clone(dir),+ name: OsString::from_wide(&name),+ kind,+ apparent: bytes_from(signed(offset_of!(+ FILE_ID_EXTD_DIR_INFO,+ EndOfFile+ ))),+ allocated: bytes_from(signed(offset_of!(+ FILE_ID_EXTD_DIR_INFO,+ AllocationSize+ ))),+ modified: unix_seconds(signed(offset_of!(+ FILE_ID_EXTD_DIR_INFO,+ LastWriteTime+ ))),+ identity: self.volume.zip(file_id(id)),+ };+ Ok((Some(entry), next))+ }+}++/// The part of a 128-bit file id that names a file by itself.+///+/// NTFS keeps the high half zero ([MS-FSCC] 2.1.10), so the low half is the+/// id. Zero is what a file system without ids reports; FAT and exFAT do,+/// and their 64-bit ids are documented as not unique, so trusting them could+/// merge two files into one.+///+/// [MS-FSCC]: https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-fscc/98860416-1caf-4c80-a9ab-8d61e1ccf5a5+fn file_id(id: u128) -> Option<u64> {+ // TODO(refs-hardlinks): ReFS ids use both halves, which a (u64, u64)+ // key cannot hold together with the volume, so hardlinks on ReFS (Dev+ // Drives) are counted once per name. That overcounts; it never drops a+ // file's size.+ u64::try_from(id).ok().filter(|&low| low != 0)+}++/// `(volume serial, file index)` of what `path` names, following links: how+/// a walk that follows links notices it has been somewhere before. `None`+/// where there is no usable index; zero and all ones mean exactly that+/// ([MS-FSCC] 2.1.9).+///+/// [MS-FSCC]: https://learn.microsoft.com/en-us/openspecs/windows_protocols/ms-fscc/2d3333fe-fc98-4a6f-98a2-4bb805aff407+pub fn identity(path: &Path) -> Option<(u64, u64)> {+ let file = OpenOptions::new()+ .access_mode(FILE_READ_ATTRIBUTES)+ .custom_flags(FILE_FLAG_BACKUP_SEMANTICS)+ .open(path)+ .ok()?;+ let info = winapi_util::file::information(&file).ok()?;+ let index = info.file_index();+ (index != 0 && index != u64::MAX)+ .then(|| (info.volume_serial_number(), index))+}++/// Capacity and free space of the volume holding `path`.+pub fn space_info(path: &Path) -> io::Result<SpaceInfo> {+ // A network share is only accepted with a trailing separator.+ let directory = wide(path, true)?;+ let (mut available, mut total, mut free) = (0_u64, 0_u64, 0_u64);+ // SAFETY: `directory` is NUL-terminated and outlives the call, and each+ // out pointer is to a live, writable `u64`.+ let ok = unsafe {+ GetDiskFreeSpaceExW(+ directory.as_ptr(),+ &raw mut available,+ &raw mut total,+ &raw mut free,+ )+ };+ if ok == 0 {+ return Err(io::Error::last_os_error());+ }+ Ok(SpaceInfo {+ total,+ free,+ available,+ })+}++/// Where the volume holding `path` is mounted: a drive such as `C:\`, a+/// share, or a folder another volume is mounted on.+pub fn volume_root(path: &Path) -> Option<PathBuf> {+ let name = wide(path, false).ok()?;+ // The answer is a prefix of the path made absolute; the path's length+ // plus room for the longest drive and directory it could gain is ample.+ let mut root = vec![0_u16; name.len() + 260];+ // SAFETY: `name` is NUL-terminated and outlives the call, and `root` is+ // writable for the length passed.+ let ok = unsafe {+ GetVolumePathNameW(+ name.as_ptr(),+ root.as_mut_ptr(),+ u32::try_from(root.len()).ok()?,+ )+ };+ if ok == 0 {+ return None;+ }+ let end = root.iter().position(|&unit| unit == 0)?;+ Some(PathBuf::from(OsString::from_wide(&root[..end])))+}++/// Whether `path` is a folder another volume is mounted on. Removing one+/// would reach onto that volume, which nobody marked.+pub fn is_mount_point(path: &Path) -> bool {+ path.parent().is_some()+ && volume_root(path).is_some_and(|root| same(&root, path))+}++/// Whether `path` is `base` or inside it, compared the way Windows compares+/// names: without regard to case, so `C:\WINDOWS\System32` is inside+/// `C:\Windows`, and with `\\?\C:\` the same place as `C:\`.+pub fn within(path: &Path, base: &Path) -> bool {+ folded(path).starts_with(&folded(base))+}++/// Whether `left` and `right` name the same place, as [`within`] compares.+pub fn same(left: &Path, right: &Path) -> bool {+ folded(left) == folded(right)+}++/// Each component in the form Windows would treat as equal.+fn folded(path: &Path) -> Vec<String> {+ path.components()+ .map(|component| match component {+ Component::Prefix(prefix) => match prefix.kind() {+ Prefix::Disk(letter) | Prefix::VerbatimDisk(letter) => {+ format!("{}:", char::from(letter.to_ascii_lowercase()))+ }+ Prefix::UNC(server, share)+ | Prefix::VerbatimUNC(server, share) => format!(+ r"\\{}\{}",+ server.to_string_lossy(),+ share.to_string_lossy()+ )+ .to_lowercase(),+ Prefix::Verbatim(_) | Prefix::DeviceNS(_) => {+ prefix.as_os_str().to_string_lossy().to_lowercase()+ }+ },+ other => other.as_os_str().to_string_lossy().to_lowercase(),+ })+ .collect()+}++/// `path` as a NUL-terminated wide string, with a trailing separator when+/// `directory` is set.+fn wide(path: &Path, directory: bool) -> io::Result<Vec<u16>> {+ let mut wide: Vec<u16> = path.as_os_str().encode_wide().collect();+ if wide.contains(&0) {+ return Err(io::Error::new(+ io::ErrorKind::InvalidInput,+ "a path cannot contain NUL",+ ));+ }+ let separator =+ |unit: &u16| *unit == u16::from(b'\\') || *unit == u16::from(b'/');+ if directory && !wide.last().is_some_and(separator) {+ wide.push(u16::from(b'\\'));+ }+ wide.push(0);+ Ok(wide)+}++/// Errors a file system or redirector gives for a listing it does not+/// implement.+fn unsupported(error: &io::Error) -> bool {+ matches!(+ code(error),+ Some(+ ERROR_INVALID_FUNCTION+ | ERROR_NOT_SUPPORTED+ | ERROR_INVALID_PARAMETER+ | ERROR_INVALID_LEVEL+ )+ )+}++fn code(error: &io::Error) -> Option<u32> {+ error+ .raw_os_error()+ .and_then(|code| u32::try_from(code).ok())+}++/// A byte count the file system reports as signed; it never is negative.+fn bytes_from(value: i64) -> u64 {+ u64::try_from(value).unwrap_or(0)+}++/// A `FILETIME` as Unix seconds, `0` before 1970.+const fn unix_seconds(ticks: i64) -> i64 {+ if ticks <= EPOCH_TICKS {+ 0+ } else {+ (ticks - EPOCH_TICKS) / TICKS_PER_SECOND+ }+}++/// Make a directory junction for a test: unlike a symbolic link, one needs+/// no privilege to create. `false` when there is no `cmd` to make it with.+#[cfg(test)]+pub fn make_junction(link: &Path, target: &Path) -> bool {+ // Rebuilt from components, because `mklink` takes no `/` in a path, and+ // a test's `root.join("sub/loop")` has one.+ let native = |path: &Path| path.components().collect::<PathBuf>();+ std::process::Command::new("cmd")+ .args(["/C", "mklink", "/J"])+ .arg(native(link))+ .arg(native(target))+ .output()+ .is_ok_and(|output| output.status.success())+}++#[cfg(test)]+mod tests {+ use super::*;+ use tempfile::TempDir;++ fn listed(dir: &Path) -> Vec<Entry> {+ let mut entries: Vec<Entry> = read_dir(dir)+ .expect("list")+ .collect::<io::Result<_>>()+ .expect("entries");+ entries.sort_by(|left, right| left.name.cmp(&right.name));+ entries+ }++ #[test]+ fn a_listing_has_names_kinds_lengths_and_no_dot_entries() {+ let temp = TempDir::new().expect("tempdir");+ fs::create_dir(temp.path().join("sub")).expect("mkdir");+ fs::write(temp.path().join("data.bin"), vec![7_u8; 100_000])+ .expect("write");++ let entries = listed(temp.path());+ let names: Vec<&OsStr> = entries.iter().map(Entry::file_name).collect();+ assert_eq!(names, ["data.bin", "sub"]);+ assert_eq!(entries[0].kind(), Kind::File);+ assert_eq!(entries[0].apparent(), 100_000);+ assert_eq!(entries[0].path(), temp.path().join("data.bin"));+ assert_eq!(entries[1].kind(), Kind::Directory);+ assert!(entries[0].modified() > 0, "written just now");+ }++ #[test]+ fn the_allocation_is_whole_clusters_of_the_data() {+ let temp = TempDir::new().expect("tempdir");+ // Noise, so a compressed folder cannot store it in less.+ let mut state = 0x9e37_79b9_7f4a_7c15_u64;+ let noise: Vec<u8> = (0..100_000)+ .map(|_| {+ state ^= state << 13;+ state ^= state >> 7;+ state ^= state << 17;+ state.to_le_bytes()[0]+ })+ .collect();+ fs::write(temp.path().join("data.bin"), noise).expect("write");+ let entry = &listed(temp.path())[0];+ // Clusters are powers of two between 512 bytes and 2 MiB, so the+ // allocation covers the data and is a whole number of sectors.+ assert!(entry.allocated() >= 100_000, "{}", entry.allocated());+ assert!(entry.allocated() < 100_000 + 2 * 1024 * 1024);+ assert_eq!(entry.allocated() % 512, 0);+ }++ #[test]+ fn two_names_of_one_file_share_an_identity() {+ let temp = TempDir::new().expect("tempdir");+ let original = temp.path().join("original.bin");+ fs::write(&original, b"payload").expect("write");+ fs::hard_link(&original, temp.path().join("link.bin"))+ .expect("hard link");+ fs::write(temp.path().join("other.bin"), b"payload").expect("write");++ let entries = listed(temp.path());+ let id = |name: &str| {+ entries+ .iter()+ .find(|entry| entry.file_name() == name)+ .and_then(Entry::identity)+ };+ assert!(id("original.bin").is_some(), "NTFS gives ids");+ assert_eq!(id("link.bin"), id("original.bin"));+ assert_ne!(id("other.bin"), id("original.bin"));+ assert_eq!(identity(&original), id("original.bin"), "one id scheme");+ }++ #[test]+ fn a_junction_is_a_link_and_listing_it_lists_its_target() {+ let temp = TempDir::new().expect("tempdir");+ let target = temp.path().join("target");+ fs::create_dir(&target).expect("mkdir");+ fs::write(target.join("inside.bin"), b"x").expect("write");+ let junction = temp.path().join("junction");+ if !make_junction(&junction, &target) {+ return; // no cmd.exe to make one with+ }++ let entries = listed(temp.path());+ let kind = |name: &str| {+ entries+ .iter()+ .find(|entry| entry.file_name() == name)+ .map(Entry::kind)+ };+ assert_eq!(kind("junction"), Some(Kind::Link));+ assert_eq!(kind("target"), Some(Kind::Directory));+ let through: Vec<OsString> = listed(&junction)+ .into_iter()+ .map(|entry| entry.name)+ .collect();+ assert_eq!(through, ["inside.bin"], "a walk that enters one follows");+ }++ #[test]+ fn a_large_directory_spans_several_buffers() {+ let temp = TempDir::new().expect("tempdir");+ // Long names so the records overflow one 64 KiB buffer many times.+ for index in 0..2000 {+ let name = format!("{index:04}-{}", "n".repeat(120));+ fs::write(temp.path().join(name), b"").expect("write");+ }+ let entries = listed(temp.path());+ assert_eq!(entries.len(), 2000);+ assert!(+ entries[1999]+ .file_name()+ .to_string_lossy()+ .starts_with("1999")+ );+ }++ #[test]+ fn free_space_is_plausible_and_a_missing_path_is_not_found() {+ let temp = TempDir::new().expect("tempdir");+ let space = space_info(temp.path()).expect("space");+ assert!(space.total > 0 && space.free <= space.total, "{space:?}");+ assert!(space.available <= space.free, "{space:?}");+ let error = space_info(&temp.path().join("absent"))+ .expect_err("no such directory");+ assert_eq!(error.kind(), io::ErrorKind::NotFound);+ }++ #[test]+ fn a_path_is_on_its_drive_and_a_folder_is_no_mount_point() {+ let temp = TempDir::new().expect("tempdir");+ let drive = temp.path().ancestors().last().expect("a drive");+ let root = volume_root(temp.path()).expect("a volume");+ assert!(+ same(&root, drive),+ "{} on {}",+ root.display(),+ drive.display()+ );+ assert!(!is_mount_point(temp.path()));+ assert!(!is_mount_point(drive), "a drive is a root, not a folder");+ }++ #[test]+ fn paths_compare_without_case_or_verbatim_prefixes() {+ let windows = Path::new(r"C:\Windows");+ assert!(within(Path::new(r"c:\WINDOWS\System32"), windows));+ assert!(within(Path::new(r"\\?\C:\Windows\Temp"), windows));+ assert!(!within(Path::new(r"C:\Windows.old"), windows), "components");+ assert!(!within(Path::new(r"D:\Windows"), windows));+ assert!(same(+ Path::new(r"\\server\Share\Dir"),+ Path::new(r"\\?\UNC\SERVER\share\dir")+ ));+ assert!(within(+ Path::new(r"C:\Users\Олег\x"),+ Path::new(r"c:\users\ОЛЕГ")+ ));+ }++ #[test]+ fn times_convert_to_unix_seconds() {+ assert_eq!(unix_seconds(0), 0, "before 1970");+ assert_eq!(unix_seconds(EPOCH_TICKS), 0);+ assert_eq!(unix_seconds(EPOCH_TICKS + 90 * TICKS_PER_SECOND), 90);+ }++ #[test]+ fn only_whole_ids_name_a_file() {+ assert_eq!(file_id(0), None, "no id at all");+ assert_eq!(file_id(0x0005_0000_0000_1234), Some(0x0005_0000_0000_1234));+ assert_eq!(file_id((1 << 64) | 7), None, "a ReFS id needs both halves");+ }+}