1use std::collections::HashMap;
8
9use procfs::process::{MMapPath, Process, all_processes};
10use procfs::{Current, Meminfo};
11
12pub 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 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
37pub 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 pub uss_kb: u64,
54 pub swap_kb: u64,
55 pub anon_kb: u64,
57 pub pss_anon_kb: u64,
59 pub pss_file_kb: u64,
60 pub pss_shmem_kb: u64,
61 pub swap_pss_kb: u64,
63 pub thp_kb: u64,
65 pub ksm_kb: u64,
67}
68
69fn bytes(map: &HashMap<String, u64>, key: &str) -> u64 {
71 map.get(key).copied().unwrap_or(0)
72}
73
74const KB: u64 = 1024;
75
76#[derive(Debug, Clone, Copy, PartialEq, Eq)]
79pub enum RollupError {
80 Denied,
82 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
96pub 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#[derive(Clone, Debug)]
125pub struct Vma {
126 pub start: u64,
127 pub end: u64,
128 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 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 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
193pub 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
265pub 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 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#[derive(Default, Clone, Copy, Debug)]
321pub struct Pressure {
322 pub some10: f32,
324 pub full10: f32,
326}
327
328pub 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
349pub 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}