Struct Process 

pub struct Process { /* private fields */ }

Struct containing information of a process.

iOS

This information cannot be retrieved on iOS due to sandboxing.

Apple app store

If you are building a macOS Apple app store, it won’t be able to retrieve this information.

use sysinfo::{Pid, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("{:?}", process.name());
}

Implementations

impl Process

pub fn kill(&self) -> bool

Sends Signal::Kill to the process (which is the only signal supported on all supported platforms by this crate).

Returns true if the signal was sent successfully. If you want to wait for this process to end, you can use Process::wait or directly Process::kill_and_wait.

⚠️ Even if this function returns true, it doesn’t necessarily mean that the process will be killed. It just means that the signal was sent successfully.

⚠️ Please note that some processes might not be “killable”, like if they run with higher levels than the current process for example.

If you want to use another signal, take a look at Process::kill_with.

To get the list of the supported signals on this system, use SUPPORTED_SIGNALS.

use sysinfo::{Pid, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    process.kill();
}

pub fn kill_with(&self, signal: Signal) -> Option<bool>

Sends the given signal to the process. If the signal doesn’t exist on this platform, it’ll do nothing and will return None. Otherwise it’ll return Some(bool). The boolean value will depend on whether or not the signal was sent successfully.

If you just want to kill the process, use Process::kill directly. If you want to wait for this process to end, you can use Process::wait or Process::kill_with_and_wait.

⚠️ Please note that some processes might not be “killable”, like if they run with higher levels than the current process for example.

To get the list of the supported signals on this system, use SUPPORTED_SIGNALS.

use sysinfo::{Pid, Signal, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("Trying to send `kill` signal to {}", process.pid());
    if process.kill_with(Signal::Kill).is_none() {
        println!("This signal isn't supported on this platform");
    }
}

Examples found in repository

examples/simple.rs (line 359)

fn interpret_input(
    input: &str,
    sys: Result<&mut System, &mut Error>,
    gpus: Result<&mut Gpus, &mut Error>,
    networks: Result<&mut Networks, &mut Error>,
    disks: Result<&mut Disks, &mut Error>,
    components: Result<&mut Components, &mut Error>,
    users: Result<&mut Users, &mut Error>,
) -> bool {
    match input.trim() {
        "help" => print_help(),
        "refresh_disks" => match disks {
            Ok(disks) => {
                println!("Refreshing disk list...");
                disks.refresh(true);
                println!("Done.");
            }
            Err(error) => {
                println!("Disks information cannot be retrieved: {error}");
            }
        },
        "refresh_users" => match users {
            Ok(users) => {
                println!("Refreshing user list...");
                users.refresh();
                println!("Done.");
            }
            Err(error) => {
                println!("Users information cannot be retrieved: {error}");
            }
        },
        "refresh_networks" => match networks {
            Ok(networks) => {
                println!("Refreshing network list...");
                networks.refresh(true);
                println!("Done.");
            }
            Err(error) => {
                println!("Networks information cannot be retrieved: {error}");
            }
        },
        "refresh_components" => match components {
            Ok(components) => {
                println!("Refreshing component list...");
                components.refresh(true);
                println!("Done.");
            }
            Err(error) => {
                println!("Components information cannot be retrieved: {error}");
            }
        },
        "refresh_cpu" => match sys {
            Ok(sys) => {
                println!("Refreshing CPUs...");
                sys.refresh_cpu_all();
                println!("Done.");
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "signals" => {
            for (nb, sig) in SUPPORTED_SIGNALS.iter().enumerate() {
                println!("{:2}:{sig:?}", nb + 1);
            }
        }
        "cpus" => {
            match sys {
                Ok(sys) => {
                    // Note: you should refresh a few times before using this, so that usage statistics
                    // can be ascertained
                    println!(
                        "number of physical cores: {}",
                        System::physical_core_count()
                            .map(|c| c.to_string())
                            .unwrap_or_else(|_| "Unknown".to_owned()),
                    );
                    println!("total CPU usage: {}%", sys.global_cpu_usage());
                    for cpu in sys.cpus() {
                        println!("{cpu:?}");
                    }
                }
                Err(error) => {
                    println!("System information cannot be retrieved: {error}");
                }
            }
        }
        "gpus" => match gpus {
            Ok(gpus) => {
                gpus.refresh(true);
                for gpu in &*gpus {
                    println!(
                        "GPU (PCI: {}): Vendor: {}",
                        gpu.pci(),
                        gpu.vendor().unwrap_or("Unknown")
                    );
                    if let Some(model) = gpu.model() {
                        println!("  model: {model}");
                    }
                    match gpu.usage() {
                        Some(usage) => println!("  usage: {usage}%"),
                        None => println!("  usage: N/A"),
                    }
                    if let (Some(used), Some(total)) = (gpu.used_memory(), gpu.total_memory()) {
                        println!("  memory: {}/{} KB", used / 1_000, total / 1_000);
                    } else {
                        println!("  memory: N/A");
                    }
                }
            }
            Err(error) => {
                println!("GPU information cannot be retrieved on this system: {error}");
            }
        },
        "memory" => match sys {
            Ok(sys) => {
                println!("total memory:     {: >10} KB", sys.total_memory() / 1_000);
                println!(
                    "available memory: {: >10} KB",
                    sys.available_memory() / 1_000
                );
                println!("used memory:      {: >10} KB", sys.used_memory() / 1_000);
                println!("total swap:       {: >10} KB", sys.total_swap() / 1_000);
                println!("used swap:        {: >10} KB", sys.used_swap() / 1_000);
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "quit" | "exit" => return true,
        "all" => match sys {
            Ok(sys) => {
                for (pid, proc_) in sys.processes() {
                    println!(
                        "{}:{} status={:?}",
                        pid,
                        proc_.name().to_string_lossy(),
                        proc_.status()
                    );
                }
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "frequency" => match sys {
            Ok(sys) => {
                for cpu in sys.cpus() {
                    println!("[{}] {} MHz", cpu.name(), cpu.frequency());
                }
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "vendor_id" => match sys {
            Ok(sys) => {
                println!("vendor ID: {}", sys.cpus()[0].vendor_id());
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "brand" => match sys {
            Ok(sys) => {
                println!("brand: {}", sys.cpus()[0].brand());
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "load_avg" => match System::load_average() {
            Ok(load_avg) => {
                println!("one minute     : {}%", load_avg.one);
                println!("five minutes   : {}%", load_avg.five);
                println!("fifteen minutes: {}%", load_avg.fifteen);
            }
            Err(error) => {
                eprintln!("Failed to get `load_average`: {error}");
            }
        },
        e if e.starts_with("show ") => {
            let tmp: Vec<&str> = e.split(' ').filter(|s| !s.is_empty()).collect();

            if tmp.len() != 2 {
                println!("show command takes a pid or a name in parameter!");
                println!("example: show 1254");
            } else {
                match sys {
                    Ok(sys) => {
                        if let Ok(pid) = Pid::from_str(tmp[1]) {
                            match sys.process(pid) {
                                Some(p) => {
                                    println!("{:#?}", *p);
                                    println!(
                                        "Files open/limit: {:?}/{:?}",
                                        p.open_files(),
                                        p.open_files_limit(),
                                    );
                                }
                                None => {
                                    println!("pid \"{pid:?}\" not found");
                                }
                            }
                        } else {
                            let proc_name = tmp[1];
                            for proc_ in sys.processes_by_name(proc_name.as_ref()) {
                                println!("==== {} ====", proc_.name().to_string_lossy());
                                println!("{proc_:?}");
                            }
                        }
                    }
                    Err(error) => {
                        println!("System information cannot be retrieved: {error}");
                    }
                }
            }
        }
        "temperature" => match components {
            Ok(components) => {
                for component in components.iter() {
                    println!("{component:?}");
                }
            }
            Err(error) => {
                println!("Components information cannot be retrieved: {error}");
            }
        },
        "network" => match networks {
            Ok(networks) => {
                for (interface_name, data) in networks.iter() {
                    println!(
                        "\
    {}:
      operational state {}
      ether {}
      input data  (new / total): {} / {} B
      output data (new / total): {} / {} B",
                        interface_name.display(),
                        data.operational_state(),
                        data.mac_address(),
                        data.received(),
                        data.total_received(),
                        data.transmitted(),
                        data.total_transmitted(),
                    );
                }
            }
            Err(error) => {
                println!("Networks information cannot be retrieved: {error}");
            }
        },
        "show" => {
            println!("'show' command expects a pid number or a process name");
        }
        e if e.starts_with("kill ") => {
            let tmp: Vec<&str> = e
                .split(' ')
                .map(|s| s.trim())
                .filter(|s| !s.is_empty())
                .collect();

            if tmp.len() != 3 {
                println!("kill command takes the pid and a signal number in parameter!");
                println!("example: kill 1254 9");
            } else {
                let Ok(pid) = Pid::from_str(tmp[1]) else {
                    eprintln!("Expected a number for the PID, found {:?}", tmp[1]);
                    return false;
                };
                let Ok(signal) = usize::from_str(tmp[2]) else {
                    eprintln!("Expected a number for the signal, found {:?}", tmp[2]);
                    return false;
                };
                let Some(signal) = SUPPORTED_SIGNALS.get(signal) else {
                    eprintln!(
                        "No signal matching {signal}. Use the `signals` command to get the \
                         list of signals.",
                    );
                    return false;
                };

                match sys {
                    Ok(sys) => match sys.process(pid) {
                        Some(p) => {
                            if let Some(res) = p.kill_with(*signal) {
                                println!("kill: {res}");
                            } else {
                                eprintln!("kill: signal not supported on this platform");
                            }
                        }
                        None => {
                            eprintln!("pid not found");
                        }
                    },
                    Err(error) => {
                        println!("System information cannot be retrieved: {error}");
                    }
                }
            }
        }
        "disks" => match disks {
            Ok(disks) => {
                for disk in disks {
                    println!("{disk:?}");
                }
            }
            Err(error) => {
                println!("Disks information cannot be retrieved: {error}");
            }
        },
        "users" => match users {
            Ok(users) => {
                for user in users {
                    println!("{:?} => {:?}", user.name(), user.groups());
                }
            }
            Err(error) => {
                println!("Users information cannot be retrieved: {error}");
            }
        },
        "groups" => match Groups::new_with_refreshed_list() {
            Ok(groups) => {
                for group in &groups {
                    println!("{group:?}");
                }
            }
            Err(error) => {
                println!("Groups information cannot be retrieved: {error}");
            }
        },
        "boot_time" => match System::boot_time() {
            Ok(boot_time) => println!("{boot_time} seconds"),
            Err(error) => eprintln!("Failed to get `boot_time`: {error}"),
        },
        "uptime" => match System::uptime() {
            Ok(up) => {
                let mut uptime = up;
                let days = uptime / 86400;
                uptime -= days * 86400;
                let hours = uptime / 3600;
                uptime -= hours * 3600;
                let minutes = uptime / 60;
                println!("{days} days {hours} hours {minutes} minutes ({up} seconds in total)");
            }
            Err(error) => eprintln!("Failed to get `uptime`: {error}"),
        },
        x if x.starts_with("refresh") => {
            if x == "refresh" {
                match sys {
                    Ok(sys) => {
                        println!("Getting processes' information...");
                        sys.refresh_all();
                        println!("Done.");
                    }
                    Err(error) => {
                        println!("System information cannot be retrieved: {error}");
                    }
                }
            } else if x.starts_with("refresh ") {
                println!("Getting process' information...");
                if let Some(pid) = x
                    .split(' ')
                    .filter_map(|pid| pid.parse().ok())
                    .take(1)
                    .next()
                {
                    match sys {
                        Ok(sys) => {
                            if sys.refresh_processes_specifics(
                                sysinfo::ProcessesToUpdate::Some(&[pid]),
                                true,
                                ProcessRefreshKind::everything(),
                            ) != 0
                            {
                                println!("Process `{pid}` updated successfully");
                            } else {
                                println!("Process `{pid}` couldn't be updated...");
                            }
                        }
                        Err(error) => {
                            println!("System information cannot be retrieved: {error}");
                        }
                    }
                } else {
                    println!("Invalid [pid] received...");
                }
            } else {
                println!(
                    "\"{x}\": Unknown command. Enter 'help' if you want to get the commands' \
                     list.",
                );
            }
        }
        "pid" => {
            println!(
                "PID: {}",
                sysinfo::get_current_pid().expect("failed to get PID")
            );
        }
        "system" => {
            println!(
                "System name:              {}\n\
                 System kernel version:    {}\n\
                 System OS version:        {}\n\
                 System OS (long) version: {}\n\
                 System host name:         {}\n\
                 System kernel:            {}",
                System::name().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::kernel_version().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::os_version().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::long_os_version().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::host_name().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::kernel_long_version().unwrap_or_else(|_| "<unknown>".to_owned()),
            );
        }
        "motherboard" => match Motherboard::new() {
            Ok(m) => println!("{m:#?}"),
            Err(error) => println!("Cannot retrieve motherboard information: {error:?}"),
        },
        "product" => {
            println!("{:#?}", Product);
        }
        e => {
            println!(
                "\"{e}\": Unknown command. Enter 'help' if you want to get the commands' \
                 list.",
            );
        }
    }
    false
}

pub fn kill_and_wait(&self) -> Result<Option<ExitStatus>, KillError>

Sends Signal::Kill to the process then waits for its termination.

Internally, this method is calling Process::kill then Process::wait.

⚠️ Please note that some processes might not be “killable”, like if they run with higher levels than the current process for example. In this case, this method could enter an infinite loop.

use sysinfo::{Pid, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("Trying to kill and wait for process {}", process.pid());
    if let Err(error) = process.kill_and_wait() {
        println!("`kill_and_wait` failed: {error:?}");
    }
}

pub fn kill_with_and_wait( &self, signal: Signal, ) -> Result<Option<ExitStatus>, KillError>

Sends the given signal to the process.then waits for its termination.

Internally, this method is calling Process::kill_with then Process::wait.

⚠️ Please note that some processes might not be “killable”, like if they run with higher levels than the current process for example. In this case, this method could enter an infinite loop.

To get the list of the supported signals on this system, use SUPPORTED_SIGNALS.

use sysinfo::{Pid, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("Trying to kill and wait process {}", process.pid());
    if let Err(error) = process.kill_and_wait() {
        println!("`kill_and_wait` failed: {error:?}");
    }
}

pub fn wait(&self) -> Option<ExitStatus>

Waits for process termination and returns its [ExitStatus] if it could be retrieved, returns None otherwise. It means that as long as the process is alive, this method will not return.

⚠️ On macOS and FreeBSD, if the process died and a new one took its PID, unless you refreshed, it will wait for the new process to end.

On Windows, as long as we have a (internal) handle, we can always retrieve the exit status.

On Linux/Android, we check that the start time of the PID we’re waiting is the same as the current process’. If not it means the process died and a new one got its PID.

use sysinfo::{Pid, System};

if let Ok(mut s) = System::new_all() {
    println!("Looking for process 1337");
    if let Some(process) = s.process(Pid::from(1337)) {
        println!("Waiting for pid 1337");
        let exit_status = process.wait();
        println!("Pid 1337 exited with: {exit_status:?}");
    }
}

pub fn name(&self) -> &OsStr

Returns the name of the process.

⚠️ Important ⚠️

On Linux, there are two things to know about processes’ name:

1. It is limited to 15 characters.
2. It is not always the exe name.

If you are looking for a specific process, unless you know what you are doing, in most cases it’s better to use Process::exe instead (which can be empty sometimes!).

use sysinfo::{Pid, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("{:?}", process.name());
}

Examples found in repository

examples/simple.rs (line 210)

fn interpret_input(
    input: &str,
    sys: Result<&mut System, &mut Error>,
    gpus: Result<&mut Gpus, &mut Error>,
    networks: Result<&mut Networks, &mut Error>,
    disks: Result<&mut Disks, &mut Error>,
    components: Result<&mut Components, &mut Error>,
    users: Result<&mut Users, &mut Error>,
) -> bool {
    match input.trim() {
        "help" => print_help(),
        "refresh_disks" => match disks {
            Ok(disks) => {
                println!("Refreshing disk list...");
                disks.refresh(true);
                println!("Done.");
            }
            Err(error) => {
                println!("Disks information cannot be retrieved: {error}");
            }
        },
        "refresh_users" => match users {
            Ok(users) => {
                println!("Refreshing user list...");
                users.refresh();
                println!("Done.");
            }
            Err(error) => {
                println!("Users information cannot be retrieved: {error}");
            }
        },
        "refresh_networks" => match networks {
            Ok(networks) => {
                println!("Refreshing network list...");
                networks.refresh(true);
                println!("Done.");
            }
            Err(error) => {
                println!("Networks information cannot be retrieved: {error}");
            }
        },
        "refresh_components" => match components {
            Ok(components) => {
                println!("Refreshing component list...");
                components.refresh(true);
                println!("Done.");
            }
            Err(error) => {
                println!("Components information cannot be retrieved: {error}");
            }
        },
        "refresh_cpu" => match sys {
            Ok(sys) => {
                println!("Refreshing CPUs...");
                sys.refresh_cpu_all();
                println!("Done.");
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "signals" => {
            for (nb, sig) in SUPPORTED_SIGNALS.iter().enumerate() {
                println!("{:2}:{sig:?}", nb + 1);
            }
        }
        "cpus" => {
            match sys {
                Ok(sys) => {
                    // Note: you should refresh a few times before using this, so that usage statistics
                    // can be ascertained
                    println!(
                        "number of physical cores: {}",
                        System::physical_core_count()
                            .map(|c| c.to_string())
                            .unwrap_or_else(|_| "Unknown".to_owned()),
                    );
                    println!("total CPU usage: {}%", sys.global_cpu_usage());
                    for cpu in sys.cpus() {
                        println!("{cpu:?}");
                    }
                }
                Err(error) => {
                    println!("System information cannot be retrieved: {error}");
                }
            }
        }
        "gpus" => match gpus {
            Ok(gpus) => {
                gpus.refresh(true);
                for gpu in &*gpus {
                    println!(
                        "GPU (PCI: {}): Vendor: {}",
                        gpu.pci(),
                        gpu.vendor().unwrap_or("Unknown")
                    );
                    if let Some(model) = gpu.model() {
                        println!("  model: {model}");
                    }
                    match gpu.usage() {
                        Some(usage) => println!("  usage: {usage}%"),
                        None => println!("  usage: N/A"),
                    }
                    if let (Some(used), Some(total)) = (gpu.used_memory(), gpu.total_memory()) {
                        println!("  memory: {}/{} KB", used / 1_000, total / 1_000);
                    } else {
                        println!("  memory: N/A");
                    }
                }
            }
            Err(error) => {
                println!("GPU information cannot be retrieved on this system: {error}");
            }
        },
        "memory" => match sys {
            Ok(sys) => {
                println!("total memory:     {: >10} KB", sys.total_memory() / 1_000);
                println!(
                    "available memory: {: >10} KB",
                    sys.available_memory() / 1_000
                );
                println!("used memory:      {: >10} KB", sys.used_memory() / 1_000);
                println!("total swap:       {: >10} KB", sys.total_swap() / 1_000);
                println!("used swap:        {: >10} KB", sys.used_swap() / 1_000);
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "quit" | "exit" => return true,
        "all" => match sys {
            Ok(sys) => {
                for (pid, proc_) in sys.processes() {
                    println!(
                        "{}:{} status={:?}",
                        pid,
                        proc_.name().to_string_lossy(),
                        proc_.status()
                    );
                }
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "frequency" => match sys {
            Ok(sys) => {
                for cpu in sys.cpus() {
                    println!("[{}] {} MHz", cpu.name(), cpu.frequency());
                }
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "vendor_id" => match sys {
            Ok(sys) => {
                println!("vendor ID: {}", sys.cpus()[0].vendor_id());
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "brand" => match sys {
            Ok(sys) => {
                println!("brand: {}", sys.cpus()[0].brand());
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "load_avg" => match System::load_average() {
            Ok(load_avg) => {
                println!("one minute     : {}%", load_avg.one);
                println!("five minutes   : {}%", load_avg.five);
                println!("fifteen minutes: {}%", load_avg.fifteen);
            }
            Err(error) => {
                eprintln!("Failed to get `load_average`: {error}");
            }
        },
        e if e.starts_with("show ") => {
            let tmp: Vec<&str> = e.split(' ').filter(|s| !s.is_empty()).collect();

            if tmp.len() != 2 {
                println!("show command takes a pid or a name in parameter!");
                println!("example: show 1254");
            } else {
                match sys {
                    Ok(sys) => {
                        if let Ok(pid) = Pid::from_str(tmp[1]) {
                            match sys.process(pid) {
                                Some(p) => {
                                    println!("{:#?}", *p);
                                    println!(
                                        "Files open/limit: {:?}/{:?}",
                                        p.open_files(),
                                        p.open_files_limit(),
                                    );
                                }
                                None => {
                                    println!("pid \"{pid:?}\" not found");
                                }
                            }
                        } else {
                            let proc_name = tmp[1];
                            for proc_ in sys.processes_by_name(proc_name.as_ref()) {
                                println!("==== {} ====", proc_.name().to_string_lossy());
                                println!("{proc_:?}");
                            }
                        }
                    }
                    Err(error) => {
                        println!("System information cannot be retrieved: {error}");
                    }
                }
            }
        }
        "temperature" => match components {
            Ok(components) => {
                for component in components.iter() {
                    println!("{component:?}");
                }
            }
            Err(error) => {
                println!("Components information cannot be retrieved: {error}");
            }
        },
        "network" => match networks {
            Ok(networks) => {
                for (interface_name, data) in networks.iter() {
                    println!(
                        "\
    {}:
      operational state {}
      ether {}
      input data  (new / total): {} / {} B
      output data (new / total): {} / {} B",
                        interface_name.display(),
                        data.operational_state(),
                        data.mac_address(),
                        data.received(),
                        data.total_received(),
                        data.transmitted(),
                        data.total_transmitted(),
                    );
                }
            }
            Err(error) => {
                println!("Networks information cannot be retrieved: {error}");
            }
        },
        "show" => {
            println!("'show' command expects a pid number or a process name");
        }
        e if e.starts_with("kill ") => {
            let tmp: Vec<&str> = e
                .split(' ')
                .map(|s| s.trim())
                .filter(|s| !s.is_empty())
                .collect();

            if tmp.len() != 3 {
                println!("kill command takes the pid and a signal number in parameter!");
                println!("example: kill 1254 9");
            } else {
                let Ok(pid) = Pid::from_str(tmp[1]) else {
                    eprintln!("Expected a number for the PID, found {:?}", tmp[1]);
                    return false;
                };
                let Ok(signal) = usize::from_str(tmp[2]) else {
                    eprintln!("Expected a number for the signal, found {:?}", tmp[2]);
                    return false;
                };
                let Some(signal) = SUPPORTED_SIGNALS.get(signal) else {
                    eprintln!(
                        "No signal matching {signal}. Use the `signals` command to get the \
                         list of signals.",
                    );
                    return false;
                };

                match sys {
                    Ok(sys) => match sys.process(pid) {
                        Some(p) => {
                            if let Some(res) = p.kill_with(*signal) {
                                println!("kill: {res}");
                            } else {
                                eprintln!("kill: signal not supported on this platform");
                            }
                        }
                        None => {
                            eprintln!("pid not found");
                        }
                    },
                    Err(error) => {
                        println!("System information cannot be retrieved: {error}");
                    }
                }
            }
        }
        "disks" => match disks {
            Ok(disks) => {
                for disk in disks {
                    println!("{disk:?}");
                }
            }
            Err(error) => {
                println!("Disks information cannot be retrieved: {error}");
            }
        },
        "users" => match users {
            Ok(users) => {
                for user in users {
                    println!("{:?} => {:?}", user.name(), user.groups());
                }
            }
            Err(error) => {
                println!("Users information cannot be retrieved: {error}");
            }
        },
        "groups" => match Groups::new_with_refreshed_list() {
            Ok(groups) => {
                for group in &groups {
                    println!("{group:?}");
                }
            }
            Err(error) => {
                println!("Groups information cannot be retrieved: {error}");
            }
        },
        "boot_time" => match System::boot_time() {
            Ok(boot_time) => println!("{boot_time} seconds"),
            Err(error) => eprintln!("Failed to get `boot_time`: {error}"),
        },
        "uptime" => match System::uptime() {
            Ok(up) => {
                let mut uptime = up;
                let days = uptime / 86400;
                uptime -= days * 86400;
                let hours = uptime / 3600;
                uptime -= hours * 3600;
                let minutes = uptime / 60;
                println!("{days} days {hours} hours {minutes} minutes ({up} seconds in total)");
            }
            Err(error) => eprintln!("Failed to get `uptime`: {error}"),
        },
        x if x.starts_with("refresh") => {
            if x == "refresh" {
                match sys {
                    Ok(sys) => {
                        println!("Getting processes' information...");
                        sys.refresh_all();
                        println!("Done.");
                    }
                    Err(error) => {
                        println!("System information cannot be retrieved: {error}");
                    }
                }
            } else if x.starts_with("refresh ") {
                println!("Getting process' information...");
                if let Some(pid) = x
                    .split(' ')
                    .filter_map(|pid| pid.parse().ok())
                    .take(1)
                    .next()
                {
                    match sys {
                        Ok(sys) => {
                            if sys.refresh_processes_specifics(
                                sysinfo::ProcessesToUpdate::Some(&[pid]),
                                true,
                                ProcessRefreshKind::everything(),
                            ) != 0
                            {
                                println!("Process `{pid}` updated successfully");
                            } else {
                                println!("Process `{pid}` couldn't be updated...");
                            }
                        }
                        Err(error) => {
                            println!("System information cannot be retrieved: {error}");
                        }
                    }
                } else {
                    println!("Invalid [pid] received...");
                }
            } else {
                println!(
                    "\"{x}\": Unknown command. Enter 'help' if you want to get the commands' \
                     list.",
                );
            }
        }
        "pid" => {
            println!(
                "PID: {}",
                sysinfo::get_current_pid().expect("failed to get PID")
            );
        }
        "system" => {
            println!(
                "System name:              {}\n\
                 System kernel version:    {}\n\
                 System OS version:        {}\n\
                 System OS (long) version: {}\n\
                 System host name:         {}\n\
                 System kernel:            {}",
                System::name().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::kernel_version().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::os_version().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::long_os_version().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::host_name().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::kernel_long_version().unwrap_or_else(|_| "<unknown>".to_owned()),
            );
        }
        "motherboard" => match Motherboard::new() {
            Ok(m) => println!("{m:#?}"),
            Err(error) => println!("Cannot retrieve motherboard information: {error:?}"),
        },
        "product" => {
            println!("{:#?}", Product);
        }
        e => {
            println!(
                "\"{e}\": Unknown command. Enter 'help' if you want to get the commands' \
                 list.",
            );
        }
    }
    false
}

pub fn cmd(&self) -> &[OsString]

Returns the command line.

⚠️ Important ⚠️

On Windows, you might need to use administrator privileges when running your program to have access to this information.

use sysinfo::{Pid, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("{:?}", process.cmd());
}

pub fn exe(&self) -> Option<&Path>

Returns the path to the process.

use sysinfo::{Pid, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("{:?}", process.exe());
}

Implementation notes

On Linux, this method will return an empty path if there was an error trying to read /proc/<pid>/exe. This can happen, for example, if the permission levels or UID namespaces between the caller and target processes are different.

It is also the case that cmd[0] is not usually a correct replacement for this. A process may change its cmd[0] value freely, making this an untrustworthy source of information.

pub fn pid(&self) -> Pid

Returns the PID of the process.

use sysinfo::{Pid, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("{}", process.pid());
}

pub fn cgroup_limits(&self) -> Option<CGroupLimits>

Retrieves the limits for the process cgroup (if any), otherwise it returns None.

This information is computed every time the method is called.

⚠️ This method is only implemented for Linux. It always returns None for all other systems.

use sysinfo::{Pid, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("limits: {:?}", process.cgroup_limits());
}

pub fn environ(&self) -> &[OsString]

Returns the environment variables of the process.

use sysinfo::{Pid, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("{:?}", process.environ());
}

pub fn cwd(&self) -> Option<&Path>

Returns the current working directory.

use sysinfo::{Pid, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("{:?}", process.cwd());
}

pub fn root(&self) -> Option<&Path>

Returns the path of the root directory.

⚠️ Not implemented in NetBSD.

use sysinfo::{Pid, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("{:?}", process.root());
}

pub fn memory(&self) -> u64

Returns the memory usage (in bytes).

This method returns the size of the resident set, that is, the amount of memory that the process allocated and which is currently mapped in physical RAM. It does not include memory that is swapped out, or, in some operating systems, that has been allocated but never used.

Thus, it represents exactly the amount of physical RAM that the process is using at the present time, but it might not be a good indicator of the total memory that the process will be using over its lifetime. For that purpose, you can try and use virtual_memory.

use sysinfo::{Pid, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("{} bytes", process.memory());
}

pub fn virtual_memory(&self) -> u64

Returns the virtual memory usage (in bytes).

This method returns the size of virtual memory, that is, the amount of memory that the process can access, whether it is currently mapped in physical RAM or not. It includes physical RAM, allocated but not used regions, swapped-out regions, and even memory associated with memory-mapped files.

This value has limitations though. Depending on the operating system and type of process, this value might be a good indicator of the total memory that the process will be using over its lifetime. However, for example, in the version 14 of macOS this value is in the order of the hundreds of gigabytes for every process, and thus not very informative. Moreover, if a process maps into memory a very large file, this value will increase accordingly, even if the process is not actively using the memory.

use sysinfo::{Pid, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("{} bytes", process.virtual_memory());
}

pub fn parent(&self) -> Option<Pid>

Returns the parent PID.

use sysinfo::{Pid, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("{:?}", process.parent());
}

pub fn status(&self) -> ProcessStatus

Returns the status of the process.

use sysinfo::{Pid, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("{:?}", process.status());
}

Examples found in repository

examples/simple.rs (line 211)

fn interpret_input(
    input: &str,
    sys: Result<&mut System, &mut Error>,
    gpus: Result<&mut Gpus, &mut Error>,
    networks: Result<&mut Networks, &mut Error>,
    disks: Result<&mut Disks, &mut Error>,
    components: Result<&mut Components, &mut Error>,
    users: Result<&mut Users, &mut Error>,
) -> bool {
    match input.trim() {
        "help" => print_help(),
        "refresh_disks" => match disks {
            Ok(disks) => {
                println!("Refreshing disk list...");
                disks.refresh(true);
                println!("Done.");
            }
            Err(error) => {
                println!("Disks information cannot be retrieved: {error}");
            }
        },
        "refresh_users" => match users {
            Ok(users) => {
                println!("Refreshing user list...");
                users.refresh();
                println!("Done.");
            }
            Err(error) => {
                println!("Users information cannot be retrieved: {error}");
            }
        },
        "refresh_networks" => match networks {
            Ok(networks) => {
                println!("Refreshing network list...");
                networks.refresh(true);
                println!("Done.");
            }
            Err(error) => {
                println!("Networks information cannot be retrieved: {error}");
            }
        },
        "refresh_components" => match components {
            Ok(components) => {
                println!("Refreshing component list...");
                components.refresh(true);
                println!("Done.");
            }
            Err(error) => {
                println!("Components information cannot be retrieved: {error}");
            }
        },
        "refresh_cpu" => match sys {
            Ok(sys) => {
                println!("Refreshing CPUs...");
                sys.refresh_cpu_all();
                println!("Done.");
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "signals" => {
            for (nb, sig) in SUPPORTED_SIGNALS.iter().enumerate() {
                println!("{:2}:{sig:?}", nb + 1);
            }
        }
        "cpus" => {
            match sys {
                Ok(sys) => {
                    // Note: you should refresh a few times before using this, so that usage statistics
                    // can be ascertained
                    println!(
                        "number of physical cores: {}",
                        System::physical_core_count()
                            .map(|c| c.to_string())
                            .unwrap_or_else(|_| "Unknown".to_owned()),
                    );
                    println!("total CPU usage: {}%", sys.global_cpu_usage());
                    for cpu in sys.cpus() {
                        println!("{cpu:?}");
                    }
                }
                Err(error) => {
                    println!("System information cannot be retrieved: {error}");
                }
            }
        }
        "gpus" => match gpus {
            Ok(gpus) => {
                gpus.refresh(true);
                for gpu in &*gpus {
                    println!(
                        "GPU (PCI: {}): Vendor: {}",
                        gpu.pci(),
                        gpu.vendor().unwrap_or("Unknown")
                    );
                    if let Some(model) = gpu.model() {
                        println!("  model: {model}");
                    }
                    match gpu.usage() {
                        Some(usage) => println!("  usage: {usage}%"),
                        None => println!("  usage: N/A"),
                    }
                    if let (Some(used), Some(total)) = (gpu.used_memory(), gpu.total_memory()) {
                        println!("  memory: {}/{} KB", used / 1_000, total / 1_000);
                    } else {
                        println!("  memory: N/A");
                    }
                }
            }
            Err(error) => {
                println!("GPU information cannot be retrieved on this system: {error}");
            }
        },
        "memory" => match sys {
            Ok(sys) => {
                println!("total memory:     {: >10} KB", sys.total_memory() / 1_000);
                println!(
                    "available memory: {: >10} KB",
                    sys.available_memory() / 1_000
                );
                println!("used memory:      {: >10} KB", sys.used_memory() / 1_000);
                println!("total swap:       {: >10} KB", sys.total_swap() / 1_000);
                println!("used swap:        {: >10} KB", sys.used_swap() / 1_000);
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "quit" | "exit" => return true,
        "all" => match sys {
            Ok(sys) => {
                for (pid, proc_) in sys.processes() {
                    println!(
                        "{}:{} status={:?}",
                        pid,
                        proc_.name().to_string_lossy(),
                        proc_.status()
                    );
                }
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "frequency" => match sys {
            Ok(sys) => {
                for cpu in sys.cpus() {
                    println!("[{}] {} MHz", cpu.name(), cpu.frequency());
                }
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "vendor_id" => match sys {
            Ok(sys) => {
                println!("vendor ID: {}", sys.cpus()[0].vendor_id());
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "brand" => match sys {
            Ok(sys) => {
                println!("brand: {}", sys.cpus()[0].brand());
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "load_avg" => match System::load_average() {
            Ok(load_avg) => {
                println!("one minute     : {}%", load_avg.one);
                println!("five minutes   : {}%", load_avg.five);
                println!("fifteen minutes: {}%", load_avg.fifteen);
            }
            Err(error) => {
                eprintln!("Failed to get `load_average`: {error}");
            }
        },
        e if e.starts_with("show ") => {
            let tmp: Vec<&str> = e.split(' ').filter(|s| !s.is_empty()).collect();

            if tmp.len() != 2 {
                println!("show command takes a pid or a name in parameter!");
                println!("example: show 1254");
            } else {
                match sys {
                    Ok(sys) => {
                        if let Ok(pid) = Pid::from_str(tmp[1]) {
                            match sys.process(pid) {
                                Some(p) => {
                                    println!("{:#?}", *p);
                                    println!(
                                        "Files open/limit: {:?}/{:?}",
                                        p.open_files(),
                                        p.open_files_limit(),
                                    );
                                }
                                None => {
                                    println!("pid \"{pid:?}\" not found");
                                }
                            }
                        } else {
                            let proc_name = tmp[1];
                            for proc_ in sys.processes_by_name(proc_name.as_ref()) {
                                println!("==== {} ====", proc_.name().to_string_lossy());
                                println!("{proc_:?}");
                            }
                        }
                    }
                    Err(error) => {
                        println!("System information cannot be retrieved: {error}");
                    }
                }
            }
        }
        "temperature" => match components {
            Ok(components) => {
                for component in components.iter() {
                    println!("{component:?}");
                }
            }
            Err(error) => {
                println!("Components information cannot be retrieved: {error}");
            }
        },
        "network" => match networks {
            Ok(networks) => {
                for (interface_name, data) in networks.iter() {
                    println!(
                        "\
    {}:
      operational state {}
      ether {}
      input data  (new / total): {} / {} B
      output data (new / total): {} / {} B",
                        interface_name.display(),
                        data.operational_state(),
                        data.mac_address(),
                        data.received(),
                        data.total_received(),
                        data.transmitted(),
                        data.total_transmitted(),
                    );
                }
            }
            Err(error) => {
                println!("Networks information cannot be retrieved: {error}");
            }
        },
        "show" => {
            println!("'show' command expects a pid number or a process name");
        }
        e if e.starts_with("kill ") => {
            let tmp: Vec<&str> = e
                .split(' ')
                .map(|s| s.trim())
                .filter(|s| !s.is_empty())
                .collect();

            if tmp.len() != 3 {
                println!("kill command takes the pid and a signal number in parameter!");
                println!("example: kill 1254 9");
            } else {
                let Ok(pid) = Pid::from_str(tmp[1]) else {
                    eprintln!("Expected a number for the PID, found {:?}", tmp[1]);
                    return false;
                };
                let Ok(signal) = usize::from_str(tmp[2]) else {
                    eprintln!("Expected a number for the signal, found {:?}", tmp[2]);
                    return false;
                };
                let Some(signal) = SUPPORTED_SIGNALS.get(signal) else {
                    eprintln!(
                        "No signal matching {signal}. Use the `signals` command to get the \
                         list of signals.",
                    );
                    return false;
                };

                match sys {
                    Ok(sys) => match sys.process(pid) {
                        Some(p) => {
                            if let Some(res) = p.kill_with(*signal) {
                                println!("kill: {res}");
                            } else {
                                eprintln!("kill: signal not supported on this platform");
                            }
                        }
                        None => {
                            eprintln!("pid not found");
                        }
                    },
                    Err(error) => {
                        println!("System information cannot be retrieved: {error}");
                    }
                }
            }
        }
        "disks" => match disks {
            Ok(disks) => {
                for disk in disks {
                    println!("{disk:?}");
                }
            }
            Err(error) => {
                println!("Disks information cannot be retrieved: {error}");
            }
        },
        "users" => match users {
            Ok(users) => {
                for user in users {
                    println!("{:?} => {:?}", user.name(), user.groups());
                }
            }
            Err(error) => {
                println!("Users information cannot be retrieved: {error}");
            }
        },
        "groups" => match Groups::new_with_refreshed_list() {
            Ok(groups) => {
                for group in &groups {
                    println!("{group:?}");
                }
            }
            Err(error) => {
                println!("Groups information cannot be retrieved: {error}");
            }
        },
        "boot_time" => match System::boot_time() {
            Ok(boot_time) => println!("{boot_time} seconds"),
            Err(error) => eprintln!("Failed to get `boot_time`: {error}"),
        },
        "uptime" => match System::uptime() {
            Ok(up) => {
                let mut uptime = up;
                let days = uptime / 86400;
                uptime -= days * 86400;
                let hours = uptime / 3600;
                uptime -= hours * 3600;
                let minutes = uptime / 60;
                println!("{days} days {hours} hours {minutes} minutes ({up} seconds in total)");
            }
            Err(error) => eprintln!("Failed to get `uptime`: {error}"),
        },
        x if x.starts_with("refresh") => {
            if x == "refresh" {
                match sys {
                    Ok(sys) => {
                        println!("Getting processes' information...");
                        sys.refresh_all();
                        println!("Done.");
                    }
                    Err(error) => {
                        println!("System information cannot be retrieved: {error}");
                    }
                }
            } else if x.starts_with("refresh ") {
                println!("Getting process' information...");
                if let Some(pid) = x
                    .split(' ')
                    .filter_map(|pid| pid.parse().ok())
                    .take(1)
                    .next()
                {
                    match sys {
                        Ok(sys) => {
                            if sys.refresh_processes_specifics(
                                sysinfo::ProcessesToUpdate::Some(&[pid]),
                                true,
                                ProcessRefreshKind::everything(),
                            ) != 0
                            {
                                println!("Process `{pid}` updated successfully");
                            } else {
                                println!("Process `{pid}` couldn't be updated...");
                            }
                        }
                        Err(error) => {
                            println!("System information cannot be retrieved: {error}");
                        }
                    }
                } else {
                    println!("Invalid [pid] received...");
                }
            } else {
                println!(
                    "\"{x}\": Unknown command. Enter 'help' if you want to get the commands' \
                     list.",
                );
            }
        }
        "pid" => {
            println!(
                "PID: {}",
                sysinfo::get_current_pid().expect("failed to get PID")
            );
        }
        "system" => {
            println!(
                "System name:              {}\n\
                 System kernel version:    {}\n\
                 System OS version:        {}\n\
                 System OS (long) version: {}\n\
                 System host name:         {}\n\
                 System kernel:            {}",
                System::name().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::kernel_version().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::os_version().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::long_os_version().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::host_name().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::kernel_long_version().unwrap_or_else(|_| "<unknown>".to_owned()),
            );
        }
        "motherboard" => match Motherboard::new() {
            Ok(m) => println!("{m:#?}"),
            Err(error) => println!("Cannot retrieve motherboard information: {error:?}"),
        },
        "product" => {
            println!("{:#?}", Product);
        }
        e => {
            println!(
                "\"{e}\": Unknown command. Enter 'help' if you want to get the commands' \
                 list.",
            );
        }
    }
    false
}

pub fn start_time(&self) -> u64

Returns the time where the process was started (in seconds) from epoch.

use sysinfo::{Pid, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("Started at {} seconds", process.start_time());
}

pub fn run_time(&self) -> u64

Returns for how much time the process has been running (in seconds).

use sysinfo::{Pid, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("Running since {} seconds", process.run_time());
}

pub fn cpu_usage(&self) -> f32

Returns the total CPU usage (in %). Notice that it might be bigger than 100 if run on a multi-core machine.

If you want a value between 0% and 100%, divide the returned value by the number of CPUs.

⚠️ To start to have accurate CPU usage, a process needs to be refreshed twice because CPU usage computation is based on time diff (process time on a given time period divided by total system time on the same time period).

⚠️ If you want accurate CPU usage number, better leave a bit of time between two calls of this method (take a look at MINIMUM_CPU_UPDATE_INTERVAL for more information).

use sysinfo::{Pid, ProcessesToUpdate, ProcessRefreshKind, System};

if let Ok(mut s) = System::new_all() {
    // Wait a bit because CPU usage is based on diff.
    std::thread::sleep(sysinfo::MINIMUM_CPU_UPDATE_INTERVAL);
    // Refresh CPU usage to get actual value.
    s.refresh_processes_specifics(
        ProcessesToUpdate::All,
        true,
        ProcessRefreshKind::nothing().with_cpu()
    );
    if let Some(process) = s.process(Pid::from(1337)) {
        println!("{}%", process.cpu_usage());
    }
}

pub fn accumulated_cpu_time(&self) -> u64

Returns the total accumulated CPU usage (in CPU-milliseconds). Note that it might be bigger than the total clock run time of a process if run on a multi-core machine.

use sysinfo::{Pid, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("{}", process.accumulated_cpu_time());
}

pub fn disk_usage(&self) -> DiskUsage

Returns number of bytes read and written to disk.

⚠️ On Windows, this method actually returns ALL I/O read and written bytes.

⚠️ Files might be cached in memory by your OS, meaning that reading/writing them might not increase the read_bytes/written_bytes values. You can find more information about it in the proc_pid_io manual (man proc_pid_io on unix platforms).

use sysinfo::{Pid, System};

if let Ok(s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    let disk_usage = process.disk_usage();
    println!("read bytes   : new/total => {}/{}",
        disk_usage.read_bytes,
        disk_usage.total_read_bytes,
    );
    println!("written bytes: new/total => {}/{}",
        disk_usage.written_bytes,
        disk_usage.total_written_bytes,
    );
}

pub fn user_id(&self) -> Option<&Uid>

Returns the ID of the owner user of this process or None if this information couldn’t be retrieved. If you want to get the User from it, take a look at Users::get_user_by_id.

use sysinfo::{Pid, System};

if let Ok(mut s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("User id for process 1337: {:?}", process.user_id());
}

pub fn effective_user_id(&self) -> Option<&Uid>

Returns the user ID of the effective owner of this process or None if this information couldn’t be retrieved. If you want to get the User from it, take a look at Users::get_user_by_id.

If you run something with sudo, the real user ID of the launched process will be the ID of the user you are logged in as but effective user ID will be 0 (i-e root).

⚠️ It always returns None on Windows.

use sysinfo::{Pid, System};

if let Ok(mut s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("User id for process 1337: {:?}", process.effective_user_id());
}

pub fn group_id(&self) -> Option<Gid>

Returns the process group ID of the process.

⚠️ It always returns None on Windows.

use sysinfo::{Pid, System};

if let Ok(mut s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("Group ID for process 1337: {:?}", process.group_id());
}

pub fn effective_group_id(&self) -> Option<Gid>

Returns the effective group ID of the process.

If you run something with sudo, the real group ID of the launched process will be the primary group ID you are logged in as but effective group ID will be 0 (i-e root).

⚠️ It always returns None on Windows.

use sysinfo::{Pid, System};

if let Ok(mut s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("User id for process 1337: {:?}", process.effective_group_id());
}

pub fn session_id(&self) -> Option<Pid>

Returns the session ID for the current process or None if it couldn’t be retrieved.

⚠️ This information is computed every time this method is called.

use sysinfo::{Pid, System};

if let Ok(mut s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    println!("Session ID for process 1337: {:?}", process.session_id());
}

pub fn tasks(&self) -> Option<&HashSet<Pid>>

Tasks run by this process. If there are none, returns None.

⚠️ This method always returns None on other platforms than Linux.

use sysinfo::{Pid, System};

if let Ok(mut s) = System::new_all()
    && let Some(process) = s.process(Pid::from(1337))
{
    if let Some(tasks) = process.tasks() {
        println!("Listing tasks for process {:?}", process.pid());
        for task_pid in tasks {
            if let Some(task) = s.process(*task_pid) {
                println!("Task {:?}: {:?}", task.pid(), task.name());
            }
        }
    }
}

pub fn thread_kind(&self) -> Option<ThreadKind>

If the process is a thread, it’ll return Some with the kind of thread it is. Returns None otherwise.

⚠️ This method always returns None on other platforms than Linux.

use sysinfo::System;

if let Ok(s) = System::new_all() {
    for (_, process) in s.processes() {
        if let Some(thread_kind) = process.thread_kind() {
            println!("Process {:?} is a {thread_kind:?} thread", process.pid());
        }
    }
}

pub fn exists(&self) -> bool

Returns true if the process doesn’t exist anymore but was not yet removed from the processes list because the remove_dead_processes argument was set to false in methods like System::refresh_processes.

use sysinfo::{ProcessesToUpdate, System};

if let Ok(mut s) = System::new_all() {
    // We set the `remove_dead_processes` to `false`.
    s.refresh_processes(ProcessesToUpdate::All, false);

    for (_, process) in s.processes() {
        println!(
            "Process {:?} {}",
            process.pid(),
            if process.exists() { "exists" } else { "doesn't exist" },
        );
    }
}

pub fn open_files(&self) -> Option<usize>

Returns the number of open files in the current process.

Returns None if it failed retrieving the information or if the current system is not supported.

Important: this information is computed every time this function is called.

⚠️ Not implemented on NetBSD.

use sysinfo::System;

if let Ok(s) = System::new_all() {
    for (_, process) in s.processes() {
        println!(
            "Process {:?} {:?}",
            process.pid(),
            process.open_files(),
        );
    }
}

Examples found in repository

examples/simple.rs (line 270)

fn interpret_input(
    input: &str,
    sys: Result<&mut System, &mut Error>,
    gpus: Result<&mut Gpus, &mut Error>,
    networks: Result<&mut Networks, &mut Error>,
    disks: Result<&mut Disks, &mut Error>,
    components: Result<&mut Components, &mut Error>,
    users: Result<&mut Users, &mut Error>,
) -> bool {
    match input.trim() {
        "help" => print_help(),
        "refresh_disks" => match disks {
            Ok(disks) => {
                println!("Refreshing disk list...");
                disks.refresh(true);
                println!("Done.");
            }
            Err(error) => {
                println!("Disks information cannot be retrieved: {error}");
            }
        },
        "refresh_users" => match users {
            Ok(users) => {
                println!("Refreshing user list...");
                users.refresh();
                println!("Done.");
            }
            Err(error) => {
                println!("Users information cannot be retrieved: {error}");
            }
        },
        "refresh_networks" => match networks {
            Ok(networks) => {
                println!("Refreshing network list...");
                networks.refresh(true);
                println!("Done.");
            }
            Err(error) => {
                println!("Networks information cannot be retrieved: {error}");
            }
        },
        "refresh_components" => match components {
            Ok(components) => {
                println!("Refreshing component list...");
                components.refresh(true);
                println!("Done.");
            }
            Err(error) => {
                println!("Components information cannot be retrieved: {error}");
            }
        },
        "refresh_cpu" => match sys {
            Ok(sys) => {
                println!("Refreshing CPUs...");
                sys.refresh_cpu_all();
                println!("Done.");
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "signals" => {
            for (nb, sig) in SUPPORTED_SIGNALS.iter().enumerate() {
                println!("{:2}:{sig:?}", nb + 1);
            }
        }
        "cpus" => {
            match sys {
                Ok(sys) => {
                    // Note: you should refresh a few times before using this, so that usage statistics
                    // can be ascertained
                    println!(
                        "number of physical cores: {}",
                        System::physical_core_count()
                            .map(|c| c.to_string())
                            .unwrap_or_else(|_| "Unknown".to_owned()),
                    );
                    println!("total CPU usage: {}%", sys.global_cpu_usage());
                    for cpu in sys.cpus() {
                        println!("{cpu:?}");
                    }
                }
                Err(error) => {
                    println!("System information cannot be retrieved: {error}");
                }
            }
        }
        "gpus" => match gpus {
            Ok(gpus) => {
                gpus.refresh(true);
                for gpu in &*gpus {
                    println!(
                        "GPU (PCI: {}): Vendor: {}",
                        gpu.pci(),
                        gpu.vendor().unwrap_or("Unknown")
                    );
                    if let Some(model) = gpu.model() {
                        println!("  model: {model}");
                    }
                    match gpu.usage() {
                        Some(usage) => println!("  usage: {usage}%"),
                        None => println!("  usage: N/A"),
                    }
                    if let (Some(used), Some(total)) = (gpu.used_memory(), gpu.total_memory()) {
                        println!("  memory: {}/{} KB", used / 1_000, total / 1_000);
                    } else {
                        println!("  memory: N/A");
                    }
                }
            }
            Err(error) => {
                println!("GPU information cannot be retrieved on this system: {error}");
            }
        },
        "memory" => match sys {
            Ok(sys) => {
                println!("total memory:     {: >10} KB", sys.total_memory() / 1_000);
                println!(
                    "available memory: {: >10} KB",
                    sys.available_memory() / 1_000
                );
                println!("used memory:      {: >10} KB", sys.used_memory() / 1_000);
                println!("total swap:       {: >10} KB", sys.total_swap() / 1_000);
                println!("used swap:        {: >10} KB", sys.used_swap() / 1_000);
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "quit" | "exit" => return true,
        "all" => match sys {
            Ok(sys) => {
                for (pid, proc_) in sys.processes() {
                    println!(
                        "{}:{} status={:?}",
                        pid,
                        proc_.name().to_string_lossy(),
                        proc_.status()
                    );
                }
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "frequency" => match sys {
            Ok(sys) => {
                for cpu in sys.cpus() {
                    println!("[{}] {} MHz", cpu.name(), cpu.frequency());
                }
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "vendor_id" => match sys {
            Ok(sys) => {
                println!("vendor ID: {}", sys.cpus()[0].vendor_id());
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "brand" => match sys {
            Ok(sys) => {
                println!("brand: {}", sys.cpus()[0].brand());
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "load_avg" => match System::load_average() {
            Ok(load_avg) => {
                println!("one minute     : {}%", load_avg.one);
                println!("five minutes   : {}%", load_avg.five);
                println!("fifteen minutes: {}%", load_avg.fifteen);
            }
            Err(error) => {
                eprintln!("Failed to get `load_average`: {error}");
            }
        },
        e if e.starts_with("show ") => {
            let tmp: Vec<&str> = e.split(' ').filter(|s| !s.is_empty()).collect();

            if tmp.len() != 2 {
                println!("show command takes a pid or a name in parameter!");
                println!("example: show 1254");
            } else {
                match sys {
                    Ok(sys) => {
                        if let Ok(pid) = Pid::from_str(tmp[1]) {
                            match sys.process(pid) {
                                Some(p) => {
                                    println!("{:#?}", *p);
                                    println!(
                                        "Files open/limit: {:?}/{:?}",
                                        p.open_files(),
                                        p.open_files_limit(),
                                    );
                                }
                                None => {
                                    println!("pid \"{pid:?}\" not found");
                                }
                            }
                        } else {
                            let proc_name = tmp[1];
                            for proc_ in sys.processes_by_name(proc_name.as_ref()) {
                                println!("==== {} ====", proc_.name().to_string_lossy());
                                println!("{proc_:?}");
                            }
                        }
                    }
                    Err(error) => {
                        println!("System information cannot be retrieved: {error}");
                    }
                }
            }
        }
        "temperature" => match components {
            Ok(components) => {
                for component in components.iter() {
                    println!("{component:?}");
                }
            }
            Err(error) => {
                println!("Components information cannot be retrieved: {error}");
            }
        },
        "network" => match networks {
            Ok(networks) => {
                for (interface_name, data) in networks.iter() {
                    println!(
                        "\
    {}:
      operational state {}
      ether {}
      input data  (new / total): {} / {} B
      output data (new / total): {} / {} B",
                        interface_name.display(),
                        data.operational_state(),
                        data.mac_address(),
                        data.received(),
                        data.total_received(),
                        data.transmitted(),
                        data.total_transmitted(),
                    );
                }
            }
            Err(error) => {
                println!("Networks information cannot be retrieved: {error}");
            }
        },
        "show" => {
            println!("'show' command expects a pid number or a process name");
        }
        e if e.starts_with("kill ") => {
            let tmp: Vec<&str> = e
                .split(' ')
                .map(|s| s.trim())
                .filter(|s| !s.is_empty())
                .collect();

            if tmp.len() != 3 {
                println!("kill command takes the pid and a signal number in parameter!");
                println!("example: kill 1254 9");
            } else {
                let Ok(pid) = Pid::from_str(tmp[1]) else {
                    eprintln!("Expected a number for the PID, found {:?}", tmp[1]);
                    return false;
                };
                let Ok(signal) = usize::from_str(tmp[2]) else {
                    eprintln!("Expected a number for the signal, found {:?}", tmp[2]);
                    return false;
                };
                let Some(signal) = SUPPORTED_SIGNALS.get(signal) else {
                    eprintln!(
                        "No signal matching {signal}. Use the `signals` command to get the \
                         list of signals.",
                    );
                    return false;
                };

                match sys {
                    Ok(sys) => match sys.process(pid) {
                        Some(p) => {
                            if let Some(res) = p.kill_with(*signal) {
                                println!("kill: {res}");
                            } else {
                                eprintln!("kill: signal not supported on this platform");
                            }
                        }
                        None => {
                            eprintln!("pid not found");
                        }
                    },
                    Err(error) => {
                        println!("System information cannot be retrieved: {error}");
                    }
                }
            }
        }
        "disks" => match disks {
            Ok(disks) => {
                for disk in disks {
                    println!("{disk:?}");
                }
            }
            Err(error) => {
                println!("Disks information cannot be retrieved: {error}");
            }
        },
        "users" => match users {
            Ok(users) => {
                for user in users {
                    println!("{:?} => {:?}", user.name(), user.groups());
                }
            }
            Err(error) => {
                println!("Users information cannot be retrieved: {error}");
            }
        },
        "groups" => match Groups::new_with_refreshed_list() {
            Ok(groups) => {
                for group in &groups {
                    println!("{group:?}");
                }
            }
            Err(error) => {
                println!("Groups information cannot be retrieved: {error}");
            }
        },
        "boot_time" => match System::boot_time() {
            Ok(boot_time) => println!("{boot_time} seconds"),
            Err(error) => eprintln!("Failed to get `boot_time`: {error}"),
        },
        "uptime" => match System::uptime() {
            Ok(up) => {
                let mut uptime = up;
                let days = uptime / 86400;
                uptime -= days * 86400;
                let hours = uptime / 3600;
                uptime -= hours * 3600;
                let minutes = uptime / 60;
                println!("{days} days {hours} hours {minutes} minutes ({up} seconds in total)");
            }
            Err(error) => eprintln!("Failed to get `uptime`: {error}"),
        },
        x if x.starts_with("refresh") => {
            if x == "refresh" {
                match sys {
                    Ok(sys) => {
                        println!("Getting processes' information...");
                        sys.refresh_all();
                        println!("Done.");
                    }
                    Err(error) => {
                        println!("System information cannot be retrieved: {error}");
                    }
                }
            } else if x.starts_with("refresh ") {
                println!("Getting process' information...");
                if let Some(pid) = x
                    .split(' ')
                    .filter_map(|pid| pid.parse().ok())
                    .take(1)
                    .next()
                {
                    match sys {
                        Ok(sys) => {
                            if sys.refresh_processes_specifics(
                                sysinfo::ProcessesToUpdate::Some(&[pid]),
                                true,
                                ProcessRefreshKind::everything(),
                            ) != 0
                            {
                                println!("Process `{pid}` updated successfully");
                            } else {
                                println!("Process `{pid}` couldn't be updated...");
                            }
                        }
                        Err(error) => {
                            println!("System information cannot be retrieved: {error}");
                        }
                    }
                } else {
                    println!("Invalid [pid] received...");
                }
            } else {
                println!(
                    "\"{x}\": Unknown command. Enter 'help' if you want to get the commands' \
                     list.",
                );
            }
        }
        "pid" => {
            println!(
                "PID: {}",
                sysinfo::get_current_pid().expect("failed to get PID")
            );
        }
        "system" => {
            println!(
                "System name:              {}\n\
                 System kernel version:    {}\n\
                 System OS version:        {}\n\
                 System OS (long) version: {}\n\
                 System host name:         {}\n\
                 System kernel:            {}",
                System::name().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::kernel_version().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::os_version().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::long_os_version().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::host_name().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::kernel_long_version().unwrap_or_else(|_| "<unknown>".to_owned()),
            );
        }
        "motherboard" => match Motherboard::new() {
            Ok(m) => println!("{m:#?}"),
            Err(error) => println!("Cannot retrieve motherboard information: {error:?}"),
        },
        "product" => {
            println!("{:#?}", Product);
        }
        e => {
            println!(
                "\"{e}\": Unknown command. Enter 'help' if you want to get the commands' \
                 list.",
            );
        }
    }
    false
}

pub fn open_files_limit(&self) -> Option<usize>

Returns the maximum number of open files for the current process.

Returns None if it failed retrieving the information or if the current system is not supported.

Important: this information is computed every time this function is called.

use sysinfo::System;

if let Ok(s) = System::new_all() {
    for (_, process) in s.processes() {
        println!(
            "Process {:?} {:?}",
            process.pid(),
            process.open_files_limit(),
        );
    }
}

Examples found in repository

examples/simple.rs (line 271)

fn interpret_input(
    input: &str,
    sys: Result<&mut System, &mut Error>,
    gpus: Result<&mut Gpus, &mut Error>,
    networks: Result<&mut Networks, &mut Error>,
    disks: Result<&mut Disks, &mut Error>,
    components: Result<&mut Components, &mut Error>,
    users: Result<&mut Users, &mut Error>,
) -> bool {
    match input.trim() {
        "help" => print_help(),
        "refresh_disks" => match disks {
            Ok(disks) => {
                println!("Refreshing disk list...");
                disks.refresh(true);
                println!("Done.");
            }
            Err(error) => {
                println!("Disks information cannot be retrieved: {error}");
            }
        },
        "refresh_users" => match users {
            Ok(users) => {
                println!("Refreshing user list...");
                users.refresh();
                println!("Done.");
            }
            Err(error) => {
                println!("Users information cannot be retrieved: {error}");
            }
        },
        "refresh_networks" => match networks {
            Ok(networks) => {
                println!("Refreshing network list...");
                networks.refresh(true);
                println!("Done.");
            }
            Err(error) => {
                println!("Networks information cannot be retrieved: {error}");
            }
        },
        "refresh_components" => match components {
            Ok(components) => {
                println!("Refreshing component list...");
                components.refresh(true);
                println!("Done.");
            }
            Err(error) => {
                println!("Components information cannot be retrieved: {error}");
            }
        },
        "refresh_cpu" => match sys {
            Ok(sys) => {
                println!("Refreshing CPUs...");
                sys.refresh_cpu_all();
                println!("Done.");
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "signals" => {
            for (nb, sig) in SUPPORTED_SIGNALS.iter().enumerate() {
                println!("{:2}:{sig:?}", nb + 1);
            }
        }
        "cpus" => {
            match sys {
                Ok(sys) => {
                    // Note: you should refresh a few times before using this, so that usage statistics
                    // can be ascertained
                    println!(
                        "number of physical cores: {}",
                        System::physical_core_count()
                            .map(|c| c.to_string())
                            .unwrap_or_else(|_| "Unknown".to_owned()),
                    );
                    println!("total CPU usage: {}%", sys.global_cpu_usage());
                    for cpu in sys.cpus() {
                        println!("{cpu:?}");
                    }
                }
                Err(error) => {
                    println!("System information cannot be retrieved: {error}");
                }
            }
        }
        "gpus" => match gpus {
            Ok(gpus) => {
                gpus.refresh(true);
                for gpu in &*gpus {
                    println!(
                        "GPU (PCI: {}): Vendor: {}",
                        gpu.pci(),
                        gpu.vendor().unwrap_or("Unknown")
                    );
                    if let Some(model) = gpu.model() {
                        println!("  model: {model}");
                    }
                    match gpu.usage() {
                        Some(usage) => println!("  usage: {usage}%"),
                        None => println!("  usage: N/A"),
                    }
                    if let (Some(used), Some(total)) = (gpu.used_memory(), gpu.total_memory()) {
                        println!("  memory: {}/{} KB", used / 1_000, total / 1_000);
                    } else {
                        println!("  memory: N/A");
                    }
                }
            }
            Err(error) => {
                println!("GPU information cannot be retrieved on this system: {error}");
            }
        },
        "memory" => match sys {
            Ok(sys) => {
                println!("total memory:     {: >10} KB", sys.total_memory() / 1_000);
                println!(
                    "available memory: {: >10} KB",
                    sys.available_memory() / 1_000
                );
                println!("used memory:      {: >10} KB", sys.used_memory() / 1_000);
                println!("total swap:       {: >10} KB", sys.total_swap() / 1_000);
                println!("used swap:        {: >10} KB", sys.used_swap() / 1_000);
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "quit" | "exit" => return true,
        "all" => match sys {
            Ok(sys) => {
                for (pid, proc_) in sys.processes() {
                    println!(
                        "{}:{} status={:?}",
                        pid,
                        proc_.name().to_string_lossy(),
                        proc_.status()
                    );
                }
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "frequency" => match sys {
            Ok(sys) => {
                for cpu in sys.cpus() {
                    println!("[{}] {} MHz", cpu.name(), cpu.frequency());
                }
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "vendor_id" => match sys {
            Ok(sys) => {
                println!("vendor ID: {}", sys.cpus()[0].vendor_id());
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "brand" => match sys {
            Ok(sys) => {
                println!("brand: {}", sys.cpus()[0].brand());
            }
            Err(error) => {
                println!("System information cannot be retrieved: {error}");
            }
        },
        "load_avg" => match System::load_average() {
            Ok(load_avg) => {
                println!("one minute     : {}%", load_avg.one);
                println!("five minutes   : {}%", load_avg.five);
                println!("fifteen minutes: {}%", load_avg.fifteen);
            }
            Err(error) => {
                eprintln!("Failed to get `load_average`: {error}");
            }
        },
        e if e.starts_with("show ") => {
            let tmp: Vec<&str> = e.split(' ').filter(|s| !s.is_empty()).collect();

            if tmp.len() != 2 {
                println!("show command takes a pid or a name in parameter!");
                println!("example: show 1254");
            } else {
                match sys {
                    Ok(sys) => {
                        if let Ok(pid) = Pid::from_str(tmp[1]) {
                            match sys.process(pid) {
                                Some(p) => {
                                    println!("{:#?}", *p);
                                    println!(
                                        "Files open/limit: {:?}/{:?}",
                                        p.open_files(),
                                        p.open_files_limit(),
                                    );
                                }
                                None => {
                                    println!("pid \"{pid:?}\" not found");
                                }
                            }
                        } else {
                            let proc_name = tmp[1];
                            for proc_ in sys.processes_by_name(proc_name.as_ref()) {
                                println!("==== {} ====", proc_.name().to_string_lossy());
                                println!("{proc_:?}");
                            }
                        }
                    }
                    Err(error) => {
                        println!("System information cannot be retrieved: {error}");
                    }
                }
            }
        }
        "temperature" => match components {
            Ok(components) => {
                for component in components.iter() {
                    println!("{component:?}");
                }
            }
            Err(error) => {
                println!("Components information cannot be retrieved: {error}");
            }
        },
        "network" => match networks {
            Ok(networks) => {
                for (interface_name, data) in networks.iter() {
                    println!(
                        "\
    {}:
      operational state {}
      ether {}
      input data  (new / total): {} / {} B
      output data (new / total): {} / {} B",
                        interface_name.display(),
                        data.operational_state(),
                        data.mac_address(),
                        data.received(),
                        data.total_received(),
                        data.transmitted(),
                        data.total_transmitted(),
                    );
                }
            }
            Err(error) => {
                println!("Networks information cannot be retrieved: {error}");
            }
        },
        "show" => {
            println!("'show' command expects a pid number or a process name");
        }
        e if e.starts_with("kill ") => {
            let tmp: Vec<&str> = e
                .split(' ')
                .map(|s| s.trim())
                .filter(|s| !s.is_empty())
                .collect();

            if tmp.len() != 3 {
                println!("kill command takes the pid and a signal number in parameter!");
                println!("example: kill 1254 9");
            } else {
                let Ok(pid) = Pid::from_str(tmp[1]) else {
                    eprintln!("Expected a number for the PID, found {:?}", tmp[1]);
                    return false;
                };
                let Ok(signal) = usize::from_str(tmp[2]) else {
                    eprintln!("Expected a number for the signal, found {:?}", tmp[2]);
                    return false;
                };
                let Some(signal) = SUPPORTED_SIGNALS.get(signal) else {
                    eprintln!(
                        "No signal matching {signal}. Use the `signals` command to get the \
                         list of signals.",
                    );
                    return false;
                };

                match sys {
                    Ok(sys) => match sys.process(pid) {
                        Some(p) => {
                            if let Some(res) = p.kill_with(*signal) {
                                println!("kill: {res}");
                            } else {
                                eprintln!("kill: signal not supported on this platform");
                            }
                        }
                        None => {
                            eprintln!("pid not found");
                        }
                    },
                    Err(error) => {
                        println!("System information cannot be retrieved: {error}");
                    }
                }
            }
        }
        "disks" => match disks {
            Ok(disks) => {
                for disk in disks {
                    println!("{disk:?}");
                }
            }
            Err(error) => {
                println!("Disks information cannot be retrieved: {error}");
            }
        },
        "users" => match users {
            Ok(users) => {
                for user in users {
                    println!("{:?} => {:?}", user.name(), user.groups());
                }
            }
            Err(error) => {
                println!("Users information cannot be retrieved: {error}");
            }
        },
        "groups" => match Groups::new_with_refreshed_list() {
            Ok(groups) => {
                for group in &groups {
                    println!("{group:?}");
                }
            }
            Err(error) => {
                println!("Groups information cannot be retrieved: {error}");
            }
        },
        "boot_time" => match System::boot_time() {
            Ok(boot_time) => println!("{boot_time} seconds"),
            Err(error) => eprintln!("Failed to get `boot_time`: {error}"),
        },
        "uptime" => match System::uptime() {
            Ok(up) => {
                let mut uptime = up;
                let days = uptime / 86400;
                uptime -= days * 86400;
                let hours = uptime / 3600;
                uptime -= hours * 3600;
                let minutes = uptime / 60;
                println!("{days} days {hours} hours {minutes} minutes ({up} seconds in total)");
            }
            Err(error) => eprintln!("Failed to get `uptime`: {error}"),
        },
        x if x.starts_with("refresh") => {
            if x == "refresh" {
                match sys {
                    Ok(sys) => {
                        println!("Getting processes' information...");
                        sys.refresh_all();
                        println!("Done.");
                    }
                    Err(error) => {
                        println!("System information cannot be retrieved: {error}");
                    }
                }
            } else if x.starts_with("refresh ") {
                println!("Getting process' information...");
                if let Some(pid) = x
                    .split(' ')
                    .filter_map(|pid| pid.parse().ok())
                    .take(1)
                    .next()
                {
                    match sys {
                        Ok(sys) => {
                            if sys.refresh_processes_specifics(
                                sysinfo::ProcessesToUpdate::Some(&[pid]),
                                true,
                                ProcessRefreshKind::everything(),
                            ) != 0
                            {
                                println!("Process `{pid}` updated successfully");
                            } else {
                                println!("Process `{pid}` couldn't be updated...");
                            }
                        }
                        Err(error) => {
                            println!("System information cannot be retrieved: {error}");
                        }
                    }
                } else {
                    println!("Invalid [pid] received...");
                }
            } else {
                println!(
                    "\"{x}\": Unknown command. Enter 'help' if you want to get the commands' \
                     list.",
                );
            }
        }
        "pid" => {
            println!(
                "PID: {}",
                sysinfo::get_current_pid().expect("failed to get PID")
            );
        }
        "system" => {
            println!(
                "System name:              {}\n\
                 System kernel version:    {}\n\
                 System OS version:        {}\n\
                 System OS (long) version: {}\n\
                 System host name:         {}\n\
                 System kernel:            {}",
                System::name().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::kernel_version().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::os_version().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::long_os_version().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::host_name().unwrap_or_else(|_| "<unknown>".to_owned()),
                System::kernel_long_version().unwrap_or_else(|_| "<unknown>".to_owned()),
            );
        }
        "motherboard" => match Motherboard::new() {
            Ok(m) => println!("{m:#?}"),
            Err(error) => println!("Cannot retrieve motherboard information: {error:?}"),
        },
        "product" => {
            println!("{:#?}", Product);
        }
        e => {
            println!(
                "\"{e}\": Unknown command. Enter 'help' if you want to get the commands' \
                 list.",
            );
        }
    }
    false
}

pub fn gpu_usage(&self) -> Option<f32>

Returns the total % usage of all GPUs by this process.

Returns None if it failed retrieving the information or if the current system is not supported.

use sysinfo::System;

if let Ok(s) = System::new_all() {
    for (_, process) in s.processes() {
        println!(
            "[Process {:?}] GPU usage: {:?}%",
            process.pid(),
            process.gpu_usage(),
        );
    }
}

pub fn gpu_memory(&self) -> Option<u64>

Returns the GPU memory usage of all GPUs by this process in bytes. It doesn’t necessarily mean the VRAM, just the memory used by the GPU(s).

Returns None if it failed retrieving the information or if the current system is not supported.

use sysinfo::System;

if let Ok(s) = System::new_all() {
    for (_, process) in s.processes() {
        println!(
            "[Process {:?}] GPU memory usage: {:?} bytes",
            process.pid(),
            process.gpu_memory(),
        );
    }
}

Trait Implementations

impl Debug for Process

Available on crate feature system only.

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Serialize for Process

Available on crate feature system only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.