mirror of https://github.com/aya-rs/aya
feat(aya-ebpf): BTF maps
Before this change, Aya supported only legacy BPF map definitions, which are instances of the `bpf_map_def` struct and end up in the `maps` ELF section. This change introduces BTF maps, with custom structs indicating the metadata of the map, which end up in the `.maps` section. Legacy maps are not supported by libbpf anymore and not even by the kernel for newer types of maps like inode/task storage. Add support of BTF maps in aya-ebpf under the `btf-maps` feature flag. Usage of this feature requires emitting debug info for the eBPF crate and passing the `--btf` flag to bpf-linker.
Michal Rostecki
2 months ago
parent
5a43bedc01
commit
d102383d31
@ -0,0 +1,73 @@
|
|||||||
|
use proc_macro2::TokenStream;
|
||||||
|
use quote::quote;
|
||||||
|
use syn::{ItemStatic, Result};
|
||||||
|
|
||||||
|
use crate::args::name_arg;
|
||||||
|
|
||||||
|
pub(crate) struct BtfMap {
|
||||||
|
item: ItemStatic,
|
||||||
|
name: String,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl BtfMap {
|
||||||
|
pub(crate) fn parse(attrs: TokenStream, item: TokenStream) -> Result<BtfMap> {
|
||||||
|
let item: ItemStatic = syn::parse2(item)?;
|
||||||
|
let mut args = syn::parse2(attrs)?;
|
||||||
|
let name = name_arg(&mut args).unwrap_or_else(|| item.ident.to_string());
|
||||||
|
Ok(BtfMap { item, name })
|
||||||
|
}
|
||||||
|
|
||||||
|
pub(crate) fn expand(&self) -> TokenStream {
|
||||||
|
let section_name = ".maps";
|
||||||
|
let name = &self.name;
|
||||||
|
let item = &self.item;
|
||||||
|
quote! {
|
||||||
|
#[link_section = #section_name]
|
||||||
|
#[export_name = #name]
|
||||||
|
#item
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use syn::parse_quote;
|
||||||
|
|
||||||
|
use super::*;
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_map_with_name() {
|
||||||
|
let map = BtfMap::parse(
|
||||||
|
parse_quote!(name = "foo"),
|
||||||
|
parse_quote!(
|
||||||
|
static BAR: HashMap<&'static str, u32> = HashMap::new();
|
||||||
|
),
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
let expanded = map.expand();
|
||||||
|
let expected = quote!(
|
||||||
|
#[link_section = ".maps"]
|
||||||
|
#[export_name = "foo"]
|
||||||
|
static BAR: HashMap<&'static str, u32> = HashMap::new();
|
||||||
|
);
|
||||||
|
assert_eq!(expected.to_string(), expanded.to_string());
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test]
|
||||||
|
fn test_map_no_name() {
|
||||||
|
let map = BtfMap::parse(
|
||||||
|
parse_quote!(),
|
||||||
|
parse_quote!(
|
||||||
|
static BAR: HashMap<&'static str, u32> = HashMap::new();
|
||||||
|
),
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
|
let expanded = map.expand();
|
||||||
|
let expected = quote!(
|
||||||
|
#[link_section = ".maps"]
|
||||||
|
#[export_name = "BAR"]
|
||||||
|
static BAR: HashMap<&'static str, u32> = HashMap::new();
|
||||||
|
);
|
||||||
|
assert_eq!(expected.to_string(), expanded.to_string());
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,41 @@
|
|||||||
|
use core::{cell::UnsafeCell, ptr::NonNull};
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
bindings::bpf_map_type::BPF_MAP_TYPE_ARRAY, btf_map_def, cty::c_void,
|
||||||
|
helpers::bpf_map_lookup_elem,
|
||||||
|
};
|
||||||
|
|
||||||
|
btf_map_def!(ArrayDef, BPF_MAP_TYPE_ARRAY);
|
||||||
|
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub struct Array<T, const M: usize, const F: usize = 0>(UnsafeCell<ArrayDef<u32, T, M, F>>);
|
||||||
|
|
||||||
|
unsafe impl<T: Sync, const M: usize, const F: usize> Sync for Array<T, M, F> {}
|
||||||
|
|
||||||
|
impl<T, const M: usize, const F: usize> Array<T, M, F> {
|
||||||
|
pub const fn new() -> Self {
|
||||||
|
Array(UnsafeCell::new(ArrayDef::new()))
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline(always)]
|
||||||
|
pub fn get(&self, index: u32) -> Option<&T> {
|
||||||
|
// FIXME: alignment
|
||||||
|
unsafe { self.lookup(index).map(|p| p.as_ref()) }
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline(always)]
|
||||||
|
pub fn get_ptr(&self, index: u32) -> Option<*const T> {
|
||||||
|
unsafe { self.lookup(index).map(|p| p.as_ptr() as *const T) }
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline(always)]
|
||||||
|
pub fn get_ptr_mut(&self, index: u32) -> Option<*mut T> {
|
||||||
|
unsafe { self.lookup(index).map(|p| p.as_ptr()) }
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline(always)]
|
||||||
|
unsafe fn lookup(&self, index: u32) -> Option<NonNull<T>> {
|
||||||
|
let ptr = bpf_map_lookup_elem(self.0.get() as *mut _, &index as *const _ as *const c_void);
|
||||||
|
NonNull::new(ptr as *mut T)
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,60 @@
|
|||||||
|
use core::{cell::UnsafeCell, ptr};
|
||||||
|
|
||||||
|
use aya_ebpf_bindings::helpers::{bpf_map_peek_elem, bpf_map_push_elem};
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
bindings::bpf_map_type::BPF_MAP_TYPE_BLOOM_FILTER, btf_maps::AyaBtfMapMarker, cty::c_void,
|
||||||
|
};
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
pub struct BloomFilterDef<T, const M: usize, const H: usize = 5, const F: usize = 0> {
|
||||||
|
r#type: *const [i32; BPF_MAP_TYPE_BLOOM_FILTER as usize],
|
||||||
|
value: *const T,
|
||||||
|
max_entries: *const [i32; M],
|
||||||
|
map_extra: *const [i32; H],
|
||||||
|
map_flags: *const [i32; F],
|
||||||
|
|
||||||
|
// Anonymize the struct.
|
||||||
|
_anon: AyaBtfMapMarker,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub struct BloomFilter<T, const M: usize, const H: usize = 5, const F: usize = 0>(
|
||||||
|
UnsafeCell<BloomFilterDef<T, M, H, F>>,
|
||||||
|
);
|
||||||
|
|
||||||
|
impl<T, const M: usize, const H: usize, const F: usize> BloomFilter<T, M, H, F> {
|
||||||
|
pub const fn new() -> Self {
|
||||||
|
BloomFilter(UnsafeCell::new(BloomFilterDef {
|
||||||
|
r#type: &[0i32; BPF_MAP_TYPE_BLOOM_FILTER as usize] as *const _,
|
||||||
|
value: ptr::null(),
|
||||||
|
max_entries: &[0i32; M] as *const _,
|
||||||
|
map_extra: &[0i32; H] as *const _,
|
||||||
|
map_flags: &[0i32; F] as *const _,
|
||||||
|
_anon: AyaBtfMapMarker::new(),
|
||||||
|
}))
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
pub fn contains(&mut self, value: &T) -> Result<(), i64> {
|
||||||
|
let ret = unsafe {
|
||||||
|
bpf_map_peek_elem(
|
||||||
|
&mut self.0.get() as *mut _ as *mut _,
|
||||||
|
value as *const _ as *mut c_void,
|
||||||
|
)
|
||||||
|
};
|
||||||
|
(ret == 0).then_some(()).ok_or(ret)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
pub fn insert(&mut self, value: &T, flags: u64) -> Result<(), i64> {
|
||||||
|
let ret = unsafe {
|
||||||
|
bpf_map_push_elem(
|
||||||
|
&mut self.0.get() as *mut _ as *mut _,
|
||||||
|
value as *const _ as *const _,
|
||||||
|
flags,
|
||||||
|
)
|
||||||
|
};
|
||||||
|
(ret == 0).then_some(()).ok_or(ret)
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,202 @@
|
|||||||
|
use core::{cell::UnsafeCell, ptr::NonNull};
|
||||||
|
|
||||||
|
use aya_ebpf_bindings::bindings::bpf_map_type::BPF_MAP_TYPE_PERCPU_HASH;
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
bindings::bpf_map_type::{BPF_MAP_TYPE_HASH, BPF_MAP_TYPE_LRU_HASH},
|
||||||
|
btf_map_def,
|
||||||
|
cty::{c_long, c_void},
|
||||||
|
helpers::{bpf_map_delete_elem, bpf_map_lookup_elem, bpf_map_update_elem},
|
||||||
|
};
|
||||||
|
|
||||||
|
btf_map_def!(HashMapDef, BPF_MAP_TYPE_HASH);
|
||||||
|
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub struct HashMap<K, V, const M: usize, const F: usize = 0>(UnsafeCell<HashMapDef<K, V, M, F>>);
|
||||||
|
|
||||||
|
unsafe impl<K: Sync, V: Sync, const M: usize, const F: usize> Sync for HashMap<K, V, M, F> {}
|
||||||
|
|
||||||
|
impl<K, V, const M: usize, const F: usize> HashMap<K, V, M, F> {
|
||||||
|
pub const fn new() -> HashMap<K, V, M, F> {
|
||||||
|
HashMap(UnsafeCell::new(HashMapDef::new()))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Retrieve the value associate with `key` from the map.
|
||||||
|
/// This function is unsafe. Unless the map flag `BPF_F_NO_PREALLOC` is used, the kernel does not
|
||||||
|
/// make guarantee on the atomicity of `insert` or `remove`, and any element removed from the
|
||||||
|
/// map might get aliased by another element in the map, causing garbage to be read, or
|
||||||
|
/// corruption in case of writes.
|
||||||
|
#[inline]
|
||||||
|
pub unsafe fn get(&self, key: &K) -> Option<&V> {
|
||||||
|
get(self.0.get() as _, key)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Retrieve the value associate with `key` from the map.
|
||||||
|
/// The same caveat as `get` applies, but this returns a raw pointer and it's up to the caller
|
||||||
|
/// to decide whether it's safe to dereference the pointer or not.
|
||||||
|
#[inline]
|
||||||
|
pub fn get_ptr(&self, key: &K) -> Option<*const V> {
|
||||||
|
get_ptr(self.0.get() as _, key)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Retrieve the value associate with `key` from the map.
|
||||||
|
/// The same caveat as `get` applies, and additionally cares should be taken to avoid
|
||||||
|
/// concurrent writes, but it's up to the caller to decide whether it's safe to dereference the
|
||||||
|
/// pointer or not.
|
||||||
|
#[inline]
|
||||||
|
pub fn get_ptr_mut(&self, key: &K) -> Option<*mut V> {
|
||||||
|
get_ptr_mut(self.0.get() as _, key)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
pub fn insert(&self, key: &K, value: &V, flags: u64) -> Result<(), c_long> {
|
||||||
|
insert(self.0.get() as _, key, value, flags)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
pub fn remove(&self, key: &K) -> Result<(), c_long> {
|
||||||
|
remove(self.0.get() as _, key)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
btf_map_def!(LruHashMapDef, BPF_MAP_TYPE_LRU_HASH);
|
||||||
|
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub struct LruHashMap<K, V, const M: usize, const F: usize = 0>(
|
||||||
|
UnsafeCell<LruHashMapDef<K, V, M, F>>,
|
||||||
|
);
|
||||||
|
|
||||||
|
unsafe impl<K: Sync, V: Sync, const M: usize, const F: usize> Sync for LruHashMap<K, V, M, F> {}
|
||||||
|
|
||||||
|
impl<K, V, const M: usize, const F: usize> LruHashMap<K, V, M, F> {
|
||||||
|
pub const fn new() -> LruHashMap<K, V, M, F> {
|
||||||
|
LruHashMap(UnsafeCell::new(LruHashMapDef::new()))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Retrieve the value associate with `key` from the map.
|
||||||
|
/// This function is unsafe. Unless the map flag `BPF_F_NO_PREALLOC` is used, the kernel does not
|
||||||
|
/// make guarantee on the atomicity of `insert` or `remove`, and any element removed from the
|
||||||
|
/// map might get aliased by another element in the map, causing garbage to be read, or
|
||||||
|
/// corruption in case of writes.
|
||||||
|
#[inline]
|
||||||
|
pub unsafe fn get(&self, key: &K) -> Option<&V> {
|
||||||
|
get(self.0.get() as _, key)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Retrieve the value associate with `key` from the map.
|
||||||
|
/// The same caveat as `get` applies, but this returns a raw pointer and it's up to the caller
|
||||||
|
/// to decide whether it's safe to dereference the pointer or not.
|
||||||
|
#[inline]
|
||||||
|
pub fn get_ptr(&self, key: &K) -> Option<*const V> {
|
||||||
|
get_ptr(self.0.get() as _, key)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Retrieve the value associate with `key` from the map.
|
||||||
|
/// The same caveat as `get` applies, and additionally cares should be taken to avoid
|
||||||
|
/// concurrent writes, but it's up to the caller to decide whether it's safe to dereference the
|
||||||
|
/// pointer or not.
|
||||||
|
#[inline]
|
||||||
|
pub fn get_ptr_mut(&self, key: &K) -> Option<*mut V> {
|
||||||
|
get_ptr_mut(self.0.get() as _, key)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
pub fn insert(&self, key: &K, value: &V, flags: u64) -> Result<(), c_long> {
|
||||||
|
insert(self.0.get() as _, key, value, flags)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
pub fn remove(&self, key: &K) -> Result<(), c_long> {
|
||||||
|
remove(self.0.get() as _, key)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
btf_map_def!(PerCpuHashMapDef, BPF_MAP_TYPE_PERCPU_HASH);
|
||||||
|
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub struct PerCpuHashMap<K, V, const M: usize, const F: usize = 0>(
|
||||||
|
UnsafeCell<PerCpuHashMapDef<K, V, M, F>>,
|
||||||
|
);
|
||||||
|
|
||||||
|
unsafe impl<K, V, const M: usize, const F: usize> Sync for PerCpuHashMap<K, V, M, F> {}
|
||||||
|
|
||||||
|
impl<K, V, const M: usize, const F: usize> PerCpuHashMap<K, V, M, F> {
|
||||||
|
pub const fn new() -> PerCpuHashMap<K, V, M, F> {
|
||||||
|
PerCpuHashMap(UnsafeCell::new(PerCpuHashMapDef::new()))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Retrieve the value associate with `key` from the map.
|
||||||
|
/// This function is unsafe. Unless the map flag `BPF_F_NO_PREALLOC` is used, the kernel does not
|
||||||
|
/// make guarantee on the atomicity of `insert` or `remove`, and any element removed from the
|
||||||
|
/// map might get aliased by another element in the map, causing garbage to be read, or
|
||||||
|
/// corruption in case of writes.
|
||||||
|
#[inline]
|
||||||
|
pub unsafe fn get(&self, key: &K) -> Option<&V> {
|
||||||
|
get(self.0.get() as _, key)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Retrieve the value associate with `key` from the map.
|
||||||
|
/// The same caveat as `get` applies, but this returns a raw pointer and it's up to the caller
|
||||||
|
/// to decide whether it's safe to dereference the pointer or not.
|
||||||
|
#[inline]
|
||||||
|
pub fn get_ptr(&self, key: &K) -> Option<*const V> {
|
||||||
|
get_ptr(self.0.get() as _, key)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Retrieve the value associate with `key` from the map.
|
||||||
|
/// The same caveat as `get` applies, and additionally cares should be taken to avoid
|
||||||
|
/// concurrent writes, but it's up to the caller to decide whether it's safe to dereference the
|
||||||
|
/// pointer or not.
|
||||||
|
#[inline]
|
||||||
|
pub fn get_ptr_mut(&self, key: &K) -> Option<*mut V> {
|
||||||
|
get_ptr_mut(self.0.get() as _, key)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
pub fn insert(&self, key: &K, value: &V, flags: u64) -> Result<(), c_long> {
|
||||||
|
insert(self.0.get() as _, key, value, flags)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
pub fn remove(&self, key: &K) -> Result<(), c_long> {
|
||||||
|
remove(self.0.get() as _, key)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn get_ptr_mut<K, V>(def: *mut c_void, key: &K) -> Option<*mut V> {
|
||||||
|
unsafe {
|
||||||
|
let value = bpf_map_lookup_elem(def as *mut _, key as *const _ as *const c_void);
|
||||||
|
// FIXME: alignment
|
||||||
|
NonNull::new(value as *mut V).map(|p| p.as_ptr())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn get_ptr<K, V>(def: *mut c_void, key: &K) -> Option<*const V> {
|
||||||
|
get_ptr_mut(def, key).map(|p| p as *const V)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
unsafe fn get<'a, K, V>(def: *mut c_void, key: &K) -> Option<&'a V> {
|
||||||
|
get_ptr(def, key).map(|p| &*p)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn insert<K, V>(def: *mut c_void, key: &K, value: &V, flags: u64) -> Result<(), c_long> {
|
||||||
|
let ret = unsafe {
|
||||||
|
bpf_map_update_elem(
|
||||||
|
def as *mut _,
|
||||||
|
key as *const _ as *const _,
|
||||||
|
value as *const _ as *const _,
|
||||||
|
flags,
|
||||||
|
)
|
||||||
|
};
|
||||||
|
(ret == 0).then_some(()).ok_or(ret)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline]
|
||||||
|
fn remove<K>(def: *mut c_void, key: &K) -> Result<(), c_long> {
|
||||||
|
let ret = unsafe { bpf_map_delete_elem(def as *mut _, key as *const _ as *const c_void) };
|
||||||
|
(ret == 0).then_some(()).ok_or(ret)
|
||||||
|
}
|
||||||
@ -0,0 +1,26 @@
|
|||||||
|
// use core::mem;
|
||||||
|
//
|
||||||
|
// use crate::bindings::bpf_map_type::BPF_MAP_TYPE_BLOOM_FILTER;
|
||||||
|
|
||||||
|
// #[allow(dead_code)]
|
||||||
|
// pub struct LpmTrieDef<K, V, const M: usize, const F: usize = 0> {
|
||||||
|
// r#type: *const [i32; BPF_MAP_TYPE_BLOOM_FILTER as usize],
|
||||||
|
// key_size: *const [i32; mem::size_of::<Key<K>>()],
|
||||||
|
// value_size: *const [i32; mem::size_of::<V>()],
|
||||||
|
// max_entries: *const [i32; M],
|
||||||
|
// map_flags: *const [i32; F],
|
||||||
|
// }
|
||||||
|
|
||||||
|
#[repr(packed)]
|
||||||
|
pub struct Key<K> {
|
||||||
|
/// Represents the number of bits matched against.
|
||||||
|
pub prefix_len: u32,
|
||||||
|
/// Represents arbitrary data stored in the LpmTrie.
|
||||||
|
pub data: K,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<K> Key<K> {
|
||||||
|
pub fn new(prefix_len: u32, data: K) -> Self {
|
||||||
|
Self { prefix_len, data }
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,75 @@
|
|||||||
|
#![cfg(feature = "btf-maps")]
|
||||||
|
|
||||||
|
use core::marker::PhantomData;
|
||||||
|
|
||||||
|
pub mod array;
|
||||||
|
pub mod bloom_filter;
|
||||||
|
pub mod hash_map;
|
||||||
|
pub mod lpm_trie;
|
||||||
|
pub mod per_cpu_array;
|
||||||
|
pub mod perf;
|
||||||
|
pub mod program_array;
|
||||||
|
pub mod queue;
|
||||||
|
pub mod ring_buf;
|
||||||
|
pub mod sock_hash;
|
||||||
|
pub mod sock_map;
|
||||||
|
pub mod stack;
|
||||||
|
pub mod stack_trace;
|
||||||
|
pub mod xdp;
|
||||||
|
|
||||||
|
pub use array::Array;
|
||||||
|
pub use bloom_filter::BloomFilter;
|
||||||
|
pub use hash_map::{HashMap, LruHashMap, PerCpuHashMap};
|
||||||
|
pub use per_cpu_array::PerCpuArray;
|
||||||
|
pub use perf::{PerfEventArray, PerfEventByteArray};
|
||||||
|
pub use program_array::ProgramArray;
|
||||||
|
pub use queue::Queue;
|
||||||
|
pub use ring_buf::RingBuf;
|
||||||
|
pub use sock_hash::SockHash;
|
||||||
|
pub use sock_map::SockMap;
|
||||||
|
pub use stack::Stack;
|
||||||
|
pub use stack_trace::StackTrace;
|
||||||
|
pub use xdp::{CpuMap, DevMap, DevMapHash, XskMap};
|
||||||
|
|
||||||
|
/// A marker used to remove names of annotated types in LLVM debug info and
|
||||||
|
/// therefore also in BTF.
|
||||||
|
///
|
||||||
|
/// # Example
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub(crate) struct AyaBtfMapMarker(PhantomData<()>);
|
||||||
|
|
||||||
|
impl AyaBtfMapMarker {
|
||||||
|
pub(crate) const fn new() -> Self {
|
||||||
|
Self(PhantomData)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[macro_export]
|
||||||
|
macro_rules! btf_map_def {
|
||||||
|
($name:ident, $t:ident) => {
|
||||||
|
#[allow(dead_code)]
|
||||||
|
pub struct $name<K, V, const M: usize, const F: usize = 0> {
|
||||||
|
r#type: *const [i32; $t as usize],
|
||||||
|
key: *const K,
|
||||||
|
value: *const V,
|
||||||
|
max_entries: *const [i32; M],
|
||||||
|
map_flags: *const [i32; F],
|
||||||
|
|
||||||
|
// Anonymize the struct.
|
||||||
|
_anon: $crate::btf_maps::AyaBtfMapMarker,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<K, V, const M: usize, const F: usize> $name<K, V, M, F> {
|
||||||
|
pub const fn new() -> $name<K, V, M, F> {
|
||||||
|
$name {
|
||||||
|
r#type: &[0i32; $t as usize],
|
||||||
|
key: ::core::ptr::null(),
|
||||||
|
value: ::core::ptr::null(),
|
||||||
|
max_entries: &[0i32; M],
|
||||||
|
map_flags: &[0i32; F],
|
||||||
|
_anon: $crate::btf_maps::AyaBtfMapMarker::new(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
};
|
||||||
|
}
|
||||||
@ -0,0 +1,44 @@
|
|||||||
|
use core::{cell::UnsafeCell, ptr::NonNull};
|
||||||
|
|
||||||
|
use aya_ebpf_bindings::helpers::bpf_map_lookup_elem;
|
||||||
|
|
||||||
|
use crate::{bindings::bpf_map_type::BPF_MAP_TYPE_PERCPU_ARRAY, btf_map_def, cty::c_void};
|
||||||
|
|
||||||
|
btf_map_def!(PerCpuArrayDef, BPF_MAP_TYPE_PERCPU_ARRAY);
|
||||||
|
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub struct PerCpuArray<T, const M: usize, const F: usize = 0>(
|
||||||
|
UnsafeCell<PerCpuArrayDef<u32, T, M, F>>,
|
||||||
|
);
|
||||||
|
|
||||||
|
unsafe impl<T: Sync, const M: usize, const F: usize> Sync for PerCpuArray<T, M, F> {}
|
||||||
|
|
||||||
|
impl<T, const M: usize, const F: usize> PerCpuArray<T, M, F> {
|
||||||
|
pub const fn new() -> Self {
|
||||||
|
Self(UnsafeCell::new(PerCpuArrayDef::new()))
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline(always)]
|
||||||
|
pub fn get(&self, index: u32) -> Option<&T> {
|
||||||
|
unsafe {
|
||||||
|
// FIXME: alignment
|
||||||
|
self.lookup(index).map(|p| p.as_ref())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline(always)]
|
||||||
|
pub fn get_ptr(&self, index: u32) -> Option<*const T> {
|
||||||
|
unsafe { self.lookup(index).map(|p| p.as_ptr() as *const T) }
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline(always)]
|
||||||
|
pub fn get_ptr_mut(&self, index: u32) -> Option<*mut T> {
|
||||||
|
unsafe { self.lookup(index).map(|p| p.as_ptr()) }
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline(always)]
|
||||||
|
unsafe fn lookup(&self, index: u32) -> Option<NonNull<T>> {
|
||||||
|
let ptr = bpf_map_lookup_elem(self.0.get() as *mut _, &index as *const _ as *const c_void);
|
||||||
|
NonNull::new(ptr as *mut T)
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,34 @@
|
|||||||
|
use core::mem;
|
||||||
|
|
||||||
|
mod perf_event_array;
|
||||||
|
mod perf_event_byte_array;
|
||||||
|
|
||||||
|
pub use perf_event_array::PerfEventArray;
|
||||||
|
pub use perf_event_byte_array::PerfEventByteArray;
|
||||||
|
|
||||||
|
use crate::{bindings::bpf_map_type::BPF_MAP_TYPE_PERF_EVENT_ARRAY, btf_maps::AyaBtfMapMarker};
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
pub struct PerfEventArrayDef<const F: usize = 0> {
|
||||||
|
r#type: *const [i32; BPF_MAP_TYPE_PERF_EVENT_ARRAY as usize],
|
||||||
|
key_size: *const [i32; mem::size_of::<u32>()],
|
||||||
|
value_size: *const [i32; mem::size_of::<u32>()],
|
||||||
|
max_entries: *const [i32; 0],
|
||||||
|
map_flags: *const [i32; F],
|
||||||
|
|
||||||
|
// Anonymize the struct.
|
||||||
|
_anon: AyaBtfMapMarker,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<const F: usize> PerfEventArrayDef<F> {
|
||||||
|
pub const fn new() -> Self {
|
||||||
|
Self {
|
||||||
|
r#type: &[0i32; BPF_MAP_TYPE_PERF_EVENT_ARRAY as usize],
|
||||||
|
key_size: &[0i32; mem::size_of::<u32>()],
|
||||||
|
value_size: &[0i32; mem::size_of::<u32>()],
|
||||||
|
max_entries: &[0i32; 0],
|
||||||
|
map_flags: &[0i32; F],
|
||||||
|
_anon: AyaBtfMapMarker::new(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,40 @@
|
|||||||
|
use core::{cell::UnsafeCell, marker::PhantomData, mem};
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
bindings::BPF_F_CURRENT_CPU, btf_maps::perf::PerfEventArrayDef, helpers::bpf_perf_event_output,
|
||||||
|
EbpfContext,
|
||||||
|
};
|
||||||
|
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub struct PerfEventArray<T, const F: usize = 0> {
|
||||||
|
def: UnsafeCell<PerfEventArrayDef<F>>,
|
||||||
|
_t: PhantomData<T>,
|
||||||
|
}
|
||||||
|
|
||||||
|
unsafe impl<T: Sync, const F: usize> Sync for PerfEventArray<T, F> {}
|
||||||
|
|
||||||
|
impl<T, const F: usize> PerfEventArray<T, F> {
|
||||||
|
pub const fn new() -> Self {
|
||||||
|
Self {
|
||||||
|
def: UnsafeCell::new(PerfEventArrayDef::new()),
|
||||||
|
_t: PhantomData,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn output<C: EbpfContext>(&self, ctx: &C, data: &T, flags: u32) {
|
||||||
|
self.output_at_index(ctx, BPF_F_CURRENT_CPU as u32, data, flags)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn output_at_index<C: EbpfContext>(&self, ctx: &C, index: u32, data: &T, flags: u32) {
|
||||||
|
let flags = u64::from(flags) << 32 | u64::from(index);
|
||||||
|
unsafe {
|
||||||
|
bpf_perf_event_output(
|
||||||
|
ctx.as_ptr(),
|
||||||
|
self.def.get() as *mut _,
|
||||||
|
flags,
|
||||||
|
data as *const _ as *mut _,
|
||||||
|
mem::size_of::<T>() as u64,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,34 @@
|
|||||||
|
use core::cell::UnsafeCell;
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
bindings::BPF_F_CURRENT_CPU, btf_maps::perf::PerfEventArrayDef, helpers::bpf_perf_event_output,
|
||||||
|
EbpfContext,
|
||||||
|
};
|
||||||
|
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub struct PerfEventByteArray<const F: usize = 0>(UnsafeCell<PerfEventArrayDef<F>>);
|
||||||
|
|
||||||
|
unsafe impl<const F: usize> Sync for PerfEventByteArray<F> {}
|
||||||
|
|
||||||
|
impl<const F: usize> PerfEventByteArray<F> {
|
||||||
|
pub const fn new() -> Self {
|
||||||
|
Self(UnsafeCell::new(PerfEventArrayDef::new()))
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn output<C: EbpfContext>(&self, ctx: &C, data: &[u8], flags: u32) {
|
||||||
|
self.output_at_index(ctx, BPF_F_CURRENT_CPU as u32, data, flags)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn output_at_index<C: EbpfContext>(&self, ctx: &C, index: u32, data: &[u8], flags: u32) {
|
||||||
|
let flags = u64::from(flags) << 32 | u64::from(index);
|
||||||
|
unsafe {
|
||||||
|
bpf_perf_event_output(
|
||||||
|
ctx.as_ptr(),
|
||||||
|
self.0.get() as *mut _,
|
||||||
|
flags,
|
||||||
|
data.as_ptr() as *mut _,
|
||||||
|
data.len() as u64,
|
||||||
|
);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,80 @@
|
|||||||
|
use core::{cell::UnsafeCell, hint::unreachable_unchecked, mem};
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
bindings::bpf_map_type::BPF_MAP_TYPE_PROG_ARRAY, btf_maps::AyaBtfMapMarker, cty::c_long,
|
||||||
|
helpers::bpf_tail_call, EbpfContext,
|
||||||
|
};
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
pub struct ProgramArrayDef<const M: usize, const F: usize = 0> {
|
||||||
|
r#type: *const [i32; BPF_MAP_TYPE_PROG_ARRAY as usize],
|
||||||
|
key_size: *const [i32; mem::size_of::<u32>()],
|
||||||
|
value_size: *const [i32; mem::size_of::<u32>()],
|
||||||
|
max_entries: *const [i32; M],
|
||||||
|
map_flags: *const [i32; F],
|
||||||
|
|
||||||
|
// Anonymize the struct.
|
||||||
|
_anon: AyaBtfMapMarker,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub struct ProgramArray<const M: usize, const F: usize = 0>(UnsafeCell<ProgramArrayDef<M, F>>);
|
||||||
|
|
||||||
|
impl<const M: usize, const F: usize> ProgramArray<M, F> {
|
||||||
|
pub const fn new() -> Self {
|
||||||
|
Self(UnsafeCell::new(ProgramArrayDef {
|
||||||
|
r#type: &[0i32; BPF_MAP_TYPE_PROG_ARRAY as usize] as *const _,
|
||||||
|
key_size: &[0i32; mem::size_of::<u32>()] as *const _,
|
||||||
|
value_size: &[0i32; mem::size_of::<u32>()] as *const _,
|
||||||
|
max_entries: &[0i32; M] as *const _,
|
||||||
|
map_flags: &[0i32; F] as *const _,
|
||||||
|
_anon: AyaBtfMapMarker::new(),
|
||||||
|
}))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Perform a tail call into a program indexed by this map.
|
||||||
|
///
|
||||||
|
/// # Safety
|
||||||
|
///
|
||||||
|
/// This function is inherently unsafe, since it causes control flow to jump into
|
||||||
|
/// another eBPF program. This can have side effects, such as drop methods not being
|
||||||
|
/// called. Note that tail calling into an eBPF program is not the same thing as
|
||||||
|
/// a function call -- control flow never returns to the caller.
|
||||||
|
///
|
||||||
|
/// # Return Value
|
||||||
|
///
|
||||||
|
/// On success, this function **does not return** into the original program.
|
||||||
|
/// On failure, a negative error is returned, wrapped in `Err()`.
|
||||||
|
#[cfg(not(unstable))]
|
||||||
|
pub unsafe fn tail_call<C: EbpfContext>(&self, ctx: &C, index: u32) -> Result<(), c_long> {
|
||||||
|
let res = bpf_tail_call(ctx.as_ptr(), self.0.get() as *mut _, index);
|
||||||
|
if res != 0 {
|
||||||
|
Err(res)
|
||||||
|
} else {
|
||||||
|
unreachable_unchecked()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Perform a tail call into a program indexed by this map.
|
||||||
|
///
|
||||||
|
/// # Safety
|
||||||
|
///
|
||||||
|
/// This function is inherently unsafe, since it causes control flow to jump into
|
||||||
|
/// another eBPF program. This can have side effects, such as drop methods not being
|
||||||
|
/// called. Note that tail calling into an eBPF program is not the same thing as
|
||||||
|
/// a function call -- control flow never returns to the caller.
|
||||||
|
///
|
||||||
|
/// # Return Value
|
||||||
|
///
|
||||||
|
/// On success, this function **does not return** into the original program.
|
||||||
|
/// On failure, a negative error is returned, wrapped in `Err()`.
|
||||||
|
#[cfg(unstable)]
|
||||||
|
pub unsafe fn tail_call<C: EbpfContext>(&self, ctx: &C, index: u32) -> Result<!, c_long> {
|
||||||
|
let res = bpf_tail_call(ctx.as_ptr(), self.0.get() as *mut _, index);
|
||||||
|
if res != 0 {
|
||||||
|
Err(res)
|
||||||
|
} else {
|
||||||
|
unreachable_unchecked()
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,50 @@
|
|||||||
|
use core::{cell::UnsafeCell, mem, ptr};
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
bindings::bpf_map_type::BPF_MAP_TYPE_QUEUE,
|
||||||
|
btf_maps::AyaBtfMapMarker,
|
||||||
|
helpers::{bpf_map_pop_elem, bpf_map_push_elem},
|
||||||
|
};
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
pub struct QueueDef<T, const M: usize, const F: usize = 0> {
|
||||||
|
r#type: *const [i32; BPF_MAP_TYPE_QUEUE as usize],
|
||||||
|
value: *const T,
|
||||||
|
max_entries: *const [i32; M],
|
||||||
|
map_flags: *const [i32; F],
|
||||||
|
|
||||||
|
// Anonymize the struct.
|
||||||
|
_anon: AyaBtfMapMarker,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub struct Queue<T, const M: usize, const F: usize = 0>(UnsafeCell<QueueDef<T, M, F>>);
|
||||||
|
|
||||||
|
unsafe impl<T: Sync, const M: usize, const F: usize> Sync for Queue<T, M, F> {}
|
||||||
|
|
||||||
|
impl<T, const M: usize, const F: usize> Queue<T, M, F> {
|
||||||
|
pub const fn new() -> Self {
|
||||||
|
Self(UnsafeCell::new(QueueDef {
|
||||||
|
r#type: &[0i32; BPF_MAP_TYPE_QUEUE as usize],
|
||||||
|
value: ptr::null(),
|
||||||
|
max_entries: &[0i32; M],
|
||||||
|
map_flags: &[0i32; F],
|
||||||
|
_anon: AyaBtfMapMarker::new(),
|
||||||
|
}))
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn push(&self, value: &T, flags: u64) -> Result<(), i64> {
|
||||||
|
let ret = unsafe {
|
||||||
|
bpf_map_push_elem(self.0.get() as *mut _, value as *const _ as *const _, flags)
|
||||||
|
};
|
||||||
|
(ret == 0).then_some(()).ok_or(ret)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn pop(&self) -> Option<T> {
|
||||||
|
unsafe {
|
||||||
|
let mut value = mem::MaybeUninit::uninit();
|
||||||
|
let ret = bpf_map_pop_elem(self.0.get() as *mut _, value.as_mut_ptr() as *mut _);
|
||||||
|
(ret == 0).then_some(value.assume_init())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,159 @@
|
|||||||
|
use core::{
|
||||||
|
cell::UnsafeCell,
|
||||||
|
mem::{self, MaybeUninit},
|
||||||
|
ops::{Deref, DerefMut},
|
||||||
|
};
|
||||||
|
|
||||||
|
#[cfg(unstable)]
|
||||||
|
mod const_assert {
|
||||||
|
pub struct Assert<const COND: bool> {}
|
||||||
|
|
||||||
|
pub trait IsTrue {}
|
||||||
|
|
||||||
|
impl IsTrue for Assert<true> {}
|
||||||
|
}
|
||||||
|
#[cfg(unstable)]
|
||||||
|
use const_assert::{Assert, IsTrue};
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
bindings::bpf_map_type::BPF_MAP_TYPE_RINGBUF,
|
||||||
|
btf_maps::AyaBtfMapMarker,
|
||||||
|
helpers::{
|
||||||
|
bpf_ringbuf_discard, bpf_ringbuf_output, bpf_ringbuf_query, bpf_ringbuf_reserve,
|
||||||
|
bpf_ringbuf_submit,
|
||||||
|
},
|
||||||
|
};
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
pub struct RingBufDef<const S: usize, const F: usize = 0> {
|
||||||
|
r#type: *const [i32; BPF_MAP_TYPE_RINGBUF as usize],
|
||||||
|
max_entries: *const [i32; S],
|
||||||
|
|
||||||
|
// Anonymize the struct.
|
||||||
|
_anon: AyaBtfMapMarker,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub struct RingBuf<const S: usize, const F: usize = 0>(UnsafeCell<RingBufDef<S, F>>);
|
||||||
|
|
||||||
|
unsafe impl<const S: usize, const F: usize> Sync for RingBuf<S, F> {}
|
||||||
|
|
||||||
|
/// A ring buffer entry, returned from [`RingBuf::reserve`].
|
||||||
|
///
|
||||||
|
/// You must [`submit`] or [`discard`] this entry before it gets dropped.
|
||||||
|
///
|
||||||
|
/// [`submit`]: RingBufEntry::submit
|
||||||
|
/// [`discard`]: RingBufEntry::discard
|
||||||
|
#[must_use = "eBPF verifier requires ring buffer entries to be either submitted or discarded"]
|
||||||
|
pub struct RingBufEntry<T: 'static>(&'static mut MaybeUninit<T>);
|
||||||
|
|
||||||
|
impl<T> Deref for RingBufEntry<T> {
|
||||||
|
type Target = MaybeUninit<T>;
|
||||||
|
|
||||||
|
fn deref(&self) -> &Self::Target {
|
||||||
|
self.0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T> DerefMut for RingBufEntry<T> {
|
||||||
|
fn deref_mut(&mut self) -> &mut Self::Target {
|
||||||
|
self.0
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<T> RingBufEntry<T> {
|
||||||
|
/// Discard this ring buffer entry. The entry will be skipped by the userspace reader.
|
||||||
|
pub fn discard(self, flags: u64) {
|
||||||
|
unsafe { bpf_ringbuf_discard(self.0.as_mut_ptr() as *mut _, flags) };
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Commit this ring buffer entry. The entry will be made visible to the userspace reader.
|
||||||
|
pub fn submit(self, flags: u64) {
|
||||||
|
unsafe { bpf_ringbuf_submit(self.0.as_mut_ptr() as *mut _, flags) };
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl<const S: usize, const F: usize> RingBuf<S, F> {
|
||||||
|
/// Declare an eBPF ring buffer.
|
||||||
|
///
|
||||||
|
/// The linux kernel requires that `byte_size` be a power-of-2 multiple of the page size. The
|
||||||
|
/// loading program may coerce the size when loading the map.
|
||||||
|
pub const fn new() -> Self {
|
||||||
|
Self(UnsafeCell::new(RingBufDef {
|
||||||
|
r#type: &[0i32; BPF_MAP_TYPE_RINGBUF as usize],
|
||||||
|
max_entries: &[0i32; S],
|
||||||
|
_anon: AyaBtfMapMarker::new(),
|
||||||
|
}))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Reserve memory in the ring buffer that can fit `T`.
|
||||||
|
///
|
||||||
|
/// Returns `None` if the ring buffer is full.
|
||||||
|
#[cfg(unstable)]
|
||||||
|
pub fn reserve<T: 'static>(&self, flags: u64) -> Option<RingBufEntry<T>>
|
||||||
|
where
|
||||||
|
Assert<{ 8 % mem::align_of::<T>() == 0 }>: IsTrue,
|
||||||
|
{
|
||||||
|
self.reserve_impl(flags)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Reserve memory in the ring buffer that can fit `T`.
|
||||||
|
///
|
||||||
|
/// Returns `None` if the ring buffer is full.
|
||||||
|
///
|
||||||
|
/// The kernel will reserve memory at an 8-bytes aligned boundary, so `mem::align_of<T>()` must
|
||||||
|
/// be equal or smaller than 8. If you use this with a `T` that isn't properly aligned, this
|
||||||
|
/// function will be compiled to a panic; depending on your panic_handler, this may make
|
||||||
|
/// the eBPF program fail to load, or it may make it have undefined behavior.
|
||||||
|
#[cfg(not(unstable))]
|
||||||
|
pub fn reserve<T: 'static>(&self, flags: u64) -> Option<RingBufEntry<T>> {
|
||||||
|
assert_eq!(8 % mem::align_of::<T>(), 0);
|
||||||
|
self.reserve_impl(flags)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn reserve_impl<T: 'static>(&self, flags: u64) -> Option<RingBufEntry<T>> {
|
||||||
|
let ptr =
|
||||||
|
unsafe { bpf_ringbuf_reserve(self.0.get() as *mut _, mem::size_of::<T>() as _, flags) }
|
||||||
|
as *mut MaybeUninit<T>;
|
||||||
|
unsafe { ptr.as_mut() }.map(|ptr| RingBufEntry(ptr))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Copy `data` to the ring buffer output.
|
||||||
|
///
|
||||||
|
/// Consider using [`reserve`] and [`submit`] if `T` is statically sized and you want to save a
|
||||||
|
/// copy from either a map buffer or the stack.
|
||||||
|
///
|
||||||
|
/// Unlike [`reserve`], this function can handle dynamically sized types (which is hard to
|
||||||
|
/// create in eBPF but still possible, e.g. by slicing an array).
|
||||||
|
///
|
||||||
|
/// Note: `T` must be aligned to no more than 8 bytes; it's not possible to fulfill larger
|
||||||
|
/// alignment requests. If you use this with a `T` that isn't properly aligned, this function will
|
||||||
|
/// be compiled to a panic and silently make your eBPF program fail to load.
|
||||||
|
/// See [here](https://github.com/torvalds/linux/blob/3f01e9fed/kernel/bpf/ringbuf.c#L418).
|
||||||
|
///
|
||||||
|
/// [`reserve`]: RingBuf::reserve
|
||||||
|
/// [`submit`]: RingBufEntry::submit
|
||||||
|
pub fn output<T: ?Sized>(&self, data: &T, flags: u64) -> Result<(), i64> {
|
||||||
|
assert_eq!(8 % mem::align_of_val(data), 0);
|
||||||
|
let ret = unsafe {
|
||||||
|
bpf_ringbuf_output(
|
||||||
|
self.0.get() as *mut _,
|
||||||
|
data as *const _ as *mut _,
|
||||||
|
mem::size_of_val(data) as _,
|
||||||
|
flags,
|
||||||
|
)
|
||||||
|
};
|
||||||
|
if ret < 0 {
|
||||||
|
Err(ret)
|
||||||
|
} else {
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Query various information about the ring buffer.
|
||||||
|
///
|
||||||
|
/// Consult `bpf_ringbuf_query` documentation for a list of allowed flags.
|
||||||
|
pub fn query(&self, flags: u64) -> u64 {
|
||||||
|
unsafe { bpf_ringbuf_query(self.0.get() as *mut _, flags) }
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,98 @@
|
|||||||
|
use core::{borrow::Borrow, cell::UnsafeCell, ptr};
|
||||||
|
|
||||||
|
use aya_ebpf_cty::c_void;
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
bindings::{bpf_map_type::BPF_MAP_TYPE_SOCKHASH, bpf_sock_ops},
|
||||||
|
btf_maps::AyaBtfMapMarker,
|
||||||
|
helpers::{
|
||||||
|
bpf_map_lookup_elem, bpf_msg_redirect_hash, bpf_sk_assign, bpf_sk_redirect_hash,
|
||||||
|
bpf_sk_release, bpf_sock_hash_update,
|
||||||
|
},
|
||||||
|
programs::{SkBuffContext, SkLookupContext, SkMsgContext},
|
||||||
|
EbpfContext,
|
||||||
|
};
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
pub struct SockHashDef<K, const M: usize, const F: usize = 0> {
|
||||||
|
r#type: *const [i32; BPF_MAP_TYPE_SOCKHASH as usize],
|
||||||
|
key: *const K,
|
||||||
|
value: *const u32,
|
||||||
|
max_entries: *const [i32; M],
|
||||||
|
map_flags: *const [i32; F],
|
||||||
|
|
||||||
|
// Anonymize the struct.
|
||||||
|
_anon: AyaBtfMapMarker,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub struct SockHash<K, const M: usize, const F: usize = 0>(UnsafeCell<SockHashDef<K, M, F>>);
|
||||||
|
|
||||||
|
unsafe impl<K: Sync, const M: usize, const F: usize> Sync for SockHash<K, M, F> {}
|
||||||
|
|
||||||
|
impl<K, const M: usize, const F: usize> SockHash<K, M, F> {
|
||||||
|
pub const fn new() -> Self {
|
||||||
|
Self(UnsafeCell::new(SockHashDef {
|
||||||
|
r#type: &[0i32; BPF_MAP_TYPE_SOCKHASH as usize],
|
||||||
|
key: ptr::null(),
|
||||||
|
value: ptr::null(),
|
||||||
|
max_entries: &[0i32; M],
|
||||||
|
map_flags: &[0i32; F],
|
||||||
|
_anon: AyaBtfMapMarker::new(),
|
||||||
|
}))
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn update(&self, key: &mut K, sk_ops: &mut bpf_sock_ops, flags: u64) -> Result<(), i64> {
|
||||||
|
let ret = unsafe {
|
||||||
|
bpf_sock_hash_update(
|
||||||
|
sk_ops as *mut _,
|
||||||
|
self.0.get() as *mut _,
|
||||||
|
key as *mut _ as *mut c_void,
|
||||||
|
flags,
|
||||||
|
)
|
||||||
|
};
|
||||||
|
(ret == 0).then_some(()).ok_or(ret)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn redirect_msg(&self, ctx: &SkMsgContext, key: &mut K, flags: u64) -> i64 {
|
||||||
|
unsafe {
|
||||||
|
bpf_msg_redirect_hash(
|
||||||
|
ctx.as_ptr() as *mut _,
|
||||||
|
self.0.get() as *mut _,
|
||||||
|
key as *mut _ as *mut _,
|
||||||
|
flags,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn redirect_skb(&self, ctx: &SkBuffContext, key: &mut K, flags: u64) -> i64 {
|
||||||
|
unsafe {
|
||||||
|
bpf_sk_redirect_hash(
|
||||||
|
ctx.as_ptr() as *mut _,
|
||||||
|
self.0.get() as *mut _,
|
||||||
|
key as *mut _ as *mut _,
|
||||||
|
flags,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn redirect_sk_lookup(
|
||||||
|
&mut self,
|
||||||
|
ctx: &SkLookupContext,
|
||||||
|
key: impl Borrow<K>,
|
||||||
|
flags: u64,
|
||||||
|
) -> Result<(), u32> {
|
||||||
|
unsafe {
|
||||||
|
let sk = bpf_map_lookup_elem(
|
||||||
|
&mut self.0 as *mut _ as *mut _,
|
||||||
|
&key as *const _ as *const c_void,
|
||||||
|
);
|
||||||
|
if sk.is_null() {
|
||||||
|
return Err(1);
|
||||||
|
}
|
||||||
|
let ret = bpf_sk_assign(ctx.as_ptr() as *mut _, sk, flags);
|
||||||
|
bpf_sk_release(sk);
|
||||||
|
(ret == 0).then_some(()).ok_or(1)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,91 @@
|
|||||||
|
use core::{cell::UnsafeCell, ptr};
|
||||||
|
|
||||||
|
use aya_ebpf_cty::c_void;
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
bindings::{bpf_map_type::BPF_MAP_TYPE_SOCKMAP, bpf_sock_ops},
|
||||||
|
btf_maps::AyaBtfMapMarker,
|
||||||
|
helpers::{
|
||||||
|
bpf_map_lookup_elem, bpf_msg_redirect_map, bpf_sk_assign, bpf_sk_redirect_map,
|
||||||
|
bpf_sk_release, bpf_sock_map_update,
|
||||||
|
},
|
||||||
|
programs::{SkBuffContext, SkLookupContext, SkMsgContext},
|
||||||
|
EbpfContext,
|
||||||
|
};
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
pub struct SockMapDef<const M: usize, const F: usize = 0> {
|
||||||
|
r#type: *const [i32; BPF_MAP_TYPE_SOCKMAP as usize],
|
||||||
|
key: *const u32,
|
||||||
|
value: *const u32,
|
||||||
|
max_entries: *const [i32; M],
|
||||||
|
map_flags: *const [i32; F],
|
||||||
|
|
||||||
|
// Anonymize the struct.
|
||||||
|
_anon: AyaBtfMapMarker,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub struct SockMap<const M: usize, const F: usize = 0>(UnsafeCell<SockMapDef<M, F>>);
|
||||||
|
|
||||||
|
unsafe impl<const M: usize, const F: usize> Sync for SockMap<M, F> {}
|
||||||
|
|
||||||
|
impl<const M: usize, const F: usize> SockMap<M, F> {
|
||||||
|
pub const fn new() -> Self {
|
||||||
|
Self(UnsafeCell::new(SockMapDef {
|
||||||
|
r#type: &[0i32; BPF_MAP_TYPE_SOCKMAP as usize],
|
||||||
|
key: ptr::null(),
|
||||||
|
value: ptr::null(),
|
||||||
|
max_entries: &[0i32; M],
|
||||||
|
map_flags: &[0i32; F],
|
||||||
|
_anon: AyaBtfMapMarker::new(),
|
||||||
|
}))
|
||||||
|
}
|
||||||
|
|
||||||
|
pub unsafe fn update(
|
||||||
|
&self,
|
||||||
|
mut index: u32,
|
||||||
|
sk_ops: *mut bpf_sock_ops,
|
||||||
|
flags: u64,
|
||||||
|
) -> Result<(), i64> {
|
||||||
|
let ret = bpf_sock_map_update(
|
||||||
|
sk_ops,
|
||||||
|
self.0.get() as *mut _,
|
||||||
|
&mut index as *mut _ as *mut c_void,
|
||||||
|
flags,
|
||||||
|
);
|
||||||
|
if ret == 0 {
|
||||||
|
Ok(())
|
||||||
|
} else {
|
||||||
|
Err(ret)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub unsafe fn redirect_msg(&self, ctx: &SkMsgContext, index: u32, flags: u64) -> i64 {
|
||||||
|
bpf_msg_redirect_map(ctx.as_ptr() as *mut _, self.0.get() as *mut _, index, flags)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub unsafe fn redirect_skb(&self, ctx: &SkBuffContext, index: u32, flags: u64) -> i64 {
|
||||||
|
bpf_sk_redirect_map(ctx.as_ptr() as *mut _, self.0.get() as *mut _, index, flags)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn redirect_sk_lookup(
|
||||||
|
&mut self,
|
||||||
|
ctx: &SkLookupContext,
|
||||||
|
index: u32,
|
||||||
|
flags: u64,
|
||||||
|
) -> Result<(), u32> {
|
||||||
|
unsafe {
|
||||||
|
let sk = bpf_map_lookup_elem(
|
||||||
|
&mut self.0 as *mut _ as *mut _,
|
||||||
|
&index as *const _ as *const c_void,
|
||||||
|
);
|
||||||
|
if sk.is_null() {
|
||||||
|
return Err(1);
|
||||||
|
}
|
||||||
|
let ret = bpf_sk_assign(ctx.as_ptr() as *mut _, sk, flags);
|
||||||
|
bpf_sk_release(sk);
|
||||||
|
(ret == 0).then_some(()).ok_or(1)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,53 @@
|
|||||||
|
use core::{cell::UnsafeCell, mem, ptr};
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
bindings::bpf_map_type::BPF_MAP_TYPE_STACK,
|
||||||
|
btf_maps::AyaBtfMapMarker,
|
||||||
|
helpers::{bpf_map_pop_elem, bpf_map_push_elem},
|
||||||
|
};
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
pub struct StackDef<T, const M: usize, const F: usize = 0> {
|
||||||
|
r#type: *const [i32; BPF_MAP_TYPE_STACK as usize],
|
||||||
|
value: *const T,
|
||||||
|
max_entries: *const [i32; M],
|
||||||
|
|
||||||
|
// Anonymize the struct.
|
||||||
|
_anon: AyaBtfMapMarker,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub struct Stack<T, const M: usize, const F: usize = 0>(UnsafeCell<StackDef<T, M, F>>);
|
||||||
|
|
||||||
|
impl<T, const M: usize, const F: usize> Stack<T, M, F> {
|
||||||
|
pub const fn new() -> Self {
|
||||||
|
Self(UnsafeCell::new(StackDef {
|
||||||
|
r#type: &[0i32; BPF_MAP_TYPE_STACK as usize],
|
||||||
|
value: ptr::null(),
|
||||||
|
max_entries: &[0i32; M],
|
||||||
|
_anon: AyaBtfMapMarker::new(),
|
||||||
|
}))
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn push(&mut self, value: &T, flags: u64) -> Result<(), i64> {
|
||||||
|
let ret = unsafe {
|
||||||
|
bpf_map_push_elem(
|
||||||
|
&mut self.0 as *mut _ as *mut _,
|
||||||
|
value as *const _ as *const _,
|
||||||
|
flags,
|
||||||
|
)
|
||||||
|
};
|
||||||
|
(ret == 0).then_some(()).ok_or(ret)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn pop(&mut self) -> Option<T> {
|
||||||
|
unsafe {
|
||||||
|
let mut value = mem::MaybeUninit::uninit();
|
||||||
|
let ret = bpf_map_pop_elem(
|
||||||
|
&mut self.0 as *mut _ as *mut _,
|
||||||
|
value.as_mut_ptr() as *mut _,
|
||||||
|
);
|
||||||
|
(ret == 0).then_some(value.assume_init())
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,48 @@
|
|||||||
|
use core::{cell::UnsafeCell, mem};
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
bindings::bpf_map_type::BPF_MAP_TYPE_STACK_TRACE, btf_maps::AyaBtfMapMarker,
|
||||||
|
helpers::bpf_get_stackid, EbpfContext,
|
||||||
|
};
|
||||||
|
|
||||||
|
const PERF_MAX_STACK_DEPTH: usize = 127;
|
||||||
|
const VALUE_SIZE: usize = mem::size_of::<u64>() * PERF_MAX_STACK_DEPTH;
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
pub struct StackTraceDef<const M: usize, const F: usize = 0> {
|
||||||
|
r#type: *const [i32; BPF_MAP_TYPE_STACK_TRACE as usize],
|
||||||
|
key_size: *const [i32; mem::size_of::<u32>()],
|
||||||
|
value_size: *const [i32; VALUE_SIZE],
|
||||||
|
max_entries: *const [i32; M],
|
||||||
|
map_flags: *const [i32; F],
|
||||||
|
|
||||||
|
// Anonymize the struct.
|
||||||
|
_anon: AyaBtfMapMarker,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub struct StackTrace<const M: usize, const F: usize = 0>(UnsafeCell<StackTraceDef<M, F>>);
|
||||||
|
|
||||||
|
unsafe impl<const M: usize, const F: usize> Sync for StackTrace<M, F> {}
|
||||||
|
|
||||||
|
impl<const M: usize, const F: usize> StackTrace<M, F> {
|
||||||
|
pub const fn new() -> Self {
|
||||||
|
Self(UnsafeCell::new(StackTraceDef {
|
||||||
|
r#type: &[0i32; BPF_MAP_TYPE_STACK_TRACE as usize],
|
||||||
|
key_size: &[0i32; mem::size_of::<u32>()],
|
||||||
|
value_size: &[0i32; VALUE_SIZE],
|
||||||
|
max_entries: &[0i32; M],
|
||||||
|
map_flags: &[0i32; F],
|
||||||
|
_anon: AyaBtfMapMarker::new(),
|
||||||
|
}))
|
||||||
|
}
|
||||||
|
|
||||||
|
pub unsafe fn get_stackid<C: EbpfContext>(&self, ctx: &C, flags: u64) -> Result<i64, i64> {
|
||||||
|
let ret = bpf_get_stackid(ctx.as_ptr(), self.0.get() as *mut _, flags);
|
||||||
|
if ret < 0 {
|
||||||
|
Err(ret)
|
||||||
|
} else {
|
||||||
|
Ok(ret)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,92 @@
|
|||||||
|
use core::{cell::UnsafeCell, mem};
|
||||||
|
|
||||||
|
use aya_ebpf_bindings::bindings::bpf_cpumap_val;
|
||||||
|
|
||||||
|
use super::try_redirect_map;
|
||||||
|
use crate::bindings::bpf_map_type::BPF_MAP_TYPE_CPUMAP;
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
pub struct CpuMapDef<const M: usize, const F: usize> {
|
||||||
|
r#type: *const [i32; BPF_MAP_TYPE_CPUMAP as usize],
|
||||||
|
key_size: *const [i32; mem::size_of::<u32>()],
|
||||||
|
value_size: *const [i32; mem::size_of::<bpf_cpumap_val>()],
|
||||||
|
max_entries: *const [i32; M],
|
||||||
|
map_flags: *const [i32; F],
|
||||||
|
}
|
||||||
|
|
||||||
|
/// An array of available CPUs.
|
||||||
|
///
|
||||||
|
/// XDP programs can use this map to redirect packets to a target CPU for processing.
|
||||||
|
///
|
||||||
|
/// # Minimum kernel version
|
||||||
|
///
|
||||||
|
/// The minimum kernel version required to use this feature is 4.15.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```rust,no_run
|
||||||
|
/// use aya_ebpf::{bindings::xdp_action, btf_maps::CpuMap, macros::{btf_map, xdp}, programs::XdpContext};
|
||||||
|
///
|
||||||
|
/// #[btf_map]
|
||||||
|
/// static MAP: CpuMap<8> = CpuMap::new();
|
||||||
|
///
|
||||||
|
/// #[xdp]
|
||||||
|
/// fn xdp(_ctx: XdpContext) -> u32 {
|
||||||
|
/// // Redirect to CPU 7 or drop packet if no entry found.
|
||||||
|
/// MAP.redirect(7, xdp_action::XDP_DROP as u64).unwrap_or(xdp_action::XDP_DROP)
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub struct CpuMap<const M: usize, const F: usize = 0>(UnsafeCell<CpuMapDef<M, F>>);
|
||||||
|
|
||||||
|
unsafe impl<const M: usize, const F: usize> Sync for CpuMap<M, F> {}
|
||||||
|
|
||||||
|
impl<const M: usize, const F: usize> CpuMap<M, F> {
|
||||||
|
/// Creates a [`CpuMap`] with a set maximum number of elements.
|
||||||
|
///
|
||||||
|
/// In a CPU map, an entry represents a CPU core. Thus there should be as many entries as there
|
||||||
|
/// are CPU cores on the system. `max_entries` can be set to zero here, and updated by userspace
|
||||||
|
/// at runtime. Refer to the userspace documentation for more information.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```rust,no_run
|
||||||
|
/// use aya_ebpf::{macros::btf_map, btf_maps::CpuMap};
|
||||||
|
///
|
||||||
|
/// #[btf_map]
|
||||||
|
/// static MAP: CpuMap<8, 0> = CpuMap::new();
|
||||||
|
/// ```
|
||||||
|
pub const fn new() -> Self {
|
||||||
|
Self(UnsafeCell::new(CpuMapDef {
|
||||||
|
r#type: &[0i32; BPF_MAP_TYPE_CPUMAP as usize],
|
||||||
|
key_size: &[0i32; mem::size_of::<u32>()],
|
||||||
|
value_size: &[0i32; mem::size_of::<bpf_cpumap_val>()],
|
||||||
|
max_entries: &[0i32; M],
|
||||||
|
map_flags: &[0i32; F],
|
||||||
|
}))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Redirects the current packet on the CPU at `index`.
|
||||||
|
///
|
||||||
|
/// The lower two bits of `flags` are used for the return code if the map lookup fails, which
|
||||||
|
/// can be used as the XDP program's return code if a CPU cannot be found.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```rust,no_run
|
||||||
|
/// use aya_ebpf::{bindings::xdp_action, btf_maps::CpuMap, macros::{btf_map, xdp}, programs::XdpContext};
|
||||||
|
///
|
||||||
|
/// #[btf_map]
|
||||||
|
/// static MAP: CpuMap<8> = CpuMap::new();
|
||||||
|
///
|
||||||
|
/// #[xdp]
|
||||||
|
/// fn xdp(_ctx: XdpContext) -> u32 {
|
||||||
|
/// // Redirect to CPU 7 or drop packet if no entry found.
|
||||||
|
/// MAP.redirect(7, 0).unwrap_or(xdp_action::XDP_DROP)
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
#[inline(always)]
|
||||||
|
pub fn redirect(&self, index: u32, flags: u64) -> Result<u32, u32> {
|
||||||
|
try_redirect_map(&self.0, index, flags)
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,138 @@
|
|||||||
|
use core::{cell::UnsafeCell, mem, num::NonZeroU32, ptr::NonNull};
|
||||||
|
|
||||||
|
use aya_ebpf_bindings::bindings::bpf_devmap_val;
|
||||||
|
use aya_ebpf_cty::c_void;
|
||||||
|
|
||||||
|
use super::try_redirect_map;
|
||||||
|
use crate::{
|
||||||
|
bindings::bpf_map_type::BPF_MAP_TYPE_DEVMAP, btf_maps::AyaBtfMapMarker,
|
||||||
|
helpers::bpf_map_lookup_elem,
|
||||||
|
};
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
pub struct DevMapDef<const M: usize, const F: usize> {
|
||||||
|
r#type: *const [i32; BPF_MAP_TYPE_DEVMAP as usize],
|
||||||
|
key_size: *const [i32; mem::size_of::<u32>()],
|
||||||
|
value_size: *const [i32; mem::size_of::<bpf_devmap_val>()],
|
||||||
|
max_entries: *const [i32; M],
|
||||||
|
map_flags: *const [i32; F],
|
||||||
|
|
||||||
|
// Anonymize the struct.
|
||||||
|
_anon: AyaBtfMapMarker,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// An array of network devices.
|
||||||
|
///
|
||||||
|
/// XDP programs can use this map to redirect packets to other network deviecs.
|
||||||
|
///
|
||||||
|
/// # Minimum kernel version
|
||||||
|
///
|
||||||
|
/// The minimum kernel version required to use this feature is 4.14.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```rust,no_run
|
||||||
|
/// use aya_ebpf::{
|
||||||
|
/// bindings::xdp_action,
|
||||||
|
/// btf_maps::DevMap,
|
||||||
|
/// macros::{btf_map, xdp},
|
||||||
|
/// programs::XdpContext,
|
||||||
|
/// };
|
||||||
|
///
|
||||||
|
/// #[btf_map]
|
||||||
|
/// static MAP: DevMap<1> = DevMap::new();
|
||||||
|
///
|
||||||
|
/// #[xdp]
|
||||||
|
/// fn xdp(_ctx: XdpContext) -> u32 {
|
||||||
|
/// MAP.redirect(0, xdp_action::XDP_PASS as u64).unwrap_or(xdp_action::XDP_DROP)
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub struct DevMap<const M: usize, const F: usize = 0>(UnsafeCell<DevMapDef<M, F>>);
|
||||||
|
|
||||||
|
unsafe impl<const M: usize, const F: usize> Sync for DevMap<M, F> {}
|
||||||
|
|
||||||
|
impl<const M: usize, const F: usize> DevMap<M, F> {
|
||||||
|
/// Creates a [`DevMap`] with a set maximum number of elements.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```rust,no_run
|
||||||
|
/// use aya_ebpf::{macros::btf_map, btf_maps::DevMap};
|
||||||
|
///
|
||||||
|
/// #[btf_map]
|
||||||
|
/// static MAP: DevMap<8> = DevMap::new();
|
||||||
|
/// ```
|
||||||
|
pub const fn new() -> Self {
|
||||||
|
Self(UnsafeCell::new(DevMapDef {
|
||||||
|
r#type: &[0; BPF_MAP_TYPE_DEVMAP as usize],
|
||||||
|
key_size: &[0; mem::size_of::<u32>()],
|
||||||
|
value_size: &[0; mem::size_of::<bpf_devmap_val>()],
|
||||||
|
max_entries: &[0; M],
|
||||||
|
map_flags: &[0; F],
|
||||||
|
_anon: AyaBtfMapMarker::new(),
|
||||||
|
}))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Retrieves the interface index at `index` in the array.
|
||||||
|
///
|
||||||
|
/// To actually redirect a packet, see [`DevMap::redirect`].
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```rust,no_run
|
||||||
|
/// use aya_ebpf::{macros::map, maps::DevMap};
|
||||||
|
///
|
||||||
|
/// #[map]
|
||||||
|
/// static MAP: DevMap = DevMap::with_max_entries(1, 0);
|
||||||
|
///
|
||||||
|
/// let target_if_index = MAP.get(0).unwrap().if_index;
|
||||||
|
///
|
||||||
|
/// // redirect to if_index
|
||||||
|
/// ```
|
||||||
|
#[inline(always)]
|
||||||
|
pub fn get(&self, index: u32) -> Option<DevMapValue> {
|
||||||
|
unsafe {
|
||||||
|
let value =
|
||||||
|
bpf_map_lookup_elem(self.0.get() as *mut _, &index as *const _ as *const c_void);
|
||||||
|
NonNull::new(value as *mut bpf_devmap_val).map(|p| DevMapValue {
|
||||||
|
if_index: p.as_ref().ifindex,
|
||||||
|
// SAFETY: map writes use fd, map reads use id.
|
||||||
|
// https://elixir.bootlin.com/linux/v6.2/source/include/uapi/linux/bpf.h#L6136
|
||||||
|
prog_id: NonZeroU32::new(p.as_ref().bpf_prog.id),
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Redirects the current packet on the interface at `index`.
|
||||||
|
///
|
||||||
|
/// The lower two bits of `flags` are used for the return code if the map lookup fails, which
|
||||||
|
/// can be used as the XDP program's return code if a CPU cannot be found.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```rust,no_run
|
||||||
|
/// use aya_ebpf::{bindings::xdp_action, macros::{map, xdp}, maps::DevMap, programs::XdpContext};
|
||||||
|
///
|
||||||
|
/// #[map]
|
||||||
|
/// static MAP: DevMap = DevMap::with_max_entries(8, 0);
|
||||||
|
///
|
||||||
|
/// #[xdp]
|
||||||
|
/// fn xdp(_ctx: XdpContext) -> u32 {
|
||||||
|
/// MAP.redirect(7, 0).unwrap_or(xdp_action::XDP_DROP)
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
#[inline(always)]
|
||||||
|
pub fn redirect(&self, index: u32, flags: u64) -> Result<u32, u32> {
|
||||||
|
try_redirect_map(&self.0, index, flags)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Clone, Copy)]
|
||||||
|
/// The value of a device map.
|
||||||
|
pub struct DevMapValue {
|
||||||
|
/// Target interface index to redirect to.
|
||||||
|
pub if_index: u32,
|
||||||
|
/// Chained XDP program ID.
|
||||||
|
pub prog_id: Option<NonZeroU32>,
|
||||||
|
}
|
||||||
@ -0,0 +1,119 @@
|
|||||||
|
use core::{cell::UnsafeCell, mem, num::NonZeroU32, ptr::NonNull};
|
||||||
|
|
||||||
|
use aya_ebpf_bindings::bindings::bpf_devmap_val;
|
||||||
|
use aya_ebpf_cty::c_void;
|
||||||
|
|
||||||
|
use super::{dev_map::DevMapValue, try_redirect_map};
|
||||||
|
use crate::{bindings::bpf_map_type::BPF_MAP_TYPE_DEVMAP_HASH, helpers::bpf_map_lookup_elem};
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
pub struct DevMapHashDef<const M: usize, const F: usize> {
|
||||||
|
r#type: *const [i32; BPF_MAP_TYPE_DEVMAP_HASH as usize],
|
||||||
|
key_size: *const [i32; mem::size_of::<u32>()],
|
||||||
|
value_size: *const [i32; mem::size_of::<bpf_devmap_val>()],
|
||||||
|
max_entries: *const [i32; M],
|
||||||
|
map_flags: *const [i32; F],
|
||||||
|
}
|
||||||
|
|
||||||
|
/// A map of network devices.
|
||||||
|
///
|
||||||
|
/// XDP programs can use this map to redirect packets to other network devices. It is similar to
|
||||||
|
/// [`DevMap`](super::DevMap), but is an hash map rather than an array. Keys do not need to be
|
||||||
|
/// contiguous nor start at zero, but there is a hashing cost to every lookup.
|
||||||
|
///
|
||||||
|
/// # Minimum kernel version
|
||||||
|
///
|
||||||
|
/// The minimum kernel version required to use this feature is 5.4.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```rust,no_run
|
||||||
|
/// use aya_ebpf::{bindings::xdp_action, btf_maps::DevMapHash, macros::{btf_map, xdp}, programs::XdpContext};
|
||||||
|
///
|
||||||
|
/// #[btf_map]
|
||||||
|
/// static MAP: DevMapHash<1> = DevMapHash::new();
|
||||||
|
///
|
||||||
|
/// #[xdp]
|
||||||
|
/// fn xdp(_ctx: XdpContext) -> u32 {
|
||||||
|
/// MAP.redirect(42, xdp_action::XDP_PASS as u64).unwrap_or(xdp_action::XDP_DROP)
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub struct DevMapHash<const M: usize, const F: usize = 0>(UnsafeCell<DevMapHashDef<M, F>>);
|
||||||
|
|
||||||
|
unsafe impl<const M: usize, const F: usize> Sync for DevMapHash<M, F> {}
|
||||||
|
|
||||||
|
impl<const M: usize, const F: usize> DevMapHash<M, F> {
|
||||||
|
/// Creates a [`DevMapHash`] with a set maximum number of elements.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```rust,no_run
|
||||||
|
/// use aya_ebpf::{btf_maps::DevMapHash, macros::btf_map};
|
||||||
|
///
|
||||||
|
/// #[btf_map]
|
||||||
|
/// static MAP: DevMapHash<8> = DevMapHash::new();
|
||||||
|
/// ```
|
||||||
|
pub const fn new() -> Self {
|
||||||
|
Self(UnsafeCell::new(DevMapHashDef {
|
||||||
|
r#type: &[0; BPF_MAP_TYPE_DEVMAP_HASH as usize],
|
||||||
|
key_size: &[0; mem::size_of::<u32>()],
|
||||||
|
value_size: &[0; mem::size_of::<bpf_devmap_val>()],
|
||||||
|
max_entries: &[0; M],
|
||||||
|
map_flags: &[0; F],
|
||||||
|
}))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Retrieves the interface index with `key` in the map.
|
||||||
|
///
|
||||||
|
/// To actually redirect a packet, see [`DevMapHash::redirect`].
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```rust,no_run
|
||||||
|
/// use aya_ebpf::{btf_maps::DevMapHash, macros::btf_map};
|
||||||
|
///
|
||||||
|
/// #[btf_map]
|
||||||
|
/// static MAP: DevMapHash<1> = DevMapHash::new();
|
||||||
|
///
|
||||||
|
/// let target_if_index = MAP.get(42).unwrap().if_index;
|
||||||
|
///
|
||||||
|
/// // redirect to ifindex
|
||||||
|
/// ```
|
||||||
|
#[inline(always)]
|
||||||
|
pub fn get(&self, key: u32) -> Option<DevMapValue> {
|
||||||
|
unsafe {
|
||||||
|
let value =
|
||||||
|
bpf_map_lookup_elem(self.0.get() as *mut _, &key as *const _ as *const c_void);
|
||||||
|
NonNull::new(value as *mut bpf_devmap_val).map(|p| DevMapValue {
|
||||||
|
if_index: p.as_ref().ifindex,
|
||||||
|
// SAFETY: map writes use fd, map reads use id.
|
||||||
|
// https://elixir.bootlin.com/linux/v6.2/source/include/uapi/linux/bpf.h#L6136
|
||||||
|
prog_id: NonZeroU32::new(p.as_ref().bpf_prog.id),
|
||||||
|
})
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Redirects the current packet on the interface at `key`.
|
||||||
|
///
|
||||||
|
/// The lower two bits of `flags` are used for the return code if the map lookup fails, which
|
||||||
|
/// can be used as the XDP program's return code if a CPU cannot be found.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```rust,no_run
|
||||||
|
/// use aya_ebpf::{bindings::xdp_action, btf_maps::DevMapHash, macros::{btf_map, xdp}, programs::XdpContext};
|
||||||
|
///
|
||||||
|
/// #[btf_map]
|
||||||
|
/// static MAP: DevMapHash<8> = DevMapHash::new();
|
||||||
|
///
|
||||||
|
/// #[xdp]
|
||||||
|
/// fn xdp(_ctx: XdpContext) -> u32 {
|
||||||
|
/// MAP.redirect(7, 0).unwrap_or(xdp_action::XDP_DROP)
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
#[inline(always)]
|
||||||
|
pub fn redirect(&self, key: u32, flags: u64) -> Result<u32, u32> {
|
||||||
|
try_redirect_map(&self.0, key, flags)
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,30 @@
|
|||||||
|
mod cpu_map;
|
||||||
|
mod dev_map;
|
||||||
|
mod dev_map_hash;
|
||||||
|
mod xsk_map;
|
||||||
|
|
||||||
|
use core::cell::UnsafeCell;
|
||||||
|
|
||||||
|
use aya_ebpf_bindings::{bindings::xdp_action::XDP_REDIRECT, helpers::bpf_redirect_map};
|
||||||
|
pub use cpu_map::CpuMap;
|
||||||
|
pub use dev_map::DevMap;
|
||||||
|
pub use dev_map_hash::DevMapHash;
|
||||||
|
pub use xsk_map::XskMap;
|
||||||
|
|
||||||
|
/// Wrapper aroung the `bpf_redirect_map` function.
|
||||||
|
///
|
||||||
|
/// # Return value
|
||||||
|
///
|
||||||
|
/// - `Ok(XDP_REDIRECT)` on success.
|
||||||
|
/// - `Err(_)` of the lowest two bits of `flags` on failure.
|
||||||
|
#[inline(always)]
|
||||||
|
fn try_redirect_map<T>(def: &UnsafeCell<T>, key: u32, flags: u64) -> Result<u32, u32> {
|
||||||
|
// Return XDP_REDIRECT on success, or the value of the two lower bits of the flags argument on
|
||||||
|
// error. Thus I have no idea why it returns a long (i64) instead of something saner, hence the
|
||||||
|
// unsigned_abs.
|
||||||
|
let ret = unsafe { bpf_redirect_map(def.get() as *mut _, key.into(), flags) };
|
||||||
|
match ret.unsigned_abs() as u32 {
|
||||||
|
XDP_REDIRECT => Ok(XDP_REDIRECT),
|
||||||
|
ret => Err(ret),
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,142 @@
|
|||||||
|
use core::{cell::UnsafeCell, mem, ptr::NonNull};
|
||||||
|
|
||||||
|
use aya_ebpf_bindings::bindings::bpf_xdp_sock;
|
||||||
|
use aya_ebpf_cty::c_void;
|
||||||
|
|
||||||
|
use crate::{
|
||||||
|
bindings::bpf_map_type::BPF_MAP_TYPE_XSKMAP,
|
||||||
|
btf_maps::{xdp::try_redirect_map, AyaBtfMapMarker},
|
||||||
|
helpers::bpf_map_lookup_elem,
|
||||||
|
};
|
||||||
|
|
||||||
|
#[allow(dead_code)]
|
||||||
|
pub struct XskMapDef<const M: usize, const F: usize> {
|
||||||
|
r#type: *const [i32; BPF_MAP_TYPE_XSKMAP as usize],
|
||||||
|
key_size: *const [i32; mem::size_of::<u32>()],
|
||||||
|
value_size: *const [i32; mem::size_of::<u32>()],
|
||||||
|
max_entries: *const [i32; M],
|
||||||
|
map_flags: *const [i32; F],
|
||||||
|
|
||||||
|
// Anonymize the struct.
|
||||||
|
_anon: AyaBtfMapMarker,
|
||||||
|
}
|
||||||
|
|
||||||
|
/// An array of AF_XDP sockets.
|
||||||
|
///
|
||||||
|
/// XDP programs can use this map to redirect packets to a target AF_XDP socket using the
|
||||||
|
/// `XDP_REDIRECT` action.
|
||||||
|
///
|
||||||
|
/// # Minimum kernel version
|
||||||
|
///
|
||||||
|
/// The minimum kernel version required to use this feature is 4.18.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```rust,no_run
|
||||||
|
/// use aya_ebpf::{bindings::xdp_action, btf_maps::XskMap, macros::{btf_map, xdp}, programs::XdpContext};
|
||||||
|
///
|
||||||
|
/// #[btf_map]
|
||||||
|
/// static SOCKS: XskMap<8> = XskMap::new();
|
||||||
|
///
|
||||||
|
/// #[xdp]
|
||||||
|
/// fn xdp(ctx: XdpContext) -> u32 {
|
||||||
|
/// let queue_id = unsafe { (*ctx.ctx).rx_queue_index };
|
||||||
|
/// SOCKS.redirect(queue_id, xdp_action::XDP_DROP as u64).unwrap_or(xdp_action::XDP_DROP)
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
///
|
||||||
|
/// # Queue management
|
||||||
|
///
|
||||||
|
/// Packets received on a RX queue can only be redirected to sockets bound on the same queue. Most
|
||||||
|
/// hardware NICs have multiple RX queue to spread the load across multiple CPU cores using RSS.
|
||||||
|
///
|
||||||
|
/// Three strategies are possible:
|
||||||
|
///
|
||||||
|
/// - Reduce the RX queue count to a single one. This option is great for development, but is
|
||||||
|
/// detrimental for performance as the single CPU core recieving packets will get overwhelmed.
|
||||||
|
/// Setting the queue count for a NIC can be achieved using `ethtool -L <ifname> combined 1`.
|
||||||
|
/// - Create a socket for every RX queue. Most modern NICs will have an RX queue per CPU thread, so
|
||||||
|
/// a socket per CPU thread is best for performance. To dynamically size the map depending on the
|
||||||
|
/// recieve queue count, see the userspace documentation of `CpuMap`.
|
||||||
|
/// - Create a single socket and use a [`CpuMap`](super::CpuMap) to redirect the packet to the
|
||||||
|
/// correct CPU core. This way, the packet is sent to another CPU, and a chained XDP program can
|
||||||
|
/// the redirect to the AF_XDP socket. Using a single socket simplifies the userspace code but
|
||||||
|
/// will not perform great unless not a lot of traffic is redirected to the socket. Regular
|
||||||
|
/// traffic however will not be impacted, contrary to reducing the queue count.
|
||||||
|
#[repr(transparent)]
|
||||||
|
pub struct XskMap<const M: usize, const F: usize = 0>(UnsafeCell<XskMapDef<M, F>>);
|
||||||
|
|
||||||
|
unsafe impl<const M: usize, const F: usize> Sync for XskMap<M, F> {}
|
||||||
|
|
||||||
|
impl<const M: usize, const F: usize> XskMap<M, F> {
|
||||||
|
/// Creates a [`XskMap`] with a set maximum number of elements.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```rust,no_run
|
||||||
|
/// use aya_ebpf::{btf_maps::XskMap, macros::btf_map};
|
||||||
|
///
|
||||||
|
/// #[btf_map]
|
||||||
|
/// static SOCKS: XskMap<8> = XskMap::new();
|
||||||
|
/// ```
|
||||||
|
pub const fn new() -> Self {
|
||||||
|
Self(UnsafeCell::new(XskMapDef {
|
||||||
|
r#type: &[0; BPF_MAP_TYPE_XSKMAP as usize],
|
||||||
|
key_size: &[0; mem::size_of::<u32>()],
|
||||||
|
value_size: &[0; mem::size_of::<u32>()],
|
||||||
|
max_entries: &[0; M],
|
||||||
|
map_flags: &[0; F],
|
||||||
|
_anon: AyaBtfMapMarker::new(),
|
||||||
|
}))
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Retrieves the queue to which the socket is bound at `index` in the array.
|
||||||
|
///
|
||||||
|
/// To actually redirect a packet, see [`XskMap::redirect`].
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```rust,no_run
|
||||||
|
/// use aya_ebpf::{macros::map, maps::XskMap};
|
||||||
|
///
|
||||||
|
/// #[map]
|
||||||
|
/// static SOCKS: XskMap = XskMap::with_max_entries(8, 0);
|
||||||
|
///
|
||||||
|
/// let queue_id = SOCKS.get(0);
|
||||||
|
/// ```
|
||||||
|
#[inline(always)]
|
||||||
|
pub fn get(&self, index: u32) -> Option<u32> {
|
||||||
|
unsafe {
|
||||||
|
let value =
|
||||||
|
bpf_map_lookup_elem(self.0.get() as *mut _, &index as *const _ as *const c_void);
|
||||||
|
NonNull::new(value as *mut bpf_xdp_sock).map(|p| p.as_ref().queue_id)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Redirects the current packet to the AF_XDP socket at `index`.
|
||||||
|
///
|
||||||
|
/// The lower two bits of `flags` are used for the return code if the map lookup fails, which
|
||||||
|
/// can be used as the XDP program's return code if a matching socket cannot be found.
|
||||||
|
///
|
||||||
|
/// However, if the socket at `index` is bound to a RX queue which is not the current RX queue,
|
||||||
|
/// the packet will be dropped.
|
||||||
|
///
|
||||||
|
/// # Examples
|
||||||
|
///
|
||||||
|
/// ```rust,no_run
|
||||||
|
/// use aya_ebpf::{bindings::xdp_action, macros::{map, xdp}, maps::XskMap, programs::XdpContext};
|
||||||
|
///
|
||||||
|
/// #[map]
|
||||||
|
/// static SOCKS: XskMap = XskMap::with_max_entries(8, 0);
|
||||||
|
///
|
||||||
|
/// #[xdp]
|
||||||
|
/// fn xdp(ctx: XdpContext) -> u32 {
|
||||||
|
/// let queue_id = unsafe { (*ctx.ctx).rx_queue_index };
|
||||||
|
/// SOCKS.redirect(queue_id, 0).unwrap_or(xdp_action::XDP_DROP)
|
||||||
|
/// }
|
||||||
|
/// ```
|
||||||
|
#[inline(always)]
|
||||||
|
pub fn redirect(&self, index: u32, flags: u64) -> Result<u32, u32> {
|
||||||
|
try_redirect_map(&self.0, index, flags)
|
||||||
|
}
|
||||||
|
}
|
||||||
@ -0,0 +1,5 @@
|
|||||||
|
[target.bpfeb-unknown-none]
|
||||||
|
rustflags = "-C debuginfo=2 -C link-arg=--btf"
|
||||||
|
|
||||||
|
[target.bpfel-unknown-none]
|
||||||
|
rustflags = "-C debuginfo=2 -C link-arg=--btf"
|
||||||
@ -0,0 +1,74 @@
|
|||||||
|
#![no_std]
|
||||||
|
#![no_main]
|
||||||
|
|
||||||
|
use aya_ebpf::{
|
||||||
|
cty::c_long,
|
||||||
|
macros::{map, uprobe},
|
||||||
|
maps::{array::Array, hash_map::HashMap},
|
||||||
|
programs::ProbeContext,
|
||||||
|
};
|
||||||
|
|
||||||
|
#[map]
|
||||||
|
static HASH_MAP: HashMap<u32, u32> = HashMap::with_max_entries(10, 0);
|
||||||
|
|
||||||
|
#[map]
|
||||||
|
static RESULT: Array<u32> = Array::with_max_entries(1, 0);
|
||||||
|
|
||||||
|
#[uprobe]
|
||||||
|
pub fn hash_map_insert(ctx: ProbeContext) {
|
||||||
|
match try_hash_map_insert(ctx) {
|
||||||
|
Ok(_) => {}
|
||||||
|
Err(_) => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn try_hash_map_insert(ctx: ProbeContext) -> Result<(), c_long> {
|
||||||
|
let key: u32 = ctx.arg(0).ok_or(1)?;
|
||||||
|
let value: u32 = ctx.arg(1).ok_or(1)?;
|
||||||
|
|
||||||
|
HASH_MAP.insert(&key, &value, 0)?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[uprobe]
|
||||||
|
pub fn hash_map_get(ctx: ProbeContext) {
|
||||||
|
match try_hash_map_get(ctx) {
|
||||||
|
Ok(_) => {}
|
||||||
|
Err(_) => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn try_hash_map_get(ctx: ProbeContext) -> Result<(), c_long> {
|
||||||
|
// Retrieve the value from the map.
|
||||||
|
let key: u32 = ctx.arg(0).ok_or(1)?;
|
||||||
|
let res = unsafe { HASH_MAP.get(&key).ok_or(1)? };
|
||||||
|
|
||||||
|
// Save it in the array.
|
||||||
|
let ptr = RESULT.get_ptr_mut(0).ok_or(1)?;
|
||||||
|
unsafe { *ptr = *res };
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[uprobe]
|
||||||
|
pub fn hash_map_remove(ctx: ProbeContext) {
|
||||||
|
match try_hash_map_remove(ctx) {
|
||||||
|
Ok(_) => {}
|
||||||
|
Err(_) => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn try_hash_map_remove(ctx: ProbeContext) -> Result<(), c_long> {
|
||||||
|
let key: u32 = ctx.arg(0).ok_or(1)?;
|
||||||
|
|
||||||
|
HASH_MAP.remove(&key)?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(not(test))]
|
||||||
|
#[panic_handler]
|
||||||
|
fn panic(_info: &core::panic::PanicInfo) -> ! {
|
||||||
|
loop {}
|
||||||
|
}
|
||||||
@ -0,0 +1,74 @@
|
|||||||
|
#![no_std]
|
||||||
|
#![no_main]
|
||||||
|
|
||||||
|
use aya_ebpf::{
|
||||||
|
btf_maps::{array::Array, hash_map::HashMap},
|
||||||
|
cty::c_long,
|
||||||
|
macros::{btf_map, uprobe},
|
||||||
|
programs::ProbeContext,
|
||||||
|
};
|
||||||
|
|
||||||
|
#[btf_map]
|
||||||
|
static HASH_MAP: HashMap<u32, u32, 10> = HashMap::new();
|
||||||
|
|
||||||
|
#[btf_map]
|
||||||
|
static RESULT: Array<u32, 1> = Array::new();
|
||||||
|
|
||||||
|
#[uprobe]
|
||||||
|
pub fn hash_map_insert(ctx: ProbeContext) {
|
||||||
|
match try_hash_map_insert(ctx) {
|
||||||
|
Ok(_) => {}
|
||||||
|
Err(_) => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn try_hash_map_insert(ctx: ProbeContext) -> Result<(), c_long> {
|
||||||
|
let key: u32 = ctx.arg(0).ok_or(1)?;
|
||||||
|
let value: u32 = ctx.arg(1).ok_or(1)?;
|
||||||
|
|
||||||
|
HASH_MAP.insert(&key, &value, 0)?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[uprobe]
|
||||||
|
pub fn hash_map_get(ctx: ProbeContext) {
|
||||||
|
match try_hash_map_get(ctx) {
|
||||||
|
Ok(_) => {}
|
||||||
|
Err(_) => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn try_hash_map_get(ctx: ProbeContext) -> Result<(), c_long> {
|
||||||
|
// Retrieve the value from the map.
|
||||||
|
let key: u32 = ctx.arg(0).ok_or(1)?;
|
||||||
|
let res = unsafe { HASH_MAP.get(&key).ok_or(1)? };
|
||||||
|
|
||||||
|
// Save it in the array.
|
||||||
|
let ptr = RESULT.get_ptr_mut(0).ok_or(1)?;
|
||||||
|
unsafe { *ptr = *res };
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[uprobe]
|
||||||
|
pub fn hash_map_remove(ctx: ProbeContext) {
|
||||||
|
match try_hash_map_remove(ctx) {
|
||||||
|
Ok(_) => {}
|
||||||
|
Err(_) => {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn try_hash_map_remove(ctx: ProbeContext) -> Result<(), c_long> {
|
||||||
|
let key: u32 = ctx.arg(0).ok_or(1)?;
|
||||||
|
|
||||||
|
HASH_MAP.remove(&key)?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(not(test))]
|
||||||
|
#[panic_handler]
|
||||||
|
fn panic(_info: &core::panic::PanicInfo) -> ! {
|
||||||
|
loop {}
|
||||||
|
}
|
||||||
@ -0,0 +1,73 @@
|
|||||||
|
#![no_std]
|
||||||
|
#![no_main]
|
||||||
|
|
||||||
|
use aya_ebpf::{
|
||||||
|
bindings::xdp_action,
|
||||||
|
btf_maps::{Array, CpuMap, DevMap, DevMapHash, XskMap},
|
||||||
|
macros::{btf_map, xdp},
|
||||||
|
programs::XdpContext,
|
||||||
|
};
|
||||||
|
|
||||||
|
#[btf_map]
|
||||||
|
static SOCKS: XskMap<1> = XskMap::new();
|
||||||
|
#[btf_map]
|
||||||
|
static DEVS: DevMap<1> = DevMap::new();
|
||||||
|
#[btf_map]
|
||||||
|
static DEVS_HASH: DevMapHash<1> = DevMapHash::new();
|
||||||
|
#[btf_map]
|
||||||
|
static CPUS: CpuMap<1> = CpuMap::new();
|
||||||
|
|
||||||
|
/// Hits of a probe, used to test program chaining through CpuMap/DevMap.
|
||||||
|
/// The first slot counts how many times the "raw" xdp program got executed, while the second slot
|
||||||
|
/// counts how many times the map programs got executed.
|
||||||
|
/// This allows the test harness to assert that a specific step got executed.
|
||||||
|
#[btf_map]
|
||||||
|
static HITS: Array<u32, 2> = Array::new();
|
||||||
|
|
||||||
|
#[xdp]
|
||||||
|
pub fn redirect_sock(_ctx: XdpContext) -> u32 {
|
||||||
|
SOCKS.redirect(0, 0).unwrap_or(xdp_action::XDP_ABORTED)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[xdp]
|
||||||
|
pub fn redirect_dev(_ctx: XdpContext) -> u32 {
|
||||||
|
inc_hit(0);
|
||||||
|
DEVS.redirect(0, 0).unwrap_or(xdp_action::XDP_ABORTED)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[xdp]
|
||||||
|
pub fn redirect_dev_hash(_ctx: XdpContext) -> u32 {
|
||||||
|
inc_hit(0);
|
||||||
|
DEVS_HASH.redirect(10, 0).unwrap_or(xdp_action::XDP_ABORTED)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[xdp]
|
||||||
|
pub fn redirect_cpu(_ctx: XdpContext) -> u32 {
|
||||||
|
inc_hit(0);
|
||||||
|
CPUS.redirect(0, 0).unwrap_or(xdp_action::XDP_ABORTED)
|
||||||
|
}
|
||||||
|
|
||||||
|
#[xdp(map = "cpumap")]
|
||||||
|
pub fn redirect_cpu_chain(_ctx: XdpContext) -> u32 {
|
||||||
|
inc_hit(1);
|
||||||
|
xdp_action::XDP_PASS
|
||||||
|
}
|
||||||
|
|
||||||
|
#[xdp(map = "devmap")]
|
||||||
|
pub fn redirect_dev_chain(_ctx: XdpContext) -> u32 {
|
||||||
|
inc_hit(1);
|
||||||
|
xdp_action::XDP_PASS
|
||||||
|
}
|
||||||
|
|
||||||
|
#[inline(always)]
|
||||||
|
fn inc_hit(index: u32) {
|
||||||
|
if let Some(hit) = HITS.get_ptr_mut(index) {
|
||||||
|
unsafe { *hit += 1 };
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(not(test))]
|
||||||
|
#[panic_handler]
|
||||||
|
fn panic(_info: &core::panic::PanicInfo) -> ! {
|
||||||
|
loop {}
|
||||||
|
}
|
||||||
@ -0,0 +1,59 @@
|
|||||||
|
#![no_std]
|
||||||
|
#![no_main]
|
||||||
|
|
||||||
|
use aya_ebpf::{
|
||||||
|
btf_maps::{PerCpuArray, RingBuf},
|
||||||
|
macros::{btf_map, uprobe},
|
||||||
|
programs::ProbeContext,
|
||||||
|
};
|
||||||
|
|
||||||
|
#[btf_map]
|
||||||
|
static RING_BUF: RingBuf<0> = RingBuf::new();
|
||||||
|
|
||||||
|
// This structure's definition is duplicated in userspace.
|
||||||
|
#[repr(C)]
|
||||||
|
struct Registers {
|
||||||
|
dropped: u64,
|
||||||
|
rejected: u64,
|
||||||
|
}
|
||||||
|
|
||||||
|
// Use a PerCpuArray to store the registers so that we can update the values from multiple CPUs
|
||||||
|
// without needing synchronization. Atomics exist [1], but aren't exposed.
|
||||||
|
//
|
||||||
|
// [1]: https://lwn.net/Articles/838884/
|
||||||
|
#[btf_map]
|
||||||
|
static REGISTERS: PerCpuArray<Registers, 1> = PerCpuArray::new();
|
||||||
|
|
||||||
|
#[uprobe]
|
||||||
|
pub fn ring_buf_test(ctx: ProbeContext) {
|
||||||
|
let Registers { dropped, rejected } = match REGISTERS.get_ptr_mut(0) {
|
||||||
|
Some(regs) => unsafe { &mut *regs },
|
||||||
|
None => return,
|
||||||
|
};
|
||||||
|
let mut entry = match RING_BUF.reserve::<u64>(0) {
|
||||||
|
Some(entry) => entry,
|
||||||
|
None => {
|
||||||
|
*dropped += 1;
|
||||||
|
return;
|
||||||
|
}
|
||||||
|
};
|
||||||
|
// Write the first argument to the function back out to RING_BUF if it is even,
|
||||||
|
// otherwise increment the counter in REJECTED. This exercises discarding data.
|
||||||
|
let arg: u64 = match ctx.arg(0) {
|
||||||
|
Some(arg) => arg,
|
||||||
|
None => return,
|
||||||
|
};
|
||||||
|
if arg % 2 == 0 {
|
||||||
|
entry.write(arg);
|
||||||
|
entry.submit(0);
|
||||||
|
} else {
|
||||||
|
*rejected += 1;
|
||||||
|
entry.discard(0);
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
#[cfg(not(test))]
|
||||||
|
#[panic_handler]
|
||||||
|
fn panic(_info: &core::panic::PanicInfo) -> ! {
|
||||||
|
loop {}
|
||||||
|
}
|
||||||
@ -0,0 +1,82 @@
|
|||||||
|
use aya::{
|
||||||
|
maps::{Array, HashMap, MapError},
|
||||||
|
programs::UProbe,
|
||||||
|
Ebpf,
|
||||||
|
};
|
||||||
|
|
||||||
|
#[no_mangle]
|
||||||
|
#[inline(never)]
|
||||||
|
pub extern "C" fn trigger_hash_map_insert(_key: u32, _value: u32) {
|
||||||
|
core::hint::black_box(trigger_hash_map_insert);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[no_mangle]
|
||||||
|
#[inline(never)]
|
||||||
|
pub extern "C" fn trigger_hash_map_get(_key: u32) {
|
||||||
|
core::hint::black_box(trigger_hash_map_get);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[no_mangle]
|
||||||
|
#[inline(never)]
|
||||||
|
pub extern "C" fn trigger_hash_map_remove(_key: u32) {
|
||||||
|
core::hint::black_box(trigger_hash_map_remove);
|
||||||
|
}
|
||||||
|
|
||||||
|
#[test_case::test_case(crate::MAPS; "legacy maps")]
|
||||||
|
#[test_case::test_case(crate::MAPS_BTF; "BTF maps")]
|
||||||
|
fn test_hash_map(prog: &[u8]) {
|
||||||
|
let mut ebpf = Ebpf::load(prog).unwrap();
|
||||||
|
|
||||||
|
{
|
||||||
|
let insert_prog: &mut UProbe = ebpf
|
||||||
|
.program_mut("hash_map_insert")
|
||||||
|
.unwrap()
|
||||||
|
.try_into()
|
||||||
|
.unwrap();
|
||||||
|
insert_prog.load().unwrap();
|
||||||
|
insert_prog
|
||||||
|
.attach(Some("trigger_hash_map_insert"), 0, "/proc/self/exe", None)
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
trigger_hash_map_insert(69, 420);
|
||||||
|
|
||||||
|
let hash_map: HashMap<_, u32, u32> =
|
||||||
|
HashMap::try_from(ebpf.map_mut("HASH_MAP").unwrap()).unwrap();
|
||||||
|
let value = hash_map.get(&69, 0).unwrap();
|
||||||
|
assert_eq!(value, 420);
|
||||||
|
}
|
||||||
|
{
|
||||||
|
let get_prog: &mut UProbe = ebpf
|
||||||
|
.program_mut("hash_map_get")
|
||||||
|
.unwrap()
|
||||||
|
.try_into()
|
||||||
|
.unwrap();
|
||||||
|
get_prog.load().unwrap();
|
||||||
|
get_prog
|
||||||
|
.attach(Some("trigger_hash_map_get"), 0, "/proc/self/exe", None)
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
trigger_hash_map_get(69);
|
||||||
|
|
||||||
|
let results: Array<_, u32> = Array::try_from(ebpf.map_mut("RESULT").unwrap()).unwrap();
|
||||||
|
let value = results.get(&0, 0).unwrap();
|
||||||
|
assert_eq!(value, 420);
|
||||||
|
}
|
||||||
|
{
|
||||||
|
let remove_prog: &mut UProbe = ebpf
|
||||||
|
.program_mut("hash_map_remove")
|
||||||
|
.unwrap()
|
||||||
|
.try_into()
|
||||||
|
.unwrap();
|
||||||
|
remove_prog.load().unwrap();
|
||||||
|
remove_prog
|
||||||
|
.attach(Some("trigger_hash_map_remove"), 0, "/proc/self/exe", None)
|
||||||
|
.unwrap();
|
||||||
|
|
||||||
|
trigger_hash_map_remove(69);
|
||||||
|
let hash_map: HashMap<_, u32, u32> =
|
||||||
|
HashMap::try_from(ebpf.map_mut("HASH_MAP").unwrap()).unwrap();
|
||||||
|
let res = hash_map.get(&69, 0);
|
||||||
|
assert!(matches!(res.err(), Some(MapError::KeyNotFound)));
|
||||||
|
}
|
||||||
|
}
|
||||||
Loading…
Reference in New Issue