pmap: implement --extended (#368)

* add inode in MapLine

inode information is used by extended options

* pmap: implement extended option

* formatted files

* updated test_pmap.rs

* fixed lint errors

* fixed missing fields and typo

* fixed parse_smap_entries algorithm
removed a redundant field

* pmap: fixed `parse_smap_entries` algorithm
to improve its endurance against platform variations

* pmap: fixed typo

* Update src/uu/pmap/src/smaps_format_parser.rs

Incorporate the suggested change

Co-authored-by: Daniel Hofstetter <[email protected]>

---------

Co-authored-by: Daniel Hofstetter <[email protected]>

Author: estodi

src/uu/pmap/src/maps_format_parser.rs

@@ -6,20 +6,20 @@
 use std::fmt;
 use std::io::{Error, ErrorKind};
 
-// Represents a parsed single line from /proc/<PID>/maps for the default and device formats. It
-// omits the inode information because it's not used by those formats.
-#[derive(Debug, PartialEq)]
+// Represents a parsed single line from /proc/<PID>/maps.
+#[derive(Debug, Clone, Default, PartialEq)]
 pub struct MapLine {
     pub address: String,
     pub size_in_kb: u64,
     pub perms: Perms,
     pub offset: String,
     pub device: String,
+    pub inode: u64,
     pub mapping: String,
 }
 
 // Represents a set of permissions from the "perms" column of /proc/<PID>/maps.
-#[derive(Clone, Copy, Debug, PartialEq)]
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
 pub struct Perms {
     pub readable: bool,
     pub writable: bool,
@@ -84,8 +84,12 @@ pub fn parse_map_line(line: &str) -> Result<MapLine, Error> {
         .ok_or_else(|| Error::from(ErrorKind::InvalidData))?;
     let device = parse_device(device)?;
 
-    // skip the "inode" column
-    let mapping: String = rest.splitn(2, ' ').skip(1).collect();
+    let (inode, mapping) = rest
+        .split_once(' ')
+        .ok_or_else(|| Error::from(ErrorKind::InvalidData))?;
+    let inode = inode
+        .parse::<u64>()
+        .map_err(|_| Error::from(ErrorKind::InvalidData))?;
     let mapping = mapping.trim_ascii_start();
     let mapping = parse_mapping(mapping);
 
@@ -95,6 +99,7 @@ pub fn parse_map_line(line: &str) -> Result<MapLine, Error> {
         perms,
         offset,
         device,
+        inode,
         mapping,
     })
 }
@@ -146,6 +151,7 @@ mod test {
         perms: Perms,
         offset: &str,
         device: &str,
+        inode: u64,
         mapping: &str,
     ) -> MapLine {
         MapLine {
@@ -154,6 +160,7 @@ mod test {
             perms,
             offset: offset.to_string(),
             device: device.to_string(),
+            inode,
             mapping: mapping.to_string(),
         }
     }
@@ -169,31 +176,31 @@ mod test {
     fn test_parse_map_line() {
         let data = [
             (
-                create_map_line("000062442eb9e000", 16, Perms::from("r--p"), "0000000000000000", "008:00008", "konsole"),
+                create_map_line("000062442eb9e000", 16, Perms::from("r--p"), "0000000000000000", "008:00008", 10813151, "konsole"),
                 "62442eb9e000-62442eba2000 r--p 00000000 08:08 10813151                   /usr/bin/konsole"
             ),
             (
-                create_map_line("000071af50000000", 132, Perms::from("rw-p"), "0000000000000000", "000:00000", "  [ anon ]"),
+                create_map_line("000071af50000000", 132, Perms::from("rw-p"), "0000000000000000", "000:00000", 0, "  [ anon ]"),
                 "71af50000000-71af50021000 rw-p 00000000 00:00 0 "
             ),
             (
-                create_map_line("00007ffc3f8df000", 132, Perms::from("rw-p"), "0000000000000000", "000:00000", "  [ stack ]"),
+                create_map_line("00007ffc3f8df000", 132, Perms::from("rw-p"), "0000000000000000", "000:00000", 0, "  [ stack ]"),
                 "7ffc3f8df000-7ffc3f900000 rw-p 00000000 00:00 0                          [stack]"
             ),
             (
-                create_map_line("000071af8c9e6000", 16, Perms::from("rw-s"), "0000000105830000", "000:00010", "  [ anon ]"),
+                create_map_line("000071af8c9e6000", 16, Perms::from("rw-s"), "0000000105830000", "000:00010", 1075, "  [ anon ]"),
                 "71af8c9e6000-71af8c9ea000 rw-s 105830000 00:10 1075                      anon_inode:i915.gem"
             ),
             (
-                create_map_line("000071af6cf0c000", 3560, Perms::from("rw-s"), "0000000000000000", "000:00001", "memfd:wayland-shm (deleted)"),
+                create_map_line("000071af6cf0c000", 3560, Perms::from("rw-s"), "0000000000000000", "000:00001", 256481, "memfd:wayland-shm (deleted)"),
                 "71af6cf0c000-71af6d286000 rw-s 00000000 00:01 256481                     /memfd:wayland-shm (deleted)"
             ),
             (
-                create_map_line("ffffffffff600000", 4, Perms::from("--xp"), "0000000000000000", "000:00000", "  [ anon ]"),
+                create_map_line("ffffffffff600000", 4, Perms::from("--xp"), "0000000000000000", "000:00000", 0, "  [ anon ]"),
                 "ffffffffff600000-ffffffffff601000 --xp 00000000 00:00 0                  [vsyscall]"
             ),
             (
-                create_map_line("00005e8187da8000", 24, Perms::from("r--p"), "0000000000000000", "008:00008", "hello   world"),
+                create_map_line("00005e8187da8000", 24, Perms::from("r--p"), "0000000000000000", "008:00008", 9524160, "hello   world"),
                 "5e8187da8000-5e8187dae000 r--p 00000000 08:08 9524160                    /usr/bin/hello   world"
             ),
         ];

src/uu/pmap/src/pmap.rs

@@ -5,13 +5,15 @@
 
 use clap::{crate_version, Arg, ArgAction, Command};
 use maps_format_parser::{parse_map_line, MapLine};
+use smaps_format_parser::{parse_smap_entries, SmapEntry};
 use std::env;
 use std::fs;
 use std::io::Error;
 use uucore::error::{set_exit_code, UResult};
 use uucore::{format_usage, help_about, help_usage};
 
 mod maps_format_parser;
+mod smaps_format_parser;
 
 const ABOUT: &str = help_about!("pmap.md");
 const USAGE: &str = help_usage!("pmap.md");
@@ -49,7 +51,11 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> {
             }
         }
 
-        if matches.get_flag(options::DEVICE) {
+        if matches.get_flag(options::EXTENDED) {
+            output_extended_format(pid)
+                .map_err(|_| set_exit_code(1))
+                .ok();
+        } else if matches.get_flag(options::DEVICE) {
             output_device_format(pid).map_err(|_| set_exit_code(1)).ok();
         } else {
             output_default_format(pid)
@@ -90,6 +96,21 @@ where
     Ok(())
 }
 
+fn process_smaps<F>(pid: &str, mut process_entry: F) -> Result<(), Error>
+where
+    F: FnMut(&SmapEntry),
+{
+    let path = format!("/proc/{pid}/smaps");
+    let contents = fs::read_to_string(path)?;
+    let smap_entries = parse_smap_entries(&contents)?;
+
+    for entry in smap_entries {
+        process_entry(&entry);
+    }
+
+    Ok(())
+}
+
 fn output_default_format(pid: &str) -> Result<(), Error> {
     let mut total = 0;
 
@@ -106,6 +127,34 @@ fn output_default_format(pid: &str) -> Result<(), Error> {
     Ok(())
 }
 
+fn output_extended_format(pid: &str) -> Result<(), Error> {
+    let mut total_mapped = 0;
+    let mut total_rss = 0;
+    let mut total_dirty = 0;
+
+    println!("Address           Kbytes     RSS   Dirty Mode  Mapping");
+
+    process_smaps(pid, |smap_entry| {
+        println!(
+            "{} {:>7} {:>7} {:>7} {} {}",
+            smap_entry.map_line.address,
+            smap_entry.map_line.size_in_kb,
+            smap_entry.rss_in_kb,
+            smap_entry.shared_dirty_in_kb + smap_entry.private_dirty_in_kb,
+            smap_entry.map_line.perms,
+            smap_entry.map_line.mapping
+        );
+        total_mapped += smap_entry.map_line.size_in_kb;
+        total_rss += smap_entry.rss_in_kb;
+        total_dirty += smap_entry.shared_dirty_in_kb + smap_entry.private_dirty_in_kb;
+    })?;
+
+    println!("---------------- ------- ------- ------- ");
+    println!("total kB         {total_mapped:>7} {total_rss:>7} {total_dirty:>7}");
+
+    Ok(())
+}
+
 fn output_device_format(pid: &str) -> Result<(), Error> {
     let mut total_mapped = 0;
     let mut total_writeable_private = 0;