header: introduce support for server legacy type0 header

This patch introduces the support for decoding Crash Log records from
server products that have a legacy header type0.

This patch is also introducing a module called `Errata`. The purpose of
this module is to indicate scenarios where there could be exceptions or
corner cases in the layout.

Because this legacy type0 header contains a different layout where the
`RecordSize` is allocated, there is the need to use the `Errata` module
to indicate whether this scenario is present.

Signed-off-by: Rivas Paz, Jose L <[email protected]>

Author: jlrivasp

lib/src/errata.rs

@@ -0,0 +1,24 @@
+// Copyright (C) 2025 Intel Corporation
+// SPDX-License-Identifier: MIT
+
+use crate::header::Version;
+
+/// Collection of Intel Crash Log erratas
+pub struct Errata {
+    /// Type0 server legacy header
+    ///
+    /// Some Intel(R) products in the server segment are using legacy Crash Log record headers with
+    /// Type0, which has a different layout compared with the currently defined Type0 Header.
+    ///
+    pub type0_legacy_server: bool,
+}
+
+impl Errata {
+    pub fn from_version(version: &Version) -> Self {
+        let type0_legacy_server = version.header_type == 0 && version.product_id == 0x2f;
+
+        Errata {
+            type0_legacy_server,
+        }
+    }
+}

lib/src/header.rs

@@ -5,6 +5,7 @@
 
 #[cfg(feature = "collateral_manager")]
 use crate::collateral::{CollateralManager, CollateralTree, ItemPath, PVSS};
+use crate::errata::Errata;
 use crate::error::Error;
 use crate::node::Node;
 #[cfg(not(feature = "std"))]
@@ -78,6 +79,16 @@ pub enum HeaderType {
         completion_status: Vec<u32>,
         collection_complete: bool,
     },
+
+    Type0LegacyServer {
+        timestamp: u64,
+        agent_version: u32,
+        reason: u32,
+        die_id: u8,
+        socket_id: u8,
+        completion_status: u32,
+        collection_complete: bool,
+    },
 }
 
 impl HeaderType {
@@ -177,6 +188,36 @@ impl HeaderType {
         })
     }
 
+    fn type0_legacy_server_from_slice(slice: &[u8]) -> Option<Self> {
+        let reason = u32::from_le_bytes(slice.get(4..8)?.try_into().ok()?);
+        let timestamp = u64::from_le_bytes(slice.get(8..16)?.try_into().ok()?);
+        let agent_version = u32::from_le_bytes(slice.get(20..24)?.try_into().ok()?);
+        let socket_id = slice[24];
+        let cs_data = u32::from_le_bytes(slice.get(28..32)?.try_into().ok()?);
+        let completion_status = cs_data & 0x7FFFFFFF;
+        let collection_complete = (cs_data >> 31) != 0;
+
+        // Encoded die_id
+        let revision = slice[0];
+        let die_idx = revision & 0x3;
+
+        let die_id = if ((revision >> 7) & 1) == 1 {
+            die_idx + 9
+        } else {
+            die_idx << 2
+        };
+
+        Some(HeaderType::Type0LegacyServer {
+            timestamp,
+            agent_version,
+            reason,
+            die_id,
+            socket_id,
+            completion_status,
+            collection_complete,
+        })
+    }
+
     pub fn from_slice(header_type_value: u16, slice: &[u8]) -> Result<Self, Error> {
         match header_type_value {
             0 => Ok(HeaderType::Type0),
@@ -189,6 +230,10 @@ impl HeaderType {
             type_value => Err(Error::InvalidHeaderType(type_value)),
         }
     }
+
+    pub fn from_slice_type0_legacy_server(slice: &[u8]) -> Result<Self, Error> {
+        Self::type0_legacy_server_from_slice(slice).ok_or(Error::InvalidHeader)
+    }
 }
 
 /// Header of a Crash Log record
@@ -209,8 +254,19 @@ impl Header {
             // Termination marker
             return Ok(None);
         };
-        let size = RecordSize::from_slice(slice).ok_or(Error::InvalidHeader)?;
-        let header_type = HeaderType::from_slice(version.header_type, slice)?;
+        let errata = Errata::from_version(&version);
+
+        let size = if errata.type0_legacy_server {
+            RecordSize::from_slice_type0_legacy_server(slice).ok_or(Error::InvalidHeader)?
+        } else {
+            RecordSize::from_slice(slice).ok_or(Error::InvalidHeader)?
+        };
+
+        let header_type = if errata.type0_legacy_server {
+            HeaderType::from_slice_type0_legacy_server(slice)?
+        } else {
+            HeaderType::from_slice(version.header_type, slice)?
+        };
 
         Ok(Some(Header {
             version,
@@ -280,19 +336,19 @@ impl Header {
 
     /// Returns the ID of the socket that generated the record.
     pub fn socket_id(&self) -> u8 {
-        if let HeaderType::Type6 { socket_id, .. } = self.header_type {
-            socket_id
-        } else {
-            0
+        match self.header_type {
+            HeaderType::Type6 { socket_id, .. } => socket_id,
+            HeaderType::Type0LegacyServer { socket_id, .. } => socket_id,
+            _ => 0,
         }
     }
 
     /// Returns the ID of the die that generated the record.
     pub fn die_id(&self) -> Option<u8> {
-        if let HeaderType::Type6 { die_id, .. } = self.header_type {
-            Some(die_id)
-        } else {
-            None
+        match self.header_type {
+            HeaderType::Type6 { die_id, .. } => Some(die_id),
+            HeaderType::Type0LegacyServer { die_id, .. } => Some(die_id),
+            _ => None,
         }
     }
 
@@ -372,6 +428,7 @@ impl Header {
                 completion_status_size,
                 ..
             } => 28 + completion_status_size as usize * 4,
+            HeaderType::Type0LegacyServer { .. } => 32,
         }
     }
 
@@ -380,25 +437,28 @@ impl Header {
         &self,
         cm: &CollateralManager<T>,
     ) -> Option<String> {
-        if let HeaderType::Type6 { socket_id, .. } = self.header_type {
-            if let Some(die) = self.die(cm) {
-                Some(format!("processors.cpu{socket_id}.{die}"))
-            } else {
-                self.get_root_path()
+        match self.header_type {
+            HeaderType::Type6 { socket_id, .. }
+            | HeaderType::Type0LegacyServer { socket_id, .. } => {
+                if let Some(die) = self.die(cm) {
+                    Some(format!("processors.cpu{socket_id}.{die}"))
+                } else {
+                    self.get_root_path()
+                }
             }
-        } else {
-            None
+            _ => None,
         }
     }
 
     pub(super) fn get_root_path(&self) -> Option<String> {
-        if let HeaderType::Type6 {
-            socket_id, die_id, ..
-        } = self.header_type
-        {
-            Some(format!("processors.cpu{socket_id}.die{die_id}"))
-        } else {
-            None
+        match self.header_type {
+            HeaderType::Type6 {
+                socket_id, die_id, ..
+            }
+            | HeaderType::Type0LegacyServer {
+                socket_id, die_id, ..
+            } => Some(format!("processors.cpu{socket_id}.die{die_id}")),
+            _ => None,
         }
     }
 }
@@ -412,8 +472,13 @@ impl fmt::Display for Header {
         );
         let header_type = match self.header_type {
             HeaderType::Type6 {
-                die_id, socket_id, ..
-            } => format!("die_id={die_id}, socket_id={socket_id}"),
+                socket_id, die_id, ..
+            }
+            | HeaderType::Type0LegacyServer {
+                socket_id, die_id, ..
+            } => {
+                format!("die_id={die_id}, socket_id={socket_id}")
+            }
             _ => "..".to_string(),
         };
 
@@ -512,6 +577,14 @@ impl RecordSize {
             extended_record_size: u16::from_le_bytes(slice.get(6..8)?.try_into().ok()?),
         })
     }
+
+    /// Creates a [RecordSize] from the raw record of a server product with legacy header type0
+    pub fn from_slice_type0_legacy_server(slice: &[u8]) -> Option<Self> {
+        Some(RecordSize {
+            record_size: u16::from_le_bytes(slice.get(16..18)?.try_into().ok()?),
+            extended_record_size: 0,
+        })
+    }
 }
 
 impl From<&RecordSize> for Node {
@@ -641,6 +714,26 @@ impl From<&Header> for Node {
                     ));
                 }
             }
+            HeaderType::Type0LegacyServer {
+                timestamp,
+                agent_version,
+                reason,
+                die_id,
+                socket_id,
+                completion_status,
+                collection_complete,
+            } => {
+                node.add(Node::field("timestamp", timestamp));
+                node.add(Node::field("agent_version", agent_version as u64));
+                node.add(Node::field("reason", reason as u64));
+                node.add(Node::field("die_id", die_id as u64));
+                node.add(Node::field("socket_id", socket_id as u64));
+                node.add(Node::field("completion_status", completion_status as u64));
+                node.add(Node::field(
+                    "record_collection_completed",
+                    collection_complete as u64,
+                ));
+            }
             _ => (),
         }
 

lib/src/lib.rs

@@ -114,6 +114,7 @@ mod bert;
 pub mod collateral;
 mod cper;
 mod crashlog;
+pub mod errata;
 mod error;
 #[cfg(feature = "extraction")]
 mod extract;

lib/tests/header.rs

@@ -71,3 +71,15 @@ fn decode_die_id_header() {
     let die = header.die(&cm).unwrap();
     assert_eq!(die, "io1");
 }
+
+#[test]
+fn decode_legacy_header_type0() {
+    let data = fs::read("tests/samples/legacy_type0.crashlog").unwrap();
+    let header = Header::from_slice(&data).unwrap().unwrap();
+
+    let socket_id = header.socket_id();
+    assert_eq!(socket_id, 1);
+
+    let die_id = header.die_id().unwrap();
+    assert_eq!(die_id, 10);
+}

lib/tests/record.rs

@@ -238,3 +238,19 @@ fn box_header_type6() {
 
     assert_eq!(header_type.kind, NodeType::Field { value: 3 })
 }
+
+#[test]
+fn header_type0_legacy_server() {
+    let mut cm = CollateralManager::file_system_tree(Path::new(COLLATERAL_TREE_PATH)).unwrap();
+    let data = fs::read("tests/samples/legacy_type0.crashlog").unwrap();
+
+    let crashlog = CrashLog::from_slice(&data).unwrap();
+
+    let root = crashlog.decode(&mut cm);
+
+    let header_type = root
+        .get_by_path("processors.cpu1.die10.mca.hdr.version.header_type")
+        .unwrap();
+
+    assert_eq!(header_type.kind, NodeType::Field { value: 0 })
+}