Merge pull request #3 from fmckeogh/master

Bump dependencies

Author: sum-catnip

Cargo.toml

@@ -1,15 +1,15 @@
 [package]
 name = "libipt"
-version = "0.1.4"
+version = "0.2.0"
 authors = ["sum_catnip <catnip@catnip.fyi>"]
-edition = "2018"
+edition = "2021"
 license = "MIT"
 description = "The Intel Processor Trace (Intel PT) Decoder Library is Intel's reference implementation for decoding Intel PT."
 repository = "https://github.com/sum-catnip/libipt-rs"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-libipt-sys = "^0.1.4"
-bitflags = "1.2.1"
-num_enum = "0.4.2"
+libipt-sys = { git = "https://github.com/sum-catnip/libipt-sys" }
+bitflags = "2.4.1"
+num_enum = "0.7.1"

src/block/decoder.rs

@@ -1,39 +1,22 @@
 use super::Block;
 use crate::asid::Asid;
 use crate::config::Config;
+use crate::error::{
+    deref_ptresult, deref_ptresult_mut, ensure_ptok, extract_pterr, PtError, PtErrorCode,
+};
 use crate::event::Event;
 use crate::flags::Status;
 use crate::image::Image;
-use crate::error::{
-    PtError, ensure_ptok,
-    extract_pterr, deref_ptresult,
-    deref_ptresult_mut, PtErrorCode
-};
 
+use std::marker::PhantomData;
 use std::mem;
 use std::ptr;
-use std::marker::PhantomData;
 
 use libipt_sys::{
-    pt_event,
-    pt_block,
-    pt_block_decoder,
-    pt_blk_alloc_decoder,
-    pt_blk_core_bus_ratio,
-    pt_blk_free_decoder,
-    pt_blk_get_config,
-    pt_blk_get_image,
-    pt_blk_get_offset,
-    pt_blk_get_sync_offset,
-    pt_blk_set_image,
-    pt_blk_sync_backward,
-    pt_blk_sync_forward,
-    pt_blk_sync_set,
-    pt_blk_time,
-    pt_blk_next,
-    pt_blk_event,
-    pt_blk_asid,
-    pt_asid
+    pt_asid, pt_blk_alloc_decoder, pt_blk_asid, pt_blk_core_bus_ratio, pt_blk_event,
+    pt_blk_free_decoder, pt_blk_get_config, pt_blk_get_image, pt_blk_get_offset,
+    pt_blk_get_sync_offset, pt_blk_next, pt_blk_set_image, pt_blk_sync_backward,
+    pt_blk_sync_forward, pt_blk_sync_set, pt_blk_time, pt_block, pt_block_decoder, pt_event,
 };
 
 #[cfg(test)]
@@ -44,23 +27,19 @@ mod test {
     #[test]
     fn test_blkdec_alloc() {
         let kek = &mut [1; 2];
-        BlockDecoder::new(
-            &ConfigBuilder::new(kek).unwrap().finish()
-        ).unwrap();
+        BlockDecoder::new(&ConfigBuilder::new(kek).unwrap().finish()).unwrap();
     }
 
-    #[test ]
+    #[test]
     fn test_blkdec_props() {
         let kek = &mut [1; 2];
         // this just checks memory safety for property access
         // usage can be found in the integration tests
-        let mut b = BlockDecoder::new(
-            &ConfigBuilder::new(kek).unwrap().finish()
-        ).unwrap();
+        let mut b = BlockDecoder::new(&ConfigBuilder::new(kek).unwrap().finish()).unwrap();
         let a = b.asid().unwrap();
         assert!(a.cr3().is_none());
         assert!(a.vmcs().is_none());
-        assert!(b.core_bus_ratio().is_err());
+        assert!(b.core_bus_ratio().is_ok());
         assert!(b.event().is_err());
         assert!(b.config().is_ok());
         assert!(b.image().unwrap().name().is_none());
@@ -69,7 +48,7 @@ mod test {
         assert!(b.next().is_err());
         assert!(b.sync_backward().is_err());
         assert!(b.sync_forward().is_err());
-        assert!(b.time().is_err());
+        assert!(b.time().is_ok());
     }
 }
 
@@ -89,7 +68,7 @@ impl<'a, T> BlockDecoder<'a, T> {
     pub fn new(cfg: &Config<T>) -> Result<Self, PtError> {
         // deref_ptresult(unsafe{ pt_blk_alloc_decoder(&cfg.0) })
         //     .map(|x| BlockDecoder::<T>(*x, PhantomData))
-        deref_ptresult_mut(unsafe{ pt_blk_alloc_decoder(cfg.0.as_ref()) })
+        deref_ptresult_mut(unsafe { pt_blk_alloc_decoder(cfg.0.as_ref()) })
             .map(|x| BlockDecoder::<T>(x, PhantomData))
     }
 
@@ -99,10 +78,7 @@ impl<'a, T> BlockDecoder<'a, T> {
     /// Returns Asid on success, a PtError otherwise.
     pub fn asid(&self) -> Result<Asid, PtError> {
         let mut a: Asid = Default::default();
-        unsafe {
-            ensure_ptok(pt_blk_asid(self.0, &mut a.0, mem::size_of::<pt_asid>()))
-                .map(|_| a)
-        }
+        unsafe { ensure_ptok(pt_blk_asid(self.0, &mut a.0, mem::size_of::<pt_asid>())).map(|_| a) }
     }
 
     /// Return the current core bus ratio.
@@ -121,25 +97,20 @@ impl<'a, T> BlockDecoder<'a, T> {
     /// Returns BadQuery if there is no event.
     pub fn event(&mut self) -> Result<(Event, Status), PtError> {
         let mut evt: pt_event = unsafe { mem::zeroed() };
-        extract_pterr(unsafe {
-            pt_blk_event(self.0,
-                         &mut evt,
-                         mem::size_of::<pt_event>())
-        }).map(|s| (Event(evt), Status::from_bits(s).unwrap()))
+        extract_pterr(unsafe { pt_blk_event(self.0, &mut evt, mem::size_of::<pt_event>()) })
+            .map(|s| (Event(evt), Status::from_bits(s).unwrap()))
     }
 
     pub fn config(&self) -> Result<Config<T>, PtError> {
-        deref_ptresult(unsafe { pt_blk_get_config(self.0) })
-            .map(Config::from)
+        deref_ptresult(unsafe { pt_blk_get_config(self.0) }).map(Config::from)
     }
 
     /// Get the traced image.
     ///
     /// The returned image may be modified as long as @decoder is not running.
     /// Returns the traced image the decoder uses for reading memory.
     pub fn image(&mut self) -> Result<Image, PtError> {
-        deref_ptresult_mut(unsafe { pt_blk_get_image(self.0) })
-            .map(Image::from)
+        deref_ptresult_mut(unsafe { pt_blk_get_image(self.0) }).map(Image::from)
     }
 
     /// Get the current decoder position.
@@ -148,17 +119,15 @@ impl<'a, T> BlockDecoder<'a, T> {
     /// Returns Nosync if decoder is out of sync.
     pub fn offset(&self) -> Result<u64, PtError> {
         let mut off: u64 = 0;
-        ensure_ptok(unsafe { pt_blk_get_offset(self.0, &mut off) })
-            .map(|_| off)
+        ensure_ptok(unsafe { pt_blk_get_offset(self.0, &mut off) }).map(|_| off)
     }
 
     /// Get the position of the last synchronization point.
     ///
     /// Returns Nosync if the decoder is out of sync.
     pub fn sync_offset(&self) -> Result<u64, PtError> {
         let mut off: u64 = 0;
-        ensure_ptok(unsafe { pt_blk_get_sync_offset(self.0, &mut off) })
-            .map(|_| off)
+        ensure_ptok(unsafe { pt_blk_get_sync_offset(self.0, &mut off) }).map(|_| off)
     }
 
     /// Determine the next block of instructions.
@@ -176,13 +145,8 @@ impl<'a, T> BlockDecoder<'a, T> {
     /// Returns Nosync if the decoder is out of sync.
     pub fn next(&mut self) -> Result<(Block, Status), PtError> {
         let mut blk: pt_block = unsafe { mem::zeroed() };
-        extract_pterr(
-            unsafe {
-                pt_blk_next(self.0,
-                            &mut blk,
-                            mem::size_of::<pt_block>())
-            }
-        ).map(|s| (Block(blk), Status::from_bits(s).unwrap()))
+        extract_pterr(unsafe { pt_blk_next(self.0, &mut blk, mem::size_of::<pt_block>()) })
+            .map(|s| (Block(blk), Status::from_bits(s).unwrap()))
     }
 
     /// Set the traced image.
@@ -192,11 +156,13 @@ impl<'a, T> BlockDecoder<'a, T> {
     /// Only one image can be active at any time.
     pub fn set_image(&mut self, img: Option<&mut Image>) -> Result<(), PtError> {
         ensure_ptok(unsafe {
-            pt_blk_set_image(self.0,
-                             match img {
-                                 None => ptr::null_mut(),
-                                 Some(i) => i.inner
-                             })
+            pt_blk_set_image(
+                self.0,
+                match img {
+                    None => ptr::null_mut(),
+                    Some(i) => i.inner,
+                },
+            )
         })
     }
 
@@ -214,8 +180,7 @@ impl<'a, T> BlockDecoder<'a, T> {
     /// Returns BadPacket if an unknown packet payload is encountered.
     /// Returns Eos if no further synchronization point is found.
     pub fn sync_forward(&mut self) -> Result<Status, PtError> {
-        extract_pterr(unsafe { pt_blk_sync_forward(self.0) })
-            .map(|s| Status::from_bits(s).unwrap())
+        extract_pterr(unsafe { pt_blk_sync_forward(self.0) }).map(|s| Status::from_bits(s).unwrap())
     }
 
     /// Manually synchronize an Intel PT block decoder.
@@ -227,7 +192,7 @@ impl<'a, T> BlockDecoder<'a, T> {
     /// Returns Eos if the decoder reaches the end of its trace buffer.
     /// Returns Nosync if there is no syncpoint at @offset.
     pub fn set_sync(&mut self, offset: u64) -> Result<(), PtError> {
-        ensure_ptok(unsafe { pt_blk_sync_set(self.0, offset)})
+        ensure_ptok(unsafe { pt_blk_sync_set(self.0, offset) })
     }
 
     /// Return the current time.
@@ -247,14 +212,8 @@ impl<'a, T> BlockDecoder<'a, T> {
         let mut time: u64 = 0;
         let mut lost_mtc: u32 = 0;
         let mut lost_cyc: u32 = 0;
-        ensure_ptok(
-            unsafe {
-                pt_blk_time(self.0,
-                            &mut time,
-                            &mut lost_mtc,
-                            &mut lost_cyc)
-            }
-        ).map(|_| (time, lost_mtc, lost_cyc))
+        ensure_ptok(unsafe { pt_blk_time(self.0, &mut time, &mut lost_mtc, &mut lost_cyc) })
+            .map(|_| (time, lost_mtc, lost_cyc))
     }
 }
 
@@ -265,7 +224,7 @@ impl<'a, T> Iterator for BlockDecoder<'a, T> {
         match self.next() {
             // eos to stop iterating
             Err(x) if x.code() == PtErrorCode::Eos => None,
-            x => Some(x)
+            x => Some(x),
         }
     }
 }