+ unit tests, changed ownership to ref on drop types

sum-catnip · sum-catnip · commit 945e10e1b307 · 2020-01-23T17:07:32.000+01:00
diff --git a/src/image/image.rs b/src/image/image.rs
@@ -29,6 +29,7 @@ use libipt_sys::{
 #[cfg(test)]
 mod test {
     use super::*;
+    use std::path::PathBuf;
 
     // not much to test for in the unit tests
     // the integration tests should have way more stuffs
@@ -46,6 +47,82 @@ mod test {
         let i = Image::new(None).unwrap();
         assert!(i.name().is_none());
     }
+
+    fn img_with_file<'a>() -> Image<'a> {
+        let file: PathBuf = [
+            env!("CARGO_MANIFEST_DIR"), "testfiles", "garbage.txt"
+        ].iter().collect();
+    
+        let mut i = Image::new(None).unwrap();
+        let asid = Asid::new(Some(1), Some(2));
+        i.add_file(file.to_str().unwrap(), 3, 10, Some(asid), 0x123)
+            .unwrap();
+        i
+    }
+
+    #[test]
+    fn test_img_file() {
+        img_with_file();
+    }
+
+    #[test]
+    fn test_img_remove_filename() {
+        let file: PathBuf = [
+            env!("CARGO_MANIFEST_DIR"), "testfiles", "garbage.txt"
+        ].iter().collect();
+
+        assert_eq!(
+            img_with_file()
+                .remove_by_filename(file.to_str().unwrap(), 
+                                    Asid::new(Some(1), Some(2)))
+                .unwrap(),
+            1
+        );
+    }
+
+    #[test]
+    fn test_img_remove_asid() {
+        assert_eq!(
+            img_with_file()
+                .remove_by_asid(Asid::new(Some(1), Some(2)))
+                .unwrap(),
+            1
+        );
+    }
+
+    #[test]
+    fn test_img_copy() {
+        let file: PathBuf = [
+            env!("CARGO_MANIFEST_DIR"), "testfiles", "garbage.txt"
+        ].iter().collect();
+    
+        let mut i = Image::new(None).unwrap();
+        let asid = Asid::new(Some(3), Some(4));
+        i.add_file(file.to_str().unwrap(), 3, 10, Some(asid), 0x666)
+            .unwrap();
+ 
+        assert_eq!(
+            img_with_file().copy(&i).unwrap(),
+            1
+        )
+    }
+
+    #[test]
+    fn test_img_add_cached() {
+        let file: PathBuf = [
+            env!("CARGO_MANIFEST_DIR"), "testfiles", "garbage.txt"
+        ].iter().collect();
+        println!("{:?}", file);
+
+        let mut c = SectionCache::new(None).unwrap();
+        let isid = c.add_file(file.to_str().unwrap(), 5, 15, 0x1337).unwrap();
+        let mut i = img_with_file();
+        i.add_cached(&mut c, isid, Asid::new(Some(3), Some(4))).unwrap();
+        assert_eq!(
+            i.remove_by_asid(Asid::new(Some(3), Some(4))).unwrap(),
+            1
+        );
+    }
 }
 
 unsafe extern "C" fn read_callback(buffer: *mut u8,
@@ -115,11 +192,11 @@ impl<'a> Image<'a> {
         let cfilename = CString::new(filename).map_err(|_| PtError::new(
             PtErrorCode::Invalid,
             "Error converting filename to Cstring as it contains null bytes")
-        )?.as_ptr();
+        )?;
 
         extract_pterr( unsafe {
             pt_image_remove_by_filename(self.inner,
-                                        cfilename,
+                                        cfilename.as_ptr(),
                                         &asid.0)
         })
     }
@@ -147,7 +224,7 @@ impl<'a> Image<'a> {
     /// Sections that could not be added will be ignored.
     /// Returns the number of ignored sections on success.
     pub fn copy(&mut self, src: &Image) -> Result<u32, PtError> {
-        extract_pterr( unsafe { pt_image_copy(self.inner, src.inner)})
+        extract_pterr( unsafe { pt_image_copy(self.inner, src.inner) })
     }
 
     /// Add a section from an image section cache.
@@ -157,10 +234,10 @@ impl<'a> Image<'a> {
     /// Returns BadImage if @iscache does not contain @isid.
     pub fn add_cached(&mut self,
                       iscache: &mut SectionCache,
-                      isid: i32,
+                      isid: u32,
                       asid: Asid) -> Result<(), PtError> {
         ensure_ptok( unsafe {
-            pt_image_add_cached(self.inner, iscache.0, isid, &asid.0
+            pt_image_add_cached(self.inner, iscache.0, isid as i32, &asid.0
         )})
     }
 
@@ -184,11 +261,11 @@ impl<'a> Image<'a> {
         let cfilename = CString::new(filename).map_err(|_| PtError::new(
             PtErrorCode::Invalid,
             "Error converting filename to Cstring as it contains null bytes")
-        )?.as_ptr();
+        )?;
 
         ensure_ptok( unsafe {
             pt_image_add_file(self.inner,
-                              cfilename,
+                              cfilename.as_ptr(),
                               offset,
                               size,
                               match asid {
diff --git a/src/insn/decoder.rs b/src/insn/decoder.rs
@@ -36,23 +36,54 @@ use libipt_sys::{
     pt_insn_time
 };
 
-pub struct InsnDecoder<T>(pt_insn_decoder, PhantomData<T>);
-impl<T> InsnDecoder<T> {
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_blkdec_alloc() {
+        InsnDecoder::new(&Config::<()>::new(&mut [0; 0])).unwrap();
+    }
+
+    #[test ]
+    fn test_blkdec_props() {
+        // this just checks memory safety for property access
+        // usage can be found in the integration tests
+        let mut b = InsnDecoder::new(&Config::<()>::new(&mut [0; 0])).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.event().is_err());
+        assert!(b.config().is_ok());
+        assert!(b.image().unwrap().name().is_none());
+        assert!(b.offset().is_err());
+        assert!(b.sync_offset().is_err());
+        assert!(b.next().is_err());
+        assert!(b.sync_backward().is_err());
+        assert!(b.sync_forward().is_err());
+        assert!(b.time().is_err());
+    }
+}
+
+pub struct InsnDecoder<'a, T>(&'a mut pt_insn_decoder, PhantomData<T>);
+impl<'a, T> InsnDecoder<'a, T> {
     /// Allocate an Intel PT instruction flow decoder.
     ///
     /// The decoder will work on the buffer defined in @config,
     /// it shall contain raw trace data and remain valid for the lifetime of the decoder.
     /// The decoder needs to be synchronized before it can be used.
     pub fn new(cfg: &Config<T>) -> Result<Self, PtError> {
-        deref_ptresult(unsafe { pt_insn_alloc_decoder(cfg.0.as_ref()) })
-            .map(|d| InsnDecoder::<T>(*d, PhantomData))
+        deref_ptresult_mut(unsafe { pt_insn_alloc_decoder(cfg.0.as_ref()) })
+            .map(|d| InsnDecoder::<T>(d, PhantomData))
     }
 
     /// Return the current address space identifier.
     pub fn asid(&self) -> Result<Asid, PtError> {
         let mut asid: pt_asid = unsafe { mem::zeroed() };
         ensure_ptok(unsafe {
-            pt_insn_asid(&self.0,
+            pt_insn_asid(self.0,
                          &mut asid,
                          mem::size_of::<pt_asid>())
         }).map(|_| Asid(asid))
@@ -65,7 +96,7 @@ impl<T> InsnDecoder<T> {
     /// Returns NoCbr if there has not been a CBR packet.
     pub fn core_bus_ratio(&mut self) -> Result<u32, PtError> {
         let mut cbr: u32 = 0;
-        ensure_ptok(unsafe { pt_insn_core_bus_ratio(&mut self.0, &mut cbr) })
+        ensure_ptok(unsafe { pt_insn_core_bus_ratio(self.0, &mut cbr) })
             .map(|_| cbr)
     }
 
@@ -76,14 +107,14 @@ impl<T> InsnDecoder<T> {
     pub fn event(&mut self) -> Result<(Event, Status), PtError> {
         let mut evt: pt_event = unsafe { mem::zeroed() };
         extract_pterr(unsafe {
-            pt_insn_event(&mut self.0,
+            pt_insn_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_insn_get_config(&self.0) })
+        deref_ptresult(unsafe { pt_insn_get_config(self.0) })
             .map(Config::from)
     }
 
@@ -92,7 +123,7 @@ impl<T> InsnDecoder<T> {
     /// The returned image may be modified as long as no decoder that uses this image is running.
     /// Returns the traced image the decoder uses for reading memory.
     pub fn image(&mut self) -> Result<Image, PtError> {
-        deref_ptresult_mut(unsafe { pt_insn_get_image(&mut self.0) })
+        deref_ptresult_mut(unsafe { pt_insn_get_image(self.0) })
             .map(Image::from)
     }
 
@@ -101,7 +132,7 @@ impl<T> InsnDecoder<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_insn_get_offset(&self.0, &mut off) })
+        ensure_ptok(unsafe { pt_insn_get_offset(self.0, &mut off) })
             .map(|_| off)
     }
 
@@ -110,7 +141,7 @@ impl<T> InsnDecoder<T> {
     /// Returns Nosync if @decoder is out of sync.
     pub fn sync_offset(&self) -> Result<u64, PtError> {
         let mut off = 0;
-        ensure_ptok(unsafe { pt_insn_get_sync_offset(&self.0, &mut off) })
+        ensure_ptok(unsafe { pt_insn_get_sync_offset(self.0, &mut off) })
             .map(|_| off)
     }
 
@@ -129,7 +160,7 @@ impl<T> InsnDecoder<T> {
     pub fn next(&mut self) -> Result<(Insn, Status), PtError> {
         let mut insn: pt_insn = unsafe { mem::zeroed() };
         extract_pterr(unsafe {
-            pt_insn_next(&mut self.0,
+            pt_insn_next(self.0,
                          &mut insn,
                          mem::size_of::<pt_insn>())
         }).map(|s| (Insn(insn), Status::from_bits(s).unwrap()))
@@ -142,7 +173,7 @@ impl<T> InsnDecoder<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_insn_set_image(&mut self.0,
+            pt_insn_set_image(self.0,
                              match img {
                                  None => ptr::null_mut(),
                                  Some(i) => i.inner
@@ -151,7 +182,7 @@ impl<T> InsnDecoder<T> {
     }
 
     pub fn sync_backward(&mut self) -> Result<(), PtError> {
-        ensure_ptok(unsafe { pt_insn_sync_backward(&mut self.0) })
+        ensure_ptok(unsafe { pt_insn_sync_backward(self.0) })
     }
 
     /// Synchronize an Intel PT instruction flow decoder.
@@ -165,7 +196,7 @@ impl<T> InsnDecoder<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<(), PtError> {
-        ensure_ptok(unsafe { pt_insn_sync_forward(&mut self.0) })
+        ensure_ptok(unsafe { pt_insn_sync_forward(self.0) })
     }
 
     /// Manually synchronize an Intel PT instruction flow decoder.
@@ -178,7 +209,7 @@ impl<T> InsnDecoder<T> {
     /// Returns Eos if decoder reaches the end of its trace buffer.
     /// Returns Nosync if there is no syncpoint at @offset.
     pub fn sync_set(&mut self, offset: u64) -> Result<(), PtError> {
-        ensure_ptok(unsafe { pt_insn_sync_set(&mut self.0, offset) })
+        ensure_ptok(unsafe { pt_insn_sync_set(self.0, offset) })
     }
 
     /// Return the current time.
@@ -200,7 +231,7 @@ impl<T> InsnDecoder<T> {
         let mut lost_cyc: u32 = 0;
         ensure_ptok(
             unsafe {
-                pt_insn_time(&mut self.0,
+                pt_insn_time(self.0,
                              &mut time,
                              &mut lost_mtc,
                              &mut lost_cyc)
@@ -209,6 +240,6 @@ impl<T> InsnDecoder<T> {
     }
 }
 
-impl<T> Drop for InsnDecoder<T> {
-    fn drop(&mut self) { unsafe { pt_insn_free_decoder(&mut self.0) } }
+impl<'a, T> Drop for InsnDecoder<'a, T> {
+    fn drop(&mut self) { unsafe { pt_insn_free_decoder(self.0) } }
 }
diff --git a/src/insn/insn.rs b/src/insn/insn.rs
@@ -5,6 +5,36 @@ use std::convert::TryFrom;
 
 use libipt_sys::pt_insn;
 
+#[cfg(test)]
+mod test {
+    use super::*;
+    use libipt_sys::pt_insn_class_ptic_call;
+    use libipt_sys::pt_exec_mode_ptem_32bit;
+
+    #[test]
+    fn test_insn_props() {
+        let data: [u8; 15] = [17; 15];
+        let blk = Insn(pt_insn{
+            ip: 1,
+            isid: 2,
+            mode: pt_exec_mode_ptem_32bit,
+            iclass: pt_insn_class_ptic_call,
+            raw: data,
+            size: 8,
+            _bitfield_1: pt_insn::new_bitfield_1(0, 1),
+            __bindgen_padding_0: Default::default()
+       });
+
+       assert_eq!(blk.ip(), 1);
+       assert_eq!(blk.isid(), 2);
+       assert_eq!(blk.mode(), ExecModeType::Bit32);
+       assert_eq!(blk.class(), Class::Call);
+       assert_eq!(blk.raw(), &data[..8]);
+       assert!(blk.truncated());
+       assert!(!blk.speculative());
+    }
+}
+
 /// A single traced instruction.
 #[derive(Clone, Copy)]
 pub struct Insn(pub(crate) pt_insn);
@@ -14,13 +44,11 @@ impl Insn {
 
     /// The image section identifier for the section containing this instruction.
     ///
-    /// None if the section was not added via an image section cache or the memory was read via the read memory callback.
-    pub fn isid(self) -> Option<i32> {
-        match self.0.isid { 0 => None, x => Some(x) }
-    }
+    /// A value of zero means that the section did not have an identifier.
+    pub fn isid(self) -> i32 { self.0.isid }
 
     /// The execution mode.
-    pub fn exec_mode(self) -> ExecModeType {
+    pub fn mode(self) -> ExecModeType {
         ExecModeType::try_from(self.0.mode)
             .expect(concat!("unmatched ExecModeType enum value, ",
                 "this is a bug in either libipt or the bindings"))
