/proc/[pid]/stat

Author: danburkert

Cargo.toml

@@ -13,5 +13,6 @@ exclude = [
 ]
 
 [dependencies]
+libc = "0.1"
 nom = "0.4"
 byteorder = "0.3"

src/lib.rs

@@ -7,9 +7,12 @@
 extern crate nom;
 
 extern crate byteorder;
+extern crate libc;
 
-mod loadavg;
+#[macro_use]
 mod parsers;
+
+mod loadavg;
 pub mod pid;
 
 pub use loadavg::{LoadAvg, loadavg};

src/loadavg.rs

@@ -1,4 +1,4 @@
-//! Parsers and data structures for `/proc/loadavg`.
+//! System load and task statistics from `/proc/loadavg`.
 
 use std::fs::File;
 use std::io::Result;
@@ -13,7 +13,7 @@ use parsers::{map_result, parse_f32, parse_i32, parse_u32, read_to_end};
 /// The load average is the ratio of runnable and uninterruptible (waiting on IO) tasks to total
 /// tasks on the system.
 ///
-/// See `man proc 5` and `Linux/fs/proc/loadavg.c`.
+/// See `man 5 proc` and `Linux/fs/proc/loadavg.c`.
 #[derive(Debug, Default, PartialEq)]
 pub struct LoadAvg {
     /// Load average over the last minute.

src/parsers.rs

@@ -1,11 +1,22 @@
 //! Parsers and utility functions.
 
+use std::borrow::ToOwned;
+use std::fs::File;
 use std::io::{Error, ErrorKind, Read, Result};
 use std::str::{self, FromStr};
-use std::fs::File;
 
 use byteorder::{ByteOrder, LittleEndian};
-use nom::{IResult, alphanumeric, digit, is_digit, not_line_ending, space};
+use libc::clock_t;
+use nom::{
+    alphanumeric,
+    digit,
+    Err,
+    ErrorCode,
+    IResult,
+    is_digit,
+    not_line_ending,
+    space
+};
 
 /// Read all bytes in the file until EOF, placing them into `buf`.
 ///
@@ -54,12 +65,13 @@ pub fn map_result<T>(result: IResult<&[u8], T>) -> Result<T> {
             }
         }
         IResult::Error(err) => Err(Error::new(ErrorKind::InvalidInput,
-                           format!("unable to parse input: {:?}", err))),
+                                              format!("unable to parse input: {:?}", err))),
         _ => Err(Error::new(ErrorKind::InvalidInput, "unable to parse input")),
     }
 }
 
 
+/// Recognizes numerical characters: 0-9, and periods: '.'.
 fn fdigit(input: &[u8]) -> IResult<&[u8], &[u8]> {
     for idx in 0..input.len() {
         if (!is_digit(input[idx])) && ('.' as u8 != input[idx]) {
@@ -69,26 +81,44 @@ fn fdigit(input: &[u8]) -> IResult<&[u8], &[u8]> {
     IResult::Done(b"", input)
 }
 
-/// Parses the remainder of the line to a string.
-named!(pub parse_to_end<String>,
-       map_res!(map_res!(not_line_ending, str::from_utf8), FromStr::from_str));
+/// Recognizes numerical characters: 0-9, and an optional leading dash: '-'.
+pub fn sdigit(input:&[u8]) -> IResult<&[u8], &[u8]> {
+    if input.is_empty() {
+        return IResult::Done(b"", input)
+    }
 
-/// Parses a u32 in base-10 format.
-named!(pub parse_u32<u32>,
-       map_res!(map_res!(digit, str::from_utf8), FromStr::from_str));
+    let start = if input[0] == '-' as u8 { 1 } else { 0 };
+    for (idx, item) in input.iter().enumerate().skip(start) {
+        if !is_digit(*item) {
+            if idx == start {
+                return IResult::Error(Err::Position(ErrorCode::Digit as u32, input));
+            } else {
+                return IResult::Done(&input[idx..], &input[0..idx]);
+            }
+        }
+    }
+    IResult::Done(b"", input)
+}
 
-/// Parses a f32 in base-10 format.
-named!(pub parse_f32<f32>,
-      map_res!(map_res!(fdigit, str::from_utf8), FromStr::from_str));
+/// Parses a line to a string.
+named!(pub parse_line<String>,
+       map!(map_res!(not_line_ending, str::from_utf8), ToOwned::to_owned));
 
-/// Parses a sequence of whitespace seperated u32s.
-named!(pub parse_u32s<Vec<u32> >, separated_list!(space, parse_u32));
+/// Parses a clock_t in base-10 format.
+named!(pub parse_clock<clock_t>,
+       map_res!(map_res!(sdigit, str::from_utf8), FromStr::from_str));
 
 /// Parses an i32 in base-10 format.
-named!(pub parse_i32<i32>, map!(parse_u32, { |n| { n as i32 } }));
+named!(pub parse_i32<i32>,
+       map_res!(map_res!(sdigit, str::from_utf8), FromStr::from_str));
 
-/// Parses a sequence of whitespace seperated i32s.
-named!(pub parse_i32s<Vec<i32> >, separated_list!(space, parse_i32));
+/// Parses an i64 in base-10 format.
+named!(pub parse_i64<i64>,
+       map_res!(map_res!(sdigit, str::from_utf8), FromStr::from_str));
+
+/// Parses a u32 in base-10 format.
+named!(pub parse_u32<u32>,
+       map_res!(map_res!(digit, str::from_utf8), FromStr::from_str));
 
 /// Parses a u64 in base-10 format.
 named!(pub parse_u64<u64>,
@@ -98,6 +128,16 @@ named!(pub parse_u64<u64>,
 named!(pub parse_usize<usize>,
        map_res!(map_res!(digit, str::from_utf8), FromStr::from_str));
 
+/// Parses a f32 in base-10 format.
+named!(pub parse_f32<f32>,
+      map_res!(map_res!(fdigit, str::from_utf8), FromStr::from_str));
+
+/// Parses a sequence of whitespace seperated u32s.
+named!(pub parse_u32s<Vec<u32> >, separated_list!(space, parse_u32));
+
+/// Parses a sequence of whitespace seperated i32s.
+named!(pub parse_i32s<Vec<i32> >, separated_list!(space, parse_i32));
+
 /// Parses a usize followed by a kB unit tag.
 named!(pub parse_kb<usize>,
        chain!(space ~ bytes: parse_usize ~ space ~ tag!("kB"), || { bytes }));
@@ -138,6 +178,35 @@ named!(pub parse_u32_mask_list<Box<[u8]> >,
            bytes.into_boxed_slice()
        }));
 
+/// `take_until_right_and_consume!(tag) => &[T] -> IResult<&[T], &[T]>`
+/// generates a parser consuming bytes until the specified byte sequence is found, and consumes it.
+/// The sequence is searched for in the input in right to left order.
+macro_rules! take_until_right_and_consume(
+    ($i:expr, $inp:expr) => ({
+        #[inline(always)]
+        fn as_bytes<T: nom::AsBytes>(b: &T) -> &[u8] {
+            b.as_bytes()
+        }
+
+        let expected   = $inp;
+        let bytes      = as_bytes(&expected);
+        let mut index  = 0;
+        let mut parsed = false;
+        for idx in (0..(($i.len() + 1) - bytes.len())).rev() {
+            if &$i[idx..idx + bytes.len()] == bytes {
+                index = idx;
+                parsed = true;
+                break;
+            }
+        }
+        if parsed {
+            nom::IResult::Done(&$i[(index + bytes.len())..], &$i[0..index])
+        } else {
+            nom::IResult::Error(nom::Err::Position(nom::ErrorCode::TakeUntilAndConsume as u32, $i))
+        }
+    });
+);
+
 #[cfg(test)]
 pub mod tests {
 
@@ -147,8 +216,8 @@ pub mod tests {
 
     use nom::IResult;
 
-    use super::{map_result, parse_f32, parse_i32s, parse_u32_hex, parse_u32_mask_list, parse_u32s,
-                reverse};
+    use super::{map_result, parse_f32, parse_i32, parse_i32s, parse_i64, parse_u32_hex,
+                parse_u32_mask_list, parse_u32s, reverse};
 
     /// Unwrap a complete parse result.
     pub fn unwrap<T>(result: IResult<&[u8], T>) -> T {
@@ -208,7 +277,23 @@ pub mod tests {
         assert_eq!(Vec::<i32>::new(), &*unwrap(parse_i32s(b"")));
         assert_eq!(vec![0i32], &*unwrap(parse_i32s(b"0")));
         assert_eq!(vec![0i32, 1], &*unwrap(parse_i32s(b"0 1")));
-        assert_eq!(vec![99999i32, 32, 22, 888], &*unwrap(parse_i32s(b"99999 32 22 	888")));
+        assert_eq!(vec![99999i32, 0, -22, 32, 888], &*unwrap(parse_i32s(b"99999 0 -22 32 888")));
+    }
+
+    #[test]
+    fn test_parse_i32() {
+        assert_eq!(0i32, unwrap(parse_i32(b"0")));
+        assert_eq!(0i32, unwrap(parse_i32(b"-0")));
+        assert_eq!(32i32, unwrap(parse_i32(b"32")));
+        assert_eq!(-32i32, unwrap(parse_i32(b"-32")));
+    }
+
+    #[test]
+    fn test_parse_i64() {
+        assert_eq!(0i64, unwrap(parse_i64(b"0")));
+        assert_eq!(0i64, unwrap(parse_i64(b"-0")));
+        assert_eq!(32i64, unwrap(parse_i64(b"32")));
+        assert_eq!(-32i64, unwrap(parse_i64(b"-32")));
     }
 
     #[test]

src/pid/mod.rs

@@ -1,10 +1,12 @@
 //! Process-specific information from `/proc/[pid]/`.
 
+mod stat;
 mod statm;
 mod status;
 
 pub use pid::statm::{Statm, statm, statm_self};
 pub use pid::status::{SeccompMode, Status, status, status_self};
+pub use pid::stat::{Stat};
 
 /// The state of a process.
 #[derive(Debug, PartialEq, Eq, Hash)]
@@ -50,18 +52,3 @@ impl Default for State {
         State::Running
     }
 }
-
-/// Parse the stat state format.
-named!(parse_stat_state<State>,
-       alt!(tag!("R") => { |_| State::Running  }
-          | tag!("S") => { |_| State::Sleeping }
-          | tag!("D") => { |_| State::Waiting }
-          | tag!("Z") => { |_| State::Zombie }
-          | tag!("T") => { |_| State::Stopped }
-          | tag!("t") => { |_| State::TraceStopped }
-          | tag!("W") => { |_| State::Paging }
-          | tag!("X") => { |_| State::Dead }
-          | tag!("x") => { |_| State::Dead }
-          | tag!("K") => { |_| State::Wakekill }
-          | tag!("W") => { |_| State::Waking }
-          | tag!("P") => { |_| State::Parked }));