Struct aya::BpfLoader

pub struct BpfLoader<'a> { /* private fields */ }

Builder style API for advanced loading of eBPF programs.

Loading eBPF code involves a few steps, including loading maps and applying relocations. You can use BpfLoader to customize some of the loading options.

Examples

use aya::{BpfLoader, Btf};
use std::fs;

let bpf = BpfLoader::new()
    // load the BTF data from /sys/kernel/btf/vmlinux
    .btf(Btf::from_sys_fs().ok().as_ref())
    // load pinned maps from /sys/fs/bpf/my-program
    .map_pin_path("/sys/fs/bpf/my-program")
    // finally load the code
    .load_file("file.o")?;

Implementations

impl<'a> BpfLoader<'a>

pub fn new() -> BpfLoader<'a>

Creates a new loader instance.

pub fn btf(&mut self, btf: Option<&'a Btf>) -> &mut BpfLoader<'a>

Sets the target BTF info.

The loader defaults to loading BTF info using Btf::from_sys_fs. Use this method if you want to load BTF from a custom location or pass None to disable BTF relocations entirely.

Example

use aya::{BpfLoader, Btf, Endianness};

let bpf = BpfLoader::new()
    // load the BTF data from a custom location
    .btf(Btf::parse_file("/custom_btf_file", Endianness::default()).ok().as_ref())
    .load_file("file.o")?;

pub fn map_pin_path<P: AsRef<Path>>(&mut self, path: P) -> &mut BpfLoader<'a>

Sets the base directory path for pinned maps.

Pinned maps will be loaded from path/MAP_NAME. The caller is responsible for ensuring the directory exists.

Example

use aya::BpfLoader;

let bpf = BpfLoader::new()
    .map_pin_path("/sys/fs/bpf/my-program")
    .load_file("file.o")?;

pub fn set_global<V: Pod>(
    &mut self,
    name: &'a str,
    value: &'a V
) -> &mut BpfLoader<'a>

Sets the value of a global variable

From Rust eBPF, a global variable would be constructed as follows:

#[no_mangle]
static VERSION: i32 = 0;

Then it would be accessed with core::ptr::read_volatile inside functions:

let version = core::ptr::read_volatile(&VERSION);

If using a struct, ensure that it is #[repr(C)] to ensure the size will match that of the corresponding ELF symbol.

From C eBPF, you would annotate a variable as volatile const

Example

use aya::BpfLoader;

let bpf = BpfLoader::new()
    .set_global("VERSION", &2)
    .load_file("file.o")?;

pub fn extension(&mut self, name: &'a str) -> &mut BpfLoader<'a>

Treat the provided program as an Extension

When attempting to load the program with the provided name the program type is forced to be ] Extension and is not inferred from the ELF section name.

Example

use aya::BpfLoader;

let bpf = BpfLoader::new()
    .extension("myfunc")
    .load_file("file.o")?;

pub fn load_file<P: AsRef<Path>>(&mut self, path: P) -> Result<Bpf, BpfError>

Loads eBPF bytecode from a file.

Examples

use aya::BpfLoader;

let bpf = BpfLoader::new().load_file("file.o")?;

pub fn load(&mut self, data: &[u8]) -> Result<Bpf, BpfError>

Loads eBPF bytecode from a buffer.

Examples

use aya::BpfLoader;
use std::fs;

let data = fs::read("file.o").unwrap();
let bpf = BpfLoader::new().load(&data)?;

Trait Implementations

impl<'a> Debug for BpfLoader<'a>

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

Formats the value using the given formatter.

impl<'a> Default for BpfLoader<'a>

fn default() -> Self

Returns the “default value” for a type.