Add integration test for df fallback when /proc is masked

Author: ChrisDryden

src/uu/df/src/df.rs

@@ -16,7 +16,7 @@ use uucore::error::{UError, UResult, USimpleError, get_exit_code};
 use uucore::fsext::{MountInfo, read_fs_list};
 use uucore::parser::parse_size::ParseSizeError;
 use uucore::translate;
-use uucore::{format_usage, show};
+use uucore::{format_usage, show, show_warning};
 
 use clap::{Arg, ArgAction, ArgMatches, Command, parser::ValueSource};
 
@@ -112,10 +112,7 @@ impl Default for Options {
 }
 
 impl Options {
-    /// Check if the mount table is required for these options.
-    ///
-    /// Options like -a (show all), -l (local only), -t (include type),
-    /// and -x (exclude type) require the mount table to filter filesystems.
+    /// Whether -a, -l, -t, or -x options require the mount table.
     fn requires_mount_table(&self) -> bool {
         self.show_all_fs || self.show_local_fs || self.include.is_some() || self.exclude.is_some()
     }
@@ -367,23 +364,17 @@ fn get_named_filesystems<P>(paths: &[P], opt: &Options) -> UResult<Vec<Filesyste
 where
     P: AsRef<Path>,
 {
-    // Try to read the list of all mounted filesystems.
-    // If this fails and we need the mount table (for -a, -l, -t, -x options),
-    // we must return an error. Otherwise, we can fall back to using statfs directly.
+    // The list of all mounted filesystems.
     let mounts_result = read_fs_list();
 
     let (mounts, use_fallback) = match mounts_result {
         Ok(m) => (m, false),
         Err(e) => {
             if opt.requires_mount_table() {
-                // Options like -a, -l, -t, -x require the mount table
                 return Err(e);
             }
-            // Warn about the missing mount table but continue with fallback.
-            // Don't set exit code here - we'll still try to produce output.
-            eprintln!(
-                "{}: {}",
-                uucore::util_name(),
+            show_warning!(
+                "{}",
                 translate!("df-error-cannot-read-table-of-mounted-filesystems")
             );
             (vec![], true)
@@ -397,7 +388,6 @@ where
     for path in paths {
         #[cfg(unix)]
         let fs_result = if use_fallback {
-            // Use statfs directly when mount table is unavailable
             Filesystem::from_path_direct(path)
         } else {
             Filesystem::from_path(&mounts, path)

src/uu/df/src/filesystem.rs

@@ -15,9 +15,9 @@ use std::{ffi::OsString, path::Path};
 #[cfg(unix)]
 use std::os::unix::fs::MetadataExt;
 
-use uucore::fsext::{FsUsage, MountInfo};
 #[cfg(unix)]
 use uucore::fsext::{FsMeta, pretty_fstype, statfs};
+use uucore::fsext::{FsUsage, MountInfo};
 
 /// Summary representation of a filesystem.
 ///
@@ -66,14 +66,7 @@ fn is_over_mounted(mounts: &[MountInfo], mount: &MountInfo) -> bool {
     }
 }
 
-/// Find the mount point for a given path by walking up the directory tree.
-///
-/// This function walks up the directory tree from `path` until it finds a
-/// directory that is on a different device (different `st_dev`), which indicates
-/// a mount point boundary. This is used as a fallback when the mount table is
-/// unavailable.
-///
-/// Returns the path to the mount point directory.
+/// Find mount point by walking up the directory tree until device ID changes.
 #[cfg(unix)]
 pub(crate) fn find_mount_point<P: AsRef<Path>>(path: P) -> io::Result<PathBuf> {
     let mut current = path.as_ref().canonicalize()?;
@@ -87,11 +80,9 @@ pub(crate) fn find_mount_point<P: AsRef<Path>>(path: P) -> io::Result<PathBuf> {
 
         let parent_dev = parent.metadata()?.dev();
         if parent_dev != current_dev {
-            // We crossed a mount point boundary
             return Ok(current);
         }
 
-        // Check if we've reached the root (parent equals current)
         if parent == current {
             return Ok(current);
         }
@@ -235,37 +226,23 @@ impl Filesystem {
         return result.and_then(|mount_info| Self::from_mount(mounts, mount_info, Some(file)));
     }
 
-    /// Create a filesystem directly from a path using statfs, without needing the mount table.
-    ///
-    /// This is a fallback method used when the mount table (e.g., /proc/self/mountinfo)
-    /// is unavailable. It uses `statfs()` to get filesystem usage and `find_mount_point()`
-    /// to determine the mount directory by walking up the directory tree.
-    ///
-    /// Note: Some mount info fields (like device name) may be incomplete when using this method.
+    /// Fallback using statfs when mount table is unavailable.
     #[cfg(unix)]
     pub(crate) fn from_path_direct<P>(path: P) -> Result<Self, FsError>
     where
         P: AsRef<Path>,
     {
         let file = path.as_ref().as_os_str().to_owned();
 
-        // Get the canonical path first
         let canonical_path = path
             .as_ref()
             .canonicalize()
             .map_err(|_| FsError::InvalidPath)?;
 
-        // Get filesystem info using statfs
         let stat_result = statfs(canonical_path.as_os_str()).map_err(|_| FsError::MountMissing)?;
-
-        // Find the mount point by walking up the directory tree
         let mount_dir = find_mount_point(&canonical_path).map_err(|_| FsError::MountMissing)?;
-
-        // Get filesystem type from statfs f_type using the FsMeta trait
         let fs_type = pretty_fstype(stat_result.fs_type()).into_owned();
 
-        // Create a MountInfo with the information we have
-        // Note: dev_name will be "-" since we can't determine it without the mount table
         let mount_info = MountInfo {
             dev_id: String::new(),
             dev_name: "-".to_string(),

tests/by-util/test_df.rs

@@ -15,6 +15,7 @@ use std::collections::HashSet;
 #[cfg(not(any(target_os = "freebsd", target_os = "windows")))]
 use uutests::at_and_ucmd;
 use uutests::new_ucmd;
+use uutests::util::TestScenario;
 
 #[test]
 fn test_invalid_arg() {
@@ -1091,3 +1092,62 @@ fn test_df_hides_binfmt_misc_by_default() {
     }
     // If binfmt_misc is not mounted, skip the test silently
 }
+
+/// Run df inside a mount namespace where /proc is masked with tmpfs.
+/// Returns (success, stdout, stderr).
+#[cfg(target_os = "linux")]
+fn run_df_with_masked_proc(args: &str) -> Option<(bool, String, String)> {
+    use std::process::Command;
+
+    // Check if user namespaces are available
+    if !Command::new("unshare")
+        .args(["-rm", "true"])
+        .status()
+        .is_ok_and(|s| s.success())
+    {
+        return None;
+    }
+
+    let df_path = TestScenario::new("df").bin_path.clone();
+    let output = Command::new("unshare")
+        .args(["-rm", "sh", "-c"])
+        .arg(format!(
+            "mount -t tmpfs tmpfs /proc && {} df {args}",
+            df_path.display()
+        ))
+        .output()
+        .ok()?;
+
+    Some((
+        output.status.success(),
+        String::from_utf8_lossy(&output.stdout).to_string(),
+        String::from_utf8_lossy(&output.stderr).to_string(),
+    ))
+}
+
+/// Test df fallback when /proc is masked - should work with path, fail without or with filters.
+#[test]
+#[cfg(target_os = "linux")]
+fn test_df_masked_proc_fallback() {
+    if let Some((ok, stdout, stderr)) = run_df_with_masked_proc(".") {
+        assert!(ok, "df . should succeed: {stderr}");
+        assert!(stderr.contains("cannot read table of mounted file systems"));
+        assert!(stdout.contains("Filesystem"));
+    }
+
+    if let Some((ok, _, _)) = run_df_with_masked_proc("") {
+        assert!(!ok, "df without args should fail when /proc is masked");
+    }
+
+    for args in ["-a .", "-l .", "-t ext4 .", "-x tmpfs ."] {
+        if let Some((ok, _, _)) = run_df_with_masked_proc(args) {
+            assert!(!ok, "df {args} should fail when /proc is masked");
+        }
+    }
+
+    for args in ["-i .", "-T .", "--total ."] {
+        if let Some((ok, _, stderr)) = run_df_with_masked_proc(args) {
+            assert!(ok, "df {args} should succeed: {stderr}");
+        }
+    }
+}