running-process-platform-internal 4.10.11

Blessed platform process operations for running-process (implementation detail)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60


    //! Linux `/proc/<pid>/cmdline` implementation. The kernel writes argv as
    //! NUL-separated opaque bytes, with a trailing NUL.

    use std::os::unix::ffi::OsStringExt;

    /// Return the process argv without flattening its argument boundaries.
    pub fn read_process_argv(pid: u32) -> std::io::Result<Vec<std::ffi::OsString>> {
        if pid == 0 {
            return Err(std::io::Error::new(
                std::io::ErrorKind::InvalidInput,
                "pid 0 is the kernel scheduler — not queryable",
            ));
        }
        let path = format!("/proc/{pid}/cmdline");
        let bytes = std::fs::read(&path)?;
        // `/proc/<pid>/cmdline` is empty for kernel threads.
        if bytes.is_empty() {
            return Ok(Vec::new());
        }
        let bytes = bytes.strip_suffix(&[0]).unwrap_or(&bytes);
        Ok(bytes
            .split(|byte| *byte == 0)
            .map(|argument| std::ffi::OsString::from_vec(argument.to_vec()))
            .collect())
    }

    /// Return a stable human-readable rendering of [`read_process_argv`].
    ///
    /// This intentionally is not shell syntax and must not be parsed back
    /// into argv. It preserves the historical `read_process_cmdline` output.
    pub fn read_process_cmdline(pid: u32) -> std::io::Result<String> {
        Ok(render_display(&read_process_argv(pid)?))
    }

    fn render_display(argv: &[std::ffi::OsString]) -> String {
        argv.iter()
            .map(|argument| argument.to_string_lossy())
            .collect::<Vec<_>>()
            .join(" ")
    }

    #[cfg(test)]
    mod tests {
        use super::render_display;
        use std::os::unix::ffi::OsStringExt;

        #[test]
        fn display_is_separate_from_structured_argv() {
            let argv = vec![
                std::ffi::OsString::from("tool"),
                std::ffi::OsString::from("has space"),
                std::ffi::OsString::from("quote\""),
                std::ffi::OsString::new(),
                std::ffi::OsString::from_vec(b"back\\slash".to_vec()),
            ];
            assert_eq!(render_display(&argv), "tool has space quote\"  back\\slash");
            assert_eq!(argv[3], std::ffi::OsString::new());
        }
    }