use crate::error::IronError;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
pub enum EdacMemType {
Ddr,
Ddr2,
Ddr3,
Ddr4,
Ddr5,
Rddr3,
Rddr4,
Rddr5,
Lpddr4,
Lpddr5,
Hbm2,
Hbm3,
Unknown,
}
impl std::fmt::Display for EdacMemType {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Ddr => write!(f, "DDR"),
Self::Ddr2 => write!(f, "DDR2"),
Self::Ddr3 => write!(f, "DDR3"),
Self::Ddr4 => write!(f, "DDR4"),
Self::Ddr5 => write!(f, "DDR5"),
Self::Rddr3 => write!(f, "Registered DDR3"),
Self::Rddr4 => write!(f, "Registered DDR4"),
Self::Rddr5 => write!(f, "Registered DDR5"),
Self::Lpddr4 => write!(f, "LPDDR4"),
Self::Lpddr5 => write!(f, "LPDDR5"),
Self::Hbm2 => write!(f, "HBM2"),
Self::Hbm3 => write!(f, "HBM3"),
Self::Unknown => write!(f, "Unknown"),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EdacCsRow {
pub index: u32,
pub label: String,
pub mem_type: EdacMemType,
pub size_mb: Option<u64>,
pub ce_count: Option<u64>,
pub ue_count: Option<u64>,
pub location: String,
pub grain: Option<u32>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EdacMemoryController {
pub index: u32,
pub mc_name: String,
pub ce_count: Option<u64>,
pub ue_count: Option<u64>,
pub ce_noinfo_count: Option<u64>,
pub ue_noinfo_count: Option<u64>,
pub csrows: Vec<EdacCsRow>,
pub seconds_since_reset: Option<u64>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EdacOverview {
pub controllers: Vec<EdacMemoryController>,
pub total_controllers: u32,
pub total_ce: Option<u64>,
pub total_ue: Option<u64>,
pub ecc_active: bool,
pub recommendations: Vec<String>,
}
pub struct EdacMonitor {
overview: EdacOverview,
}
impl EdacMonitor {
pub fn new() -> Result<Self, IronError> {
let overview = Self::scan()?;
Ok(Self { overview })
}
pub fn refresh(&mut self) -> Result<(), IronError> {
self.overview = Self::scan()?;
Ok(())
}
pub fn overview(&self) -> &EdacOverview {
&self.overview
}
pub fn controllers(&self) -> &[EdacMemoryController] {
&self.overview.controllers
}
pub fn total_correctable_errors(&self) -> Option<u64> {
self.overview.total_ce
}
pub fn total_uncorrectable_errors(&self) -> Option<u64> {
self.overview.total_ue
}
pub fn dimms_with_errors(&self) -> Vec<&EdacCsRow> {
self.overview
.controllers
.iter()
.flat_map(|mc| mc.csrows.iter())
.filter(|cs| cs.ce_count.is_some_and(|c| c > 0) || cs.ue_count.is_some_and(|c| c > 0))
.collect()
}
#[cfg(target_os = "linux")]
fn scan() -> Result<EdacOverview, IronError> {
let mc_base = std::path::Path::new("/sys/devices/system/edac");
if !mc_base.exists() {
return Err(IronError::FeatureNotAvailable(
"the kernel exposes no /sys/devices/system/edac: no EDAC driver \
is loaded for this memory controller"
.into(),
));
}
let mut controllers = Vec::new();
for i in 0..16 {
let mc_path = mc_base.join(format!("mc/mc{}", i));
if !mc_path.exists() {
continue;
}
let mc_name =
Self::read_sysfs(&mc_path.join("mc_name")).unwrap_or_else(|| format!("mc{}", i));
let ce_count = Self::read_sysfs_u64(&mc_path.join("ce_count"));
let ue_count = Self::read_sysfs_u64(&mc_path.join("ue_count"));
let ce_noinfo = Self::read_sysfs_u64(&mc_path.join("ce_noinfo_count"));
let ue_noinfo = Self::read_sysfs_u64(&mc_path.join("ue_noinfo_count"));
let seconds = Self::read_sysfs_u64(&mc_path.join("seconds_since_reset"));
let mut csrows = Vec::new();
for j in 0..32 {
let csrow_path = mc_path.join(format!("csrow{}", j));
if !csrow_path.exists() {
continue;
}
let label = Self::read_sysfs(&csrow_path.join("ch0_dimm_label"))
.or_else(|| Self::read_sysfs(&csrow_path.join("dimm_label")))
.unwrap_or_else(|| format!("csrow{}", j));
let mem_type_str =
Self::read_sysfs(&csrow_path.join("mem_type")).unwrap_or_default();
let mem_type = Self::parse_mem_type(&mem_type_str);
let size_mb = Self::read_sysfs_u64(&csrow_path.join("size_mb"));
let cs_ce = Self::read_sysfs_u64(&csrow_path.join("ce_count"));
let cs_ue = Self::read_sysfs_u64(&csrow_path.join("ue_count"));
let grain = Self::read_sysfs_u32(&csrow_path.join("grain"));
let location = Self::read_sysfs(&csrow_path.join("location")).unwrap_or_default();
csrows.push(EdacCsRow {
index: j,
label,
mem_type,
size_mb,
ce_count: cs_ce,
ue_count: cs_ue,
location,
grain,
});
}
for j in 0..64 {
let dimm_path = mc_path.join(format!("dimm{}", j));
if !dimm_path.exists() {
continue;
}
let label = Self::read_sysfs(&dimm_path.join("dimm_label"))
.unwrap_or_else(|| format!("dimm{}", j));
let mem_type_str =
Self::read_sysfs(&dimm_path.join("dimm_mem_type")).unwrap_or_default();
let mem_type = Self::parse_mem_type(&mem_type_str);
let size_mb = Self::read_sysfs_u64(&dimm_path.join("size"));
let cs_ce = Self::read_sysfs_u64(&dimm_path.join("dimm_ce_count"));
let cs_ue = Self::read_sysfs_u64(&dimm_path.join("dimm_ue_count"));
let location =
Self::read_sysfs(&dimm_path.join("dimm_location")).unwrap_or_default();
csrows.push(EdacCsRow {
index: j,
label,
mem_type,
size_mb,
ce_count: cs_ce,
ue_count: cs_ue,
location,
grain: None,
});
}
controllers.push(EdacMemoryController {
index: i,
mc_name,
ce_count,
ue_count,
ce_noinfo_count: ce_noinfo,
ue_noinfo_count: ue_noinfo,
csrows,
seconds_since_reset: seconds,
});
}
let total = controllers.len() as u32;
let total_ce: Option<u64> = controllers
.iter()
.map(|mc| mc.ce_count)
.try_fold(0u64, |acc, c| c.map(|c| acc + c));
let total_ue: Option<u64> = controllers
.iter()
.map(|mc| mc.ue_count)
.try_fold(0u64, |acc, c| c.map(|c| acc + c));
let ecc_active = total > 0;
let mut recs = Vec::new();
match total_ue {
Some(count) if count > 0 => recs.push(format!(
"CRITICAL: {} uncorrectable ECC error(s) detected — replace affected DIMM(s)",
count
)),
Some(_) => {}
None => recs.push(
concat!(
"ECC uncorrectable-error counters could not be read on at ",
"least one controller — memory health cannot be assessed ",
"from this host"
)
.into(),
),
}
match total_ce {
Some(count) if count > 100 => recs.push(format!(
"WARNING: {} correctable ECC errors — monitor for increasing rate",
count
)),
Some(_) => {}
None => recs.push(
concat!(
"ECC correctable-error counters could not be read on at ",
"least one controller — a rising error rate would not be ",
"visible here"
)
.into(),
),
}
if !ecc_active {
recs.push(
"No EDAC memory controllers found — ECC may be disabled or not supported".into(),
);
}
Ok(EdacOverview {
controllers,
total_controllers: total,
total_ce,
total_ue,
ecc_active,
recommendations: recs,
})
}
#[cfg(target_os = "linux")]
fn parse_mem_type(s: &str) -> EdacMemType {
match s.to_lowercase().as_str() {
"ddr" => EdacMemType::Ddr,
"ddr2" => EdacMemType::Ddr2,
"ddr3" => EdacMemType::Ddr3,
"ddr4" | "unbuffered-ddr4" => EdacMemType::Ddr4,
"ddr5" | "unbuffered-ddr5" => EdacMemType::Ddr5,
"rddr3" | "registered-ddr3" => EdacMemType::Rddr3,
"rddr4" | "registered-ddr4" => EdacMemType::Rddr4,
"rddr5" | "registered-ddr5" => EdacMemType::Rddr5,
"lpddr4" => EdacMemType::Lpddr4,
"lpddr5" => EdacMemType::Lpddr5,
_ => EdacMemType::Unknown,
}
}
#[cfg(target_os = "linux")]
fn read_sysfs(path: &std::path::Path) -> Option<String> {
std::fs::read_to_string(path)
.ok()
.map(|s| s.trim().to_string())
}
#[cfg(target_os = "linux")]
fn read_sysfs_u64(path: &std::path::Path) -> Option<u64> {
std::fs::read_to_string(path)
.ok()
.and_then(|s| s.trim().parse().ok())
}
#[cfg(target_os = "linux")]
fn read_sysfs_u32(path: &std::path::Path) -> Option<u32> {
std::fs::read_to_string(path)
.ok()
.and_then(|s| s.trim().parse().ok())
}
#[cfg(not(target_os = "linux"))]
fn scan() -> Result<EdacOverview, IronError> {
Err(IronError::UnsupportedPlatform(
"ECC error counts are read from /sys/devices/system/edac, which \
exists on Linux only; this platform exposes no interface ironmon \
reads for correctable and uncorrectable counts"
.into(),
))
}
fn empty_overview() -> EdacOverview {
EdacOverview {
controllers: Vec::new(),
total_controllers: 0,
total_ce: None,
total_ue: None,
ecc_active: false,
recommendations: Vec::new(),
}
}
}
impl Default for EdacMonitor {
fn default() -> Self {
Self::new().unwrap_or(Self {
overview: Self::empty_overview(),
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_mem_type_display() {
assert_eq!(EdacMemType::Ddr4.to_string(), "DDR4");
assert_eq!(EdacMemType::Ddr5.to_string(), "DDR5");
assert_eq!(EdacMemType::Rddr4.to_string(), "Registered DDR4");
}
#[test]
fn test_dimms_with_errors() {
let overview = EdacOverview {
controllers: vec![EdacMemoryController {
index: 0,
mc_name: "test_mc".into(),
ce_count: Some(5),
ue_count: Some(0),
ce_noinfo_count: Some(0),
ue_noinfo_count: Some(0),
csrows: vec![
EdacCsRow {
index: 0,
label: "DIMM_A1".into(),
mem_type: EdacMemType::Ddr4,
size_mb: Some(16384),
ce_count: Some(5),
ue_count: Some(0),
location: "ch0/slot0".into(),
grain: Some(8),
},
EdacCsRow {
index: 1,
label: "DIMM_A2".into(),
mem_type: EdacMemType::Ddr4,
size_mb: Some(16384),
ce_count: Some(0),
ue_count: Some(0),
location: "ch0/slot1".into(),
grain: Some(8),
},
],
seconds_since_reset: Some(86400),
}],
total_controllers: 1,
total_ce: Some(5),
total_ue: Some(0),
ecc_active: true,
recommendations: Vec::new(),
};
let monitor = EdacMonitor { overview };
let errored = monitor.dimms_with_errors();
assert_eq!(errored.len(), 1);
assert_eq!(errored[0].label, "DIMM_A1");
}
#[test]
fn test_monitor_default() {
let monitor = EdacMonitor::default();
let _overview = monitor.overview();
}
#[test]
fn test_serialization() {
let cs = EdacCsRow {
index: 0,
label: "DIMM0".into(),
mem_type: EdacMemType::Ddr5,
size_mb: Some(32768),
ce_count: Some(3),
ue_count: Some(0),
location: "mc0/ch0/dimm0".into(),
grain: Some(8),
};
let json = serde_json::to_string(&cs).unwrap();
assert!(json.contains("DIMM0"));
let _: EdacCsRow = serde_json::from_str(&json).unwrap();
}
}