use crate::ffi::trace as ffi;
use std::borrow::Cow;
pub const MAGIC_HEADER: u32 = ffi::TRACE_MAGIC_HEADER;
pub const VERSION_MAJOR: u16 = ffi::TRACE_VERSION_MAJOR as u16;
pub const VERSION_MINOR: u16 = ffi::TRACE_VERSION_MINOR as u16;
const STD_HEADER_SIZE: usize = 64;
const ENTRY_HEADER_SIZE: usize = 16;
const SIZE_HEADER_SIZE: usize = 4;
const _: () = assert!(core::mem::size_of::<ffi::trace_buffer_std_header_t>() == STD_HEADER_SIZE);
const _: () = assert!(core::mem::size_of::<ffi::trace_entry_header_t>() == ENTRY_HEADER_SIZE);
const _: () = assert!(core::mem::size_of::<ffi::trace_buffer_size_header_t>() == SIZE_HEADER_SIZE);
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum TraceError {
TooShort,
BadMagic(u32),
IncompatibleVersion {
major: u16,
minor: u16,
},
}
impl std::fmt::Display for TraceError {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
TraceError::TooShort => write!(f, "trace buffer shorter than its header"),
TraceError::BadMagic(m) => write!(f, "bad trace magic 0x{m:08x}"),
TraceError::IncompatibleVersion { major, minor } => {
write!(f, "incompatible trace layout version {major}.{minor}")
}
}
}
}
impl std::error::Error for TraceError {}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Header {
pub version: (u16, u16, u16),
pub buffer_type: u16,
pub data_size: u32,
pub sub_buffer_size: u32,
pub sub_buffer_count: u16,
}
#[derive(Clone, Copy, Debug)]
pub struct TraceBuffer<'a> {
data: &'a [u8],
header: Header,
}
impl<'a> TraceBuffer<'a> {
pub fn parse(data: &'a [u8]) -> Result<Self, TraceError> {
if data.len() < STD_HEADER_SIZE {
return Err(TraceError::TooShort);
}
let magic = rd_u32(data, 0);
if magic != MAGIC_HEADER {
return Err(TraceError::BadMagic(magic));
}
let major = rd_u16(data, 4);
let minor = rd_u16(data, 6);
let patch = rd_u16(data, 8);
if major != VERSION_MAJOR || minor > VERSION_MINOR {
return Err(TraceError::IncompatibleVersion { major, minor });
}
let header = Header {
version: (major, minor, patch),
buffer_type: rd_u16(data, 10),
data_size: rd_u32(data, 12),
sub_buffer_size: rd_u32(data, 16),
sub_buffer_count: rd_u16(data, 20),
};
Ok(TraceBuffer { data, header })
}
pub fn header(&self) -> Header {
self.header
}
pub fn entries(&self) -> Entries<'a> {
Entries {
data: self.data,
segments: self.segments(),
segment: 0,
offset: 0,
started: false,
}
}
pub fn string_entries(&self) -> impl Iterator<Item = (u16, Cow<'a, str>)> + 'a {
self.entries().filter_map(|e| match e.decoded() {
DecodedEntry::String(s) => Some((e.hart_id, s)),
_ => None,
})
}
fn segments(&self) -> Vec<Segment> {
let len = self.data.len();
let mut segs = Vec::new();
let data_end = (self.header.data_size as usize).min(len);
if data_end > STD_HEADER_SIZE {
segs.push(Segment {
start: STD_HEADER_SIZE,
end: data_end,
});
}
let count = self.header.sub_buffer_count as usize;
let stride = self.header.sub_buffer_size as usize;
if count > 1 && stride >= SIZE_HEADER_SIZE {
for i in 1..count {
let base = i.saturating_mul(stride);
if base + SIZE_HEADER_SIZE > len {
break;
}
let sub_size = rd_u32(self.data, base) as usize;
if sub_size > SIZE_HEADER_SIZE {
let end = base.saturating_add(sub_size).min(len);
segs.push(Segment {
start: base + SIZE_HEADER_SIZE,
end,
});
}
}
}
segs
}
}
#[derive(Clone, Copy, Debug)]
struct Segment {
start: usize,
end: usize,
}
#[derive(Clone, Debug)]
pub struct Entries<'a> {
data: &'a [u8],
segments: Vec<Segment>,
segment: usize,
offset: usize,
started: bool,
}
impl<'a> Iterator for Entries<'a> {
type Item = Entry<'a>;
fn next(&mut self) -> Option<Entry<'a>> {
loop {
let seg = *self.segments.get(self.segment)?;
if !self.started {
self.offset = seg.start;
self.started = true;
}
if self.offset + ENTRY_HEADER_SIZE > seg.end {
self.segment += 1;
self.started = false;
continue;
}
let off = self.offset;
let cycle = rd_u64(self.data, off);
let payload_size = rd_u32(self.data, off + 8) as usize;
let hart_id = rd_u16(self.data, off + 12);
let raw_type = rd_u16(self.data, off + 14);
let payload_start = off + ENTRY_HEADER_SIZE;
let payload_end = payload_start.saturating_add(payload_size);
if payload_end > seg.end || payload_end > self.data.len() {
return None;
}
self.offset = payload_end;
return Some(Entry {
cycle,
hart_id,
raw_type,
payload: &self.data[payload_start..payload_end],
});
}
}
}
#[derive(Clone, Copy, Debug)]
pub struct Entry<'a> {
pub cycle: u64,
pub hart_id: u16,
pub raw_type: u16,
pub payload: &'a [u8],
}
impl<'a> Entry<'a> {
pub fn trace_type(&self) -> TraceType {
TraceType::from_raw(self.raw_type)
}
pub fn as_str(&self) -> Option<Cow<'a, str>> {
if self.trace_type() != TraceType::String {
return None;
}
Some(decode_cstr(self.payload))
}
pub fn decoded(&self) -> DecodedEntry<'a> {
match self.trace_type() {
TraceType::String => DecodedEntry::String(decode_cstr(self.payload)),
TraceType::ValueU64 => scalar(self.payload, 8)
.map(|(tag, v)| DecodedEntry::ValueU64 { tag, value: v })
.unwrap_or(DecodedEntry::Malformed),
TraceType::ValueU32 => scalar(self.payload, 4)
.map(|(tag, v)| DecodedEntry::ValueU32 {
tag,
value: v as u32,
})
.unwrap_or(DecodedEntry::Malformed),
TraceType::ValueU16 => scalar(self.payload, 2)
.map(|(tag, v)| DecodedEntry::ValueU16 {
tag,
value: v as u16,
})
.unwrap_or(DecodedEntry::Malformed),
TraceType::ValueU8 => scalar(self.payload, 1)
.map(|(tag, v)| DecodedEntry::ValueU8 {
tag,
value: v as u8,
})
.unwrap_or(DecodedEntry::Malformed),
_ => DecodedEntry::Other {
trace_type: self.trace_type(),
payload: self.payload,
},
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum DecodedEntry<'a> {
String(Cow<'a, str>),
ValueU64 {
tag: u32,
value: u64,
},
ValueU32 { tag: u32, value: u32 },
ValueU16 { tag: u32, value: u16 },
ValueU8 { tag: u32, value: u8 },
Other {
trace_type: TraceType,
payload: &'a [u8],
},
Malformed,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TraceType {
String,
PmcCounter,
PmcCountersCompute,
PmcCountersMemory,
PmcCountersSc,
PmcCountersMs,
ValueU64,
ValueU32,
ValueU16,
ValueU8,
ValueFloat,
Memory,
Exception,
CmdStatus,
PowerStatus,
CustomEvent,
UserProfileEvent,
Unknown(u16),
}
impl TraceType {
pub fn from_raw(raw: u16) -> Self {
use ffi::trace_type::*;
match raw as ffi::trace_type::Type {
TRACE_TYPE_STRING => TraceType::String,
TRACE_TYPE_PMC_COUNTER => TraceType::PmcCounter,
TRACE_TYPE_PMC_COUNTERS_COMPUTE => TraceType::PmcCountersCompute,
TRACE_TYPE_PMC_COUNTERS_MEMORY => TraceType::PmcCountersMemory,
TRACE_TYPE_PMC_COUNTERS_SC => TraceType::PmcCountersSc,
TRACE_TYPE_PMC_COUNTERS_MS => TraceType::PmcCountersMs,
TRACE_TYPE_VALUE_U64 => TraceType::ValueU64,
TRACE_TYPE_VALUE_U32 => TraceType::ValueU32,
TRACE_TYPE_VALUE_U16 => TraceType::ValueU16,
TRACE_TYPE_VALUE_U8 => TraceType::ValueU8,
TRACE_TYPE_VALUE_FLOAT => TraceType::ValueFloat,
TRACE_TYPE_MEMORY => TraceType::Memory,
TRACE_TYPE_EXCEPTION => TraceType::Exception,
TRACE_TYPE_CMD_STATUS => TraceType::CmdStatus,
TRACE_TYPE_POWER_STATUS => TraceType::PowerStatus,
TRACE_TYPE_CUSTOM_EVENT => TraceType::CustomEvent,
TRACE_TYPE_USER_PROFILE_EVENT => TraceType::UserProfileEvent,
_ => TraceType::Unknown(raw),
}
}
}
fn scalar(payload: &[u8], value_bytes: usize) -> Option<(u32, u64)> {
if payload.len() < 4 + value_bytes {
return None;
}
let tag = rd_u32(payload, 0);
let mut v = [0u8; 8];
v[..value_bytes].copy_from_slice(&payload[4..4 + value_bytes]);
Some((tag, u64::from_le_bytes(v)))
}
fn decode_cstr(payload: &[u8]) -> Cow<'_, str> {
let end = payload
.iter()
.position(|&b| b == 0)
.unwrap_or(payload.len());
String::from_utf8_lossy(&payload[..end])
}
#[inline]
fn rd_u16(b: &[u8], off: usize) -> u16 {
u16::from_le_bytes([b[off], b[off + 1]])
}
#[inline]
fn rd_u32(b: &[u8], off: usize) -> u32 {
u32::from_le_bytes([b[off], b[off + 1], b[off + 2], b[off + 3]])
}
#[inline]
fn rd_u64(b: &[u8], off: usize) -> u64 {
u64::from_le_bytes(b[off..off + 8].try_into().unwrap())
}