#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AtaSmartAttribute {
pub id: u8,
pub flags: u16,
pub value: u8,
pub worst: u8,
pub raw: u64,
}
impl AtaSmartAttribute {
pub fn pre_fail(&self) -> bool {
self.flags & 0x0001 != 0
}
pub fn name(&self) -> String {
match self.id {
1 => "Raw_Read_Error_Rate",
2 => "Throughput_Performance",
3 => "Spin_Up_Time",
4 => "Start_Stop_Count",
5 => "Reallocated_Sector_Ct",
7 => "Seek_Error_Rate",
8 => "Seek_Time_Performance",
9 => "Power_On_Hours",
10 => "Spin_Retry_Count",
11 => "Calibration_Retry_Count",
12 => "Power_Cycle_Count",
173 => "Wear_Leveling_Count",
177 => "Wear_Leveling_Count",
179 => "Used_Rsvd_Blk_Cnt_Tot",
181 => "Program_Fail_Cnt_Total",
182 => "Erase_Fail_Count_Total",
183 => "Runtime_Bad_Block",
184 => "End-to-End_Error",
187 => "Reported_Uncorrect",
188 => "Command_Timeout",
190 => "Airflow_Temperature_Cel",
191 => "G-Sense_Error_Rate",
192 => "Power-Off_Retract_Count",
193 => "Load_Cycle_Count",
194 => "Temperature_Celsius",
195 => "Hardware_ECC_Recovered",
196 => "Reallocated_Event_Count",
197 => "Current_Pending_Sector",
198 => "Offline_Uncorrectable",
199 => "UDMA_CRC_Error_Count",
200 => "Multi_Zone_Error_Rate",
233 => "Media_Wearout_Indicator",
235 => "Good_Block_Count",
241 => "Total_LBAs_Written",
242 => "Total_LBAs_Read",
_ => return format!("Unknown_Attribute_{}", self.id),
}
.to_string()
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct AtaSmartData {
pub revision: u16,
pub attributes: Vec<AtaSmartAttribute>,
}
const ATTRIBUTE_TABLE_OFFSET: usize = 2;
const ATTRIBUTE_ENTRY_LEN: usize = 12;
const ATTRIBUTE_COUNT: usize = 30;
pub const STRUCTURE_LEN: usize = 512;
impl AtaSmartData {
pub fn parse(buf: &[u8]) -> Option<Self> {
if buf.len() != STRUCTURE_LEN || !checksum_valid(buf) {
return None;
}
let mut attributes = Vec::new();
for i in 0..ATTRIBUTE_COUNT {
let start = ATTRIBUTE_TABLE_OFFSET + i * ATTRIBUTE_ENTRY_LEN;
let e = &buf[start..start + ATTRIBUTE_ENTRY_LEN];
if e[0] == 0 {
continue;
}
attributes.push(AtaSmartAttribute {
id: e[0],
flags: u16::from_le_bytes([e[1], e[2]]),
value: e[3],
worst: e[4],
raw: u64::from(e[5])
| u64::from(e[6]) << 8
| u64::from(e[7]) << 16
| u64::from(e[8]) << 24
| u64::from(e[9]) << 32
| u64::from(e[10]) << 40,
});
}
if attributes.is_empty() {
return None;
}
Some(Self {
revision: u16::from_le_bytes([buf[0], buf[1]]),
attributes,
})
}
fn raw(&self, id: u8) -> Option<u64> {
self.attributes.iter().find(|a| a.id == id).map(|a| a.raw)
}
fn normalised(&self, id: u8) -> Option<u8> {
self.attributes.iter().find(|a| a.id == id).map(|a| a.value)
}
pub fn temperature_celsius(&self) -> Option<u32> {
self.raw(194)
.or_else(|| self.raw(190))
.map(|raw| (raw & 0xFF) as u32)
}
pub fn power_on_hours(&self) -> Option<u64> {
self.raw(9)
}
pub fn power_cycle_count(&self) -> Option<u64> {
self.raw(12)
}
pub fn reallocated_sectors(&self) -> Option<u64> {
self.raw(5)
}
pub fn pending_sectors(&self) -> Option<u64> {
self.raw(197)
}
pub fn uncorrectable_sectors(&self) -> Option<u64> {
self.raw(198)
}
pub fn total_bytes_written(&self) -> Option<u64> {
self.raw(241).map(|lbas| lbas.saturating_mul(512))
}
pub fn total_bytes_read(&self) -> Option<u64> {
self.raw(242).map(|lbas| lbas.saturating_mul(512))
}
pub fn wear_percent_used(&self) -> Option<f32> {
self.normalised(177)
.or_else(|| self.normalised(233))
.map(|value| 100.0 - f32::from(value).min(100.0))
}
}
fn checksum_valid(buf: &[u8]) -> bool {
buf.iter().fold(0u8, |acc, b| acc.wrapping_add(*b)) == 0
}
#[cfg(test)]
mod tests {
use super::*;
fn structure(revision: u16, entries: &[(u8, u16, u8, u8, u64)]) -> Vec<u8> {
let mut buf = vec![0u8; STRUCTURE_LEN];
buf[0..2].copy_from_slice(&revision.to_le_bytes());
for (i, (id, flags, value, worst, raw)) in entries.iter().enumerate() {
let start = ATTRIBUTE_TABLE_OFFSET + i * ATTRIBUTE_ENTRY_LEN;
buf[start] = *id;
buf[start + 1..start + 3].copy_from_slice(&flags.to_le_bytes());
buf[start + 3] = *value;
buf[start + 4] = *worst;
for b in 0..6 {
buf[start + 5 + b] = ((raw >> (8 * b)) & 0xFF) as u8;
}
}
let sum = buf[..STRUCTURE_LEN - 1]
.iter()
.fold(0u8, |acc, b| acc.wrapping_add(*b));
buf[STRUCTURE_LEN - 1] = sum.wrapping_neg();
buf
}
#[test]
fn a_well_formed_structure_yields_its_attributes() {
let buf = structure(
0x0010,
&[(9, 0x0032, 99, 99, 1234), (12, 0x0032, 99, 99, 56)],
);
let data = AtaSmartData::parse(&buf).expect("valid structure");
assert_eq!(data.revision, 0x0010);
assert_eq!(data.attributes.len(), 2);
assert_eq!(data.power_on_hours(), Some(1234));
assert_eq!(data.power_cycle_count(), Some(56));
assert_eq!(data.attributes[0].name(), "Power_On_Hours");
}
#[test]
fn a_corrupt_checksum_is_refused() {
let mut buf = structure(0x0010, &[(9, 0x0032, 99, 99, 1234)]);
buf[STRUCTURE_LEN - 1] = buf[STRUCTURE_LEN - 1].wrapping_add(1);
assert_eq!(AtaSmartData::parse(&buf), None);
}
#[test]
fn a_zero_filled_buffer_is_not_a_reading() {
assert_eq!(AtaSmartData::parse(&[0u8; STRUCTURE_LEN]), None);
}
#[test]
fn a_short_buffer_is_refused_rather_than_indexed_past() {
assert_eq!(AtaSmartData::parse(&[0u8; 64]), None);
assert_eq!(AtaSmartData::parse(&[]), None);
}
#[test]
fn an_unused_entry_does_not_end_the_table() {
let buf = structure(
0x0010,
&[
(9, 0x0032, 99, 99, 100),
(0, 0, 0, 0, 0),
(12, 0x0032, 99, 99, 7),
],
);
let data = AtaSmartData::parse(&buf).expect("valid structure");
assert_eq!(data.attributes.len(), 2);
assert_eq!(data.power_cycle_count(), Some(7));
}
#[test]
fn temperature_comes_from_the_low_raw_byte_only() {
let raw = 34 | (21 << 16) | (52 << 32);
let buf = structure(0x0010, &[(194, 0x0022, 66, 48, raw)]);
let data = AtaSmartData::parse(&buf).expect("valid structure");
assert_eq!(data.temperature_celsius(), Some(34));
}
#[test]
fn airflow_temperature_is_used_only_when_194_is_absent() {
let only_190 = structure(0x0010, &[(190, 0x0022, 70, 55, 30)]);
assert_eq!(
AtaSmartData::parse(&only_190)
.unwrap()
.temperature_celsius(),
Some(30)
);
let both = structure(
0x0010,
&[(190, 0x0022, 70, 55, 30), (194, 0x0022, 66, 48, 34)],
);
assert_eq!(
AtaSmartData::parse(&both).unwrap().temperature_celsius(),
Some(34)
);
}
#[test]
fn wear_is_derived_from_the_normalised_value() {
let buf = structure(0x0010, &[(177, 0x0013, 94, 94, 183)]);
let data = AtaSmartData::parse(&buf).expect("valid structure");
assert_eq!(data.wear_percent_used(), Some(6.0));
}
#[test]
fn an_absent_attribute_is_none_rather_than_zero() {
let buf = structure(0x0010, &[(9, 0x0032, 99, 99, 1234)]);
let data = AtaSmartData::parse(&buf).expect("valid structure");
assert_eq!(data.reallocated_sectors(), None);
assert_eq!(data.pending_sectors(), None);
assert_eq!(data.temperature_celsius(), None);
assert_eq!(data.wear_percent_used(), None);
}
#[test]
fn a_zero_reallocated_count_is_a_reading() {
let buf = structure(0x0010, &[(5, 0x0033, 100, 100, 0)]);
let data = AtaSmartData::parse(&buf).expect("valid structure");
assert_eq!(data.reallocated_sectors(), Some(0));
}
#[test]
fn pre_fail_comes_from_flag_bit_zero() {
let buf = structure(
0x0010,
&[(5, 0x0033, 100, 100, 0), (194, 0x0022, 66, 48, 34)],
);
let data = AtaSmartData::parse(&buf).expect("valid structure");
assert!(data.attributes[0].pre_fail());
assert!(!data.attributes[1].pre_fail());
}
#[test]
fn lba_counters_are_scaled_to_bytes() {
let buf = structure(
0x0010,
&[(241, 0x0032, 99, 99, 1000), (242, 0x0032, 99, 99, 2000)],
);
let data = AtaSmartData::parse(&buf).expect("valid structure");
assert_eq!(data.total_bytes_written(), Some(512_000));
assert_eq!(data.total_bytes_read(), Some(1_024_000));
}
#[test]
fn raw_values_use_all_forty_eight_bits() {
let buf = structure(0x0010, &[(241, 0x0032, 99, 99, 0xFFFF_FFFF_FFFF)]);
let data = AtaSmartData::parse(&buf).expect("valid structure");
assert_eq!(data.attributes[0].raw, 0xFFFF_FFFF_FFFF);
}
#[test]
fn an_unrecognised_id_is_still_reported() {
let buf = structure(0x0010, &[(250, 0x0032, 99, 99, 5)]);
let data = AtaSmartData::parse(&buf).expect("valid structure");
assert_eq!(data.attributes[0].name(), "Unknown_Attribute_250");
assert_eq!(data.attributes[0].raw, 5);
}
}