Struct aya::maps::stack_trace::StackTraceMap

pub struct StackTraceMap<T> { /* fields omitted */ }

A hash map of kernel or user space stack traces.

Stack trace maps can be used to store stack traces captured by eBPF programs, which can be useful for profiling, to associate a trace to an event, etc. You can capture traces calling stack_id = bpf_get_stackid(ctx, map, flags) from eBPF, and then you can retrieve the traces from their stack ids.

Examples

use aya::maps::StackTraceMap;
use aya::util::kernel_symbols;
use std::convert::TryFrom;

let mut stack_traces = StackTraceMap::try_from(bpf.map("STACK_TRACES")?)?;
// load kernel symbols from /proc/kallsyms
let ksyms = kernel_symbols()?;

// NOTE: you tipically send stack_ids from eBPF to user space using other maps
let stack_id = 1234;
let mut stack_trace = stack_traces.get(&stack_id, 0)?;

// here we resolve symbol names using kernel symbols. If this was a user space stack (for
// example captured from a uprobe), you'd have to load the symbols using some other mechanism
// (eg loading the target binary debuginfo)
for frame in stack_trace.resolve(&ksyms).frames() {
    println!(
        "{:#x} {}",
        frame.ip,
        frame
            .symbol_name
            .as_ref()
            .unwrap_or(&"[unknown symbol name]".to_owned())
    );
}

Implementations

impl<T: Deref<Target = Map>> StackTraceMap<T>

pub fn get(&self, stack_id: &u32, flags: u64) -> Result<StackTrace, MapError>

Returns the stack trace with the given stack_id.

Errors

Returns MapError::KeyNotFound if there is no stack trace with the given stack_id, or MapError::SyscallError if bpf_map_lookup_elem fails.

pub fn iter(&self) -> MapIter<'_, u32, StackTrace>

An iterator visiting all (stack_id, stack_trace) pairs in arbitrary order. The iterator item type is Result<(u32, StackTrace), MapError>.

pub fn stack_ids(&self) -> MapKeys<'_, u32>

An iterator visiting all the stack_ids in arbitrary order. The iterator element type is Result<u32, MapError>.

Trait Implementations

impl<T: Debug> Debug for StackTraceMap<T>

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

Formats the value using the given formatter.

impl<'a, T: Deref<Target = Map>> IntoIterator for &'a StackTraceMap<T>

type Item = Result<(u32, StackTrace), MapError>

The type of the elements being iterated over.

type IntoIter = MapIter<'a, u32, StackTrace>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl TryFrom<MapRef> for StackTraceMap<MapRef>

type Error = MapError

The type returned in the event of a conversion error.

fn try_from(a: MapRef) -> Result<StackTraceMap<MapRef>, MapError>

Performs the conversion.

impl TryFrom<MapRefMut> for StackTraceMap<MapRefMut>

type Error = MapError

The type returned in the event of a conversion error.

fn try_from(a: MapRefMut) -> Result<StackTraceMap<MapRefMut>, MapError>

Performs the conversion.