fix(tail): watch both file and parent on Linux to fix follow-name tests

naoNao89 · naoNao89 · commit 57b5a87b0171 · 2025-10-21T17:05:25.000+07:00
Previously, Linux inotify only watched the parent directory while kqueue
(macOS/BSD) watched both file and parent. This caused event path mismatches
on Linux when files were renamed:

1. File /tmp/dir/file.txt is tracked in HashMap
2. File gets renamed to /tmp/dir/backup
3. Event fires with path=/tmp/dir/backup
4. HashMap lookup fails -&gt; event ignored -&gt; tests fail

Fixes 5 failing tests on Linux CI:
- test_follow_name_move1
- test_follow_name_move_create1
- test_follow_name_move2
- test_follow_name_truncate1
- test_follow_name_move_retry2

By unifying the implementation to watch both file and parent on all
platforms, we ensure:
- Modification events captured directly from file watch
- Rename/delete events captured from parent watch
- Consistent path tracking across all platforms
- No event path mismatches
diff --git a/src/uu/tail/src/follow/watch.rs b/src/uu/tail/src/follow/watch.rs
@@ -71,49 +71,41 @@ impl WatcherRx {
             > be unexpected. See discussions in [#165] and [#166]. If less surprising behavior is wanted
             > one may non-recursively watch the _parent_ directory as well and manage related events.
 
-            On Linux (inotify): Watch parent only - events report child file paths
-            On macOS/BSD (kqueue): Watch BOTH file and parent - parent alone doesn't report child events
-
-            This fix applies to:
-            - Linux: inotify backend (parent only)
-            - macOS/FreeBSD/OpenBSD/NetBSD/DragonFly: kqueue backend (both)
-
-            Without this, kqueue doesn't properly detect when files are deleted/renamed,
-            causing --follow=name to exit prematurely instead of waiting for files to reappear.
+            Implementation: Watch BOTH file and parent on all platforms
+            - File watch: Captures modification events directly
+            - Parent watch: Captures rename/delete events reliably
+
+            This dual-watch approach is necessary because:
+            - On kqueue (macOS/BSD): Parent watch alone doesn't report child file modifications
+            - On inotify (Linux): Events from renamed files need proper path tracking
+
+            By watching both file and parent consistently across platforms, we ensure:
+            1. Modification events are captured directly from the file
+            2. Rename/delete events are captured from parent directory changes
+            3. Path mismatches in event handling are avoided
             */
             let file_path = watch_path.clone();
             if let Some(parent) = watch_path.parent() {
                 if !is_special_fs_path {
-                    // Normal case: watch parent directory (and on kqueue, also the file)
+                    // Normal case: watch both file and parent directory
                     // clippy::assigning_clones added with Rust 1.78
                     // Rust version = 1.76 on OpenBSD stable/7.5
                     #[cfg_attr(not(target_os = "openbsd"), allow(clippy::assigning_clones))]
                     if parent.is_dir() {
-                        #[cfg(target_os = "linux")]
-                        {
-                            // Linux inotify: watch parent only
-                            watch_path = parent.to_owned();
-                        }
-                        #[cfg(not(target_os = "linux"))]
-                        {
-                            // macOS/BSD kqueue: watch the file first for modification events,
-                            // then also watch parent for rename/delete detection.
-                            // kqueue doesn't send child file modification events when only
-                            // watching the parent directory, unlike Linux inotify.
-                            if let Err(e) = self.watch(&file_path, RecursiveMode::NonRecursive) {
-                                let err_str = e.to_string();
-                                if !is_special_fs_path
-                                    || !(err_str.contains("Operation not supported")
-                                        || err_str.contains("not supported by device")
-                                        || err_str.contains("Not supported")
-                                        || err_str.contains("Permission denied"))
-                                {
-                                    return Err(e);
-                                }
+                        // Watch the file first for modification events
+                        if let Err(e) = self.watch(&file_path, RecursiveMode::NonRecursive) {
+                            let err_str = e.to_string();
+                            if !is_special_fs_path
+                                || !(err_str.contains("Operation not supported")
+                                    || err_str.contains("not supported by device")
+                                    || err_str.contains("Not supported")
+                                    || err_str.contains("Permission denied"))
+                            {
+                                return Err(e);
                             }
-                            // Also watch parent for rename/delete detection
-                            watch_path = parent.to_owned();
                         }
+                        // Also watch parent for rename/delete detection
+                        watch_path = parent.to_owned();
                     } else {
                         watch_path = PathBuf::from(".");
                     }
