fix(ls): properly release parent nodes in DFS

Fixes a regression introduced in #11386 (sorry) where DFS nodes did not properly free the recorded inodes of the parent directories, causing critical errors in some instances of recursive symlinks.

Author: Alonely0

src/uu/ls/src/ls.rs

@@ -974,7 +974,11 @@ impl Colorable for PathData<'_> {
     }
 }
 
-type DirData = (PathBuf, bool);
+struct LsNode {
+    path: PathBuf,
+    needs_blank_line: bool,
+    fi: FileInformation,
+}
 
 // A struct to encapsulate state that is passed around from `list` functions.
 #[cfg_attr(not(unix), allow(dead_code))]
@@ -995,7 +999,7 @@ struct ListState<'a> {
     #[cfg(not(unix))]
     gid_cache: (),
     recent_time_range: RangeInclusive<SystemTime>,
-    stack: Vec<DirData>,
+    stack: Vec<LsNode>,
     listed_ancestors: FxHashSet<FileInformation>,
     initial_locs_len: usize,
     display_buf: Vec<u8>,
@@ -1109,22 +1113,19 @@ pub fn list(locs: Vec<&Path>, config: &Config) -> UResult<()> {
         )?;
 
         // Only runs if it must list recursively.
-        while let Some(dir_data) = state.stack.pop() {
-            let read_dir = match fs::read_dir(&dir_data.0) {
+        while let Some(node) = state.stack.pop() {
+            let read_dir = match fs::read_dir(&node.path) {
                 Err(err) => {
                     // flush stdout buffer before the error to preserve formatting and order
                     state.out.flush()?;
-                    show!(LsError::IOErrorContext(
-                        path_data.path().to_path_buf(),
-                        err,
-                        path_data.command_line
-                    ));
+                    show!(LsError::IOErrorContext(node.path, err, false));
                     continue;
                 }
                 Ok(rd) => rd,
             };
 
-            depth_first_list(dir_data, read_dir, config, &mut state, &mut dired, false)?;
+            state.listed_ancestors.remove(&node.fi);
+            depth_first_list(node.into(), read_dir, config, &mut state, &mut dired, false)?;
 
             // Heuristic to ensure stack does not keep its capacity forever if there is
             // combinatorial explosion; we decrease it logarithmically here.
@@ -1208,14 +1209,14 @@ fn sort_entries(entries: &mut [PathData], config: &Config) {
 }
 
 fn depth_first_list(
-    (dir_path, needs_blank_line): DirData,
+    (dir_path, needs_blank_line): (PathBuf, bool),
     mut read_dir: ReadDir,
     config: &Config,
     state: &mut ListState,
     dired: &mut DiredOutput,
     is_top_level: bool,
 ) -> UResult<()> {
-    let path_data = PathData::new(dir_path.as_path().into(), None, None, config, false);
+    let path_data = PathData::new(dir_path.into(), None, None, config, false);
 
     // Print dir heading - name... 'total' comes after error display
     if state.initial_locs_len > 1 || config.recursive {
@@ -1253,7 +1254,7 @@ fn depth_first_list(
     }
 
     // Append entries with initial dot files and record their existence
-    let (ref mut buf, trim) = if config.files == Files::All {
+    let (mut buf, trim) = if config.files == Files::All {
         const DOT_DIRECTORIES: usize = 2;
         let v = vec![
             PathData::new(
@@ -1299,20 +1300,20 @@ fn depth_first_list(
     // Relinquish unused space since we won't need it anymore.
     buf.shrink_to_fit();
 
-    sort_entries(buf, config);
+    sort_entries(&mut buf, config);
 
     if config.format == Format::Long || config.alloc_size {
-        let total = write_total(buf, config, &mut state.out)?;
+        let total = write_total(&buf, config, &mut state.out)?;
         if config.dired {
             dired::add_total(dired, total);
         }
     }
 
-    display_items(buf, config, state, dired)?;
+    display_items(&buf, config, state, dired)?;
 
     if config.recursive {
         for e in buf
-            .iter()
+            .into_iter()
             .skip(trim)
             .filter(|p| p.file_type().is_some_and(FileType::is_dir))
             .rev()
@@ -1327,13 +1328,13 @@ fn depth_first_list(
                 ));
             } else {
                 let fi = FileInformation::from_path(e.path(), e.must_dereference)?;
-                if state.listed_ancestors.insert(fi) {
+                if state.listed_ancestors.insert(fi.clone()) {
                     // Push to stack, but with a less aggressive growth curve.
                     let (cap, len) = (state.stack.capacity(), state.stack.len());
                     if cap == len {
                         state.stack.reserve_exact(len / 4 + 4);
                     }
-                    state.stack.push((e.path().to_path_buf(), true));
+                    state.stack.push(LsNode::new(e.p_buf, needs_blank_line, fi));
                 } else {
                     state.out.flush()?;
                     show!(LsError::AlreadyListedError(e.path().to_path_buf()));
@@ -1344,6 +1345,22 @@ fn depth_first_list(
     Ok(())
 }
 
+impl LsNode {
+    fn new(path: impl Into<PathBuf>, needs_blank_line: bool, fi: FileInformation) -> Self {
+        Self {
+            path: path.into(),
+            needs_blank_line,
+            fi,
+        }
+    }
+}
+
+impl From<LsNode> for (PathBuf, bool) {
+    fn from(val: LsNode) -> Self {
+        (val.path, val.needs_blank_line)
+    }
+}
+
 fn get_metadata_with_deref_opt(p_buf: &Path, dereference: bool) -> std::io::Result<Metadata> {
     if dereference {
         p_buf.metadata()

src/uucore/src/lib/features/fs.rs

@@ -46,6 +46,7 @@ macro_rules! has {
 }
 
 /// Information to uniquely identify a file
+#[derive(Clone)]
 pub struct FileInformation(
     #[cfg(unix)] nix::sys::stat::FileStat,
     #[cfg(windows)] winapi_util::file::Information,