lib: include die name decode in basic_decode

lib/src/crashlog.rs

@@ -155,13 +155,7 @@ impl CrashLog {
         let mut root = Node::root();
         for region in self.regions.iter() {
             for record in region.records.iter() {
-                root.merge(match record.decode(cm) {
-                    Ok(node) => node,
-                    Err(err) => {
-                        log::warn!("Cannot decode record: {err}");
-                        record.basic_decode()
-                    }
-                })
+                root.merge(record.decode(cm))
             }
         }
         root

lib/src/record/decode.rs

@@ -146,12 +146,23 @@ impl Record {
 
     /// Decodes the [Record] header into a [Node] tree.
     pub fn basic_decode(&self) -> Node {
+        let root_path = self.header.get_root_path();
+        self.decode_header(&root_path)
+    }
+
+    #[cfg(feature = "collateral_manager")]
+    fn basic_decode_cm<T: CollateralTree>(&self, cm: &mut CollateralManager<T>) -> Node {
+        let root_path = self.header.get_root_path_cm(cm);
+        self.decode_header(&root_path)
+    }
+
+    fn decode_header(&self, root_path: &Option<String>) -> Node {
         let mut record = Node::record(self.header.record_type().unwrap_or("record"));
         record.add(Node::from(&self.header));
 
         let mut root = Node::root();
-        let record_root = if let Some(custom_root) = self.header.get_root_path() {
-            root.create_hierarchy(&custom_root)
+        let record_root = if let Some(custom_root) = root_path {
+            root.create_hierarchy(custom_root)
         } else {
             &mut root
         };
@@ -193,11 +204,20 @@ impl Record {
     /// Decodes the whole [Record] into a [Node] tree using the decode definitions stored in the
     /// collateral tree.
     #[cfg(feature = "collateral_manager")]
-    pub fn decode<T: CollateralTree>(&self, cm: &mut CollateralManager<T>) -> Result<Node, Error> {
-        if let record_types::PCORE | record_types::ECORE = self.header.version.record_type {
-            return self.decode_as_core_record(cm);
-        }
+    pub fn decode<T: CollateralTree>(&self, cm: &mut CollateralManager<T>) -> Node {
+        let root =
+            if let record_types::PCORE | record_types::ECORE = self.header.version.record_type {
+                self.decode_as_core_record(cm)
+            } else {
+                self.decode_with_decode_def(cm, "layout.csv", 0)
+            };
 
-        self.decode_with_decode_def(cm, "layout.csv", 0)
+        match root {
+            Ok(node) => node,
+            Err(err) => {
+                log::warn!("Cannot decode record: {err}. Only the header fields will be decoded.");
+                self.basic_decode_cm(cm)
+            }
+        }
     }
 }

lib/tests/crashlog.rs

@@ -26,7 +26,7 @@ fn crashlog_decode() {
     let mca = root.get_by_path("mca");
     assert!(mca.is_some());
 
-    let crashlog_agent = root.get_by_path("processors.cpu0.die0.crashlog_agent");
+    let crashlog_agent = root.get_by_path("processors.cpu0.io0.crashlog_agent");
     assert!(crashlog_agent.is_some());
 }
 

lib/tests/record.rs

@@ -83,7 +83,7 @@ fn decode() {
     let header = Header::from_slice(&data).unwrap().unwrap();
     let record = Record { header, data };
 
-    let root = record.decode(&mut cm).unwrap();
+    let root = record.decode(&mut cm);
     let version = root.get_by_path("mca.hdr.version.revision").unwrap();
     assert_eq!(version.kind, NodeType::Field { value: 1 });
 }
@@ -108,7 +108,7 @@ fn decode_generic() {
     };
 
     let mut cm = CollateralManager::file_system_tree(Path::new(COLLATERAL_TREE_PATH)).unwrap();
-    let root = record.decode(&mut cm).unwrap();
+    let root = record.decode(&mut cm);
     let foo = root.get_by_path("mca.foo").unwrap();
     assert_eq!(foo.kind, NodeType::Field { value: 0x42 });
 }
@@ -134,7 +134,12 @@ fn decode_missing_decode_defs() {
 
     let mut cm = CollateralManager::file_system_tree(Path::new(COLLATERAL_TREE_PATH)).unwrap();
     let root = record.decode(&mut cm);
-    assert_matches!(root, Err(Error::MissingDecodeDefinitions(_)));
+
+    let revision = root.get_by_path("mca.hdr.version.revision").unwrap();
+    assert_eq!(revision.kind, NodeType::Field { value: 42 });
+
+    let record_size = root.get_by_path("mca.hdr.record_size.record_size").unwrap();
+    assert_eq!(record_size.kind, NodeType::Field { value: 1 });
 }
 
 #[test]
@@ -145,7 +150,7 @@ fn header_type6_decode() {
     let header = Header::from_slice(&data).unwrap().unwrap();
     let record = Record { header, data };
 
-    let root = record.decode(&mut cm).unwrap();
+    let root = record.decode(&mut cm);
     let version = root
         .get_by_path("processors.cpu0.io1.mca.hdr.version.revision")
         .unwrap();