Skip to main content

intel_crashlog/
crashlog.rs

1// Copyright (C) 2025 Intel Corporation
2// SPDX-License-Identifier: MIT
3
4use crate::Error;
5use crate::bert::{Berr, Bert};
6#[cfg(feature = "collateral_manager")]
7use crate::collateral::{CollateralManager, CollateralTree};
8use crate::cper::{Cper, CperSectionBody};
9use crate::metadata::Metadata;
10use crate::node::Node;
11use crate::region::Region;
12#[cfg(not(feature = "std"))]
13use alloc::{collections::VecDeque, vec, vec::Vec};
14#[cfg(feature = "std")]
15use std::collections::VecDeque;
16
17/// Set of all the Crash Log records captured on a platform.
18#[derive(Default)]
19pub struct CrashLog {
20    /// Crash Log regions captured on the platform.
21    pub regions: Vec<Region>,
22    /// Extra information extracted alongside the Crash Log records
23    pub metadata: Metadata,
24}
25
26impl CrashLog {
27    pub(crate) fn from_regions(regions: Vec<Region>) -> Result<Self, Error> {
28        let mut queue = VecDeque::from(regions);
29        let mut regions = Vec::new();
30
31        while let Some(region) = queue.pop_front() {
32            for child in region.get_children() {
33                queue.push_back(child);
34            }
35            regions.push(region)
36        }
37
38        if regions.is_empty() {
39            return Err(Error::InvalidCrashLog);
40        }
41
42        Ok(CrashLog {
43            regions,
44            ..CrashLog::default()
45        })
46    }
47
48    /// Extracts the Crash Log records from [Berr].
49    pub(crate) fn from_berr(berr: Berr) -> Result<Self, Error> {
50        let regions = berr
51            .entries
52            .iter()
53            .filter_map(|entry| Region::from_cper_section(&entry.cper_section))
54            .collect();
55        CrashLog::from_regions(regions)
56    }
57
58    #[cfg(any(all(target_os = "windows", feature = "extraction"), doc))]
59    /// Searches for any Intel Crash Log logged in the Windows event logs.
60    ///
61    /// The Windows event logs typically captures the records reported through ACPI.
62    pub fn from_windows_event_logs(path: Option<&std::path::Path>) -> Result<Vec<Self>, Error> {
63        Self::from_event_logs(path).map_err(|err| {
64            log::error!("Error while accessing windows event logs: {err}");
65            Error::InternalError
66        })
67    }
68
69    /// Extracts the Crash Log records from [Cper] record.
70    pub(crate) fn from_cper(cper: Cper) -> Result<Self, Error> {
71        let mut regions: Vec<Region> = Vec::new();
72        let mut extra_cper_sections: Vec<CperSectionBody> = Vec::new();
73
74        for section in cper.sections {
75            if let Some(region) = Region::from_cper_section(&section.body) {
76                regions.push(region);
77            } else {
78                extra_cper_sections.push(section.body);
79            }
80        }
81
82        if regions.is_empty() {
83            return Err(Error::NoCrashLogFound);
84        }
85
86        let mut crashlog = CrashLog::from_regions(regions)?;
87        crashlog.metadata.extra_cper_sections = extra_cper_sections;
88        Ok(crashlog)
89    }
90
91    /// Decodes a raw Crash Log binary.
92    pub fn from_slice(s: &[u8]) -> Result<Self, Error> {
93        if let Some(berr) = Berr::from_bert_file(s) {
94            CrashLog::from_berr(berr)
95        } else if let Some(cper) = Cper::from_slice(s) {
96            CrashLog::from_cper(cper)
97        } else {
98            // Input file is a single Crash Log region
99            CrashLog::from_regions(vec![Region::from_slice(s)?])
100        }
101    }
102
103    /// Exports the [CrashLog] as a BERT file.
104    pub fn to_bert(&self) -> Vec<u8> {
105        let mut berr = Berr::from_crashlog(self).to_bytes();
106        let bert = Bert {
107            region: 0,
108            region_length: berr.len() as u32,
109            ..Bert::dummy()
110        };
111
112        let mut bytes = bert.to_bytes();
113        bytes.append(&mut berr);
114        bytes
115    }
116
117    /// Exports the [CrashLog] as a CPER file that wraps the Crash Log regions into Firmware Error
118    /// Record sections.
119    pub fn to_bytes(&self) -> Vec<u8> {
120        Cper::from_raw_crashlog(self).to_bytes()
121    }
122
123    /// Returns the register tree representation of the Crash Log record headers.
124    pub fn decode_without_cm(&self) -> Node {
125        let mut root = Node::root();
126        for region in self.regions.iter() {
127            for record in region.records.iter() {
128                root.merge(record.decode_without_cm())
129            }
130        }
131        root
132    }
133
134    /// Returns the register tree representation of the Crash Log record content.
135    #[cfg(feature = "collateral_manager")]
136    pub fn decode<T: CollateralTree>(&self, cm: &mut CollateralManager<T>) -> Node {
137        let mut root = Node::root();
138        for region in self.regions.iter() {
139            for record in region.records.iter() {
140                root.merge(record.decode(cm))
141            }
142        }
143        root
144    }
145}