Skip to main content

intel_crashlog/
region.rs

1// Copyright (C) 2025 Intel Corporation
2// SPDX-License-Identifier: MIT
3
4//! Provides access to the records stored in a Crash Log region.
5
6use crate::cper::section::{CperSectionBody, fer};
7use crate::error::Error;
8use crate::header::{Header, record_types};
9use crate::record::Record;
10#[cfg(not(feature = "std"))]
11use alloc::vec::Vec;
12
13const MAX_NESTED_BOXES: usize = 4;
14
15/// A container for one or several Crash Log records.
16///
17/// A Crash Log region refers to a region in an on-die memory that is allocated for storing
18/// a contiguous sequence of Crash Log records.
19#[derive(Default)]
20pub struct Region {
21    pub records: Vec<Record>,
22    depth: usize,
23}
24
25impl Region {
26    pub(crate) fn from_cper_section(section: &CperSectionBody) -> Option<Self> {
27        match section {
28            CperSectionBody::FirmwareErrorRecord(fer) => {
29                let guid = fer.header.guid;
30                if guid == fer::guids::RECORD_ID_CRASHLOG {
31                    Region::from_slice(&fer.payload).ok()
32                } else {
33                    log::info!("Ignoring unknown Firmware Error Record: {}", guid);
34                    None
35                }
36            }
37            _ => None,
38        }
39    }
40
41    pub(crate) fn get_children(&self) -> Vec<Self> {
42        let mut children = Vec::new();
43
44        if self.depth >= MAX_NESTED_BOXES {
45            return children;
46        }
47
48        for record in self.records.iter() {
49            let errata = record.header.version.errata();
50            let is_box = record.header.version.record_type == record_types::BOX
51                || errata.type0_legacy_server_box;
52
53            if !is_box {
54                continue;
55            }
56
57            let Some(payload) = record.data.get(record.header.header_size()..) else {
58                log::error!("The Box record has an empty payload");
59                continue;
60            };
61
62            match Region::from_slice(payload) {
63                Ok(mut child) => {
64                    for child_record in child.records.iter_mut() {
65                        child_record.context.parent_header = Some(record.header.clone());
66                    }
67
68                    child.depth = self.depth + 1;
69
70                    children.push(child)
71                }
72                Err(err) => log::warn!("Invalid region in Box record: {err}"),
73            }
74        }
75
76        children
77    }
78
79    pub fn from_slice(bytes: &[u8]) -> Result<Self, Error> {
80        let mut region = Region::default();
81        let mut cursor = 0;
82
83        while cursor < bytes.len() {
84            let header = match Header::from_slice(&bytes[cursor..]) {
85                Ok(Some(header)) => header,
86                Ok(None) => {
87                    log::debug!("Found termination marker at offset {cursor}");
88                    break;
89                }
90                Err(err) => {
91                    log::warn!("Cannot decode record header: {err}");
92                    if region.records.is_empty() {
93                        // Return the error if no record can be decoded
94                        return Err(err);
95                    }
96                    break;
97                }
98            };
99
100            log::debug!("Record version: {0}", header);
101
102            let record_size = header.record_size();
103            log::debug!("Record size: 0x{record_size:04x}");
104
105            if record_size == 0 {
106                log::warn!(
107                    "{} record has an empty size. Skipping.",
108                    header.record_type().unwrap_or("UNKNOWN")
109                );
110                break;
111            }
112
113            let limit = cursor + record_size;
114            if limit > bytes.len() {
115                log::warn!(
116                    "Truncated record detected: record is expected to be {}B but is {}B",
117                    record_size,
118                    bytes.len() - cursor
119                )
120            }
121
122            region.records.push(Record {
123                header,
124                data: bytes[cursor..limit.min(bytes.len())].into(),
125                ..Default::default()
126            });
127
128            cursor += record_size;
129        }
130
131        if region.records.is_empty() {
132            return Err(Error::EmptyRegion);
133        }
134
135        Ok(region)
136    }
137
138    pub fn to_bytes(&self) -> Vec<u8> {
139        let mut bytes = Vec::new();
140        for record in self.records.iter() {
141            bytes.append(&mut record.data.clone());
142        }
143        bytes
144    }
145}