Struct aya::maps::perf::AsyncPerfEventArray

pub struct AsyncPerfEventArray<T: DerefMut<Target = Map>> { /* fields omitted */ }

A Future based map that can be used to receive events from eBPF programs using the linux perf API.

This is the async version of PerfEventArray, which provides integration with tokio and async-std and a nice Future based API.

To receive events you need to:

• call AsyncPerfEventArray::open
• call AsyncPerfEventArrayBuffer::read_events to read the events

Examples

use aya::maps::perf::{AsyncPerfEventArray, PerfBufferError};
use aya::util::online_cpus;
use std::convert::TryFrom;
use futures::future;
use bytes::BytesMut;
use tokio::task; // or async_std::task

// try to convert the PERF_ARRAY map to an AsyncPerfEventArray
let mut perf_array = AsyncPerfEventArray::try_from(bpf.map_mut("PERF_ARRAY")?)?;

for cpu_id in online_cpus()? {
    // open a separate perf buffer for each cpu
    let mut buf = perf_array.open(cpu_id, None)?;

    // process each perf buffer in a separate task
    task::spawn(async move {
        let mut buffers = (0..10)
            .map(|_| BytesMut::with_capacity(1024))
            .collect::<Vec<_>>();

        loop {
            // wait for events
            let events = buf.read_events(&mut buffers).await?;

            // events.read contains the number of events that have been read,
            // and is always <= buffers.len()
            for i in 0..events.read {
                let buf = &mut buffers[i];
                // process buf
            }
        }

        Ok::<_, PerfBufferError>(())
    });
}

Implementations

impl<T: DerefMut<Target = Map>> AsyncPerfEventArray<T>

pub fn open(
    &mut self,
    index: u32,
    page_count: Option<usize>
) -> Result<AsyncPerfEventArrayBuffer<T>, PerfBufferError>

Opens the perf buffer at the given index.

The returned buffer will receive all the events eBPF programs send at the given index.

Trait Implementations

impl TryFrom<MapRefMut> for AsyncPerfEventArray<MapRefMut>

type Error = MapError

The type returned in the event of a conversion error.

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

Performs the conversion.