pmap: implement --device

Author: cakebaker

src/uu/pmap/src/pmap.rs

@@ -4,7 +4,7 @@
 // file that was distributed with this source code.
 
 use clap::{crate_version, Arg, ArgAction, Command};
-use maps_format_parser::parse_map_line;
+use maps_format_parser::{parse_map_line, MapLine};
 use std::env;
 use std::fs;
 use std::io::Error;
@@ -49,11 +49,12 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             }
         }
 
-        match parse_maps(pid) {
-            Ok(total) => println!(" total {total:>16}K"),
-            Err(_) => {
-                set_exit_code(1);
-            }
+        if matches.get_flag(options::DEVICE) {
+            output_device_format(pid).map_err(|_| set_exit_code(1)).ok();
+        } else {
+            output_default_format(pid)
+                .map_err(|_| set_exit_code(1))
+                .ok();
         }
     }
 
@@ -74,21 +75,70 @@ fn parse_cmdline(pid: &str) -> Result<String, Error> {
     Ok(cmdline.into())
 }
 
-fn parse_maps(pid: &str) -> Result<u64, Error> {
+fn process_maps<F>(pid: &str, mut process_line: F) -> Result<(), Error>
+where
+    F: FnMut(&MapLine),
+{
     let path = format!("/proc/{pid}/maps");
     let contents = fs::read_to_string(path)?;
-    let mut total = 0;
 
     for line in contents.lines() {
         let map_line = parse_map_line(line)?;
+        process_line(&map_line);
+    }
+
+    Ok(())
+}
+
+fn output_default_format(pid: &str) -> Result<(), Error> {
+    let mut total = 0;
+
+    process_maps(pid, |map_line| {
         println!(
             "{} {:>6}K {} {}",
             map_line.address, map_line.size_in_kb, map_line.perms, map_line.mapping
         );
         total += map_line.size_in_kb;
-    }
+    })?;
+
+    println!(" total {total:>16}K");
+
+    Ok(())
+}
+
+fn output_device_format(pid: &str) -> Result<(), Error> {
+    let mut total_mapped = 0;
+    let mut total_writeable_private = 0;
+    let mut total_shared = 0;
+
+    println!("Address           Kbytes Mode  Offset           Device    Mapping");
+
+    process_maps(pid, |map_line| {
+        println!(
+            "{} {:>7} {} {} {} {}",
+            map_line.address,
+            map_line.size_in_kb,
+            map_line.perms,
+            map_line.offset,
+            map_line.device,
+            map_line.mapping
+        );
+        total_mapped += map_line.size_in_kb;
 
-    Ok(total)
+        if map_line.perms.writable && !map_line.perms.shared {
+            total_writeable_private += map_line.size_in_kb;
+        }
+
+        if map_line.perms.shared {
+            total_shared += map_line.size_in_kb;
+        }
+    })?;
+
+    println!(
+        "mapped: {total_mapped}K    writeable/private: {total_writeable_private}K    shared: {total_shared}K"
+    );
+
+    Ok(())
 }
 
 pub fn uu_app() -> Command {

tests/by-util/test_pmap.rs

@@ -73,6 +73,22 @@ fn test_non_existing_pid() {
         .no_output();
 }
 
+#[test]
+#[cfg(target_os = "linux")]
+fn test_device() {
+    let pid = process::id();
+
+    for arg in ["-d", "--device"] {
+        let result = new_ucmd!()
+            .arg(arg)
+            .arg(pid.to_string())
+            .succeeds()
+            .stdout_move_str();
+
+        assert_device_format(pid, &result);
+    }
+}
+
 #[test]
 fn test_invalid_arg() {
     new_ucmd!().arg("--definitely-invalid").fails().code_is(1);
@@ -94,9 +110,46 @@ fn assert_format(pid: u32, s: &str) {
 
     let rest = rest.trim_end();
     let (memory_map, last_line) = rest.rsplit_once('\n').unwrap();
-    let re = Regex::new("(?m)^[0-9a-f]{16} +[1-9][0-9]*K (-|r)(-|w)(-|x)(-|s)- (  $$[ (anon|stack) $$]|[a-zA-Z0-9._-]+)$").unwrap();
+    let re = Regex::new(r"(?m)^[0-9a-f]{16} +[1-9][0-9]*K (-|r)(-|w)(-|x)(-|s)- (  \[ (anon|stack) \]|[a-zA-Z0-9._-]+)$").unwrap();
     assert!(re.is_match(memory_map));
 
     let re = Regex::new("^ total +[1-9][0-9]*K$").unwrap();
     assert!(re.is_match(last_line));
 }
+
+// Ensure `s` has the following device format (--device):
+//
+// 1234:   /some/path
+// Address           Kbytes Mode  Offset           Device    Mapping
+// 000073eb5f4c7000       8 rw--- 0000000000036000 008:00008 ld-linux-x86-64.so.2
+// 00007ffd588fc000     132 rw--- 0000000000000000 000:00000   [ stack ]
+// ffffffffff600000       4 --x-- 0000000000000000 000:00000   [ anon ]
+// ...
+// mapped: 3060K    writeable/private: 348K    shared: 0K
+#[cfg(target_os = "linux")]
+fn assert_device_format(pid: u32, s: &str) {
+    let lines: Vec<_> = s.lines().collect();
+    let line_count = lines.len();
+
+    let re = Regex::new(&format!("^{pid}:   .+[^ ]$")).unwrap();
+    assert!(re.is_match(lines[0]));
+
+    let expected_header = "Address           Kbytes Mode  Offset           Device    Mapping";
+    assert_eq!(expected_header, lines[1]);
+
+    let re = Regex::new(
+        r"^[0-9a-f]{16} +[1-9][0-9]* (-|r)(-|w)(-|x)(-|s)- [0-9a-f]{16} [0-9a-f]{3}:[0-9a-f]{5} (  \[ (anon|stack) \]|[a-zA-Z0-9._-]+)$",
+    )
+    .unwrap();
+
+    for line in lines.iter().take(line_count - 1).skip(2) {
+        assert!(re.is_match(line), "failing line: {line}");
+    }
+
+    let re = Regex::new(r"^mapped: \d+K\s{4}writeable/private: \d+K\s{4}shared: \d+K$").unwrap();
+    assert!(
+        re.is_match(lines[line_count - 1]),
+        "failing line: {}",
+        lines[line_count - 1]
+    );
+}