use std::collections::HashMap;
use std::fmt::{self, Debug, Formatter};
use std::fs::File;
use std::path::{Path, PathBuf};
use libc::{c_int, gid_t, kill, uid_t};
use Pid;
use ProcessExt;
#[derive(Clone, Copy, Debug)]
pub enum ProcessStatus {
Idle,
Run,
Sleep,
Stop,
Zombie,
Tracing,
Dead,
Wakekill,
Waking,
Parked,
Unknown(u32),
}
impl From<u32> for ProcessStatus {
fn from(status: u32) -> ProcessStatus {
match status {
1 => ProcessStatus::Idle,
2 => ProcessStatus::Run,
3 => ProcessStatus::Sleep,
4 => ProcessStatus::Stop,
5 => ProcessStatus::Zombie,
x => ProcessStatus::Unknown(x),
}
}
}
impl From<char> for ProcessStatus {
fn from(status: char) -> ProcessStatus {
match status {
'R' => ProcessStatus::Run,
'S' => ProcessStatus::Sleep,
'D' => ProcessStatus::Idle,
'Z' => ProcessStatus::Zombie,
'T' => ProcessStatus::Stop,
't' => ProcessStatus::Tracing,
'X' | 'x' => ProcessStatus::Dead,
'K' => ProcessStatus::Wakekill,
'W' => ProcessStatus::Waking,
'P' => ProcessStatus::Parked,
x => ProcessStatus::Unknown(x as u32),
}
}
}
impl ProcessStatus {
pub fn to_string(&self) -> &str {
match *self {
ProcessStatus::Idle => "Idle",
ProcessStatus::Run => "Runnable",
ProcessStatus::Sleep => "Sleeping",
ProcessStatus::Stop => "Stopped",
ProcessStatus::Zombie => "Zombie",
ProcessStatus::Tracing => "Tracing",
ProcessStatus::Dead => "Dead",
ProcessStatus::Wakekill => "Wakekill",
ProcessStatus::Waking => "Waking",
ProcessStatus::Parked => "Parked",
ProcessStatus::Unknown(_) => "Unknown",
}
}
}
impl fmt::Display for ProcessStatus {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "{}", self.to_string())
}
}
pub struct Process {
pub(crate) name: String,
pub(crate) cmd: Vec<String>,
pub(crate) exe: PathBuf,
pub(crate) pid: Pid,
parent: Option<Pid>,
pub(crate) environ: Vec<String>,
pub(crate) cwd: PathBuf,
pub(crate) root: PathBuf,
pub(crate) memory: u64,
pub(crate) virtual_memory: u64,
utime: u64,
stime: u64,
old_utime: u64,
old_stime: u64,
start_time: u64,
updated: bool,
cpu_usage: f32,
pub uid: uid_t,
pub gid: gid_t,
pub(crate) status: ProcessStatus,
pub tasks: HashMap<Pid, Process>,
pub(crate) stat_file: Option<File>,
}
impl ProcessExt for Process {
fn new(pid: Pid, parent: Option<Pid>, start_time: u64) -> Process {
Process {
name: String::with_capacity(20),
pid,
parent,
cmd: Vec::with_capacity(2),
environ: Vec::with_capacity(10),
exe: PathBuf::new(),
cwd: PathBuf::new(),
root: PathBuf::new(),
memory: 0,
virtual_memory: 0,
cpu_usage: 0.,
utime: 0,
stime: 0,
old_utime: 0,
old_stime: 0,
updated: true,
start_time,
uid: 0,
gid: 0,
status: ProcessStatus::Unknown(0),
tasks: if pid == 0 {
HashMap::with_capacity(1000)
} else {
HashMap::new()
},
stat_file: None,
}
}
fn kill(&self, signal: ::Signal) -> bool {
unsafe { kill(self.pid, signal as c_int) == 0 }
}
fn name(&self) -> &str {
&self.name
}
fn cmd(&self) -> &[String] {
&self.cmd
}
fn exe(&self) -> &Path {
self.exe.as_path()
}
fn pid(&self) -> Pid {
self.pid
}
fn environ(&self) -> &[String] {
&self.environ
}
fn cwd(&self) -> &Path {
self.cwd.as_path()
}
fn root(&self) -> &Path {
self.root.as_path()
}
fn memory(&self) -> u64 {
self.memory
}
fn virtual_memory(&self) -> u64 {
self.virtual_memory
}
fn parent(&self) -> Option<Pid> {
self.parent
}
fn status(&self) -> ProcessStatus {
self.status
}
fn start_time(&self) -> u64 {
self.start_time
}
fn cpu_usage(&self) -> f32 {
self.cpu_usage
}
}
impl Drop for Process {
fn drop(&mut self) {
if self.stat_file.is_some() {
if let Ok(ref mut x) = unsafe { ::linux::system::REMAINING_FILES.lock() } {
**x += 1;
}
}
}
}
#[allow(unused_must_use)]
impl Debug for Process {
fn fmt(&self, f: &mut Formatter) -> fmt::Result {
writeln!(f, "pid: {}", self.pid);
writeln!(f, "parent: {:?}", self.parent);
writeln!(f, "name: {}", self.name);
writeln!(f, "environment:");
for var in &self.environ {
if !var.is_empty() {
writeln!(f, "\t{}", var);
}
}
writeln!(f, "command:");
for arg in &self.cmd {
writeln!(f, "\t{}", arg);
}
writeln!(f, "executable path: {:?}", self.exe);
writeln!(f, "current working directory: {:?}", self.cwd);
writeln!(f, "owner/group: {}:{}", self.uid, self.gid);
writeln!(f, "memory usage: {} KiB", self.memory);
writeln!(f, "virtual memory usage: {} KiB", self.virtual_memory);
writeln!(f, "cpu usage: {}%", self.cpu_usage);
writeln!(f, "status: {}", self.status);
write!(f, "root path: {:?}", self.root)
}
}
pub fn compute_cpu_usage(p: &mut Process, nb_processors: u64, total_time: f32) {
p.cpu_usage =
((p.utime - p.old_utime + p.stime - p.old_stime) * nb_processors * 100) as f32 / total_time;
p.updated = false;
}
pub fn set_time(p: &mut Process, utime: u64, stime: u64) {
p.old_utime = p.utime;
p.old_stime = p.stime;
p.utime = utime;
p.stime = stime;
p.updated = true;
}
pub fn has_been_updated(p: &Process) -> bool {
p.updated
}