Skip to main content

mtop/
procfs.rs

1//! /proc access is delegated to the `procfs` crate (typed, maintained, MIT).
2//! This module only maps its output onto the two-tier cost model:
3//!   statm        -> cheap RSS sweep, no page-table walk
4//!   smaps_rollup -> exact Rss/Pss/USS, walks the page table
5//!   smaps        -> per-VMA breakdown, grouped for display
6
7use std::collections::HashMap;
8
9use procfs::process::{MMapPath, Process, all_processes};
10use procfs::{Current, Meminfo};
11
12/// Memory page size, in bytes.
13pub fn page_size() -> u64 {
14    procfs::page_size()
15}
16
17pub fn list_pids() -> Vec<u32> {
18    let mut v: Vec<u32> = all_processes()
19        .map(|iter| {
20            iter.filter_map(|p| p.ok())
21                .filter_map(|p| u32::try_from(p.pid()).ok())
22                .collect()
23        })
24        .unwrap_or_default();
25    v.sort_unstable();
26    v
27}
28
29pub fn read_comm(pid: u32) -> Option<String> {
30    // Deliberately not Process::stat(): that parses ~50 numeric fields per pid
31    // and measured 4x slower for the whole-system sweep. comm is one string.
32    let s = std::fs::read_to_string(format!("/proc/{pid}/comm")).ok()?;
33    let s = s.trim_end_matches('\n');
34    (!s.is_empty()).then(|| s.replace('\n', " "))
35}
36
37/// Resident set in kB from statm. Reads mm counters, no page-table walk.
38///
39/// Read directly rather than via `Process::statm()`: `Process::new` issues an
40/// extra openat(O_PATH) per pid and allocated ~3x the sweep time (43 ms vs
41/// 15 ms for 465 pids). This is one integer from one line, not a format.
42pub fn read_rss(pid: u32, page_kb: u64) -> Option<u64> {
43    let s = std::fs::read_to_string(format!("/proc/{pid}/statm")).ok()?;
44    let pages: u64 = s.split_whitespace().nth(1)?.parse().ok()?;
45    Some(pages * page_kb)
46}
47
48#[derive(Default, Clone, Copy, Debug)]
49pub struct Rollup {
50    pub rss_kb: u64,
51    pub pss_kb: u64,
52    /// Private_Clean + Private_Dirty: memory only this process pays for.
53    pub uss_kb: u64,
54    pub swap_kb: u64,
55    /// Anonymous (heap/stack/malloc) resident.
56    pub anon_kb: u64,
57    /// PSS split: these three sum to `pss_kb`.
58    pub pss_anon_kb: u64,
59    pub pss_file_kb: u64,
60    pub pss_shmem_kb: u64,
61    /// Swap accounted with PSS weighting (more accurate than Swap for shared pages).
62    pub swap_pss_kb: u64,
63    /// Transparent huge pages holding anonymous memory.
64    pub thp_kb: u64,
65    /// Pages merged by KSM: memory that exists but is shared away.
66    pub ksm_kb: u64,
67}
68
69/// smaps field values are in bytes.
70fn bytes(map: &HashMap<String, u64>, key: &str) -> u64 {
71    map.get(key).copied().unwrap_or(0)
72}
73
74const KB: u64 = 1024;
75
76/// Why a process has no PSS. The distinction matters: `Denied` becomes readable
77/// under sudo, `NoMemoryMap` (kernel threads) never does.
78#[derive(Debug, Clone, Copy, PartialEq, Eq)]
79pub enum RollupError {
80    /// EACCES: needs CAP_SYS_PTRACE, i.e. run as root.
81    Denied,
82    /// The process has no address space (kernel thread) or is already gone.
83    NoMemoryMap,
84    Other,
85}
86
87fn classify(err: &procfs::ProcError) -> RollupError {
88    use procfs::ProcError as E;
89    match err {
90        E::PermissionDenied(_) => RollupError::Denied,
91        E::NotFound(_) => RollupError::NoMemoryMap,
92        _ => RollupError::Other,
93    }
94}
95
96/// Exact Rss/Pss/USS. Walks the page table: ~1.5 ms average, up to ~19 ms for
97/// a 520 MB browser process.
98pub fn read_rollup(pid: u32) -> Result<Rollup, RollupError> {
99    let p = Process::new(pid as i32).map_err(|e| classify(&e))?;
100    let maps = p.smaps_rollup().map_err(|e| classify(&e))?;
101    let map = &maps
102        .memory_map_rollup
103        .0
104        .first()
105        .ok_or(RollupError::NoMemoryMap)?
106        .extension
107        .map;
108    Ok(Rollup {
109        rss_kb: bytes(map, "Rss") / KB,
110        pss_kb: bytes(map, "Pss") / KB,
111        uss_kb: (bytes(map, "Private_Clean") + bytes(map, "Private_Dirty")) / KB,
112        swap_kb: bytes(map, "Swap") / KB,
113        anon_kb: bytes(map, "Anonymous") / KB,
114        pss_anon_kb: bytes(map, "Pss_Anon") / KB,
115        pss_file_kb: bytes(map, "Pss_File") / KB,
116        pss_shmem_kb: bytes(map, "Pss_Shmem") / KB,
117        swap_pss_kb: bytes(map, "SwapPss") / KB,
118        thp_kb: bytes(map, "AnonHugePages") / KB,
119        ksm_kb: bytes(map, "KSM") / KB,
120    })
121}
122
123/// One virtual memory area, as listed under a group in the detail view.
124#[derive(Clone, Debug)]
125pub struct Vma {
126    pub start: u64,
127    pub end: u64,
128    /// "rwxp"-style: read/write/execute plus private or shared.
129    pub perms: String,
130    pub size_kb: u64,
131    pub pss_kb: u64,
132    pub uss_kb: u64,
133    pub anon_kb: u64,
134    pub swap_kb: u64,
135}
136
137#[derive(Clone, Debug)]
138pub struct VmaGroup {
139    pub label: String,
140    pub size_kb: u64,
141    pub pss_kb: u64,
142    pub uss_kb: u64,
143    pub anon_kb: u64,
144    pub swap_kb: u64,
145    pub count: u32,
146    /// Individual areas, sorted by PSS descending (filled when expanded).
147    pub vmas: Vec<Vma>,
148}
149
150fn perms_string(perms: procfs::process::MMPermissions) -> String {
151    use procfs::process::MMPermissions as P;
152    let mut s = String::with_capacity(4);
153    s.push(if perms.contains(P::READ) { 'r' } else { '-' });
154    s.push(if perms.contains(P::WRITE) { 'w' } else { '-' });
155    s.push(if perms.contains(P::EXECUTE) { 'x' } else { '-' });
156    s.push(if perms.contains(P::SHARED) { 's' } else { 'p' });
157    s
158}
159
160#[derive(Default, Clone, Debug)]
161pub struct SmapsReport {
162    pub groups: Vec<VmaGroup>,
163    pub vma_count: u32,
164    pub rss_kb: u64,
165    pub pss_kb: u64,
166    pub uss_kb: u64,
167    pub swap_kb: u64,
168    pub anon_kb: u64,
169    // NOTE: Pss_Anon / Pss_File / Pss_Shmem are only emitted by smaps_rollup,
170    // not by smaps; the per-kind split therefore comes from Rollup, never from
171    // summing per-VMA fields (which are simply absent and would read as 0).
172    pub swap_pss_kb: u64,
173    pub thp_kb: u64,
174    pub ksm_kb: u64,
175}
176
177fn label(path: &MMapPath) -> String {
178    match path {
179        MMapPath::Path(path) => path.display().to_string(),
180        MMapPath::Heap => "[heap]".into(),
181        MMapPath::Stack => "[stack]".into(),
182        MMapPath::TStack(tid) => format!("[stack:{tid}]"),
183        MMapPath::Vdso => "[vdso]".into(),
184        MMapPath::Vvar => "[vvar]".into(),
185        MMapPath::Vsyscall => "[vsyscall]".into(),
186        MMapPath::Rollup => "[rollup]".into(),
187        MMapPath::Anonymous => "[anon]".into(),
188        MMapPath::Vsys(key) => format!("[vsys:{key}]"),
189        MMapPath::Other(other) => other.clone(),
190    }
191}
192
193/// Full per-VMA walk grouped by mapping name. ~30-40 ms on a large process, so
194/// only ever called on demand for the focused pid.
195pub fn read_smaps(pid: u32) -> Result<SmapsReport, procfs::ProcError> {
196    let p = Process::new(pid as i32)?;
197    let maps = p.smaps()?;
198    let mut report = SmapsReport::default();
199    let mut groups: Vec<VmaGroup> = Vec::with_capacity(64);
200    let mut idx: HashMap<String, usize> = HashMap::with_capacity(64);
201
202    for m in maps.0 {
203        let map = &m.extension.map;
204        report.vma_count += 1;
205        report.rss_kb += bytes(map, "Rss") / KB;
206        report.pss_kb += bytes(map, "Pss") / KB;
207        report.uss_kb += (bytes(map, "Private_Clean") + bytes(map, "Private_Dirty")) / KB;
208        report.swap_kb += bytes(map, "Swap") / KB;
209        report.anon_kb += bytes(map, "Anonymous") / KB;
210        report.swap_pss_kb += bytes(map, "SwapPss") / KB;
211        report.thp_kb += bytes(map, "AnonHugePages") / KB;
212        report.ksm_kb += bytes(map, "KSM") / KB;
213
214        let key = label(&m.pathname);
215        let pss_kb = bytes(map, "Pss") / KB;
216        let uss_kb = (bytes(map, "Private_Clean") + bytes(map, "Private_Dirty")) / KB;
217        let size_kb = bytes(map, "Size") / KB;
218        let anon_kb = bytes(map, "Anonymous") / KB;
219        let swap_kb = bytes(map, "Swap") / KB;
220        let vma = Vma {
221            start: m.address.0,
222            end: m.address.1,
223            perms: perms_string(m.perms),
224            size_kb,
225            pss_kb,
226            uss_kb,
227            anon_kb,
228            swap_kb,
229        };
230        match idx.get(&key) {
231            Some(&i) => {
232                let g = &mut groups[i];
233                g.size_kb += size_kb;
234                g.pss_kb += pss_kb;
235                g.uss_kb += uss_kb;
236                g.anon_kb += anon_kb;
237                g.swap_kb += swap_kb;
238                g.count += 1;
239                g.vmas.push(vma);
240            }
241            None => {
242                idx.insert(key.clone(), groups.len());
243                groups.push(VmaGroup {
244                    label: key,
245                    size_kb,
246                    pss_kb,
247                    uss_kb,
248                    anon_kb,
249                    swap_kb,
250                    count: 1,
251                    vmas: vec![vma],
252                });
253            }
254        }
255    }
256
257    groups.sort_by_key(|g| std::cmp::Reverse(g.pss_kb));
258    for g in &mut groups {
259        g.vmas.sort_by_key(|v| std::cmp::Reverse(v.pss_kb));
260    }
261    report.groups = groups;
262    Ok(report)
263}
264
265/// pid -> /proc/<pid>/exe. ~450 readlinks cost a few ms, so this runs on the
266/// slow (5 s) cadence next to the cgroup map, never in the 1 Hz sweep.
267pub fn pid_exe() -> HashMap<u32, String> {
268    let mut out = HashMap::new();
269    let Ok(entries) = std::fs::read_dir("/proc") else {
270        return out;
271    };
272    for entry in entries.flatten() {
273        let Some(pid) = entry
274            .file_name()
275            .to_str()
276            .and_then(|s| s.parse::<u32>().ok())
277        else {
278            continue;
279        };
280        if let Ok(path) = std::fs::read_link(format!("/proc/{pid}/exe"))
281            && let Some(text) = path.to_str()
282        {
283            out.insert(pid, text.to_string());
284        }
285    }
286    out
287}
288
289pub fn read_cmdline(pid: u32) -> String {
290    Process::new(pid as i32)
291        .and_then(|p| p.cmdline())
292        .map(|args| args.join(" "))
293        .unwrap_or_default()
294}
295
296#[derive(Default, Clone, Debug)]
297pub struct MemInfo {
298    pub total_kb: u64,
299    pub avail_kb: u64,
300    pub cached_kb: u64,
301    pub swap_total_kb: u64,
302    pub swap_free_kb: u64,
303}
304
305pub fn read_meminfo() -> MemInfo {
306    let Ok(m) = Meminfo::current() else {
307        return MemInfo::default();
308    };
309    // procfs::Meminfo normalizes /proc/meminfo to bytes; the UI works in kB.
310    MemInfo {
311        total_kb: m.mem_total / KB,
312        avail_kb: m.mem_available.unwrap_or(m.mem_free) / KB,
313        cached_kb: m.cached / KB,
314        swap_total_kb: m.swap_total / KB,
315        swap_free_kb: m.swap_free / KB,
316    }
317}
318
319/// Pressure Stall Information, as percentages of wall-clock time.
320#[derive(Default, Clone, Copy, Debug)]
321pub struct Pressure {
322    /// "some": at least one task stalled on memory.
323    pub some10: f32,
324    /// "full": every non-idle task stalled.
325    pub full10: f32,
326}
327
328/// Format: `some avg10=0.00 avg60=0.00 avg300=0.00 total=83528484`.
329pub fn parse_pressure(text: &str) -> Pressure {
330    let mut p = Pressure::default();
331    for line in text.lines() {
332        let Some((kind, rest)) = line.split_once(' ') else {
333            continue;
334        };
335        let avg10 = rest
336            .split_whitespace()
337            .find_map(|f| f.strip_prefix("avg10="))
338            .and_then(|v| v.parse::<f32>().ok())
339            .unwrap_or(0.0);
340        match kind {
341            "some" => p.some10 = avg10,
342            "full" => p.full10 = avg10,
343            _ => {}
344        }
345    }
346    p
347}
348
349/// System-wide memory pressure. One small file, so it can be read every tick.
350pub fn read_pressure() -> Pressure {
351    std::fs::read_to_string("/proc/pressure/memory")
352        .map(|t| parse_pressure(&t))
353        .unwrap_or_default()
354}
355
356pub fn fmt_kb(kb: u64) -> String {
357    let mb = kb as f64 / 1024.0;
358    if mb >= 1024.0 {
359        format!("{:.2}G", mb / 1024.0)
360    } else if mb >= 10.0 {
361        format!("{mb:.0}M")
362    } else {
363        format!("{mb:.1}M")
364    }
365}