df: Add a mount_dev_id to use id's instead of paths

Author: van-sprundel

src/uu/df/src/df.rs

@@ -638,6 +638,8 @@ mod tests {
                 mount_root: mount_root.into(),
                 remote: false,
                 dummy: false,
+                #[cfg(any(target_os = "linux", target_os = "android"))]
+                mount_dev_id: String::new(),
             }
         }
 
@@ -688,6 +690,8 @@ mod tests {
                 mount_root: "/".into(),
                 remote: false,
                 dummy: false,
+                #[cfg(any(target_os = "linux", target_os = "android"))]
+                mount_dev_id: String::new(),
             }
         }
 
@@ -733,6 +737,8 @@ mod tests {
                 mount_root: "/".into(),
                 remote,
                 dummy,
+                #[cfg(any(target_os = "linux", target_os = "android"))]
+                mount_dev_id: String::new(),
             }
         }
 

src/uu/df/src/filesystem.rs

@@ -45,11 +45,32 @@ pub(crate) enum FsError {
     MountMissing,
 }
 
+// spell-checker:ignore (fs) autofs binfmt
+
 /// Check whether `mount` has been over-mounted.
 ///
-/// `mount` is considered over-mounted if it there is an element in
-/// `mounts` after mount that has the same `mount_dir`.
-#[cfg(not(windows))]
+/// `mount` is considered over-mounted if there is a later element in
+/// `mounts` that has the same `mount_dir` AND the same `mount_dev_id`.
+/// Mounts with different mountinfo device IDs at the same path are considered
+/// separate filesystems (e.g., autofs trigger mounts like systemd-1 + binfmt_misc
+/// at /proc/sys/fs/binfmt_misc) and both should be shown.
+#[cfg(all(not(windows), any(target_os = "linux", target_os = "android")))]
+fn is_over_mounted(mounts: &[MountInfo], mount: &MountInfo) -> bool {
+    let last_mount_for_dir = mounts
+        .iter()
+        .rfind(|m| m.mount_dir == mount.mount_dir && m.mount_dev_id == mount.mount_dev_id);
+
+    if let Some(lmi) = last_mount_for_dir {
+        lmi.dev_name != mount.dev_name
+    } else {
+        // No mount with same dir AND same mount_dev_id found after this one,
+        // so it's not over-mounted
+        false
+    }
+}
+
+/// Check whether `mount` has been over-mounted (non-Linux platforms).
+#[cfg(all(not(windows), not(any(target_os = "linux", target_os = "android"))))]
 fn is_over_mounted(mounts: &[MountInfo], mount: &MountInfo) -> bool {
     let last_mount_for_dir = mounts.iter().rfind(|m| m.mount_dir == mount.mount_dir);
 
@@ -219,6 +240,8 @@ mod tests {
                 mount_root: OsString::default(),
                 remote: Default::default(),
                 dummy: Default::default(),
+                #[cfg(any(target_os = "linux", target_os = "android"))]
+                mount_dev_id: String::default(),
             }
         }
 
@@ -324,6 +347,27 @@ mod tests {
                 mount_root: OsString::default(),
                 remote: Default::default(),
                 dummy: Default::default(),
+                #[cfg(any(target_os = "linux", target_os = "android"))]
+                mount_dev_id: String::default(),
+            }
+        }
+
+        #[cfg(any(target_os = "linux", target_os = "android"))]
+        fn mount_info_full(
+            mount_dir: &str,
+            dev_name: Option<&str>,
+            mount_dev_id: Option<&str>,
+        ) -> MountInfo {
+            MountInfo {
+                dev_id: String::default(),
+                dev_name: dev_name.map(String::from).unwrap_or_default(),
+                fs_type: String::default(),
+                mount_dir: OsString::from(mount_dir),
+                mount_option: String::default(),
+                mount_root: OsString::default(),
+                remote: Default::default(),
+                dummy: Default::default(),
+                mount_dev_id: mount_dev_id.map(String::from).unwrap_or_default(),
             }
         }
 
@@ -355,5 +399,35 @@ mod tests {
                 FsError::OverMounted
             );
         }
+
+        /// Test for issue #9952: Two mounts at the same path with different device IDs
+        /// (like autofs + binfmt_misc at /proc/sys/fs/binfmt_misc) should NOT be
+        /// considered over-mounted. They are separate filesystems that happen to be
+        /// stacked at the same mount point.
+        #[test]
+        #[cfg(any(target_os = "linux", target_os = "android"))]
+        fn test_different_dev_ids_not_over_mounted() {
+            // Simulates: systemd-1 (autofs, dev 0:33) and binfmt_misc (dev 0:46)
+            // both at /proc/sys/fs/binfmt_misc
+            let mount_info1 =
+                mount_info_full("/proc/sys/fs/binfmt_misc", Some("systemd-1"), Some("0:33"));
+            let mount_info2 = mount_info_full(
+                "/proc/sys/fs/binfmt_misc",
+                Some("binfmt_misc"),
+                Some("0:46"),
+            );
+            let mounts = [mount_info1, mount_info2];
+
+            // With different device IDs, the first mount should NOT be over-mounted
+            assert!(
+                !is_over_mounted(&mounts, &mounts[0]),
+                "Mount with different dev_id should not be considered over-mounted"
+            );
+            // And neither should the second one
+            assert!(
+                !is_over_mounted(&mounts, &mounts[1]),
+                "Last mount at path should not be considered over-mounted"
+            );
+        }
     }
 }

src/uu/df/src/table.rs

@@ -950,6 +950,8 @@ mod tests {
                 mount_root: "/".into(),
                 remote: false,
                 dummy: false,
+                #[cfg(any(target_os = "linux", target_os = "android"))]
+                mount_dev_id: String::new(),
             },
             usage: crate::table::FsUsage {
                 blocksize: 4096,
@@ -981,6 +983,8 @@ mod tests {
                 mount_root: "/".into(),
                 remote: false,
                 dummy: false,
+                #[cfg(any(target_os = "linux", target_os = "android"))]
+                mount_dev_id: String::new(),
             },
             usage: crate::table::FsUsage {
                 blocksize: 4096,
@@ -1052,6 +1056,8 @@ mod tests {
                 mount_root: "/".into(),
                 remote: false,
                 dummy: false,
+                #[cfg(any(target_os = "linux", target_os = "android"))]
+                mount_dev_id: String::new(),
             },
             usage: crate::table::FsUsage {
                 blocksize: 4096,

src/uucore/src/lib/features/fsext.rs

@@ -5,7 +5,7 @@
 
 //! Set of functions to manage file systems
 
-// spell-checker:ignore DATETIME getmntinfo subsecond (fs) cifs smbfs
+// spell-checker:ignore DATETIME getmntinfo subsecond (fs) cifs smbfs autofs binfmt
 
 #[cfg(any(target_os = "linux", target_os = "android", target_os = "cygwin"))]
 const LINUX_MTAB: &str = "/etc/mtab";
@@ -189,6 +189,12 @@ pub struct MountInfo {
     pub mount_option: String,
     pub remote: bool,
     pub dummy: bool,
+    /// The device ID from mountinfo (major:minor format like "0:33").
+    /// This preserves the actual device ID from /proc/self/mountinfo,
+    /// which can differ from the stat-based dev_id for stacked mounts
+    /// (e.g., autofs + binfmt_misc at the same mount point).
+    #[cfg(any(target_os = "linux", target_os = "android"))]
+    pub mount_dev_id: String,
 }
 
 #[cfg(any(target_os = "linux", target_os = "android", target_os = "cygwin"))]
@@ -207,7 +213,70 @@ fn replace_special_chars(s: &[u8]) -> Vec<u8> {
 }
 
 impl MountInfo {
-    #[cfg(any(target_os = "linux", target_os = "android", target_os = "cygwin"))]
+    #[cfg(any(target_os = "linux", target_os = "android"))]
+    fn new(file_name: &str, raw: &[&[u8]]) -> Option<Self> {
+        use std::ffi::OsStr;
+        use std::os::unix::ffi::OsStrExt;
+        use std::os::unix::ffi::OsStringExt;
+
+        let dev_name;
+        let fs_type;
+        let mount_root;
+        let mount_dir;
+        let mount_option;
+        let mountinfo_dev_id;
+
+        match file_name {
+            // spell-checker:ignore (word) noatime
+            // Format: 36 35 98:0 /mnt1 /mnt2 rw,noatime master:1 - ext3 /dev/root rw,errors=continue
+            // "man proc" for more details
+            LINUX_MOUNTINFO => {
+                const FIELDS_OFFSET: usize = 6;
+                let after_fields = raw[FIELDS_OFFSET..]
+                    .iter()
+                    .position(|c| *c == b"-")
+                    .unwrap()
+                    + FIELDS_OFFSET
+                    + 1;
+                dev_name = String::from_utf8_lossy(raw[after_fields + 1]).to_string();
+                fs_type = String::from_utf8_lossy(raw[after_fields]).to_string();
+                mount_root = OsStr::from_bytes(raw[3]).to_owned();
+                mount_dir = OsString::from_vec(replace_special_chars(raw[4]));
+                mount_option = String::from_utf8_lossy(raw[5]).to_string();
+                // Store the device ID from mountinfo (major:minor format like "0:33")
+                // This is used to distinguish different filesystems at the same mount point
+                mountinfo_dev_id = String::from_utf8_lossy(raw[2]).to_string();
+            }
+            LINUX_MTAB => {
+                dev_name = String::from_utf8_lossy(raw[0]).to_string();
+                fs_type = String::from_utf8_lossy(raw[2]).to_string();
+                mount_root = OsString::new();
+                mount_dir = OsString::from_vec(replace_special_chars(raw[1]));
+                mount_option = String::from_utf8_lossy(raw[3]).to_string();
+                // mtab doesn't have the mountinfo device ID, use empty string
+                mountinfo_dev_id = String::new();
+            }
+            _ => return None,
+        }
+
+        let dev_id = mount_dev_id(&mount_dir);
+        let dummy = is_dummy_filesystem(&fs_type, &mount_option);
+        let remote = is_remote_filesystem(&dev_name, &fs_type);
+
+        Some(Self {
+            dev_id,
+            dev_name,
+            fs_type,
+            mount_root,
+            mount_dir,
+            mount_option,
+            remote,
+            dummy,
+            mount_dev_id: mountinfo_dev_id,
+        })
+    }
+
+    #[cfg(target_os = "cygwin")]
     fn new(file_name: &str, raw: &[&[u8]]) -> Option<Self> {
         use std::ffi::OsStr;
         use std::os::unix::ffi::OsStrExt;