use crate::error::Result;
use crate::util::parse;
#[derive(Debug)]
pub struct Limit {
pub soft: Option<u64>,
pub hard: Option<u64>,
pub unit: LimitUnit,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum LimitUnit {
Files,
Bytes,
Processes,
Seconds,
Microseconds,
}
#[derive(Debug)]
pub struct ProcessLimits {
pub max_cpu_time: Limit,
pub max_fsize: Limit,
pub max_data: Limit,
pub max_stack: Limit,
pub max_core: Limit,
pub max_rss: Limit,
pub max_locked: Limit,
pub max_addr_space: Limit,
pub max_open_files: Limit,
pub max_processes: Limit,
pub max_nice: Limit,
pub max_rt_priority: Limit,
pub max_rt_time: Limit,
}
impl ProcessLimits {
pub fn from_bytes(bytes: &[u8]) -> Result<Self> {
let mut limits = ProcessLimits {
max_cpu_time: Limit {
soft: None,
hard: None,
unit: LimitUnit::Seconds,
},
max_fsize: Limit {
soft: None,
hard: None,
unit: LimitUnit::Bytes,
},
max_data: Limit {
soft: None,
hard: None,
unit: LimitUnit::Bytes,
},
max_stack: Limit {
soft: None,
hard: None,
unit: LimitUnit::Bytes,
},
max_core: Limit {
soft: None,
hard: None,
unit: LimitUnit::Bytes,
},
max_rss: Limit {
soft: None,
hard: None,
unit: LimitUnit::Bytes,
},
max_locked: Limit {
soft: None,
hard: None,
unit: LimitUnit::Bytes,
},
max_addr_space: Limit {
soft: None,
hard: None,
unit: LimitUnit::Bytes,
},
max_open_files: Limit {
soft: None,
hard: None,
unit: LimitUnit::Files,
},
max_processes: Limit {
soft: None,
hard: None,
unit: LimitUnit::Processes,
},
max_nice: Limit {
soft: None,
hard: None,
unit: LimitUnit::Files,
},
max_rt_priority: Limit {
soft: None,
hard: None,
unit: LimitUnit::Files,
},
max_rt_time: Limit {
soft: None,
hard: None,
unit: LimitUnit::Microseconds,
},
};
for line in bytes.split(|&b| b == b'\n').filter(|l| !l.is_empty()) {
let trimmed = parse::trim_start(line);
if trimmed.starts_with(b"Limit") {
continue;
}
let name_end = 25.min(trimmed.len());
let name = parse::trim_end(&trimmed[..name_end]);
let rest = parse::trim_start(&trimmed[name_end..]);
let fields: Vec<&[u8]> = parse::split_spaces(rest);
if fields.len() < 3 {
continue;
}
let soft = parse_limit_value(fields[0]);
let hard = parse_limit_value(fields[1]);
let unit = parse_limit_unit(fields[2]);
let limit = Limit { soft, hard, unit };
match name {
b"Max cpu time" => limits.max_cpu_time = limit,
b"Max file size" => limits.max_fsize = limit,
b"Max data size" => limits.max_data = limit,
b"Max stack size" => limits.max_stack = limit,
b"Max core file size" => limits.max_core = limit,
b"Max resident set" => limits.max_rss = limit,
b"Max locked memory" => limits.max_locked = limit,
b"Max address space" => limits.max_addr_space = limit,
b"Max open files" => limits.max_open_files = limit,
b"Max processes" => limits.max_processes = limit,
b"Max nice priority" => limits.max_nice = limit,
b"Max realtime priority" => limits.max_rt_priority = limit,
b"Max realtime timeout" => limits.max_rt_time = limit,
_ => {}
}
}
Ok(limits)
}
}
fn parse_limit_value(s: &[u8]) -> Option<u64> {
if s == b"unlimited" {
None
} else {
parse::parse_dec_u64(s).ok()
}
}
fn parse_limit_unit(s: &[u8]) -> LimitUnit {
match s {
b"bytes" => LimitUnit::Bytes,
b"files" => LimitUnit::Files,
b"processes" => LimitUnit::Processes,
b"seconds" => LimitUnit::Seconds,
_ => LimitUnit::Files,
}
}