aya: skip map creation and relocation for maps that should be ignored

[martinsoees]

Allows programs containing unsupported maps for the current
kernel to be loaded by skipping map creation and relocation before loading.

This is useful when you have a single program containing e.g. a RingBuf
and a PerfEventArray and you decide from user space which one to use
before loading the bytecode by checking if the kernel you are running
on has support for e.g. RingBuf.
That way you can use the same eBPF bytecode across multiple kernels
regardless of the kernel has support for it or not.
Can be used with .set_global() to signal if the map is supported
until support for bpf_core_enum_value_exists.

Example user space code:

let ringbuf_supported = ...

let mut set = HashSet::new();
set.insert(bpf_map_type::BPF_MAP_TYPE_RINGBUF);

let mut ebpf = EbpfLoader::new()
    .deactivate_maps(set)
    .set_global("RINGBUF_SUPPORTED", &ringbuf_supported, true)
    .load(include_bytes_aligned!(
    "../../target/bpfel-unknown-none/debug/disable_maps"
))?;

// ...
if ringbuf_supported {
    ringbuf_events()?.await;
} else {
    perfbuf_events()?.await;
}
// ...

Example eBPF bytecode:

#[no_mangle]
static RINGBUF_SUPPORTED: i32 = 0;

#[map]
static mut RINGBUF: RingBuf = RingBuf::with_byte_size(1024 * 10, 0);

#[map]
static mut PERFBUF: PerfEventArray<Buffer> = PerfEventArray::with_max_entries(1, 0);

#[xdp]
pub fn my_func(ctx: XdpContext) -> u32 {
    match try_my_func(ctx) {
        Ok(ret) => ret,
        Err(_) => xdp_action::XDP_ABORTED,
    }
}

fn try_my_func(ctx: XdpContext) -> Result<u32, u32> {
    info!(&ctx, "received a packet");
    let ringbuf = unsafe { core::ptr::read_volatile(&RINGBUF_SUPPORTED) };
    if ringbuf == 1 {
        info!(&ctx, "Ringbuf supported");
        // do ringbuf output
    } else {
        info!(&ctx, "Defaulting to perfevent");
        // do perfbuf output
    }
    Ok(xdp_action::XDP_PASS)
}

[netlify]

❌ Deploy Preview for aya-rs-docs failed.

Built without sensitive environment variables

Name	Link
🔨 Latest commit	0b0d4c7
🔍 Latest deploy log	https://app.netlify.com/sites/aya-rs-docs/deploys/6690daa22080720008772feb

[martinsoees]

Perhaps this should be scoped to only kernel-userspace data streaming (RingBufand PerfEvent).
Then the API could define a primary and a fallback data map, where RingBuf is primary and PerfEvent is a fallback map.
Would obviously require that the dev correctly handles this and reads from the correct map

[alessandrod]

 fn try_my_func(ctx: XdpContext) -> Result<u32, u32> {
    info!(&ctx, "received a packet");
    let ringbuf = unsafe { core::ptr::read_volatile(&RINGBUF_SUPPORTED) };
    if ringbuf == 1 {
        info!(&ctx, "Ringbuf supported");
        // do ringbuf output
    } else {
        info!(&ctx, "Defaulting to perfevent");
        // do perfbuf output
    }
    Ok(xdp_action::XDP_PASS)
}

Does this actually work, if in the ringbuf==1 case you access the RINGBUF map, and then in the else you access the PERFBUF map? Because if you skip relocating it, I would have expected the verifier to complain that the map fd is not valid.

If this does work, can you add an integration test please?

[alessandrod]

Perhaps this should be scoped to only kernel-userspace data streaming (RingBufand PerfEvent). Then the API could define a primary and a fallback data map, where RingBuf is primary and PerfEvent is a fallback map. Would obviously require that the dev correctly handles this and reads from the correct map

I tend to think the opposite: the current mechanism is too restrictive and it should be more generic. Right now you can ignore loading a map type, but what if I want to ignore loading only an instance of a map type (because eg, a bit of functionality is disabled, and I want to save the memory?).

I'm thinking it's probably better to have something like EbpfLoader::ignore_maps(&["RINGBUF"]) - do the ignore by name that is. Then an user can ignore for whatever reason, not only based on map type.

[martinsoees]

Perhaps this should be scoped to only kernel-userspace data streaming (RingBufand PerfEvent). Then the API could define a primary and a fallback data map, where RingBuf is primary and PerfEvent is a fallback map. Would obviously require that the dev correctly handles this and reads from the correct map

I tend to think the opposite: the current mechanism is too restrictive and it should be more generic. Right now you can ignore loading a map type, but what if I want to ignore loading only an instance of a map type (because eg, a bit of functionality is disabled, and I want to save the memory?).

I'm thinking it's probably better to have something like EbpfLoader::ignore_maps(&["RINGBUF"]) - do the ignore by name that is. Then an user can ignore for whatever reason, not only based on map type.

It actually started out like that, with the name rather than the type. I can revert it back to that or add a new function that filters by name and keep the one by id also? I see no reason why both can't exist

[martinsoees]

This PR has a clippy allow for too_many_arguments on relocate_maps. Ideally this should be fixed, but would require a larger rewrite of the map relocation section, so I suggest that it should be a separate PR. Unless you want it in this PR?

[alessandrod]

Very nice work! See comments

[martinsoees]

Very nice work! See comments

Thanks for the feedback. I left a comment to one of your review comments. The rest is straight forward. I'll see when I have time to fix it

[mergify]

@martinsoees, this pull request is now in conflict and requires a rebase.

[alessandrod]

I don't think this is correct, it's just not getting exercised by the test because we do have symbols. We switched to putting all maps in the same section (like libbpf does), so I think that this would skip all the maps?