use crate::core::memory::{EmcInfo, IramInfo, MemoryStats, RamInfo, SwapInfo};
use crate::error::Result;
use crate::platform::common::*;
use std::fs;
pub fn read_memory_stats() -> Result<MemoryStats> {
let mut stats = MemoryStats::empty();
let meminfo = fs::read_to_string("/proc/meminfo")?;
stats.ram = parse_ram_info(&meminfo)?;
stats.swap = parse_swap_info(&meminfo)?;
stats.emc = read_emc_info().ok();
stats.iram = read_iram_info().ok();
Ok(stats)
}
fn parse_ram_info(meminfo: &str) -> Result<RamInfo> {
let mut mem_total = None;
let mut mem_free = None;
let mut mem_available = None;
let mut buffers = None;
let mut cached = None;
let mut s_reclaimable = None;
let mut shmem = None;
for line in meminfo.lines() {
let parts: Vec<&str> = line.split_whitespace().collect();
if parts.len() < 2 {
continue;
}
let key = parts[0].trim_end_matches(':');
let Ok(value) = parts[1].parse::<u64>() else {
continue;
};
match key {
"MemTotal" => mem_total = Some(value),
"MemFree" => mem_free = Some(value),
"MemAvailable" => mem_available = Some(value),
"Buffers" => buffers = Some(value),
"Cached" => cached = Some(value),
"SReclaimable" => s_reclaimable = Some(value),
"Shmem" => shmem = Some(value),
_ => {}
}
}
let missing = |field: &str| {
crate::error::IronError::Parse(format!(
"/proc/meminfo has no {field} line; refusing to report it as zero"
))
};
let total = mem_total.ok_or_else(|| missing("MemTotal"))?;
let free = mem_free.ok_or_else(|| missing("MemFree"))?;
let available = mem_available.ok_or_else(|| missing("MemAvailable"))?;
Ok(RamInfo {
total,
free: Some(free),
used: total.saturating_sub(available),
buffers,
cached: match (cached, s_reclaimable) {
(Some(c), Some(s)) => Some(c + s),
_ => None,
},
shared: shmem,
lfb: read_lfb().ok(),
})
}
fn parse_swap_info(meminfo: &str) -> Result<SwapInfo> {
let mut swap = SwapInfo::default();
for line in meminfo.lines() {
let parts: Vec<&str> = line.split_whitespace().collect();
if parts.len() < 2 {
continue;
}
let key = parts[0].trim_end_matches(':');
let Ok(value) = parts[1].parse::<u64>() else {
continue;
};
match key {
"SwapTotal" => swap.total = Some(value),
"SwapFree" => {
swap.used = swap.total.map(|t| t.saturating_sub(value));
}
"SwapCached" => swap.cached = Some(value),
_ => {}
}
}
Ok(swap)
}
fn read_lfb() -> Result<u32> {
Err(crate::error::IronError::FeatureNotAvailable(
"LFB reading not yet implemented".to_string(),
))
}
fn read_emc_info() -> Result<EmcInfo> {
let emc_path = "/sys/class/devfreq/17000000.mc";
if !path_exists(emc_path) {
let alt_path = "/sys/class/devfreq/13d00000.mc";
if !path_exists(alt_path) {
return Err(crate::error::IronError::FeatureNotAvailable(
"EMC not available".to_string(),
));
}
}
let cur = read_file_u32(format!("{}/cur_freq", emc_path))? / 1000;
let min = read_file_u32(format!("{}/min_freq", emc_path))? / 1000;
let max = read_file_u32(format!("{}/max_freq", emc_path))? / 1000;
if max == 0 {
return Err(crate::error::IronError::FeatureNotAvailable(
"EMC reports no maximum frequency".to_string(),
));
}
let clock_percent_of_max = ((cur as f32 / max as f32) * 100.0) as u32;
Ok(EmcInfo {
online: true,
clock_percent_of_max,
current: cur,
max,
min,
})
}
fn read_iram_info() -> Result<IramInfo> {
Err(crate::error::IronError::FeatureNotAvailable(
"IRAM reading not yet implemented".to_string(),
))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn swap_total_that_does_not_parse_is_absent_not_no_swap() {
let swap = parse_swap_info("SwapTotal: x kB\nSwapFree: 500 kB\n")
.ok()
.unwrap();
assert_eq!(swap.total, None);
assert_eq!(swap.used, None);
}
#[test]
fn swap_free_that_does_not_parse_leaves_used_absent() {
let swap = parse_swap_info("SwapTotal: 1000 kB\nSwapFree: ? kB\n")
.ok()
.unwrap();
assert_eq!(swap.total, Some(1000));
assert_eq!(swap.used, None);
}
#[test]
fn swap_reads_total_and_used() {
let swap = parse_swap_info("SwapTotal: 1000 kB\nSwapFree: 400 kB\n")
.ok()
.unwrap();
assert_eq!(swap.total, Some(1000));
assert_eq!(swap.used, Some(600));
}
#[test]
fn cached_needs_both_cached_and_sreclaimable() {
let base = "MemTotal: 16000 kB\nMemFree: 1000 kB\nMemAvailable: 8000 kB\n";
let only_cached = parse_ram_info(&format!("{base}Cached: 300 kB\n"))
.ok()
.unwrap();
assert_eq!(only_cached.cached, None);
let both = parse_ram_info(&format!("{base}Cached: 300 kB\nSReclaimable: 200 kB\n"))
.ok()
.unwrap();
assert_eq!(both.cached, Some(500));
}
#[test]
fn lfb_is_absent_not_zero() {
let ram = parse_ram_info("MemTotal: 16000 kB\nMemFree: 1000 kB\nMemAvailable: 8000 kB\n")
.ok()
.unwrap();
assert_eq!(ram.lfb, None);
}
}