Struct oxidebpf::ArrayMap

pub struct ArrayMap {
    pub base: Map,
}

Fields

base: Map

Implementations

impl ArrayMap

pub unsafe fn new(
    map_name: &str,
    value_size: u32,
    max_entries: u32
) -> Result<ArrayMap, OxidebpfError>

Create a new ArrayMap

Calling new will create a new BPF_MAP_TYPE_ARRAY map. It stores some meta data to track it. The array map supports read and write operations to access the members of the map

Safety

The value_size you pass in needs to match exactly with the size of the struct/type used by any other BPF program that might be using this map. Any T you use in subsequent read() and write() calls needs to match exactly (e.g., with #[repr(C)]) with the struct/type used by the BPF program as well. Additionally, std::mem::size_of::<T>() must match the given value_size here exactly. If this conditions are not met, the ArrayMap behavior is undefined.

Examples

use oxidebpf::ArrayMap;
let map: ArrayMap = unsafe {ArrayMap::new(
   "mymap",
   std::mem::size_of::<u64>() as u32,
   1024,
).expect("Failed to create map") };

Trait Implementations

impl Clone for ArrayMap

fn clone(&self) -> ArrayMap

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ArrayMap

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

Formats the value using the given formatter.

impl Display for ArrayMap

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

Formats the value using the given formatter.

impl Drop for ArrayMap

fn drop(&mut self)

Executes the destructor for this type.

impl<T> RWMap<T, u32> for ArrayMap

unsafe fn read(&self, key: c_uint) -> Result<T, OxidebpfError>

Reads an index from a map of type BPF_MAP_TYPE_ARRAY

Initiates a read from key. Read verifies that the map has been initialized. The value returned will be of the same type that was used when the ArrayMap was created

NOTE: This method calls will read a certain amount of memory based on what the size of T is. Make sure that T matches the type of the value (e.g., with #[repr(C)]) that is being used in the map.

Example

use oxidebpf::{ArrayMap, RWMap};

// this is safe because we are reading and writing a u64, and the value_size we
// pass into new() is a u64

unsafe {
    let map: ArrayMap = ArrayMap::new(
       "mymap",
       std::mem::size_of::<u64>() as u32,
       1024,
    ).expect("Failed to create map");
    let _ = map.write(0, 12345u64);
    assert_eq!(
        12345u64,
        unsafe { map.read(0).expect("Failed to read value from map") }
    );
}

unsafe fn write(&self, key: c_uint, value: T) -> Result<(), OxidebpfError>

Writes an index to and index of a map of type BPF_MAP_TYPE_ARRAY

Initiates a write to key of value. The value needs to match the array type that was used when the map was created

NOTE: This method calls will write a certain amount of memory based on what the size of T is. Make sure that T matches the type of the value (e.g., with #[repr(C)]) that is being used in the map.

Example

use oxidebpf::{ArrayMap, RWMap};

// this is safe because we are reading and writing a u64, and the value_size we
// pass into new() is a u64

unsafe {
    let map: ArrayMap = ArrayMap::new(
       "mymap",
       std::mem::size_of::<u64>() as u32,
       1024,
    ).expect("Failed to create map");
    let _ = map.write(0, 12345u64);
    assert_eq!(
        12345u64,
        map.read(0).expect("Failed to read value from map")
    );
}