event refactoring

Author: Marcondiro

Cargo.toml

@@ -19,4 +19,5 @@ libipt_master = ["libipt-sys/libipt_master"]
 [dependencies]
 libipt-sys = { version = "0.2.1", git = "https://github.com/sum-catnip/libipt-sys.git" }
 bitflags = "2.4.1"
+derive_more = { version = "2.0.1", features = ["deref"]}
 num_enum = "0.7.1"

src/error.rs

@@ -82,6 +82,12 @@ pub enum PtErrorCode {
     BadCpu = pt_error_code_pte_bad_cpu as i32,
 }
 
+impl From<PtErrorCode> for PtError {
+    fn from(value: PtErrorCode) -> Self {
+        PtError::from_code(-(value as i32))
+    }
+}
+
 #[derive(Debug, Clone, Copy)]
 pub struct PtError {
     code: PtErrorCode,

src/event/branch.rs

@@ -1,27 +1,45 @@
-use libipt_sys::pt_event__bindgen_ty_1__bindgen_ty_4;
+use crate::error::{PtError, PtErrorCode};
+use crate::event::Event;
+use derive_more::Deref;
+use libipt_sys::pt_event_type_ptev_async_branch;
 
 /// An asynchronous branch, e.g. interrupt
-#[derive(Clone, Copy, Debug)]
-pub struct AsyncBranch(pub(super) pt_event__bindgen_ty_1__bindgen_ty_4);
+#[derive(Clone, Copy, Debug, Deref)]
+#[repr(transparent)]
+pub struct AsyncBranch {
+    pub(super) event: Event,
+}
+
 impl AsyncBranch {
     /// The branch source address
     #[must_use]
-    pub fn from(&self) -> u64 {
-        self.0.from
+    pub const fn from(&self) -> u64 {
+        unsafe { self.event.0.variant.async_branch.from }
     }
 
     /// The branch destination address.
     /// This field is not valid if @ip_suppressed is set.
     #[must_use]
-    pub fn to(&self) -> u64 {
-        self.0.to
+    pub const fn to(&self) -> u64 {
+        unsafe { self.event.0.variant.async_branch.to }
+    }
+}
+
+impl TryFrom<Event> for AsyncBranch {
+    type Error = PtError;
+
+    fn try_from(event: Event) -> Result<Self, Self::Error> {
+        if event.0.type_ == pt_event_type_ptev_async_branch {
+            Ok(Self { event })
+        } else {
+            Err(PtErrorCode::Invalid.into())
+        }
     }
 }
 
 #[cfg(test)]
 mod test {
-    use super::super::Payload;
-    use super::*;
+    use super::super::EventType;
     use crate::event::Event;
     use libipt_sys::{pt_event, pt_event_type_ptev_async_branch};
     use std::mem;
@@ -30,11 +48,12 @@ mod test {
     fn test_branch_async_payload() {
         let mut evt: pt_event = unsafe { mem::zeroed() };
         evt.type_ = pt_event_type_ptev_async_branch;
-        evt.variant.async_branch = pt_event__bindgen_ty_1__bindgen_ty_4 { from: 1, to: 2 };
+        evt.variant.async_branch.from = 1;
+        evt.variant.async_branch.to = 2;
 
-        let payload: Payload = Event(evt).into();
+        let payload: EventType = Event(evt).into();
         match payload {
-            Payload::AsyncBranch(e) => {
+            EventType::AsyncBranch(e) => {
                 assert_eq!(e.from(), 1);
                 assert_eq!(e.to(), 2);
             }

src/event/cbr.rs

@@ -1,20 +1,37 @@
-use libipt_sys::pt_event__bindgen_ty_1__bindgen_ty_18;
+use crate::error::{PtError, PtErrorCode};
+use crate::event::Event;
+use derive_more::Deref;
+use libipt_sys::pt_event_type_ptev_cbr;
 
 /// A core:bus ratio event
-#[derive(Clone, Copy, Debug)]
-pub struct Cbr(pub(super) pt_event__bindgen_ty_1__bindgen_ty_18);
+#[derive(Clone, Copy, Debug, Deref)]
+#[repr(transparent)]
+pub struct Cbr {
+    pub(super) event: Event,
+}
 impl Cbr {
     /// The core:bus ratio.
     #[must_use]
-    pub fn ratio(self) -> u16 {
-        self.0.ratio
+    pub const fn ratio(&self) -> u16 {
+        unsafe { self.event.0.variant.cbr.ratio }
+    }
+}
+
+impl TryFrom<Event> for Cbr {
+    type Error = PtError;
+
+    fn try_from(event: Event) -> Result<Self, Self::Error> {
+        if event.0.type_ == pt_event_type_ptev_cbr {
+            Ok(Self { event })
+        } else {
+            Err(PtErrorCode::Invalid.into())
+        }
     }
 }
 
 #[cfg(test)]
 mod test {
-    use super::super::Payload;
-    use super::*;
+    use super::super::EventType;
     use crate::event::Event;
     use libipt_sys::{pt_event, pt_event_type_ptev_cbr};
     use std::mem;
@@ -23,11 +40,11 @@ mod test {
     fn test_cbr_payload() {
         let mut evt: pt_event = unsafe { mem::zeroed() };
         evt.type_ = pt_event_type_ptev_cbr;
-        evt.variant.cbr = pt_event__bindgen_ty_1__bindgen_ty_18 { ratio: 18 };
+        evt.variant.cbr.ratio = 18;
 
-        let payload: Payload = Event(evt).into();
+        let payload: EventType = Event(evt).into();
         match payload {
-            Payload::Cbr(e) => {
+            EventType::Cbr(e) => {
                 assert_eq!(e.ratio(), 18);
             }
             _ => unreachable!("oof"),

src/event/disabled.rs

@@ -1,41 +1,72 @@
-use libipt_sys::{pt_event__bindgen_ty_1__bindgen_ty_2, pt_event__bindgen_ty_1__bindgen_ty_3};
+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};
 
 /// Tracing has been disabled
-#[derive(Clone, Copy, Debug)]
-pub struct Disabled(pub(super) pt_event__bindgen_ty_1__bindgen_ty_2);
+#[derive(Clone, Copy, Debug, Deref)]
+#[repr(transparent)]
+pub struct Disabled {
+    pub(super) event: Event,
+}
 impl Disabled {
     /// The destination of the first branch inside a
     /// filtered area.
     ///
     /// This field is not valid if \@ip_suppressed is set.
     #[must_use]
-    pub fn ip(&self) -> u64 {
-        self.0.ip
+    pub const fn ip(&self) -> u64 {
+        unsafe { self.event.0.variant.disabled.ip }
+    }
+}
+
+impl TryFrom<Event> for Disabled {
+    type Error = PtError;
+
+    fn try_from(event: Event) -> Result<Self, Self::Error> {
+        if event.0.type_ == pt_event_type_ptev_disabled {
+            Ok(Self { event })
+        } else {
+            Err(PtErrorCode::Invalid.into())
+        }
     }
 }
 
 /// Tracing has been disabled asynchronously
 #[derive(Clone, Copy, Debug)]
-pub struct AsyncDisabled(pub(super) pt_event__bindgen_ty_1__bindgen_ty_3);
+pub struct AsyncDisabled {
+    pub(super) event: Event,
+}
 impl AsyncDisabled {
     /// The source address of the asynchronous branch that disabled tracing
     #[must_use]
-    pub fn at(&self) -> u64 {
-        self.0.at
+    pub const fn at(&self) -> u64 {
+        unsafe { self.event.0.variant.async_disabled.at }
     }
 
     /// The destination of the first branch inside a filtered area.
     /// This field is not valid if @ip_suppressed is set.
     #[must_use]
-    pub fn ip(&self) -> u64 {
-        self.0.ip
+    pub const fn ip(&self) -> u64 {
+        unsafe { self.event.0.variant.async_disabled.ip }
+    }
+}
+
+impl TryFrom<Event> for AsyncDisabled {
+    type Error = PtError;
+
+    fn try_from(event: Event) -> Result<Self, Self::Error> {
+        if event.0.type_ == pt_event_type_ptev_async_disabled {
+            Ok(Self { event })
+        } else {
+            Err(PtErrorCode::Invalid.into())
+        }
     }
 }
 
 #[cfg(test)]
 mod test {
-    use super::super::Payload;
-    use super::*;
+    use super::super::EventType;
     use crate::event::Event;
     use libipt_sys::{pt_event, pt_event_type_ptev_async_disabled, pt_event_type_ptev_disabled};
     use std::mem;
@@ -44,11 +75,11 @@ mod test {
     fn test_disabled_payload() {
         let mut evt: pt_event = unsafe { mem::zeroed() };
         evt.type_ = pt_event_type_ptev_disabled;
-        evt.variant.disabled = pt_event__bindgen_ty_1__bindgen_ty_2 { ip: 11 };
+        evt.variant.disabled.ip = 11;
 
-        let payload: Payload = Event(evt).into();
+        let payload: EventType = Event(evt).into();
         match payload {
-            Payload::Disabled(e) => {
+            EventType::Disabled(e) => {
                 assert_eq!(e.ip(), 11);
             }
             _ => unreachable!("oof"),
@@ -59,11 +90,12 @@ mod test {
     fn test_async_disabled_payload() {
         let mut evt: pt_event = unsafe { mem::zeroed() };
         evt.type_ = pt_event_type_ptev_async_disabled;
-        evt.variant.async_disabled = pt_event__bindgen_ty_1__bindgen_ty_3 { at: 1, ip: 11 };
+        evt.variant.async_disabled.at = 1;
+        evt.variant.async_disabled.ip = 11;
 
-        let payload: Payload = Event(evt).into();
+        let payload: EventType = Event(evt).into();
         match payload {
-            Payload::AsnycDisabled(e) => {
+            EventType::AsnycDisabled(e) => {
                 assert_eq!(e.ip(), 11);
                 assert_eq!(e.at(), 1);
             }

src/event/enabled.rs

@@ -1,27 +1,44 @@
-use libipt_sys::pt_event__bindgen_ty_1__bindgen_ty_1;
+use crate::error::{PtError, PtErrorCode};
+use crate::event::Event;
+use derive_more::Deref;
+use libipt_sys::pt_event_type_ptev_enabled;
 
 /// Tracing has been enabled
-#[derive(Clone, Copy, Debug)]
-pub struct Enabled(pub(super) pt_event__bindgen_ty_1__bindgen_ty_1);
+#[derive(Clone, Copy, Debug, Deref)]
+#[repr(transparent)]
+pub struct Enabled {
+    pub(super) event: Event,
+}
 impl Enabled {
     /// The address at which tracing resumes
     #[must_use]
-    pub fn ip(&self) -> u64 {
-        self.0.ip
+    pub const fn ip(&self) -> u64 {
+        unsafe { self.event.0.variant.enabled.ip }
     }
 
     /// A flag indicating that tracing resumes from the IP
     /// at which tracing had been disabled before.
     #[must_use]
     pub fn resumed(&self) -> bool {
-        self.0.resumed() > 0
+        (unsafe { self.event.0.variant.enabled.resumed() }) > 0
+    }
+}
+
+impl TryFrom<Event> for Enabled {
+    type Error = PtError;
+
+    fn try_from(event: Event) -> Result<Self, Self::Error> {
+        if event.0.type_ == pt_event_type_ptev_enabled {
+            Ok(Self { event })
+        } else {
+            Err(PtErrorCode::Invalid.into())
+        }
     }
 }
 
 #[cfg(test)]
 mod test {
-    use super::super::Payload;
-    use super::*;
+    use super::super::EventType;
     use crate::event::Event;
     use libipt_sys::{pt_event, pt_event_type_ptev_enabled};
     use std::mem;
@@ -30,16 +47,14 @@ mod test {
     fn test_enabled_payload() {
         let mut evt: pt_event = unsafe { mem::zeroed() };
         evt.type_ = pt_event_type_ptev_enabled;
-        evt.variant.enabled = pt_event__bindgen_ty_1__bindgen_ty_1 {
-            ip: 11,
-            _bitfield_align_1: [],
-            _bitfield_1: pt_event__bindgen_ty_1__bindgen_ty_1::new_bitfield_1(1),
-            __bindgen_padding_0: Default::default(),
-        };
+        evt.variant.enabled.ip = 11;
+        unsafe {
+            evt.variant.enabled.set_resumed(1);
+        }
 
-        let payload: Payload = Event(evt).into();
+        let payload: EventType = Event(evt).into();
         match payload {
-            Payload::Enabled(e) => {
+            EventType::Enabled(e) => {
                 assert_eq!(e.ip(), 11);
                 assert!(e.resumed())
             }