feat: Add parser for CLOCK_DATA & CLOCKID headers

Implements #16

Author: VorpalBlade

examples/perfdatainfo.rs

@@ -33,6 +33,12 @@ fn main() {
     if let Ok(Some(perf_version)) = perf_file.perf_version() {
         println!("Perf version: {perf_version}");
     }
+    if let Ok(Some(frequency)) = perf_file.clock_frequency() {
+        println!("Clock frequency: {frequency} ns per tick");
+    }
+    if let Ok(Some(clock_data)) = perf_file.clock_data() {
+        println!("Clock data: {clock_data:?}");
+    }
 
     // Print the feature sections.
     let features = perf_file.features();

src/feature_sections.rs

@@ -280,3 +280,38 @@ impl PmuMappings {
         Ok(Self(vec.into_iter().collect()))
     }
 }
+
+/// The clock data header contains information about the clock used to
+/// record timestamps in the perf.data file.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ClockData {
+    /// Clock ID used for timestamps
+    pub clockid: u32,
+    /// Wall clock time in nanoseconds since Unix epoch.
+    pub wall_clock_ns: u64,
+    /// Clock ID time in nanoseconds at the same instant as `wall_clock_ns`.
+    pub clockid_time_ns: u64,
+}
+
+impl ClockData {
+    pub const STRUCT_SIZE: usize = 4 + 4 + 8 + 8;
+
+    pub fn parse<R: Read, T: ByteOrder>(mut data: R) -> Result<Self, std::io::Error> {
+        let version = data.read_u32::<T>()?;
+        if version != 1 {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::InvalidData,
+                format!("Unsupported clock data version: {version}"),
+            ));
+        }
+        let clockid = data.read_u32::<T>()?;
+        let wall_clock_ns = data.read_u64::<T>()?;
+        let clockid_time_ns = data.read_u64::<T>()?;
+
+        Ok(Self {
+            clockid,
+            wall_clock_ns,
+            clockid_time_ns,
+        })
+    }
+}

src/perf_file.rs

@@ -9,7 +9,9 @@ use super::build_id_event::BuildIdEvent;
 use super::dso_info::DsoInfo;
 use super::dso_key::DsoKey;
 use super::error::Error;
-use super::feature_sections::{AttributeDescription, NrCpus, PmuMappings, SampleTimeRange};
+use super::feature_sections::{
+    AttributeDescription, ClockData, NrCpus, PmuMappings, SampleTimeRange,
+};
 use super::features::{Feature, FeatureSet};
 use super::simpleperf;
 
@@ -181,6 +183,36 @@ impl PerfFile {
         Ok(Some(mem))
     }
 
+    /// The clock frequency for the clock in [`clock_data`] expressed as ns per tick.
+    pub fn clock_frequency(&self) -> Result<Option<u64>, Error> {
+        let data = match self.feature_section_data(Feature::CLOCKID) {
+            Some(data) => data,
+            None => return Ok(None),
+        };
+        if data.len() < 8 {
+            return Err(Error::FeatureSectionTooSmall);
+        }
+        let b = data;
+        let data = [b[0], b[1], b[2], b[3], b[4], b[5], b[6], b[7]];
+        let mem = match self.endian {
+            Endianness::LittleEndian => u64::from_le_bytes(data),
+            Endianness::BigEndian => u64::from_be_bytes(data),
+        };
+        Ok(Some(mem))
+    }
+
+    /// A structure containing information about the clock
+    pub fn clock_data(&self) -> Result<Option<ClockData>, Error> {
+        self.feature_section_data(Feature::CLOCK_DATA)
+            .map(|section| {
+                Ok(match self.endian {
+                    Endianness::LittleEndian => ClockData::parse::<_, LittleEndian>(section),
+                    Endianness::BigEndian => ClockData::parse::<_, BigEndian>(section),
+                }?)
+            })
+            .transpose()
+    }
+
     /// The meta info map, if this is a Simpleperf profile.
     pub fn simpleperf_meta_info(&self) -> Result<Option<HashMap<&str, &str>>, Error> {
         match self.feature_section_data(Feature::SIMPLEPERF_META_INFO) {