Enum Breakpoint 

pub enum Breakpoint {
    Data {
        access: BreakpointAccess,
        addr: u64,
        len: u64,
    },
    Code {
        addr: u64,
    },
}

A hardware breakpoint.

A hardware breakpoint watches a region of memory for accesses. It has three parameters:

• the address that is being watched (addr)
• the number of bytes that breakpoint covers (len)
• which type of memory accesses we care about (ty)

Note that both number of bytes that can be watched as well as the number of breakpoints that is allowed to be active at any given time is limited.

Execute Breakpoint

We can use a breakpoint to count the number of times that a function gets called, as long as the compiler does not optimize the function away.

#[inline(never)]
fn do_some_things() {
    // ...
}

let fnptr = do_some_things as fn() as usize;
let mut counter = Builder::new(Breakpoint::execute(fnptr as u64)).build()?;
counter.enable()?;

for _ in 0..500 {
    do_some_things();
}

counter.disable()?;
assert_eq!(counter.read()?, 500);

Data Breakpoint

We can also use a breakpoint to count the number of times that a memory location is accessed.

let mut data: Vec<u64> = (0..1024).rev().collect();

let breakpoint = Breakpoint::read_write(&data[20] as *const _ as usize as u64, 8);
let mut counter = Builder::new(breakpoint).build()?;
counter.enable()?;
data.sort();
counter.disable()?;

println!("Position 20 accessed {} times", counter.read()?);

Usage Notes

• Some systems do not support creating read-only or write-only breakpoints. If you are getting EINVAL errors while trying to build such a counter using a read-write breakpoint might work instead.

• The valid values of len are quite limited. The perf_event_open manpage indicates that the only valid values for bp_len are 1, 2, 4, and 8.

Variants

Data

Data breakpoint. Triggers when code reads or writes to the memory area as configured by the parameters below.

Fields

access: BreakpointAccess

Bitfield containing the types of accesses we want the breakpoint to trigger on.

addr: u64

The address of the memory location on which the breakpoint should trigger.

len: u64

The length of the breakpoint being measured.

There are a limited number of valid values for this field. Basically, the options are 1, 2, 4, and 8. Setting this field to anything else will cause counter creation to fail with an error.

Code

Code breakpoint. Triggers when the code at the address is executed.

Fields

addr: u64

The address that the breakpoint is monitoring.

Implementations

impl Breakpoint

pub const fn execute(addr: u64) -> Self

Create a code execution breakpoint, that counts the number of times the instruction at the provided address was executed.

pub const fn read(addr: u64, len: u64) -> Self

Create a memory read breakpoint, that counts the number of times we read from the provided memory location.

See the struct field docs for valid values of len.

pub const fn write(addr: u64, len: u64) -> Self

Create a memory write breakpoint, that counts the number of times we write to the provided memory location.

See the struct field docs for valid values of len.

pub const fn read_write(addr: u64, len: u64) -> Self

Create a memory access breakpoint, that counts the number of times we either read from or write to the provided memory location.

See the struct field docs for valid values of len.

Trait Implementations

impl Clone for Breakpoint

fn clone(&self) -> Breakpoint

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Breakpoint

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Event for Breakpoint

fn update_attrs(self, attr: &mut perf_event_attr)

Update the perf_event_attr struct so that it will record the requested event.

fn update_attrs_with_data( self, attr: &mut perf_event_attr, ) -> Option<Arc<dyn EventData>>

Update the perf_event_attr struct so that it will record the requested event.

impl Hash for Breakpoint

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Breakpoint

fn eq(&self, other: &Breakpoint) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Breakpoint

impl Eq for Breakpoint

impl StructuralPartialEq for Breakpoint