Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
fs: Poll until watched path is created instead of watching parent (#57152)
Ben Kunklea0aa3e842f9c
diff --git a/crates/fs/src/fs.rs b/crates/fs/src/fs.rsindex eed246b37ae..7809e65eeb3 100644--- a/crates/fs/src/fs.rs+++ b/crates/fs/src/fs.rs@@ -1,5 +1,7 @@pub mod fs_watcher;+pub use fs_watcher::requires_poll_watcher;+use parking_lot::Mutex;use std::ffi::OsString;use std::sync::atomic::{AtomicU8, AtomicUsize, Ordering};@@ -71,133 +73,6 @@ pub trait Watcher: Send + Sync {fn remove(&self, path: &Path) -> Result<()>;}-/// Detect whether a path requires polling instead of native file watching.-///-/// Returns `true` for filesystem types where inotify/FSEvents/ReadDirectoryChanges-/// silently fail to deliver events: 9P (WSL drvfs), NFS, CIFS/SMB, FUSE (sshfs), etc.-///-/// Can be overridden with the `ZED_FILE_WATCHER_MODE` environment variable:-/// - `native` — always use native OS watcher-/// - `poll` — always use polling-/// - `auto` (default) — auto-detect based on filesystem type-pub fn requires_poll_watcher(path: &Path) -> bool {- match std::env::var("ZED_FILE_WATCHER_MODE")- .as_deref()- .unwrap_or("auto")- {- "native" => return false,- "poll" => return true,- _ => {}- }-- #[cfg(target_os = "linux")]- {- let path = effective_watch_path(path);- return detect_requires_poll_watcher_linux(&path);- }-- #[cfg(not(target_os = "linux"))]- {- let _ = path;- false- }-}--pub fn effective_watch_path(path: &Path) -> PathBuf {- if path.exists() {- return path.to_path_buf();- }-- for ancestor in path.ancestors() {- if ancestor.exists() {- return ancestor.to_path_buf();- }- }-- path.to_path_buf()-}--#[cfg(target_os = "linux")]-fn detect_requires_poll_watcher_linux(path: &Path) -> bool {- use std::ffi::CString;- use std::os::unix::ffi::OsStrExt;-- // Check filesystem type via statfs- let c_path = match CString::new(path.as_os_str().as_bytes()) {- Ok(p) => p,- Err(_) => return false,- };-- let mut stat: libc::statfs = unsafe { std::mem::zeroed() };- if unsafe { libc::statfs(c_path.as_ptr(), &mut stat) } != 0 {- return false;- }-- // Filesystem magic numbers where inotify does not deliver events.- // These are defined in linux/magic.h and statfs(2).- const V9FS_MAGIC: u64 = 0x0102_1997; // Plan 9 / WSL2 interop (drvfs)- const NFS_SUPER_MAGIC: u64 = 0x0000_6969;- const CIFS_MAGIC: u64 = 0xFF53_4D42; // CIFS/SMB- const SMB_SUPER_MAGIC: u64 = 0x0000_517B;- const SMB2_MAGIC: u64 = 0xFE53_4D42;- const FUSE_SUPER_MAGIC: u64 = 0x6573_5546; // FUSE (includes sshfs)-- let fs_type = (stat.f_type as u64) & 0xFFFF_FFFF;- if fs_type == V9FS_MAGIC- || fs_type == NFS_SUPER_MAGIC- || fs_type == CIFS_MAGIC- || fs_type == SMB_SUPER_MAGIC- || fs_type == SMB2_MAGIC- || fs_type == FUSE_SUPER_MAGIC- {- log::info!(- "Detected network/virtual filesystem (type 0x{:x}) at {}, using poll watcher",- fs_type,- path.display()- );- return true;- }-- // Also check for WSL + /mnt/<drive>/ pattern as a fallback- // in case statfs returns an unexpected type for drvfs- if is_wsl_drvfs_path(path) {- log::info!(- "Detected WSL drvfs mount at {}, using poll watcher",- path.display()- );- return true;- }-- false-}--#[cfg(target_os = "linux")]-fn is_wsl_drvfs_path(path: &Path) -> bool {- // Only relevant inside WSL- if std::env::var_os("WSL_DISTRO_NAME").is_none() {- if let Ok(version) = std::fs::read_to_string("/proc/version") {- let v = version.to_lowercase();- if !v.contains("microsoft") && !v.contains("wsl") {- return false;- }- } else {- return false;- }- }-- // Windows drives are mounted at /mnt/c, /mnt/d, etc.- let path_str = match path.to_str() {- Some(s) => s,- None => return false,- };- if !path_str.starts_with("/mnt/") || path_str.len() < 6 {- return false;- }- let after_mnt = &path_str[5..];- after_mnt.starts_with(|c: char| c.is_ascii_alphabetic())- && (after_mnt.len() == 1 || after_mnt.as_bytes()[1] == b'/')-}-#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug)]pub enum PathEventKind {Removed,@@ -1197,35 +1072,17 @@ impl Fs for RealFs {use util::{ResultExt as _, paths::SanitizedPath};let executor = self.executor.clone();- let use_poll = requires_poll_watcher(path);- let watch_path = effective_watch_path(path);-let (tx, rx) = async_channel::unbounded();let pending_paths: Arc<Mutex<Vec<PathEvent>>> = Default::default();- let mode = if use_poll {- log::info!(- "Using poll watcher ({}ms interval) for {}",- fs_watcher::poll_interval().as_millis(),- path.display()- );- telemetry::event!("fs_watcher_poll", path = path.display().to_string());- fs_watcher::WatcherMode::Poll- } else {- fs_watcher::WatcherMode::Native- };let watcher: Arc<dyn Watcher> = Arc::new(fs_watcher::FsWatcher::new(+ executor.clone(),tx.clone(),pending_paths.clone(),- mode,));- if let Err(e) = watcher.add(&watch_path) {- log::warn!(- "Failed to watch {} using {}:\n{e}",- path.display(),- watch_path.display()- );+ if let Err(e) = watcher.add(path) {+ log::warn!("Failed to watch {}:\n{e}", path.display());}// Check if path is a symlink and follow the target parentdiff --git a/crates/fs/src/fs_watcher.rs b/crates/fs/src/fs_watcher.rsindex 85d1e164c0b..2c8078f1324 100644--- a/crates/fs/src/fs_watcher.rs+++ b/crates/fs/src/fs_watcher.rs@@ -1,3 +1,4 @@+use gpui::{BackgroundExecutor, Task};use notify::{Event, EventKind};use parking_lot::Mutex;use std::{@@ -19,29 +20,66 @@ pub enum WatcherMode {}pub struct FsWatcher {+ executor: BackgroundExecutor,tx: async_channel::Sender<()>,pending_path_events: Arc<Mutex<Vec<PathEvent>>>,- registrations: Mutex<BTreeMap<Arc<std::path::Path>, WatcherRegistrationId>>,+ registrations: Arc<Mutex<BTreeMap<Arc<std::path::Path>, FsWatcherRegistration>>>,+ pending_registrations: Arc<Mutex<HashMap<Arc<std::path::Path>, Task<()>>>>,+}++#[derive(Clone, Copy)]+struct FsWatcherRegistration {+ id: WatcherRegistrationId,mode: WatcherMode,}impl FsWatcher {pub fn new(+ executor: BackgroundExecutor,tx: async_channel::Sender<()>,pending_path_events: Arc<Mutex<Vec<PathEvent>>>,- mode: WatcherMode,) -> Self {Self {+ executor,tx,pending_path_events,registrations: Default::default(),- mode,+ pending_registrations: Default::default(),}}++ fn add_existing_path(&self, path: Arc<Path>) -> anyhow::Result<()> {+ let registration_path = path.clone();+ let registration =+ register_existing_path(path, self.tx.clone(), self.pending_path_events.clone())?;+ self.registrations+ .lock()+ .insert(registration_path, registration);+ Ok(())+ }++ fn add_pending_path(&self, path: Arc<Path>) {+ let mut pending_registrations = self.pending_registrations.lock();+ if pending_registrations.contains_key(path.as_ref()) {+ return;+ }++ let task = self.executor.spawn(poll_path_until_created(+ self.executor.clone(),+ path.clone(),+ self.tx.clone(),+ self.pending_path_events.clone(),+ self.registrations.clone(),+ self.pending_registrations.clone(),+ ));+ pending_registrations.insert(path, task);+ }}impl Drop for FsWatcher {fn drop(&mut self) {+ self.pending_registrations.lock().clear();+let mut registrations = BTreeMap::new();{let old = &mut self.registrations.lock();@@ -50,7 +88,7 @@ impl Drop for FsWatcher {let global_watcher = global_watcher();for (_, registration) in registrations {- global_watcher.remove(registration);+ global_watcher.remove(registration.id);}}}@@ -58,59 +96,252 @@ impl Drop for FsWatcher {impl Watcher for FsWatcher {fn add(&self, path: &std::path::Path) -> anyhow::Result<()> {log::trace!("watcher add: {path:?}");- let tx = self.tx.clone();- let pending_path_events = self.pending_path_events.clone();-- if (self.mode == WatcherMode::Poll || cfg!(any(target_os = "windows", target_os = "macos")))- && let Some((watched_path, _)) = self- .registrations- .lock()- .range::<std::path::Path, _>((- std::ops::Bound::Unbounded,- std::ops::Bound::Included(path),- ))- .next_back()- && path.starts_with(watched_path.as_ref())- {- log::trace!(- "path to watch is covered by existing registration: {path:?}, {watched_path:?}"- );++ let (path_is_covered_by_recursive_registration, path_is_already_watched) = {+ let registrations = self.registrations.lock();+ (+ path.ancestors().skip(1).any(|ancestor| {+ registrations.get(ancestor).is_some_and(|registration| {+ registration.mode == WatcherMode::Poll+ || cfg!(any(target_os = "windows", target_os = "macos"))+ })+ }),+ registrations.contains_key(path),+ )+ };++ if path_is_covered_by_recursive_registration {+ log::trace!("path to watch is covered by existing registration: {path:?}");return Ok(());}- if self.registrations.lock().contains_key(path) {+ if path_is_already_watched {log::trace!("path to watch is already watched: {path:?}");return Ok(());}- let root_path = SanitizedPath::new_arc(path);- let path: Arc<std::path::Path> = path.into();-- let registration_path = path.clone();- let registration_id =- global_watcher().add(path.clone(), self.mode, move |event: ¬ify::Event| {- log::trace!("watcher received event: {event:?}");- push_notify_event(&tx, &pending_path_events, &root_path, path.as_ref(), event);- })?;+ if self.pending_registrations.lock().contains_key(path) {+ log::trace!("path to watch is already pending: {path:?}");+ return Ok(());+ }- self.registrations- .lock()- .insert(registration_path, registration_id);+ let path: Arc<std::path::Path> = path.into();+ if std::fs::symlink_metadata(path.as_ref()).is_err() {+ self.add_pending_path(path);+ return Ok(());+ }- Ok(())+ self.add_existing_path(path)}fn remove(&self, path: &std::path::Path) -> anyhow::Result<()> {log::trace!("remove watched path: {path:?}");+ self.pending_registrations.lock().remove(path);+let Some(registration) = self.registrations.lock().remove(path) else {return Ok(());};- global_watcher().remove(registration);+ global_watcher().remove(registration.id);Ok(())}}+/// Detect whether a path requires polling instead of native file watching.+///+/// Returns `true` for filesystem types where inotify/FSEvents/ReadDirectoryChanges+/// silently fail to deliver events: 9P (WSL drvfs), NFS, CIFS/SMB, FUSE (sshfs), etc.+///+/// Can be overridden with the `ZED_FILE_WATCHER_MODE` environment variable:+/// - `native` — always use native OS watcher+/// - `poll` — always use polling+/// - `auto` (default) — auto-detect based on filesystem type+pub fn requires_poll_watcher(path: &Path) -> bool {+ match std::env::var("ZED_FILE_WATCHER_MODE")+ .as_deref()+ .unwrap_or("auto")+ {+ "native" => return false,+ "poll" => return true,+ _ => {}+ }++ #[cfg(target_os = "linux")]+ {+ return detect_requires_poll_watcher_linux(path);+ }++ #[cfg(not(target_os = "linux"))]+ {+ let _ = path;+ false+ }+}++fn register_existing_path(+ path: Arc<Path>,+ tx: async_channel::Sender<()>,+ pending_path_events: Arc<Mutex<Vec<PathEvent>>>,+) -> anyhow::Result<FsWatcherRegistration> {+ let mode = if requires_poll_watcher(path.as_ref()) {+ log::info!(+ "Using poll watcher ({}ms interval) for {}",+ poll_interval().as_millis(),+ path.display()+ );+ telemetry::event!("fs_watcher_poll", path = path.display().to_string());+ WatcherMode::Poll+ } else {+ WatcherMode::Native+ };+ let root_path = SanitizedPath::new_arc(path.as_ref());+ let path_for_callback = path.clone();+ let registration_id = global_watcher().add(path, mode, move |event: ¬ify::Event| {+ log::trace!("watcher received event: {event:?}");+ push_notify_event(+ &tx,+ &pending_path_events,+ &root_path,+ path_for_callback.as_ref(),+ event,+ );+ })?;+ Ok(FsWatcherRegistration {+ id: registration_id,+ mode,+ })+}++#[cfg(target_os = "linux")]+fn detect_requires_poll_watcher_linux(path: &Path) -> bool {+ use std::ffi::CString;+ use std::os::unix::ffi::OsStrExt;++ let c_path = match CString::new(path.as_os_str().as_bytes()) {+ Ok(p) => p,+ Err(_) => return false,+ };++ let mut stat: libc::statfs = unsafe { std::mem::zeroed() };+ if unsafe { libc::statfs(c_path.as_ptr(), &mut stat) } != 0 {+ return false;+ }++ const V9FS_MAGIC: u64 = 0x0102_1997;+ const NFS_SUPER_MAGIC: u64 = 0x0000_6969;+ const CIFS_MAGIC: u64 = 0xFF53_4D42;+ const SMB_SUPER_MAGIC: u64 = 0x0000_517B;+ const SMB2_MAGIC: u64 = 0xFE53_4D42;+ const FUSE_SUPER_MAGIC: u64 = 0x6573_5546;++ let fs_type = (stat.f_type as u64) & 0xFFFF_FFFF;+ if fs_type == V9FS_MAGIC+ || fs_type == NFS_SUPER_MAGIC+ || fs_type == CIFS_MAGIC+ || fs_type == SMB_SUPER_MAGIC+ || fs_type == SMB2_MAGIC+ || fs_type == FUSE_SUPER_MAGIC+ {+ log::info!(+ "Detected network/virtual filesystem (type 0x{:x}) at {}, using poll watcher",+ fs_type,+ path.display()+ );+ return true;+ }++ if is_wsl_drvfs_path(path) {+ log::info!(+ "Detected WSL drvfs mount at {}, using poll watcher",+ path.display()+ );+ return true;+ }++ false+}++#[cfg(target_os = "linux")]+fn is_wsl_drvfs_path(path: &Path) -> bool {+ if std::env::var_os("WSL_DISTRO_NAME").is_none() {+ if let Ok(version) = std::fs::read_to_string("/proc/version") {+ let version = version.to_lowercase();+ if !version.contains("microsoft") && !version.contains("wsl") {+ return false;+ }+ } else {+ return false;+ }+ }++ let Some(path) = path.to_str() else {+ return false;+ };+ if !path.starts_with("/mnt/") || path.len() < 6 {+ return false;+ }+ let after_mnt = &path[5..];+ after_mnt.starts_with(|c: char| c.is_ascii_alphabetic())+ && (after_mnt.len() == 1 || after_mnt.as_bytes()[1] == b'/')+}++async fn poll_path_until_created(+ executor: BackgroundExecutor,+ path: Arc<Path>,+ tx: async_channel::Sender<()>,+ pending_path_events: Arc<Mutex<Vec<PathEvent>>>,+ registrations: Arc<Mutex<BTreeMap<Arc<Path>, FsWatcherRegistration>>>,+ pending_registrations: Arc<Mutex<HashMap<Arc<Path>, Task<()>>>>,+) {+ loop {+ executor.timer(poll_interval()).await;++ if !pending_registrations.lock().contains_key(path.as_ref()) {+ return;+ }++ if smol::fs::symlink_metadata(path.as_ref()).await.is_err() {+ continue;+ }++ if registrations.lock().contains_key(path.as_ref()) {+ pending_registrations.lock().remove(path.as_ref());+ return;+ }++ match register_existing_path(path.clone(), tx.clone(), pending_path_events.clone()) {+ Ok(registration) => {+ {+ let mut pending_registrations = pending_registrations.lock();+ if pending_registrations.remove(path.as_ref()).is_none() {+ global_watcher().remove(registration.id);+ return;+ }+ registrations.lock().insert(path.clone(), registration);+ }+ enqueue_path_events(+ &tx,+ &pending_path_events,+ vec![+ PathEvent {+ path: path.to_path_buf(),+ kind: Some(PathEventKind::Created),+ },+ PathEvent {+ path: path.to_path_buf(),+ kind: Some(PathEventKind::Rescan),+ },+ ],+ );+ return;+ }+ Err(error) => {+ log::warn!("failed to watch newly-created path {path:?}: {error}; retrying");+ }+ }+ }+}+fn enqueue_path_events(tx: &smol::channel::Sender<()>,pending_path_events: &Arc<Mutex<Vec<PathEvent>>>,@@ -417,9 +648,10 @@ fn path_already_covered(mode: WatcherMode,) -> bool {(mode == WatcherMode::Poll || cfg!(any(target_os = "windows", target_os = "macos")))- && path_registrations- .keys()- .any(|existing| path.starts_with(existing.as_ref()) && path != existing.as_ref())+ && path+ .ancestors()+ .skip(1)+ .any(|ancestor| path_registrations.contains_key(ancestor))}static POLL_INTERVAL: LazyLock<Duration> = LazyLock::new(|| {