Better events Debug

Author: Marcondiro

src/block/mod.rs

@@ -19,15 +19,15 @@ pub struct Block(pub(super) pt_block);
 impl Block {
     /// The IP of the first instruction in this block.
     #[must_use]
-    pub fn ip(&self) -> u64 {
+    pub const fn ip(&self) -> u64 {
         self.0.ip
     }
 
     /// The IP of the last instruction in this block.
     ///
     /// This can be used for error-detection.
     #[must_use]
-    pub fn end_ip(&self) -> u64 {
+    pub const fn end_ip(&self) -> u64 {
         self.0.end_ip
     }
 
@@ -38,7 +38,7 @@ impl Block {
     /// The section was not added via an image section cache or the memory
     /// was read via the read memory callback.
     #[must_use]
-    pub fn isid(&self) -> i32 {
+    pub const fn isid(&self) -> i32 {
         self.0.isid
     }
 
@@ -62,7 +62,7 @@ impl Block {
 
     /// The number of instructions in this block.
     #[must_use]
-    pub fn ninsn(&self) -> u16 {
+    pub const fn ninsn(&self) -> u16 {
         self.0.ninsn
     }
 

src/event/branch.rs

@@ -2,9 +2,10 @@ use crate::error::{PtError, PtErrorCode};
 use crate::event::Event;
 use derive_more::Deref;
 use libipt_sys::pt_event_type_ptev_async_branch;
+use std::fmt::{Debug, Formatter};
 
 /// An asynchronous branch, e.g. interrupt
-#[derive(Clone, Copy, Debug, Deref)]
+#[derive(Clone, Copy, Deref)]
 #[repr(transparent)]
 pub struct AsyncBranch {
     pub(super) event: Event,
@@ -25,6 +26,14 @@ impl AsyncBranch {
     }
 }
 
+impl Debug for AsyncBranch {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "AsyncBranch {{")?;
+        self.fmt_common_fields(f)?;
+        write!(f, "from: 0x{:x?}, to: 0x{:x?}, }}", self.from(), self.to())
+    }
+}
+
 impl TryFrom<Event> for AsyncBranch {
     type Error = PtError;
 

src/event/cbr.rs

@@ -2,9 +2,10 @@ use crate::error::{PtError, PtErrorCode};
 use crate::event::Event;
 use derive_more::Deref;
 use libipt_sys::pt_event_type_ptev_cbr;
+use std::fmt::{Debug, Formatter};
 
 /// A core:bus ratio event
-#[derive(Clone, Copy, Debug, Deref)]
+#[derive(Clone, Copy, Deref)]
 #[repr(transparent)]
 pub struct Cbr {
     pub(super) event: Event,
@@ -17,6 +18,14 @@ impl Cbr {
     }
 }
 
+impl Debug for Cbr {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Cbr {{")?;
+        self.fmt_common_fields(f)?;
+        write!(f, "ratio: {:?}, }}", self.ratio())
+    }
+}
+
 impl TryFrom<Event> for Cbr {
     type Error = PtError;
 

src/event/disabled.rs

@@ -2,9 +2,10 @@ use crate::error::{PtError, PtErrorCode};
 use crate::event::Event;
 use derive_more::Deref;
 use libipt_sys::{pt_event_type_ptev_async_disabled, pt_event_type_ptev_disabled};
+use std::fmt::{Debug, Formatter};
 
 /// Tracing has been disabled
-#[derive(Clone, Copy, Debug, Deref)]
+#[derive(Clone, Copy, Deref)]
 #[repr(transparent)]
 pub struct Disabled {
     pub(super) event: Event,
@@ -20,6 +21,14 @@ impl Disabled {
     }
 }
 
+impl Debug for Disabled {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Disabled {{")?;
+        self.fmt_common_fields(f)?;
+        write!(f, "ip: 0x{:x?}, }}", self.ip())
+    }
+}
+
 impl TryFrom<Event> for Disabled {
     type Error = PtError;
 
@@ -33,10 +42,11 @@ impl TryFrom<Event> for Disabled {
 }
 
 /// Tracing has been disabled asynchronously
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Deref)]
 pub struct AsyncDisabled {
     pub(super) event: Event,
 }
+
 impl AsyncDisabled {
     /// The source address of the asynchronous branch that disabled tracing
     #[must_use]
@@ -52,6 +62,14 @@ impl AsyncDisabled {
     }
 }
 
+impl Debug for AsyncDisabled {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "AsyncDisabled {{")?;
+        self.fmt_common_fields(f)?;
+        write!(f, "at: {:?}, ip: {:?}, }}", self.at(), self.ip())
+    }
+}
+
 impl TryFrom<Event> for AsyncDisabled {
     type Error = PtError;
 

src/event/enabled.rs

@@ -2,9 +2,10 @@ use crate::error::{PtError, PtErrorCode};
 use crate::event::Event;
 use derive_more::Deref;
 use libipt_sys::pt_event_type_ptev_enabled;
+use std::fmt::{Debug, Formatter};
 
 /// Tracing has been enabled
-#[derive(Clone, Copy, Debug, Deref)]
+#[derive(Clone, Copy, Deref)]
 #[repr(transparent)]
 pub struct Enabled {
     pub(super) event: Event,
@@ -24,6 +25,19 @@ impl Enabled {
     }
 }
 
+impl Debug for Enabled {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Enabled {{")?;
+        self.fmt_common_fields(f)?;
+        write!(
+            f,
+            "ip: 0x{:x?}, resumed: {:?} }}",
+            self.ip(),
+            self.resumed()
+        )
+    }
+}
+
 impl TryFrom<Event> for Enabled {
     type Error = PtError;
 

src/event/exec_mode.rs

@@ -10,6 +10,7 @@ use libipt_sys::{
 };
 use num_enum::TryFromPrimitive;
 use std::convert::TryFrom;
+use std::fmt::{Debug, Formatter};
 
 #[derive(Clone, Copy, TryFromPrimitive, Debug, PartialEq)]
 #[repr(u32)]
@@ -21,7 +22,7 @@ pub enum ExecModeType {
 }
 
 /// An execution mode change
-#[derive(Clone, Copy, Debug, Deref)]
+#[derive(Clone, Copy, Deref)]
 #[repr(transparent)]
 pub struct ExecMode {
     pub(super) event: Event,
@@ -35,12 +36,19 @@ impl ExecMode {
 
     /// The execution mode
     #[must_use]
-    #[expect(clippy::missing_panics_doc)]
     pub fn mode(&self) -> ExecModeType {
         ExecModeType::try_from(unsafe { self.event.0.variant.exec_mode.mode } as u32).unwrap()
     }
 }
 
+impl Debug for ExecMode {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "ExecMode {{")?;
+        self.fmt_common_fields(f)?;
+        write!(f, "ip: 0x{:x?}, mode: {:?} }}", self.ip(), self.mode())
+    }
+}
+
 impl TryFrom<Event> for ExecMode {
     type Error = PtError;
 

src/event/exstop.rs

@@ -2,9 +2,10 @@ use crate::error::{PtError, PtErrorCode};
 use crate::event::Event;
 use derive_more::Deref;
 use libipt_sys::pt_event_type_ptev_exstop;
+use std::fmt::{Debug, Formatter};
 
 /// Execution has stopped
-#[derive(Clone, Copy, Debug, Deref)]
+#[derive(Clone, Copy, Deref)]
 #[repr(transparent)]
 pub struct Exstop {
     pub(super) event: Event,
@@ -19,6 +20,14 @@ impl Exstop {
     }
 }
 
+impl Debug for Exstop {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Exstop {{")?;
+        self.fmt_common_fields(f)?;
+        write!(f, "ip: 0x{:x?}, }}", self.ip())
+    }
+}
+
 impl TryFrom<Event> for Exstop {
     type Error = PtError;
 

src/event/mnt.rs

@@ -2,9 +2,10 @@ use crate::error::{PtError, PtErrorCode};
 use crate::event::Event;
 use derive_more::Deref;
 use libipt_sys::pt_event_type_ptev_mnt;
+use std::fmt::{Debug, Formatter};
 
 /// A maintenance event.
-#[derive(Clone, Copy, Debug, Deref)]
+#[derive(Clone, Copy, Deref)]
 #[repr(transparent)]
 pub struct Mnt {
     pub(super) event: Event,
@@ -17,6 +18,14 @@ impl Mnt {
     }
 }
 
+impl Debug for Mnt {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Mnt {{")?;
+        self.fmt_common_fields(f)?;
+        write!(f, "payload: 0x{:x?}, }}", self.payload())
+    }
+}
+
 impl TryFrom<Event> for Mnt {
     type Error = PtError;
 

src/event/mod.rs

@@ -7,6 +7,7 @@ use libipt_sys::{
     pt_event_type_ptev_pwre, pt_event_type_ptev_pwrx, pt_event_type_ptev_stop,
     pt_event_type_ptev_tick, pt_event_type_ptev_tsx, pt_event_type_ptev_vmcs,
 };
+use std::fmt::{Debug, Formatter};
 
 mod enabled;
 pub use enabled::*;
@@ -76,9 +77,10 @@ impl From<Event> for EventType {
     }
 }
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Clone, Copy)]
 #[repr(transparent)]
 pub struct Event(pub(crate) pt_event);
+
 impl Event {
     /// A flag indicating that the event IP has been suppressed.
     #[must_use]
@@ -92,17 +94,16 @@ impl Event {
         self.0.status_update() > 0
     }
 
-    /// A flag indicating that the event has timing information.
-    #[must_use]
-    pub fn has_tsc(&self) -> bool {
-        self.0.has_tsc() > 0
-    }
-
     /// The time stamp count of the event.
-    /// This field is only valid if @has_tsc is set.
+    ///
+    /// Returns `None` if tsc information is not available
     #[must_use]
-    pub const fn tsc(&self) -> u64 {
-        self.0.tsc
+    pub fn tsc(&self) -> Option<u64> {
+        if self.0.has_tsc() > 0 {
+            Some(self.0.tsc)
+        } else {
+            None
+        }
     }
 
     /// The number of lost mtc packets.
@@ -153,6 +154,24 @@ impl Event {
             _ => unreachable!(),
         }
     }
+
+    pub(crate) fn fmt_common_fields(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "ip_suppressed : {:?}, status_update: {:?}, tsc: {:?}, lost_mtc: {:?}, lost_cyc: {:?},",
+            self.ip_suppressed(),
+            self.status_update(),
+            self.tsc(),
+            self.lost_mtc(),
+            self.lost_cyc(),
+        )
+    }
+}
+
+impl Debug for Event {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        self.event_type().fmt(f)
+    }
 }
 
 #[cfg(test)]
@@ -177,9 +196,8 @@ mod test {
         let evt = Event(evt);
         assert!(evt.ip_suppressed());
         assert!(!evt.status_update());
-        assert!(evt.has_tsc());
 
-        assert_eq!(evt.tsc(), 1);
+        assert_eq!(evt.tsc(), Some(1));
         assert_eq!(evt.lost_mtc(), 2);
         assert_eq!(evt.lost_cyc(), 3);
 

src/event/mwait.rs

@@ -2,9 +2,10 @@ use crate::error::{PtError, PtErrorCode};
 use crate::event::Event;
 use derive_more::Deref;
 use libipt_sys::pt_event_type_ptev_mwait;
+use std::fmt::{Debug, Formatter};
 
 /// An MWAIT operation completed
-#[derive(Clone, Copy, Debug, Deref)]
+#[derive(Clone, Copy, Deref)]
 #[repr(transparent)]
 pub struct Mwait {
     pub(super) event: Event,
@@ -35,6 +36,20 @@ impl Mwait {
     }
 }
 
+impl Debug for Mwait {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Mwait {{")?;
+        self.fmt_common_fields(f)?;
+        write!(
+            f,
+            "ip: 0x{:x?}, hints: 0x{:x?}, ext: 0x{:x?}, }}",
+            self.ip(),
+            self.hints(),
+            self.ext()
+        )
+    }
+}
+
 impl TryFrom<Event> for Mwait {
     type Error = PtError;