A treemap for finding and removing what fills your disk, for Omarchy. Rust + GPUI.
Rust
feat(removal): refuse profile folders and flush after elevated removals
Shishir Pai4d6a65e00c78
diff --git a/crates/disktree-core/src/removal.rs b/crates/disktree-core/src/removal.rsindex c41843d..b7bbc25 100644--- a/crates/disktree-core/src/removal.rs+++ b/crates/disktree-core/src/removal.rs@@ -400,6 +400,15 @@ fn refuse(if home_key.is_some_and(|home| home.starts_with(&key)) {return Some("it contains the home directory".into());}+ // Elevated through another account's credentials, home is that admin's,+ // and the user's own profile is just another folder; elevation opens+ // every other profile too. So on Windows each directory in the profiles+ // folder (`C:\Users\tobi`, `Public`, `Default`) is refused, taken from+ // Windows and not from home, whose parent could be anything. What is+ // inside a profile stays removable, as under one's own home.+ if profiles_key().is_some_and(|profiles| is_profile(path, &key, profiles)) {+ return Some("a user profile cannot be removed".into());+ }// By spelling too: the Data volume's root keeps its name as a key, while// everything under it is keyed as under `/`.if !key.starts_with(&root_key) && !path.starts_with(root) {@@ -616,6 +625,29 @@ const fn windows_mount_points() -> Vec<PathBuf> {Vec::new()}+/// The key of the folder every user profile is in, `C:\Users` as+/// installed; asked of Windows once, since it does not move while running.+#[cfg(windows)]+fn profiles_key() -> Option<&'static Path> {+ static PROFILES: std::sync::LazyLock<Option<PathBuf>> =+ std::sync::LazyLock::new(|| {+ crate::windows::user_profiles_dir().map(|dir| guard_key(&dir))+ });+ PROFILES.as_deref()+}++#[cfg(not(windows))]+const fn profiles_key() -> Option<&'static Path> {+ None+}++/// Whether `path`, keyed `key`, is a profile: a directory directly in+/// `profiles`. A file or a link there is no profile and stays removable.+fn is_profile(path: &Path, key: &Path, profiles: &Path) -> bool {+ key.parent() == Some(profiles)+ && fs::symlink_metadata(path).is_ok_and(|meta| meta.is_dir())+}+/// A mount point strictly inside the path keyed `key`, if there is one. A/// scan that stays on one filesystem never shows what is mounted there, so/// the user cannot have meant to remove it.@@ -929,6 +961,18 @@ fn run(});}+ // NTFS writes the file table's records lazily, and the elevated rescan+ // of a whole drive reads that table from disk, past the cache:+ // unflushed, the removed entries would still show. Only then; a folder+ // is walked. Failing only lets the table lag again.+ #[cfg(windows)]+ if removed > 0+ && plan.root.parent().is_none()+ && crate::access::administrator() == Some(true)+ {+ let _ = crate::windows::flush_volume(&plan.root);+ }+let _ = sender.send(RemovalEvent::Done {removed,bytes,@@ -1479,7 +1523,7 @@ mod tests {assert_eq!(refuse(Path::new("/home/other"), Path::new("/"), Some(&home), &[]),None,- "a sibling of home is not"+ "a sibling of home is not above it");}@@ -2155,6 +2199,31 @@ mod tests {);}+ #[cfg(windows)]+ #[test]+ fn windows_profiles_are_refused() {+ let temp = tempfile::tempdir().expect("tempdir");+ let profiles = temp.path();+ fs::create_dir_all(profiles.join(r"tobi\Downloads")).expect("mkdir");+ fs::write(profiles.join("notes.txt"), b"x").expect("write");+ let profile = |relative: &str| {+ let path = profiles.join(relative);+ is_profile(&path, &guard_key(&path), &guard_key(profiles))+ };+ assert!(profile("tobi"));+ assert!(profile("TOBI"), "compared as Windows compares names");+ assert!(!profile("notes.txt"), "a file there is no profile");+ assert!(!profile(r"tobi\Downloads"), "inside a profile is not one");+ assert!(!profile("gone"), "nothing there is no profile");++ // The rule itself, against the profiles folder Windows reports.+ let public = crate::windows::user_profiles_dir()+ .expect("profiles folder")+ .join("Public");+ let reason = refuse(&public, &system_drive(), None, &[]);+ assert!(reason.is_some_and(|reason| reason.contains("profile")));+ }+#[test]#[cfg(target_os = "macos")]fn macos_always_uses_the_system_trash() {diff --git a/crates/disktree-core/src/windows.rs b/crates/disktree-core/src/windows.rsindex b036bdb..53b8564 100644--- a/crates/disktree-core/src/windows.rs+++ b/crates/disktree-core/src/windows.rs@@ -33,6 +33,7 @@ use windows_sys::Win32::Storage::FileSystem::{FILE_ATTRIBUTE_RECALL_ON_DATA_ACCESS, FILE_ATTRIBUTE_RECALL_ON_OPEN,FILE_ATTRIBUTE_REPARSE_POINT, FILE_FLAG_BACKUP_SEMANTICS,FILE_ID_EXTD_DIR_INFO, FILE_LIST_DIRECTORY, FILE_READ_ATTRIBUTES,+ FILE_SHARE_DELETE, FILE_SHARE_READ, FILE_SHARE_WRITE,FileIdExtdDirectoryInfo, FindFirstVolumeW, FindNextVolumeW,FindVolumeClose, GetDiskFreeSpaceExW, GetFileInformationByHandleEx,GetVolumeInformationW, GetVolumePathNameW,@@ -672,6 +673,24 @@ pub fn run_elevated(program: &Path, args: &[OsString]) -> io::Result<()> {}}+/// Write out what the file system holds only in memory for the volume+/// holding `path`, its file table included. Flushing a volume takes write+/// access, so an administrator. Only a volume mounted as a drive letter:+/// for one mounted in a folder, `\\.\X:` would name the drive around it.+pub fn flush_volume(path: &Path) -> io::Result<()> {+ let root = volume_root(path).ok_or_else(|| {+ io::Error::new(io::ErrorKind::NotFound, "no volume holds the path")+ })?;+ let letter = drive_letter(&root)+ .ok_or_else(|| io::Error::from(io::ErrorKind::Unsupported))?;+ OpenOptions::new()+ .read(true)+ .write(true)+ .share_mode(FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE)+ .open(format!(r"\\.\{letter}:"))?+ .sync_all()+}+/// `C` when `canonical` is the root of drive `C:`; `None` for anything/// else, a folder or a volume mounted in one.pub fn drive_letter(canonical: &Path) -> Option<char> {@@ -688,6 +707,44 @@ pub fn drive_letter(canonical: &Path) -> Option<char> {.then_some(char::from(letter))}+/// The folder that holds every user's profile, `C:\Users` as installed,+/// from Windows itself: it can be moved, so no path is assumed. `None`+/// when Windows does not say.+pub fn user_profiles_dir() -> Option<PathBuf> {+ use windows_sys::Win32::System::Com::CoTaskMemFree;+ use windows_sys::Win32::UI::Shell::{+ FOLDERID_UserProfiles, SHGetKnownFolderPath,+ };+ let mut raw: *mut u16 = std::ptr::null_mut();+ // SAFETY: the id outlives the call, a null token means this user, and+ // `raw` receives a string the shell allocates, freed below either way.+ let result = unsafe {+ SHGetKnownFolderPath(+ &FOLDERID_UserProfiles,+ 0,+ std::ptr::null_mut(),+ &raw mut raw,+ )+ };+ let path = (result >= 0 && !raw.is_null()).then(|| {+ // SAFETY: on success `raw` is a NUL-terminated string, read up to+ // and not past its NUL.+ unsafe {+ let mut len = 0;+ while *raw.add(len) != 0 {+ len += 1;+ }+ PathBuf::from(OsString::from_wide(std::slice::from_raw_parts(+ raw, len,+ )))+ }+ });+ // SAFETY: `raw` came from the shell's allocator, or is null, which+ // the call accepts.+ unsafe { CoTaskMemFree(raw.cast()) };+ path+}+/// `arg` quoted so a program's C runtime splits it back out whole: inside/// quotes, backslashes are literal except before a quote, where they must/// be doubled, so `C:\` becomes `"C:\\"` and not `"C:\"`.