Sysinfo

https://docs.rs/sysinfo/latest
Admin
Sysinfo is a Rust crate used to retrieve comprehensive system information, including memory, CPU,...
Tokens:548,876
Snippets:4,477
Trust Score:9.7
Update:2 months ago
Show doc for...
Tokens:
Raw
### Main Loop Example

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.Networks.html

Example of integrating Networks into a command-line interface loop.

```rust
352fn main() {
353    println!("Getting system information...");
354    let mut system = System::new_all();
355    let mut networks = Networks::new_with_refreshed_list();
356    let mut disks = Disks::new_with_refreshed_list();
357    let mut components = Components::new_with_refreshed_list();
358    let mut users = Users::new_with_refreshed_list();
359
360    println!("Done.");
361    let t_stin = io::stdin();
362    let mut stin = t_stin.lock();
363    let mut done = false;
364
365    println!("To get the commands' list, enter 'help'.");
366    while !done {
367        let mut input = String::new();
368        write!(&mut io::stdout(), "> ");
369        io::stdout().flush();
370
371        stin.read_line(&mut input);
372        if input.is_empty() {
373            // The string is empty, meaning there is no '\n', meaning
374            // that the user used CTRL+D so we can just quit!
375            println!("\nLeaving, bye!");
376            break;
377        }
378        if (&input as &str).ends_with('\n') {
379            input.pop();
380        }
381        done = interpret_input(
382            input.as_ref(),
383            &mut system,
384            &mut networks,
385            &mut disks,
386            &mut components,
387            &mut users,
388        );
389    }
390}
```

--------------------------------

### System Information CLI Example

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.System.html?search=std%3A%3Avec

A comprehensive example demonstrating how to manage system, network, disk, and user information in a loop.

```rust
352fn main() {
353    println!("Getting system information...");
354    let mut system = System::new_all();
355    let mut networks = Networks::new_with_refreshed_list();
356    let mut disks = Disks::new_with_refreshed_list();
357    let mut components = Components::new_with_refreshed_list();
358    let mut users = Users::new_with_refreshed_list();
359
360    println!("Done.");
361    let t_stin = io::stdin();
362    let mut stin = t_stin.lock();
363    let mut done = false;
364
365    println!("To get the commands' list, enter 'help'.");
366    while !done {
367        let mut input = String::new();
368        write!(&mut io::stdout(), "> ");
369        io::stdout().flush();
370
371        stin.read_line(&mut input);
372        if input.is_empty() {
373            // The string is empty, meaning there is no '\n', meaning
374            // that the user used CTRL+D so we can just quit!
375            println!("\nLeaving, bye!");
376            break;
377        }
378        if (&input as &str).ends_with('\n') {
379            input.pop();
380        }
381        done = interpret_input(
382            input.as_ref(),
383            &mut system,
384            &mut networks,
385            &mut disks,
386            &mut components,
387            &mut users,
388        );
389    }
390}
```

```rust
70fn interpret_input(
71    input: &str,
72    sys: &mut System,
73    networks: &mut Networks,
74    disks: &mut Disks,
75    components: &mut Components,
76    users: &mut Users,
77) -> bool {
78    match input.trim() {
79        "help" => print_help(),
80        "refresh_disks" => {
81            println!("Refreshing disk list...");
82            disks.refresh(true);
83            println!("Done.");
84        }
85        "refresh_users" => {
86            println!("Refreshing user list...");
87            users.refresh();
88            println!("Done.");
89        }
90        "refresh_networks" => {
91            println!("Refreshing network list...");
92            networks.refresh(true);
93            println!("Done.");
94        }
95        "refresh_components" => {
96            println!("Refreshing component list...");
97            components.refresh(true);
```

--------------------------------

### Initializing Slice for Sorting

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.Components.html?search=std%3A%3Avec

Example setup for demonstrating slice sorting.

```rust
let mut v = [4, -5, 1, -3, 2];
```

--------------------------------

### Sysinfo Interactive CLI Example

Source: https://docs.rs/sysinfo/latest/src/simple/simple.rs.html?search=u32+-%3E+bool

A comprehensive example showing how to initialize system components and interpret user input to fetch various system metrics.

```rust
1// Take a look at the license at the top of the repository in the LICENSE file.
2
3#![crate_type = "bin"]
4#![allow(unused_must_use, non_upper_case_globals)]
5#![allow(clippy::manual_range_contains)]
6
7use std::io::{self, BufRead, Write};
8use std::str::FromStr;
9use sysinfo::{
10    Components, Disks, Groups, Motherboard, Networks, Pid, Product, SUPPORTED_SIGNALS, System,
11    Users,
12};
13
14fn print_help() {
15    println!(
16        "\
17== Help menu ==
18
19help               : shows this menu
20quit               : exits the program
21
22= Refresh commands =
23
24refresh            : reloads all processes information
25refresh [pid]      : reloads corresponding process information
26refresh_components : reloads components information
27refresh_cpu        : reloads CPU information
28refresh_disks      : reloads disks information
29refresh_networks   : reloads networks information
30refresh_users      : reloads users information
31
32= Process commands =
33
34all                : displays all process name and pid
35kill [pid] [signal]: sends [signal] to the process with this [pid]. To get the [signal] number, use the `signals` command.
36show [pid | name]  : shows information of the given process corresponding to [pid | name]
37signals            : shows the available signals
38pid                : displays this example's PID
39
40= CPU commands =
41
42brand              : displays CPU brand
43cpus               : displays CPUs state
44frequency          : displays CPU frequency
45vendor_id          : displays CPU vendor id
46
47= Users and groups commands =
48
49groups             : displays all groups
50users              : displays all users and their groups
51
52= System commands =
53
54boot_time          : displays system boot time
55load_avg           : displays system load average
56system             : displays system information (such as name, version and hostname)
57uptime             : displays system uptime
58motherboard        : displays motherboard information
59product            : displays product information
60
61= Extra components commands =
62
63disks              : displays disks' information
64memory             : displays memory state
65network            : displays network' information
66temperature        : displays components' temperature"
67    );
68}
69
70fn interpret_input(
71    input: &str,
72    sys: &mut System,
73    networks: &mut Networks,
74    disks: &mut Disks,
75    components: &mut Components,
76    users: &mut Users,
77) -> bool {
78    match input.trim() {
79        "help" => print_help(),
80        "refresh_disks" => {
81            println!("Refreshing disk list...");
82            disks.refresh(true);
83            println!("Done.");
84        }
85        "refresh_users" => {
86            println!("Refreshing user list...");
87            users.refresh();
88            println!("Done.");
89        }
90        "refresh_networks" => {
91            println!("Refreshing network list...");
92            networks.refresh(true);
93            println!("Done.");
94        }
95        "refresh_components" => {
96            println!("Refreshing component list...");
97            components.refresh(true);
98            println!("Done.");
99        }
100        "refresh_cpu" => {
101            println!("Refreshing CPUs...");
102            sys.refresh_cpu_all();
103            println!("Done.");
104        }
105        "signals" => {
106            for (nb, sig) in SUPPORTED_SIGNALS.iter().enumerate() {
107                println!("{:2}:{sig:?}", nb + 1);
108            }
109        }
110        "cpus" => {
111            // Note: you should refresh a few times before using this, so that usage statistics
112            // can be ascertained
113            println!(
114                "number of physical cores: {}",
115                System::physical_core_count()
116                    .map(|c| c.to_string())
117                    .unwrap_or_else(|| "Unknown".to_owned()),
118            );
119            println!("total CPU usage: {}%", sys.global_cpu_usage());
120            for cpu in sys.cpus() {
121                println!("{cpu:?}");
122            }
123        }
124        "memory" => {
125            println!("total memory:     {: >10} KB", sys.total_memory() / 1_000);
126            println!(
127                "available memory: {: >10} KB",
128                sys.available_memory() / 1_000
129            );
130            println!("used memory:      {: >10} KB", sys.used_memory() / 1_000);
131            println!("total swap:       {: >10} KB", sys.total_swap() / 1_000);
132            println!("used swap:        {: >10} KB", sys.used_swap() / 1_000);
133        }
134        "quit" | "exit" => return true,
135        "all" => {
136            for (pid, proc_) in sys.processes() {
137                println!("
```

--------------------------------

### System Example: Refreshing Users

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.Users.html

Example from the repository showing how to trigger a refresh of the user list via user input.

```rust
70fn interpret_input(
71    input: &str,
72    sys: &mut System,
73    networks: &mut Networks,
74    disks: &mut Disks,
75    components: &mut Components,
76    users: &mut Users,
77) -> bool {
78    match input.trim() {
79        "help" => print_help(),
80        "refresh_disks" => {
81            println!("Refreshing disk list...");
82            disks.refresh(true);
83            println!("Done.");
84        }
85        "refresh_users" => {
86            println!("Refreshing user list...");
87            users.refresh();
88            println!("Done.");
89        }
90        "refresh_networks" => {
91            println!("Refreshing network list...");
92            networks.refresh(true);
93            println!("Done.");
94        }
95        "refresh_components" => {
96            println!("Refreshing component list...");
97            components.refresh(true);
98            println!("Done.");
99        }
100        "refresh_cpu" => {
101            println!("Refreshing CPUs...");
102            sys.refresh_cpu_all();
103            println!("Done.");
104        }
105        "signals" => {
106            for (nb, sig) in SUPPORTED_SIGNALS.iter().enumerate() {
107                println!("{:2}:{sig:?}", nb + 1);
108            }
109        }
110        "cpus" => {
111            // Note: you should refresh a few times before using this, so that usage statistics
112            // can be ascertained
113            println!(
114                "number of physical cores: {}",
115                System::physical_core_count()
116                    .map(|c| c.to_string())
117                    .unwrap_or_else(|| "Unknown".to_owned()),
118            );
119            println!("total CPU usage: {}%", sys.global_cpu_usage());
120            for cpu in sys.cpus() {
121                println!("{cpu:?}");
122            }
123        }
124        "memory" => {
```

--------------------------------

### Repository Example: Refreshing Disks

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.Disks.html?search=std%3A%3Avec

Example from the repository showing how to trigger a disk refresh within an input loop.

```rust
70fn interpret_input(
71    input: &str,
72    sys: &mut System,
73    networks: &mut Networks,
74    disks: &mut Disks,
75    components: &mut Components,
76    users: &mut Users,
77) -> bool {
78    match input.trim() {
79        "help" => print_help(),
80        "refresh_disks" => {
81            println!("Refreshing disk list...");
82            disks.refresh(true);
83            println!("Done.");
84        }
85        "refresh_users" => {
86            println!("Refreshing user list...");
87            users.refresh();
88            println!("Done.");
89        }
90        "refresh_networks" => {
91            println!("Refreshing network list...");
92            networks.refresh(true);
93            println!("Done.");
94        }
95        "refresh_components" => {
96            println!("Refreshing component list...");
97            components.refresh(true);
98            println!("Done.");
99        }
100        "refresh_cpu" => {
```

--------------------------------

### Repository Example: Input Interpretation

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.System.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Example from the repository showing how to handle user input to refresh specific system components.

```rust
70fn interpret_input(
71    input: &str,
72    sys: &mut System,
73    networks: &mut Networks,
74    disks: &mut Disks,
75    components: &mut Components,
76    users: &mut Users,
77) -> bool {
78    match input.trim() {
79        "help" => print_help(),
80        "refresh_disks" => {
81            println!("Refreshing disk list...");
82            disks.refresh(true);
83            println!("Done.");
84        }
85        "refresh_users" => {
86            println!("Refreshing user list...");
87            users.refresh();
88            println!("Done.");
89        }
90        "refresh_networks" => {
91            println!("Refreshing network list...");
92            networks.refresh(true);
93            println!("Done.");
94        }
95        "refresh_components" => {
96            println!("Refreshing component list...");
97            components.refresh(true);
```

--------------------------------

### Repository Example: Interpret Input

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.Networks.html?search=

Handles the 'refresh_networks' command within the repository's example application.

```rust
70fn interpret_input(
71    input: &str,
72    sys: &mut System,
73    networks: &mut Networks,
74    disks: &mut Disks,
75    components: &mut Components,
76    users: &mut Users,
77) -> bool {
78    match input.trim() {
79        "help" => print_help(),
80        "refresh_disks" => {
81            println!("Refreshing disk list...");
82            disks.refresh(true);
83            println!("Done.");
84        }
85        "refresh_users" => {
86            println!("Refreshing user list...");
87            users.refresh();
88            println!("Done.");
89        }
90        "refresh_networks" => {
91            println!("Refreshing network list...");
92            networks.refresh(true);
93            println!("Done.");
94        }
95        "refresh_components" => {
96            println!("Refreshing component list...");
97            components.refresh(true);
98            println!("Done.");
99        }
100        "refresh_cpu" => {
101            println!("Refreshing CPUs...");
102            sys.refresh_cpu_all();
103            println!("Done.");
104        }
105        "signals" => {
106            for (nb, sig) in SUPPORTED_SIGNALS.iter().enumerate() {
107                println!("{:2}:{sig:?}", nb + 1);
108            }
109        }
110        "cpus" => {
111            // Note: you should refresh a few times before using this, so that usage statistics
112            // can be ascertained
113            println!(
114                "number of physical cores: {}",
115                System::physical_core_count()
116                    .map(|c| c.to_string())
117                    .unwrap_or_else(|| "Unknown".to_owned()),
118            );
119            println!("total CPU usage: {}%", sys.global_cpu_usage());
120            for cpu in sys.cpus() {
121                println!("{cpu:?}");
122            }
123        }
```

--------------------------------

### Slice Chunking and Indexing Examples

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.Users.html?search=std%3A%3Avec

Examples demonstrating the use of split_last_chunk, last_chunk, and get methods on slices.

```rust
assert_eq!(None, x.split_first_chunk_mut::<4>());
```

```rust
let x = &[0, 1, 2];

if let Some((elements, last)) = x.split_last_chunk::<2>() {
    assert_eq!(elements, &[0]);
    assert_eq!(last, &[1, 2]);
}

assert_eq!(None, x.split_last_chunk::<4>());
```

```rust
let x = &mut [0, 1, 2];

if let Some((elements, last)) = x.split_last_chunk_mut::<2>() {
    last[0] = 3;
    last[1] = 4;
    elements[0] = 5;
}
assert_eq!(x, &[5, 3, 4]);

assert_eq!(None, x.split_last_chunk_mut::<4>());
```

```rust
let u = [10, 40, 30];
assert_eq!(Some(&[40, 30]), u.last_chunk::<2>());

let v: &[i32] = &[10];
assert_eq!(None, v.last_chunk::<2>());

let w: &[i32] = &[];
assert_eq!(Some(&[]), w.last_chunk::<0>());
```

```rust
let x = &mut [0, 1, 2];

if let Some(last) = x.last_chunk_mut::<2>() {
    last[0] = 10;
    last[1] = 20;
}
assert_eq!(x, &[0, 10, 20]);

assert_eq!(None, x.last_chunk_mut::<4>());
```

```rust
let v = [10, 40, 30];
assert_eq!(Some(&40), v.get(1));
assert_eq!(Some(&[10, 40][..]), v.get(0..2));
assert_eq!(None, v.get(3));
assert_eq!(None, v.get(0..4));
```

--------------------------------

### Initialize System and Users

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.Users.html?search=

Basic setup for initializing the system and user list.

```rust
use sysinfo::{Pid, System, Users};

let mut s = System::new_all();
let users = Users::new_with_refreshed_list();
```

--------------------------------

### Repository Examples

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.Users.html?search=std%3A%3Avec

Code snippets extracted from the repository's example files.

```rust
352fn main() {
353    println!("Getting system information...");
354    let mut system = System::new_all();
355    let mut networks = Networks::new_with_refreshed_list();
356    let mut disks = Disks::new_with_refreshed_list();
357    let mut components = Components::new_with_refreshed_list();
358    let mut users = Users::new_with_refreshed_list();
359
360    println!("Done.");
361    let t_stin = io::stdin();
362    let mut stin = t_stin.lock();
363    let mut done = false;
364
365    println!("To get the commands' list, enter 'help'.");
366    while !done {
367        let mut input = String::new();
368        write!(&mut io::stdout(), "> ");
369        io::stdout().flush();
370
371        stin.read_line(&mut input);
372        if input.is_empty() {
373            // The string is empty, meaning there is no '\n', meaning
374            // that the user used CTRL+D so we can just quit!
375            println!("\nLeaving, bye!");
376            break;
377        }
378        if (&input as &str).ends_with('\n') {
379            input.pop();
380        }
381        done = interpret_input(
382            input.as_ref(),
383            &mut system,
384            &mut networks,
385            &mut disks,
386            &mut components,
387            &mut users,
388        );
389    }
390}
```

```rust
70fn interpret_input(
71    input: &str,
72    sys: &mut System,
73    networks: &mut Networks,
74    disks: &mut Disks,
75    components: &mut Components,
76    users: &mut Users,
77) -> bool {
78    match input.trim() {
79        "help" => print_help(),
80        "refresh_disks" => {
81            println!("Refreshing disk list...");
82            disks.refresh(true);
83            println!("Done.");
84        }
85        "refresh_users" => {
86            println!("Refreshing user list...");
87            users.refresh();
88            println!("Done.");
89        }
90        "refresh_networks" => {
91            println!("Refreshing network list...");
92            networks.refresh(true);
93            println!("Done.");
94        }
95        "refresh_components" => {
96            println!("Refreshing component list...");
97            components.refresh(true);
98            println!("Done.");
99        }
100        "refresh_cpu" => {
101            println!("Refreshing CPUs...");
102            sys.refresh_cpu_all();
103            println!("Done.");
104        }
105        "signals" => {
106            for (nb, sig) in SUPPORTED_SIGNALS.iter().enumerate() {
107                println!("{:2}:{sig:?}", nb + 1);
108            }
109        }
110        "cpus" => {
111            // Note: you should refresh a few times before using this, so that usage statistics
112            // can be ascertained
113            println!(
114                "number of physical cores: {}",
115                System::physical_core_count()
116                    .map(|c| c.to_string())
117                    .unwrap_or_else(|| "Unknown".to_owned()),
118            );
119            println!("total CPU usage: {}%", sys.global_cpu_usage());
120            for cpu in sys.cpus() {
121                println!("{cpu:?}");
122            }
123        }
124        "memory" => {
```

--------------------------------

### System Monitoring CLI Example

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.Process.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

A command-line interface implementation for interacting with system metrics.

```rust
70fn interpret_input(
71    input: &str,
72    sys: &mut System,
73    networks: &mut Networks,
74    disks: &mut Disks,
75    components: &mut Components,
76    users: &mut Users,
77) -> bool {
78    match input.trim() {
79        "help" => print_help(),
80        "refresh_disks" => {
81            println!("Refreshing disk list...");
82            disks.refresh(true);
83            println!("Done.");
84        }
85        "refresh_users" => {
86            println!("Refreshing user list...");
87            users.refresh();
88            println!("Done.");
89        }
90        "refresh_networks" => {
91            println!("Refreshing network list...");
92            networks.refresh(true);
93            println!("Done.");
94        }
95        "refresh_components" => {
96            println!("Refreshing component list...");
97            components.refresh(true);
98            println!("Done.");
99        }
100        "refresh_cpu" => {
101            println!("Refreshing CPUs...");
102            sys.refresh_cpu_all();
103            println!("Done.");
104        }
105        "signals" => {
106            for (nb, sig) in SUPPORTED_SIGNALS.iter().enumerate() {
107                println!("{:2}:{sig:?}", nb + 1);
108            }
109        }
110        "cpus" => {
111            // Note: you should refresh a few times before using this, so that usage statistics
112            // can be ascertained
113            println!(
114                "number of physical cores: {}",
115                System::physical_core_count()
116                    .map(|c| c.to_string())
117                    .unwrap_or_else(|| "Unknown".to_owned()),
118            );
119            println!("total CPU usage: {}%", sys.global_cpu_usage());
120            for cpu in sys.cpus() {
121                println!("{cpu:?}");
122            }
123        }
124        "memory" => {
125            println!("total memory:     {: >10} KB", sys.total_memory() / 1_000);
126            println!(
127                "available memory: {: >10} KB",
128                sys.available_memory() / 1_000
129            );
130            println!("used memory:      {: >10} KB", sys.used_memory() / 1_000);
131            println!("total swap:       {: >10} KB", sys.total_swap() / 1_000);
```

--------------------------------

### Interactive System Example

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.System.html

Example code demonstrating the use of System within an interactive command-line loop.

```rust
352fn main() {
353    println!("Getting system information...");
354    let mut system = System::new_all();
355    let mut networks = Networks::new_with_refreshed_list();
356    let mut disks = Disks::new_with_refreshed_list();
357    let mut components = Components::new_with_refreshed_list();
358    let mut users = Users::new_with_refreshed_list();
359
360    println!("Done.");
361    let t_stin = io::stdin();
362    let mut stin = t_stin.lock();
363    let mut done = false;
364
365    println!("To get the commands' list, enter 'help'.");
366    while !done {
367        let mut input = String::new();
368        write!(&mut io::stdout(), "> ");
369        io::stdout().flush();
370
371        stin.read_line(&mut input);
372        if input.is_empty() {
373            // The string is empty, meaning there is no '\n', meaning
374            // that the user used CTRL+D so we can just quit!
375            println!("\nLeaving, bye!");
376            break;
377        }
378        if (&input as &str).ends_with('\n') {
379            input.pop();
380        }
381        done = interpret_input(
382            input.as_ref(),
383            &mut system,
384            &mut networks,
385            &mut disks,
386            &mut components,
387            &mut users,
388        );
389    }
390}
```

```rust
70fn interpret_input(
71    input: &str,
72    sys: &mut System,
73    networks: &mut Networks,
74    disks: &mut Disks,
75    components: &mut Components,
76    users: &mut Users,
77) -> bool {
78    match input.trim() {
79        "help" => print_help(),
80        "refresh_disks" => {
81            println!("Refreshing disk list...");
82            disks.refresh(true);
83            println!("Done.");
84        }
85        "refresh_users" => {
86            println!("Refreshing user list...");
87            users.refresh();
88            println!("Done.");
89        }
90        "refresh_networks" => {
91            println!("Refreshing network list...");
92            networks.refresh(true);
93            println!("Done.");
94        }
95        "refresh_components" => {
96            println!("Refreshing component list...");
```

--------------------------------

### System Resource and User Enumeration

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.System.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Examples for listing disks, users, and groups.

```rust
for disk in disks {
    println!("{disk:?}");
}
```

```rust
for user in users {
    println!("{:?} => {:?}", user.name(), user.groups());
}
```

```rust
for group in Groups::new_with_refreshed_list().list() {
    println!("{group:?}");
}
```

--------------------------------

### Basic SIMD Sum Example

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.Disks.html?search=

Demonstrates a basic SIMD summation operation.

```rust
let numbers: Vec<f32> = (1..101).map(|x| x as _).collect();
assert_eq!(basic_simd_sum(&numbers[1..99]), 4949.0);
```

--------------------------------

### Get User by ID Iterator Example

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.Users.html?search=

Example usage of an iterator returning slice references.

```rust
assert_eq!(iter.next(), Some(&mut [1, 1, 2, 3][..]));
assert_eq!(iter.next(), Some(&mut [2, 3][..]));
assert_eq!(iter.next(), Some(&mut [2, 3, 4][..]));
assert_eq!(iter.next(), None);
```

--------------------------------

### Retrieve Process Start Time

Source: https://docs.rs/sysinfo/latest/src/sysinfo/common/system.rs.html?search=

Get the process start time in seconds since epoch.

```rust
use sysinfo::{Pid, System};

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

--------------------------------

### System Metrics and Utilities

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.NetworkData.html

Examples for retrieving system boot time, uptime, and refreshing process information.

```rust
        "boot_time" => {
            println!("{} seconds", System::boot_time());
        }
        "uptime" => {
            let up = System::uptime();
            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)");
        }
        x if x.starts_with("refresh") => {
            if x == "refresh" {
                println!("Getting processes' information...");
                sys.refresh_all();
                println!("Done.");
            } 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()
                {
```

--------------------------------

### Retrieve total network packet counts

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.NetworkData.html?search=

Use these methods to get the total cumulative number of packets or errors since the system started.

```rust
use sysinfo::Networks;

let networks = Networks::new_with_refreshed_list();
for (interface_name, network) in &networks {
    println!("in: {}", network.total_packets_received());
}
```

```rust
use sysinfo::Networks;

let networks = Networks::new_with_refreshed_list();
for (interface_name, network) in &networks {
    println!("out: {}", network.total_packets_transmitted());
}
```

--------------------------------

### Calling a documented function in an example

Source: https://docs.rs/sysinfo/latest/scrape-examples-help.html

Example of how to invoke a library function within an external example file to trigger scraping.

```rust
// examples/ex.rs
fn main() {
  a_crate::a_func();
}
```

--------------------------------

### Interactive System Information CLI

Source: https://docs.rs/sysinfo/latest/src/simple/simple.rs.html

A complete example showing how to initialize system components and interpret user input to display various system metrics.

```rust
1// Take a look at the license at the top of the repository in the LICENSE file.
2
3#![crate_type = "bin"]
4#![allow(unused_must_use, non_upper_case_globals)]
5#![allow(clippy::manual_range_contains)]
6
7use std::io::{self, BufRead, Write};
8use std::str::FromStr;
9use sysinfo::{
10    Components, Disks, Groups, Motherboard, Networks, Pid, Product, SUPPORTED_SIGNALS, System,
11    Users,
12};
13
14fn print_help() {
15    println!(
16        "\
17== Help menu ==
18
19help               : shows this menu
20quit               : exits the program
21
22= Refresh commands =
23
24refresh            : reloads all processes information
25refresh [pid]      : reloads corresponding process information
26refresh_components : reloads components information
27refresh_cpu        : reloads CPU information
28refresh_disks      : reloads disks information
29refresh_networks   : reloads networks information
30refresh_users      : reloads users information
31
32= Process commands =
33
34all                : displays all process name and pid
35kill [pid] [signal]: sends [signal] to the process with this [pid]. To get the [signal] number, use the `signals` command.
36show [pid | name]  : shows information of the given process corresponding to [pid | name]
37signals            : shows the available signals
38pid                : displays this example's PID
39
40= CPU commands =
41
42brand              : displays CPU brand
43cpus               : displays CPUs state
44frequency          : displays CPU frequency
45vendor_id          : displays CPU vendor id
46
47= Users and groups commands =
48
49groups             : displays all groups
50users              : displays all users and their groups
51
52= System commands =
53
54boot_time          : displays system boot time
55load_avg           : displays system load average
56system             : displays system information (such as name, version and hostname)
57uptime             : displays system uptime
58motherboard        : displays motherboard information
59product            : displays product information
60
61= Extra components commands =
62
63disks              : displays disks' information
64memory             : displays memory state
65network            : displays network' information
66temperature        : displays components' temperature"
67    );
68}
69
70fn interpret_input(
71    input: &str,
72    sys: &mut System,
73    networks: &mut Networks,
74    disks: &mut Disks,
75    components: &mut Components,
76    users: &mut Users,
77) -> bool {
78    match input.trim() {
79        "help" => print_help(),
80        "refresh_disks" => {
81            println!("Refreshing disk list...");
82            disks.refresh(true);
83            println!("Done.");
84        }
85        "refresh_users" => {
86            println!("Refreshing user list...");
87            users.refresh();
88            println!("Done.");
89        }
90        "refresh_networks" => {
91            println!("Refreshing network list...");
92            networks.refresh(true);
93            println!("Done.");
94        }
95        "refresh_components" => {
96            println!("Refreshing component list...");
97            components.refresh(true);
98            println!("Done.");
99        }
100        "refresh_cpu" => {
101            println!("Refreshing CPUs...");
102            sys.refresh_cpu_all();
103            println!("Done.");
104        }
105        "signals" => {
106            for (nb, sig) in SUPPORTED_SIGNALS.iter().enumerate() {
107                println!("{:2}:{sig:?}", nb + 1);
108            }
109        }
110        "cpus" => {
111            // Note: you should refresh a few times before using this, so that usage statistics
112            // can be ascertained
113            println!(
114                "number of physical cores: {}",
115                System::physical_core_count()
116                    .map(|c| c.to_string())
117                    .unwrap_or_else(|| "Unknown".to_owned()),
118            );
119            println!("total CPU usage: {}%", sys.global_cpu_usage());
120            for cpu in sys.cpus() {
121                println!("{cpu:?}");
122            }
123        }
124        "memory" => {
125            println!("total memory:     {: >10} KB", sys.total_memory() / 1_000);
126            println!(
127                "available memory: {: >10} KB",
128                sys.available_memory() / 1_000
129            );
130            println!("used memory:      {: >10} KB", sys.used_memory() / 1_000);
131            println!("total swap:       {: >10} KB", sys.total_swap() / 1_000);
132            println!("used swap:        {: >10} KB", sys.used_swap() / 1_000);
133        }
134        "quit" | "exit" => return true,
135        "all" => {
136            for (pid, proc_) in sys.processes() {
```

--------------------------------

### Install ARM Toolchain

Source: https://docs.rs/sysinfo/latest/index.html

Install the necessary cross-compilation toolchain on Ubuntu.

```bash
> sudo apt-get install gcc-multilib-arm-linux-gnueabihf
```

--------------------------------

### Initialize System Instance

Source: https://docs.rs/sysinfo/latest/src/sysinfo/common/system.rs.html?search=

Create a new System instance either empty or with all data pre-loaded.

```rust
use sysinfo::System;

let s = System::new();
```

```rust
use sysinfo::System;

let s = System::new_all();
```

--------------------------------

### System Information and Refresh Commands

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.System.html?search=u32+-%3E+bool

Examples for retrieving system uptime, boot time, and refreshing process information.

```rust
"boot_time" => {
            println!("{} seconds", System::boot_time());
        }
        "uptime" => {
            let up = System::uptime();
            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)");
        }
        x if x.starts_with("refresh") => {
            if x == "refresh" {
                println!("Getting processes' information...");
                sys.refresh_all();
                println!("Done.");
            } 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()
                {
                    if sys.refresh_processes(sysinfo::ProcessesToUpdate::Some(&[pid]), true) != 0 {
                        println!("Process `{pid}` updated successfully");
                    } else {
                        println!("Process `{pid}` couldn't be updated...");
                    }
                } else {
                    println!("Invalid [pid] received...");
                }
            } else {
                println!(
                    "\"{x}\": Unknown command. Enter 'help' if you want to get the commands' \
                     list.",
                );
            }
        }
```

--------------------------------

### Binary Search Example

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.Users.html

Example of performing a binary search on a sorted slice.

```rust
let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
```

--------------------------------

### Query System Components and Hardware

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.Components.html?search=

Examples for retrieving CPU frequency, vendor ID, brand, load averages, and component temperatures.

```rust
        "frequency" => {
            for cpu in sys.cpus() {
                println!("[{}] {} MHz", cpu.name(), cpu.frequency());
            }
        }
        "vendor_id" => {
            println!("vendor ID: {}", sys.cpus()[0].vendor_id());
        }
        "brand" => {
            println!("brand: {}", sys.cpus()[0].brand());
        }
        "load_avg" => {
            let load_avg = System::load_average();
            println!("one minute     : {}%", load_avg.one);
            println!("five minutes   : {}%", load_avg.five);
            println!("fifteen minutes: {}%", load_avg.fifteen);
        }
        "temperature" => {
            for component in components.iter() {
                println!("{component:?}");
            }
        }
```

--------------------------------

### Build and run C example

Source: https://docs.rs/sysinfo/latest/sysinfo/index.html

Compile the C interface example and execute the resulting binary.

```bash
> make
> ./simple
# If needed:
> LD_LIBRARY_PATH=target/debug/ ./simple
```

--------------------------------

### Build and Run C Example

Source: https://docs.rs/sysinfo/latest/index.html

Compile and execute the provided C example using the Makefile.

```bash
> make
> ./simple
# If needed:
> LD_LIBRARY_PATH=target/debug/ ./simple
```

--------------------------------

### Install ARM toolchain on Ubuntu

Source: https://docs.rs/sysinfo/latest/sysinfo/index.html

Install the necessary cross-compilation toolchain for Raspberry Pi targets.

```bash
> sudo apt-get install gcc-multilib-arm-linux-gnueabihf
```

--------------------------------

### Process Management and System Information Commands

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.Disks.html?search=u32+-%3E+bool

Examples of handling process signals, listing disks, users, groups, and system uptime/boot time.

```rust
225                println!("example: kill 1254 9");
226            } else {
227                let Ok(pid) = Pid::from_str(tmp[1]) else {
228                    eprintln!("Expected a number for the PID, found {:?}", tmp[1]);
229                    return false;
230                };
231                let Ok(signal) = usize::from_str(tmp[2]) else {
232                    eprintln!("Expected a number for the signal, found {:?}", tmp[2]);
233                    return false;
234                };
235                let Some(signal) = SUPPORTED_SIGNALS.get(signal) else {
236                    eprintln!(
237                        "No signal matching {signal}. Use the `signals` command to get the \
238                         list of signals.",
239                    );
240                    return false;
241                };
242
243                match sys.process(pid) {
244                    Some(p) => {
245                        if let Some(res) = p.kill_with(*signal) {
246                            println!("kill: {res}");
247                        } else {
248                            eprintln!("kill: signal not supported on this platform");
249                        }
250                    }
251                    None => {
252                        eprintln!("pid not found");
253                    }
254                }
255            }
256        }
257        "disks" => {
258            for disk in disks {
259                println!("{disk:?}");
260            }
261        }
262        "users" => {
263            for user in users {
264                println!("{:?} => {:?}", user.name(), user.groups());
265            }
266        }
267        "groups" => {
268            for group in Groups::new_with_refreshed_list().list() {
269                println!("{group:?}");
270            }
271        }
272        "boot_time" => {
273            println!("{} seconds", System::boot_time());
274        }
275        "uptime" => {
276            let up = System::uptime();
277            let mut uptime = up;
278            let days = uptime / 86400;
279            uptime -= days * 86400;
280            let hours = uptime / 3600;
281            uptime -= hours * 3600;
282            let minutes = uptime / 60;
283            println!("{days} days {hours} hours {minutes} minutes ({up} seconds in total)");
284        }
```

--------------------------------

### Unsound as_chunks_unchecked usage examples

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.Users.html?search=std%3A%3Avec

Examples of invalid usage of as_chunks_unchecked that would lead to unsound behavior.

```rust
// These would be unsound:
// let chunks: &[[_; 5]] = slice.as_chunks_unchecked() // The slice length is not a multiple of 5
// let chunks: &[[_; 0]] = slice.as_chunks_unchecked() // Zero-length chunks are never allowed
```

--------------------------------

### Initialize and Print Motherboard Info

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.Motherboard.html?search=

Creates a new instance of Motherboard and prints its debug representation if available.

```rust
use sysinfo::Motherboard;

if let Some(m) = Motherboard::new() {
    println!("{m:?}");
}
```

--------------------------------

### Initialize System Instance

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.System.html?search=u32+-%3E+bool

Methods for creating new System instances with different refresh configurations.

```rust
use sysinfo::System;

let s = System::new();
```

```rust
use sysinfo::System;

let s = System::new_all();
```

```rust
use sysinfo::{ProcessRefreshKind, RefreshKind, System};

// We want to only refresh processes.
let mut system = System::new_with_specifics(
     RefreshKind::nothing().with_processes(ProcessRefreshKind::everything()),
);

assert!(!system.processes().is_empty());
```

--------------------------------

### Interpret Input Example

Source: https://docs.rs/sysinfo/latest/sysinfo/struct.Networks.html

Example of handling network refresh commands within an input interpretation function.

```rust
70fn interpret_input(
71    input: &str,
72    sys: &mut System,
73    networks: &mut Networks,
74    disks: &mut Disks,
75    components: &mut Components,
76    users: &mut Users,
77) -> bool {
78    match input.trim() {
79        "help" => print_help(),
80        "refresh_disks" => {
81            println!("Refreshing disk list...");
82            disks.refresh(true);
83            println!("Done.");
84        }
85        "refresh_users" => {
86            println!("Refreshing user list...");
87            users.refresh();
88            println!("Done.");
89        }
90        "refresh_networks" => {
91            println!("Refreshing network list...");
92            networks.refresh(true);
93            println!("Done.");
94        }
95        "refresh_components" => {
96            println!("Refreshing component list...");
97            components.refresh(true);
98            println!("Done.");
99        }
100        "refresh_cpu" => {
101            println!("Refreshing CPUs...");
102            sys.refresh_cpu_all();
103            println!("Done.");
104        }
105        "signals" => {
106            for (nb, sig) in SUPPORTED_SIGNALS.iter().enumerate() {
107                println!("{:2}:{sig:?}", nb + 1);
108            }
109        }
110        "cpus" => {
111            // Note: you should refresh a few times before using this, so that usage statistics
112            // can be ascertained
113            println!(
114                "number of physical cores: {}",
115                System::physical_core_count()
116                    .map(|c| c.to_string())
117                    .unwrap_or_else(|| "Unknown".to_owned()),
118            );
119            println!("total CPU usage: {}%", sys.global_cpu_usage());
120            for cpu in sys.cpus() {
121                println!("{cpu:?}");
122            }
```

--------------------------------

### Check System Support and Initialize

Source: https://docs.rs/sysinfo/latest/src/sysinfo/common/system.rs.html?search=

Verify if the current operating system is supported by sysinfo before attempting to initialize the system information.

```rust
use sysinfo::System;

if sysinfo::IS_SUPPORTED_SYSTEM {
    println!("System: {:?}", System::new_all());
} else {
    println!("This OS isn't supported (yet?).");
}
```

--------------------------------

### Initializing and refreshing users

Source: https://docs.rs/sysinfo/latest/src/sysinfo/common/user.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to create a new Users instance and refresh the list to populate it with system data.

```rust
use sysinfo::Users;

let mut users = Users::new();
users.refresh();
for user in users.list() {
    println!("{user:?}");
}
```

```rust
use sysinfo::Users;

let mut users = Users::new_with_refreshed_list();
for user in users.list() {
    println!("{user:?}");
}
```

--------------------------------

### Process Start Time Utilities

Source: https://docs.rs/sysinfo/latest/src/sysinfo/unix/linux/process.rs.html?search=u32+-%3E+bool

Helper functions to extract and calculate process start times from raw data.

```rust
#[inline(always)]
fn start_time_raw(parts: &Parts<'_>) -> u64 {
    parts
        .str_parts
        .get(ProcIndex::StartTime as usize)
        .and_then(|part| u64::from_str(part).ok())
        .unwrap_or(0)
}

#[inline(always)]
fn compute_start_time_without_boot_time(parts: &Parts<'_>, info: &SystemInfo) -> (u64, u64) {
    let raw = start_time_raw(parts);
    // To be noted that the start time is invalid here, it still needs to be converted into
    // "real" time.
    (raw, raw / info.clock_cycle)
}
```
Tokens:
Raw