Struct Loaded

pub struct Loaded {
    pub module: Module,
    pub events: UnboundedReceiver<(String, <PerfMessageStream as Stream>::Item)>,
}

The Loaded object returned by load().

Fields

module: Module

events: UnboundedReceiver<(String, <PerfMessageStream as Stream>::Item)>

The stream of events emitted by the BPF programs.

Example

use std::path::Path;
use futures::stream::StreamExt;
use redbpf::load::Loader;
let mut loader = Loader::load_file(&Path::new("probe.elf")).unwrap();
while let Some((map_name, events)) = loader.events.next().await {
    for event in events {
        // ...
    }
}

Implementations

impl Loaded

pub fn map(&self, name: &str) -> Option<&Map>

pub fn map_mut(&mut self, name: &str) -> Option<&mut Map>

pub fn program(&self, name: &str) -> Option<&Program>

pub fn program_mut(&mut self, name: &str) -> Option<&mut Program>

pub fn kprobes_mut(&mut self) -> impl Iterator<Item = &mut KProbe>

pub fn kprobe_mut(&mut self, name: &str) -> Option<&mut KProbe>

pub fn uprobes_mut(&mut self) -> impl Iterator<Item = &mut UProbe>

pub fn uprobe_mut(&mut self, name: &str) -> Option<&mut UProbe>

pub fn xdps_mut(&mut self) -> impl Iterator<Item = &mut XDP>

pub fn xdp_mut(&mut self, name: &str) -> Option<&mut XDP>

pub fn socket_filters_mut(&mut self) -> impl Iterator<Item = &mut SocketFilter>

pub fn socket_filter_mut(&mut self, name: &str) -> Option<&mut SocketFilter>

pub fn stream_parsers(&self) -> impl Iterator<Item = &StreamParser>

pub fn stream_parsers_mut(&mut self) -> impl Iterator<Item = &mut StreamParser>

pub fn stream_parser_mut(&mut self, name: &str) -> Option<&mut StreamParser>

pub fn stream_verdicts(&self) -> impl Iterator<Item = &StreamVerdict>

pub fn stream_verdicts_mut( &mut self, ) -> impl Iterator<Item = &mut StreamVerdict>

pub fn stream_verdict_mut(&mut self, name: &str) -> Option<&mut StreamVerdict>

pub fn sk_lookups_mut(&mut self) -> impl Iterator<Item = &mut SkLookup>

pub fn sk_lookup_mut(&mut self, name: &str) -> Option<&mut SkLookup>

pub fn task_iters(&self) -> impl Iterator<Item = &TaskIter>

pub fn bpf_iters_mut(&mut self) -> impl Iterator<Item = &mut TaskIter>

pub fn task_iter_mut(&mut self, name: &str) -> Option<&mut TaskIter>