Debian Codegraph @

third_party/rust/procfs-core/src/process/status.rs

raw
1 use crate::{FromStrRadix, ProcResult};
2 use std::collections::HashMap;
3 use std::io::BufRead;
4
5 #[cfg(feature = "serde1")]
6 use serde::{Deserialize, Serialize};
7
8 /// Status information about the process, based on the `/proc/<pid>/status` file.
9 ///
10 /// Not all fields are available in every kernel. These fields have `Option<T>` types.
11 /// In general, the current kernel version will tell you what fields you can expect, but this
12 /// isn't totally reliable, since some kernels might backport certain fields, or fields might
13 /// only be present if certain kernel configuration options are enabled. Be prepared to
14 /// handle `None` values.
15 ///
16 /// New fields to this struct may be added at any time (even without a major or minor semver bump).
17 #[derive(Debug, Clone)]
18 #[cfg_attr(feature = "serde1", derive(Serialize, Deserialize))]
19 #[non_exhaustive]
20 pub struct Status {
21 /// Command run by this process.
22 pub name: String,
23 /// Process umask, expressed in octal with a leading zero; see umask(2). (Since Linux 4.7.)
24 pub umask: Option<u32>,
25 /// Current state of the process.
26 pub state: String,
27 /// Thread group ID (i.e., Process ID).
28 pub tgid: i32,
29 /// NUMA group ID (0 if none; since Linux 3.13).
30 pub ngid: Option<i32>,
31 /// Thread ID (see gettid(2)).
32 pub pid: i32,
33 /// PID of parent process.
34 pub ppid: i32,
35 /// PID of process tracing this process (0 if not being traced).
36 pub tracerpid: i32,
37 /// Real UID.
38 pub ruid: u32,
39 /// Effective UID.
40 pub euid: u32,
41 /// Saved set UID.
42 pub suid: u32,
43 /// Filesystem UID.
44 pub fuid: u32,
45 /// Real GID.
46 pub rgid: u32,
47 /// Effective GID.
48 pub egid: u32,
49 /// Saved set GID.
50 pub sgid: u32,
51 /// Filesystem GID.
52 pub fgid: u32,
53 /// Number of file descriptor slots currently allocated.
54 pub fdsize: u32,
55 /// Supplementary group list.
56 pub groups: Vec<i32>,
57 /// Thread group ID (i.e., PID) in each of the PID
58 /// namespaces of which (pid)[struct.Status.html#structfield.pid] is a member. The leftmost entry
59 /// shows the value with respect to the PID namespace of the
60 /// reading process, followed by the value in successively
61 /// nested inner namespaces. (Since Linux 4.1.)
62 pub nstgid: Option<Vec<i32>>,
63 /// Thread ID in each of the PID namespaces of which
64 /// (pid)[struct.Status.html#structfield.pid] is a member. The fields are ordered as for NStgid.
65 /// (Since Linux 4.1.)
66 pub nspid: Option<Vec<i32>>,
67 /// Process group ID in each of the PID namespaces of
68 /// which (pid)[struct.Status.html#structfield.pid] is a member. The fields are ordered as for NStgid. (Since Linux 4.1.)
69 pub nspgid: Option<Vec<i32>>,
70 /// NSsid: descendant namespace session ID hierarchy Session ID
71 /// in each of the PID namespaces of which (pid)[struct.Status.html#structfield.pid] is a member.
72 /// The fields are ordered as for NStgid. (Since Linux 4.1.)
73 pub nssid: Option<Vec<i32>>,
74 /// Peak virtual memory size by kibibytes.
75 pub vmpeak: Option<u64>,
76 /// Virtual memory size by kibibytes.
77 pub vmsize: Option<u64>,
78 /// Locked memory size by kibibytes (see mlock(3)).
79 pub vmlck: Option<u64>,
80 /// Pinned memory size by kibibytes (since Linux 3.2). These are
81 /// pages that can't be moved because something needs to
82 /// directly access physical memory.
83 pub vmpin: Option<u64>,
84 /// Peak resident set size by kibibytes ("high water mark").
85 pub vmhwm: Option<u64>,
86 /// Resident set size by kibibytes. Note that the value here is the
87 /// sum of RssAnon, RssFile, and RssShmem.
88 pub vmrss: Option<u64>,
89 /// Size of resident anonymous memory by kibibytes. (since Linux 4.5).
90 pub rssanon: Option<u64>,
91 /// Size of resident file mappings by kibibytes. (since Linux 4.5).
92 pub rssfile: Option<u64>,
93 /// Size of resident shared memory by kibibytes (includes System V
94 /// shared memory, mappings from tmpfs(5), and shared anonymous
95 /// mappings). (since Linux 4.5).
96 pub rssshmem: Option<u64>,
97 /// Size of data by kibibytes.
98 pub vmdata: Option<u64>,
99 /// Size of stack by kibibytes.
100 pub vmstk: Option<u64>,
101 /// Size of text seg‐ments by kibibytes.
102 pub vmexe: Option<u64>,
103 /// Shared library code size by kibibytes.
104 pub vmlib: Option<u64>,
105 /// Page table entries size by kibibytes (since Linux 2.6.10).
106 pub vmpte: Option<u64>,
107 /// Swapped-out virtual memory size by anonymous private
108 /// pages by kibibytes; shmem swap usage is not included (since Linux 2.6.34).
109 pub vmswap: Option<u64>,
110 /// Size of hugetlb memory portions by kB. (since Linux 4.4).
111 pub hugetlbpages: Option<u64>,
112 /// Number of threads in process containing this thread.
113 pub threads: u64,
114 /// This field contains two slash-separated numbers that
115 /// relate to queued signals for the real user ID of this
116 /// process. The first of these is the number of currently
117 /// queued signals for this real user ID, and the second is the
118 /// resource limit on the number of queued signals for this
119 /// process (see the description of RLIMIT_SIGPENDING in
120 /// getrlimit(2)).
121 pub sigq: (u64, u64),
122 /// Number of signals pending for thread (see pthreads(7) and signal(7)).
123 pub sigpnd: u64,
124 /// Number of signals pending for process as a whole (see pthreads(7) and signal(7)).
125 pub shdpnd: u64,
126 /// Masks indicating signals being blocked (see signal(7)).
127 pub sigblk: u64,
128 /// Masks indicating signals being ignored (see signal(7)).
129 pub sigign: u64,
130 /// Masks indicating signals being caught (see signal(7)).
131 pub sigcgt: u64,
132 /// Masks of capabilities enabled in inheritable sets (see capabilities(7)).
133 pub capinh: u64,
134 /// Masks of capabilities enabled in permitted sets (see capabilities(7)).
135 pub capprm: u64,
136 /// Masks of capabilities enabled in effective sets (see capabilities(7)).
137 pub capeff: u64,
138 /// Capability Bounding set (since Linux 2.6.26, see capabilities(7)).
139 pub capbnd: Option<u64>,
140 /// Ambient capability set (since Linux 4.3, see capabilities(7)).
141 pub capamb: Option<u64>,
142 /// Value of the no_new_privs bit (since Linux 4.10, see prctl(2)).
143 pub nonewprivs: Option<u64>,
144 /// Seccomp mode of the process (since Linux 3.8, see
145 /// seccomp(2)). 0 means SECCOMP_MODE_DISABLED; 1 means SEC‐
146 /// COMP_MODE_STRICT; 2 means SECCOMP_MODE_FILTER. This field
147 /// is provided only if the kernel was built with the CON‐
148 /// FIG_SECCOMP kernel configuration option enabled.
149 pub seccomp: Option<u32>,
150 /// Speculative store bypass mitigation status.
151 pub speculation_store_bypass: Option<String>,
152 /// Mask of CPUs on which this process may run (since Linux 2.6.24, see cpuset(7)).
153 pub cpus_allowed: Option<Vec<u32>>,
154 /// Same as previous, but in "list format" (since Linux 2.6.26, see cpuset(7)).
155 pub cpus_allowed_list: Option<Vec<(u32, u32)>>,
156 /// Mask of memory nodes allowed to this process (since Linux 2.6.24, see cpuset(7)).
157 pub mems_allowed: Option<Vec<u32>>,
158 /// Same as previous, but in "list format" (since Linux 2.6.26, see cpuset(7)).
159 pub mems_allowed_list: Option<Vec<(u32, u32)>>,
160 /// Number of voluntary context switches (since Linux 2.6.23).
161 pub voluntary_ctxt_switches: Option<u64>,
162 /// Number of involuntary context switches (since Linux 2.6.23).
163 pub nonvoluntary_ctxt_switches: Option<u64>,
164
165 /// Contains true if the process is currently dumping core.
166 ///
167 /// This information can be used by a monitoring process to avoid killing a processing that is
168 /// currently dumping core, which could result in a corrupted core dump file.
169 ///
170 /// (Since Linux 4.15)
171 pub core_dumping: Option<bool>,
172
173 /// Contains true if the process is allowed to use THP
174 ///
175 /// (Since Linux 5.0)
176 pub thp_enabled: Option<bool>,
177 }
178
179 impl crate::FromBufRead for Status {
180 fn from_buf_read<R: BufRead>(reader: R) -> ProcResult<Self> {
181 let mut map = HashMap::new();
182
183 for line in reader.lines() {
184 let line = line?;
185 if line.is_empty() {
186 continue;
187 }
188 let mut s = line.split(':');
189 let field = expect!(s.next());
190 let value = expect!(s.next()).trim();
191
192 map.insert(field.to_string(), value.to_string());
193 }
194
195 let status = Status {
196 name: expect!(map.remove("Name")),
197 umask: map.remove("Umask").map(|x| Ok(from_str!(u32, &x, 8))).transpose()?,
198 state: expect!(map.remove("State")),
199 tgid: from_str!(i32, &expect!(map.remove("Tgid"))),
200 ngid: map.remove("Ngid").map(|x| Ok(from_str!(i32, &x))).transpose()?,
201 pid: from_str!(i32, &expect!(map.remove("Pid"))),
202 ppid: from_str!(i32, &expect!(map.remove("PPid"))),
203 tracerpid: from_str!(i32, &expect!(map.remove("TracerPid"))),
204 ruid: expect!(Status::parse_uid_gid(expect!(map.get("Uid")), 0)),
205 euid: expect!(Status::parse_uid_gid(expect!(map.get("Uid")), 1)),
206 suid: expect!(Status::parse_uid_gid(expect!(map.get("Uid")), 2)),
207 fuid: expect!(Status::parse_uid_gid(&expect!(map.remove("Uid")), 3)),
208 rgid: expect!(Status::parse_uid_gid(expect!(map.get("Gid")), 0)),
209 egid: expect!(Status::parse_uid_gid(expect!(map.get("Gid")), 1)),
210 sgid: expect!(Status::parse_uid_gid(expect!(map.get("Gid")), 2)),
211 fgid: expect!(Status::parse_uid_gid(&expect!(map.remove("Gid")), 3)),
212 fdsize: from_str!(u32, &expect!(map.remove("FDSize"))),
213 groups: Status::parse_list(&expect!(map.remove("Groups")))?,
214 nstgid: map.remove("NStgid").map(|x| Status::parse_list(&x)).transpose()?,
215 nspid: map.remove("NSpid").map(|x| Status::parse_list(&x)).transpose()?,
216 nspgid: map.remove("NSpgid").map(|x| Status::parse_list(&x)).transpose()?,
217 nssid: map.remove("NSsid").map(|x| Status::parse_list(&x)).transpose()?,
218 vmpeak: Status::parse_with_kb(map.remove("VmPeak"))?,
219 vmsize: Status::parse_with_kb(map.remove("VmSize"))?,
220 vmlck: Status::parse_with_kb(map.remove("VmLck"))?,
221 vmpin: Status::parse_with_kb(map.remove("VmPin"))?,
222 vmhwm: Status::parse_with_kb(map.remove("VmHWM"))?,
223 vmrss: Status::parse_with_kb(map.remove("VmRSS"))?,
224 rssanon: Status::parse_with_kb(map.remove("RssAnon"))?,
225 rssfile: Status::parse_with_kb(map.remove("RssFile"))?,
226 rssshmem: Status::parse_with_kb(map.remove("RssShmem"))?,
227 vmdata: Status::parse_with_kb(map.remove("VmData"))?,
228 vmstk: Status::parse_with_kb(map.remove("VmStk"))?,
229 vmexe: Status::parse_with_kb(map.remove("VmExe"))?,
230 vmlib: Status::parse_with_kb(map.remove("VmLib"))?,
231 vmpte: Status::parse_with_kb(map.remove("VmPTE"))?,
232 vmswap: Status::parse_with_kb(map.remove("VmSwap"))?,
233 hugetlbpages: Status::parse_with_kb(map.remove("HugetlbPages"))?,
234 threads: from_str!(u64, &expect!(map.remove("Threads"))),
235 sigq: expect!(Status::parse_sigq(&expect!(map.remove("SigQ")))),
236 sigpnd: from_str!(u64, &expect!(map.remove("SigPnd")), 16),
237 shdpnd: from_str!(u64, &expect!(map.remove("ShdPnd")), 16),
238 sigblk: from_str!(u64, &expect!(map.remove("SigBlk")), 16),
239 sigign: from_str!(u64, &expect!(map.remove("SigIgn")), 16),
240 sigcgt: from_str!(u64, &expect!(map.remove("SigCgt")), 16),
241 capinh: from_str!(u64, &expect!(map.remove("CapInh")), 16),
242 capprm: from_str!(u64, &expect!(map.remove("CapPrm")), 16),
243 capeff: from_str!(u64, &expect!(map.remove("CapEff")), 16),
244 capbnd: map.remove("CapBnd").map(|x| Ok(from_str!(u64, &x, 16))).transpose()?,
245 capamb: map.remove("CapAmb").map(|x| Ok(from_str!(u64, &x, 16))).transpose()?,
246 nonewprivs: map.remove("NoNewPrivs").map(|x| Ok(from_str!(u64, &x))).transpose()?,
247 seccomp: map.remove("Seccomp").map(|x| Ok(from_str!(u32, &x))).transpose()?,
248 speculation_store_bypass: map.remove("Speculation_Store_Bypass"),
249 cpus_allowed: map
250 .remove("Cpus_allowed")
251 .map(|x| Status::parse_allowed(&x))
252 .transpose()?,
253 cpus_allowed_list: map
254 .remove("Cpus_allowed_list")
255 .and_then(|x| Status::parse_allowed_list(&x).ok()),
256 mems_allowed: map
257 .remove("Mems_allowed")
258 .map(|x| Status::parse_allowed(&x))
259 .transpose()?,
260 mems_allowed_list: map
261 .remove("Mems_allowed_list")
262 .and_then(|x| Status::parse_allowed_list(&x).ok()),
263 voluntary_ctxt_switches: map
264 .remove("voluntary_ctxt_switches")
265 .map(|x| Ok(from_str!(u64, &x)))
266 .transpose()?,
267 nonvoluntary_ctxt_switches: map
268 .remove("nonvoluntary_ctxt_switches")
269 .map(|x| Ok(from_str!(u64, &x)))
270 .transpose()?,
271 core_dumping: map.remove("CoreDumping").map(|x| x == "1"),
272 thp_enabled: map.remove("THP_enabled").map(|x| x == "1"),
273 };
274
275 if cfg!(test) && !map.is_empty() {
276 // This isn't an error because different kernels may put different data here, and distros
277 // may backport these changes into older kernels. Too hard to keep track of
278 eprintln!("Warning: status map is not empty: {:#?}", map);
279 }
280
281 Ok(status)
282 }
283 }
284
285 impl Status {
286 fn parse_with_kb<T: FromStrRadix>(s: Option<String>) -> ProcResult<Option<T>> {
287 if let Some(s) = s {
288 Ok(Some(from_str!(T, &s.replace(" kB", ""))))
289 } else {
290 Ok(None)
291 }
292 }
293
294 #[doc(hidden)]
295 pub fn parse_uid_gid(s: &str, i: usize) -> ProcResult<u32> {
296 Ok(from_str!(u32, expect!(s.split_whitespace().nth(i))))
297 }
298
299 fn parse_sigq(s: &str) -> ProcResult<(u64, u64)> {
300 let mut iter = s.split('/');
301 let first = from_str!(u64, expect!(iter.next()));
302 let second = from_str!(u64, expect!(iter.next()));
303 Ok((first, second))
304 }
305
306 fn parse_list<T: FromStrRadix>(s: &str) -> ProcResult<Vec<T>> {
307 let mut ret = Vec::new();
308 for i in s.split_whitespace() {
309 ret.push(from_str!(T, i));
310 }
311 Ok(ret)
312 }
313
314 fn parse_allowed(s: &str) -> ProcResult<Vec<u32>> {
315 let mut ret = Vec::new();
316 for i in s.split(',') {
317 ret.push(from_str!(u32, i, 16));
318 }
319 Ok(ret)
320 }
321
322 fn parse_allowed_list(s: &str) -> ProcResult<Vec<(u32, u32)>> {
323 let mut ret = Vec::new();
324 for s in s.split(',') {
325 if s.contains('-') {
326 let mut s = s.split('-');
327 let beg = from_str!(u32, expect!(s.next()));
328 if let Some(x) = s.next() {
329 let end = from_str!(u32, x);
330 ret.push((beg, end));
331 }
332 } else {
333 let beg = from_str!(u32, s);
334 let end = from_str!(u32, s);
335 ret.push((beg, end));
336 }
337 }
338 Ok(ret)
339 }
340 }