RedBPF

https://docs.rs/redbpf/latest/redbpf/
Admin
RedBPF is a Rust API to load and interact with BPF programs, providing idiomatic bindings for...
Tokens:124,759
Snippets:1,286
Trust Score:9.1
Update:5 months ago
Show doc for...
Tokens:
Raw
### Example: Using PerCpuArray in Userspace

Source: https://docs.rs/redbpf/latest/redbpf/struct.PerCpuArray.html

Demonstrates how to load a BPF program, create a PerCpuArray map in userspace, and set per-CPU values. This example assumes the existence of a BPF program with a map named 'biolat'.

```rust
use redbpf::{load::Loader, PerCpuArray, PerCpuValues};
let loaded = Loader::load(b"biolatpcts.elf").expect("error loading BPF program");
let biolat = PerCpuArray::<u64>::new(loaded.map("biolat").expect("arr not found")).expect("error creating Array in userspace");
let mut values = PerCpuValues::new(0);
values[0] = 1;
values[1] = 10;
biolat.set(0, &values);
```

--------------------------------

### Example Usage of Loaded

Source: https://docs.rs/redbpf/latest/redbpf/load/struct.Loaded.html

This example demonstrates how to load a BPF file and process events from the `Loaded` struct.

```APIDOC
## Example
```rust
use std::path::Path;
use futures::stream::StreamExt;
use redbpf::load::Loader;

let mut loader = Loader::load_file(&Path::new("probe.elf")).unwrap();

while let Some((map_name, events)) = loader.events.next().await {
    for event in events {
        // Process event
    }
}
```
```

--------------------------------

### Example: Using ProgramArray to Set a Tail Call Program

Source: https://docs.rs/redbpf/latest/redbpf/struct.ProgramArray.html

Demonstrates how to load an eBPF program and set it in a ProgramArray for tail calls. This involves loading the ELF file, getting the map and program, and then setting the program's file descriptor in the array.

```rust
pub const PROGRAM_PARSE_HTTP: u32 = 0;

use redbpf::{load::Loader, ProgramArray};
let mut loader = Loader::load_file("iotop.elf").expect("error loading probe");
let mut programs = ProgramArray::new(loader.map("program_map").unwrap()).unwrap();

programs.set(
    PROGRAM_PARSE_HTTP,
    loader.program("parse_http").unwrap().fd().unwrap(),
);
```

--------------------------------

### PerCpuValues Example

Source: https://docs.rs/redbpf/latest/redbpf/struct.PerCpuValues.html

Demonstrates basic usage of PerCpuValues, including initialization and element access.

```APIDOC
## Example
```rust
use redbpf::PerCpuValues;
let mut values = PerCpuValues::<u64>::new(0);
values[0] = 1;
```
```

--------------------------------

### StreamExt::cycle Example

Source: https://docs.rs/redbpf/latest/redbpf/load/map_io/struct.PerfMessageStream.html

Repeats a stream endlessly. Requires the stream to be Sized and Clone.

```rust
fn cycle(self) -> Cycle<Self>
where Self: Sized + Clone,
```

--------------------------------

### StreamExt::count Example

Source: https://docs.rs/redbpf/latest/redbpf/load/map_io/struct.PerfMessageStream.html

Drives a stream to completion and counts the number of items it yields. Requires the stream to be Sized.

```rust
fn count(self) -> Count<Self>
where Self: Sized,
```

--------------------------------

### HashMap Methods

Source: https://docs.rs/redbpf/latest/redbpf/struct.HashMap.html

Provides methods for creating, setting, getting, deleting, and iterating over items in a BPF hash map.

```APIDOC
## HashMap Methods

### Description
Provides methods for creating, setting, getting, deleting, and iterating over items in a BPF hash map.

### Methods

#### `new(base: &Map) -> Result<HashMap<'_, K, V>>`
Creates a new HashMap from a base Map.

#### `set(&self, key: K, value: V)`
Sets a value for a given key in the HashMap.

#### `get(&self, key: K) -> Option<V>`
Retrieves the value associated with a given key from the HashMap.

#### `delete(&self, key: K)`
Deletes an item from the HashMap using its key.

#### `iter<'a>(&'a self) -> MapIter<'a, K, V>`
Returns an iterator over all items in the map.
```

--------------------------------

### Load BPF Program Example

Source: https://docs.rs/redbpf/latest/redbpf/enum.Program.html

Demonstrates how to load BPF programs from an ELF file into a redbpf Module. Programs must be loaded before they can be attached to the kernel. Loading will fail if the BPF verifier rejects the code.

```rust
use redbpf::Module;
let mut module = Module::parse(&std::fs::read("file.elf").unwrap()).unwrap();
for program in module.programs.iter_mut() {
    program
        .load(module.version, module.license.clone()).unwrap()
}
```

--------------------------------

### Example: Listen on Port Range with SkLookup

Source: https://docs.rs/redbpf/latest/redbpf/struct.SkLookup.html

Demonstrates how to use SkLookup to listen on a range of ports. This involves binding a TcpListener, loading the BPF program, passing file descriptors and port information to BPF maps, and attaching the sk_lookup program to the network namespace.

```rust
use std::net::TcpListener;
use std::os::unix::io::AsRawFd;

use redbpf::{HashMap, SockMap};
use redbpf::load::Loader;

let mut listener = TcpListener::bind(("127.0.0.1", 12345)).unwrap();
let mut loaded = Loader::load(SK_LOOKUP).unwrap();

// Pass the listener fd to the BPF program
let mut socket = SockMap::new(loaded.map("socket")).unwrap();
socket.set(0, listener.as_raw_fd());

// Pass our port range to the BPF program
let mut ports = HashMap::<u16, u8>::new(loaded.map("ports")).unwrap();
for port in 80..430 {
    ports.set(port, 1);
}

// Attach the BPF program to the current process' network namespace
loaded
    .sk_lookup_mut("range_listener")
    .unwrap()
    .attach_sk_lookup("/proc/self/ns/net")
    .unwrap();

loop {
    let (client, _) = listener.accept().unwrap();
    let addr = client.local_addr().unwrap();
    println!("accepted new connection on `{}`", addr);
}
```

--------------------------------

### StreamExt::next Example

Source: https://docs.rs/redbpf/latest/redbpf/load/map_io/struct.PerfMessageStream.html

Creates a future that resolves to the next item in the stream. Requires the stream to be Unpin.

```rust
fn next(&mut self) -> Next<'_, Self>
where Self: Unpin,
```

--------------------------------

### StreamExt::enumerate Example

Source: https://docs.rs/redbpf/latest/redbpf/load/map_io/struct.PerfMessageStream.html

Creates a stream that yields tuples of the iteration count and the stream's item. Requires the stream to be Sized.

```rust
fn enumerate(self) -> Enumerate<Self>
where Self: Sized,
```

--------------------------------

### Calculating Product of Results

Source: https://docs.rs/redbpf/latest/redbpf/type.Result.html

This example shows how to use the `Product` trait with `Result`. It iterates over a collection of parseable strings, calculating their product. If any string fails to parse, the entire operation returns an `Err`.

```rust
let nums = vec!["5", "10", "1", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert_eq!(total, Ok(100));
let nums = vec!["5", "10", "one", "2"];
let total: Result<usize, _> = nums.iter().map(|w| w.parse::<usize>()).product();
assert!(total.is_err());
```

--------------------------------

### Access Module Programs

Source: https://docs.rs/redbpf/latest/redbpf/struct.Module.html

Provides methods to get immutable or mutable references to programs within the module by name.

```rust
pub fn program(&self, name: &str) -> Option<&Program>
```

```rust
pub fn program_mut(&mut self, name: &str) -> Option<&mut Program>
```

--------------------------------

### PerCpuArray::get

Source: https://docs.rs/redbpf/latest/redbpf/struct.PerCpuArray.html

Gets per-CPU values from the BPF map at a specific index.

```APIDOC
## PerCpuArray::get

### Description
Get per-cpu values from the BPF map at the specified `index`. This method returns `PerCpuValues`. It can return `None` if `index` is out of bounds.

### Signature
```rust
pub fn get(&self, index: u32) -> Option<PerCpuValues<T>>
```

### Parameters
* `index` (*u32*) - The index in the array map to retrieve values from.

### Returns
* `Option<PerCpuValues<T>>` - An Option containing the PerCpuValues if the index is valid, otherwise None.
```

--------------------------------

### Safely get Ok value with into_ok (nightly)

Source: https://docs.rs/redbpf/latest/redbpf/type.Result.html

Uses the nightly-only `into_ok` method to retrieve the Ok value without panicking. This is a maintainability safeguard for Results known to never be Err.

```rust
fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```

--------------------------------

### Get First Element of Option Slice

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/type.__kernel_sighandler_t.html

Shows how the first element of a slice obtained from an Option can be accessed, demonstrating the inverse relationship with as_slice().

```rust
for i in [Some(1234_u16), None] {
    assert_eq!(i.as_ref(), i.as_slice().first());
}

```

--------------------------------

### StreamExt::unzip Example

Source: https://docs.rs/redbpf/latest/redbpf/load/map_io/struct.PerfMessageStream.html

Converts a stream of pairs into a future that resolves to a pair of collections. Requires the stream to be Sized and yield pairs, and the collection types to implement Default and Extend.

```rust
fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB>
where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Stream<Item = (A, B)>,
```

--------------------------------

### Get a Bit Range

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/struct.__BindgenBitfieldUnit.html

Retrieves a value from a range of bits starting at `bit_offset` with the specified `bit_width`. The result is returned as a u64.

```rust
pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64
```

--------------------------------

### StreamExt::then Example

Source: https://docs.rs/redbpf/latest/redbpf/load/map_io/struct.PerfMessageStream.html

Applies an asynchronous closure to each item of the stream, producing new items of a potentially different type. Requires the stream to be Sized.

```rust
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>
where F: FnMut(Self::Item) -> Fut, Fut: Future, Self: Sized,
```

--------------------------------

### Get pointer from __IncompleteArrayField

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/struct.__IncompleteArrayField.html

Provides unsafe methods to get a raw pointer to the beginning of the array data. Use these methods with caution, ensuring the pointer is valid and the length is known.

```rust
pub unsafe fn as_ptr(&self) -> *const T

```

```rust
pub unsafe fn as_mut_ptr(&mut self) -> *mut T

```

--------------------------------

### Loading a BPF File and Processing Events

Source: https://docs.rs/redbpf/latest/redbpf/load/struct.Loaded.html

Demonstrates how to load a BPF program from a file and continuously process events emitted by it. Requires the `futures` crate for stream handling.

```rust
use std::path::Path;
use futures::stream::StreamExt;
use redbpf::load::Loader;
let mut loader = Loader::load_file(&Path::new("probe.elf")).unwrap();
while let Some((map_name, events)) = loader.events.next().await {
    for event in events {
        // ...
    }
}
```

--------------------------------

### PerCpuArray::len

Source: https://docs.rs/redbpf/latest/redbpf/struct.PerCpuArray.html

Gets the length of the array map.

```APIDOC
## PerCpuArray::len

### Description
Get the length of the array map.

### Signature
```rust
pub fn len(&self) -> usize
```

### Returns
* `usize` - The number of elements in the array map.
```

--------------------------------

### Get Uprobe Name

Source: https://docs.rs/redbpf/latest/redbpf/struct.UProbe.html

Retrieves the name of the UProbe. This is a simple getter method.

```rust
pub fn name(&self) -> String
```

--------------------------------

### Load and Attach Kprobes with redbpf

Source: https://docs.rs/redbpf/latest/redbpf/index.html

Loads BPF programs from an ELF file and attaches all defined kprobes. Ensure the ELF file exists and kprobe names are valid.

```rust
use redbpf::load::Loader;

let mut loader = Loader::load_file("iotop.elf").expect("error loading probe");

// attach all the kprobes defined in iotop.elf
for kprobe in loader.kprobes_mut() {
    kprobe
        .attach_kprobe(&kprobe.name(), 0)
        .expect(&format!("error attaching program {}", kprobe.name()));
}
```

--------------------------------

### Create a PerCpuValues instance

Source: https://docs.rs/redbpf/latest/redbpf/struct.PerCpuValues.html

Initializes a PerCpuValues instance with a specified default value for all CPUs. The number of elements is fixed to the number of possible CPUs.

```rust
use redbpf::PerCpuValues;
let mut values = PerCpuValues::<u64>::new(0);
values[0] = 1;
```

--------------------------------

### Load BPF Programs from File

Source: https://docs.rs/redbpf/latest/redbpf/load/struct.Loader.html

Loads BPF programs from a specified file path. This is a convenience wrapper around the `load` method, handling file reading and parsing. The file must contain a valid BPF module.

```rust
pub fn load_file<P: AsRef<Path>>(file: P) -> Result<Loaded, LoaderError>

```

--------------------------------

### take

Source: https://docs.rs/redbpf/latest/redbpf/load/map_io/struct.PerfMessageStream.html

Creates a new stream that yields at most `n` items from the underlying stream.

```APIDOC
## fn take(self, n: usize) -> Take<Self>

### Description
Creates a new stream of at most `n` items of the underlying stream.

### Parameters
- `n` (usize): The maximum number of items to yield.
```

--------------------------------

### Get Length of Array Map - Rust

Source: https://docs.rs/redbpf/latest/redbpf/struct.Array.html

Returns the total number of elements in the array map.

```rust
pub fn len(&self) -> usize
```

--------------------------------

### Clone Implementation for perf_ns_link_info

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/struct.perf_ns_link_info.html

Provides methods for cloning perf_ns_link_info instances. Use clone() to create a copy and clone_from() for in-place assignment.

```rust
fn clone(&self) -> perf_ns_link_info
```

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

--------------------------------

### Implement Any for T

Source: https://docs.rs/redbpf/latest/redbpf/enum.Error.html

Provides the ability to get the TypeId of a type, which is part of the Any trait for dynamic type checking.

```rust
impl<T> Any for T
where T: 'static + ?Sized,
Source
    fn type_id(&self) -> TypeId
```

--------------------------------

### StreamExt::filter Example

Source: https://docs.rs/redbpf/latest/redbpf/load/map_io/struct.PerfMessageStream.html

Filters items from a stream based on an asynchronous predicate. Requires the stream to be Sized.

```rust
fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F>
where F: FnMut(&Self::Item) -> Fut, Fut: Future<Output = bool>, Self: Sized,
```

--------------------------------

### get_possible

Source: https://docs.rs/redbpf/latest/redbpf/cpus/index.html

Retrieves a list of all possible CPU IDs on the system.

```APIDOC
## get_possible

### Description
Returns a list of possible CPU IDs.

### Method
Rust function call

### Endpoint
N/A (Rust function)

### Parameters
None

### Response
- **Vec<CpuId>** - A vector containing the IDs of all possible CPUs.
```

--------------------------------

### CloneToUninit implementation (Nightly)

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/struct.__kernel_fd_set.html

An experimental nightly-only API that performs copy-assignment from `self` to an uninitialized destination pointer.

```rust
unsafe fn clone_to_uninit(&self, dst: *mut u8)
```

--------------------------------

### Sample Struct Blanket Implementations

Source: https://docs.rs/redbpf/latest/redbpf/struct.Sample.html

The Sample struct benefits from blanket implementations for various traits, such as Any, Borrow, BorrowMut, From, Instrument, Into, TryFrom, TryInto, and WithSubscriber, providing common functionalities.

```APIDOC
## Blanket Implementations for Sample

### impl<T> Any for T
#### fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`.

### impl<T> Borrow<T> for T
#### fn borrow(&self) -> &T
Immutably borrows from an owned value.

### impl<T> BorrowMut<T> for T
#### fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value.

### impl<T> From<T> for T
#### fn from(t: T) -> T
Returns the argument unchanged.

### impl<T> Instrument for T
#### fn instrument(self, span: Span) -> Instrumented<Self>
Instruments this type with the provided `Span`.
#### fn in_current_span(self) -> Instrumented<Self>
Instruments this type with the current `Span`.

### impl<T, U> Into<U> for T
#### fn into(self) -> U
Calls `U::from(self)`.

### impl<T, U> TryFrom<U> for T
#### type Error = Infallible
#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.

### impl<T, U> TryInto<U> for T
#### type Error = <U as TryFrom<T>>::Error
#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.

### impl<T> WithSubscriber for T
#### fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
Attaches the provided `Subscriber` to this type.
#### fn with_current_subscriber(self) -> WithDispatch<Self>
Attaches the current default `Subscriber` to this type.
```

--------------------------------

### Get a Single Bit

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/struct.__BindgenBitfieldUnit.html

Retrieves the boolean value of a specific bit at the given index within the bitfield.

```rust
pub fn get_bit(&self, index: usize) -> bool
```

--------------------------------

### PerCpuValues::new

Source: https://docs.rs/redbpf/latest/redbpf/struct.PerCpuValues.html

Creates a new PerCpuValues instance, initializing all elements with a default value.

```APIDOC
## pub fn new(default_value: T) -> Self

### Description
Create a `PerCpuValues<T>` instance. The created instance contains the fixed number of elements filled with `default_value`.

### Parameters
* `default_value` (T) - The value to initialize each element with.
```

--------------------------------

### Iterating over Task Data with TaskIter

Source: https://docs.rs/redbpf/latest/redbpf/struct.TaskIter.html

Use this snippet to iterate over task data obtained from a BPF iterator. Ensure the BPF program and iterator name ('dump_tgid' in this example) are correctly set up.

```rust
use redbpf::load::Loader;
let mut loaded = Loader::load(probe_code()).unwrap();
let tasks = loaded
    .task_iter_mut("dump_tgid")
    .expect("dump_tgid task iterator not found");
for tgid in tasks
    .bpf_iter::<libc::pid_t>()
    .expect("error on Taskiter::bpf_iter")
{
    println!("{}", tgid);
}
```

--------------------------------

### TryFrom and TryInto Implementations

Source: https://docs.rs/redbpf/latest/redbpf/load/map_io/struct.PerfMessageStream.html

Utilities for converting between types using `TryFrom` and `TryInto`.

```APIDOC
### impl<T, U> TryFrom<U> for T

#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

### Description
Performs the conversion from `U` to `T`.

### Method
`try_from`

### Parameters
- `value`: The value to convert.
```

```APIDOC
### impl<T, U> TryInto<U> for T

#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion from `T` to `U`.

### Method
`try_into`
```

--------------------------------

### Get mem_snoopx from perf_mem_data_src__bindgen_ty_1

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/struct.perf_mem_data_src__bindgen_ty_1.html

Retrieves extended snoop information from the perf_mem_data_src__bindgen_ty_1 struct. This provides more detailed snoop-related flags.

```rust
pub fn mem_snoopx(&self) -> __u64
```

--------------------------------

### Access Module Maps

Source: https://docs.rs/redbpf/latest/redbpf/struct.Module.html

Provides methods to get immutable or mutable references to maps within the module by name.

```rust
pub fn map(&self, name: &str) -> Option<&Map>
```

```rust
pub fn map_mut(&mut self, name: &str) -> Option<&mut Map>
```

--------------------------------

### Create a new PerCpuHashMap

Source: https://docs.rs/redbpf/latest/redbpf/struct.PerCpuHashMap.html

Initializes a new PerCpuHashMap instance. Requires a reference to a base Map object.

```rust
pub fn new(base: &Map) -> Result<PerCpuHashMap<'_, K, V>>
```

--------------------------------

### take

Source: https://docs.rs/redbpf/latest/redbpf/struct.BPFIter.html

Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

```APIDOC
## fn take(self, n: usize) -> Take<Self>

### Description
Creates an iterator that yields the first `n` elements, or fewer if the underlying iterator ends sooner.

### Parameters
- **n** (usize) - The maximum number of elements to yield.
```

--------------------------------

### Get Program File Descriptor

Source: https://docs.rs/redbpf/latest/redbpf/struct.ProgramArray.html

Retrieves the file descriptor (fd) of the eBPF program at a specified index in the ProgramArray.

```rust
pub fn get(&self, index: u32) -> Result<RawFd>
```

--------------------------------

### StackTrace::new

Source: https://docs.rs/redbpf/latest/redbpf/struct.StackTrace.html

Constructs a new StackTrace instance from a given BPF map.

```APIDOC
## StackTrace::new

### Description
Constructs a new `StackTrace` instance from a given `Map`.

### Signature
```rust
pub fn new(map: &Map) -> StackTrace<'_>
```

### Parameters
* `map` (*Map) - A reference to the BPF map to be used for the stack trace.
```

--------------------------------

### StreamExt::filter_map Example

Source: https://docs.rs/redbpf/latest/redbpf/load/map_io/struct.PerfMessageStream.html

Filters and maps items from a stream simultaneously using an asynchronous closure. Requires the stream to be Sized.

```rust
fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F>
where F: FnMut(Self::Item) -> Fut, Fut: Future<Output = Option<T>>, Self: Sized,
```

--------------------------------

### Sample Struct Definition

Source: https://docs.rs/redbpf/latest/redbpf/struct.Sample.html

Defines the Sample struct with a size field and a zero-length data array. This structure is marked with `#[repr(C)]` for C-compatible memory layout.

```rust
#[repr(C)]
pub struct Sample {
    pub size: u32,
    pub data: [u8; 0],
    /* private fields */
}

```

--------------------------------

### Unwrap or compute with a closure

Source: https://docs.rs/redbpf/latest/redbpf/type.Result.html

Use `unwrap_or_else` to get the contained `Ok` value or compute it lazily from a closure when an `Err` occurs.

```rust
fn count(x: &str) -> usize { x.len() }

assert_eq!(Ok(2).unwrap_or_else(count), 2);
assert_eq!(Err("foo").unwrap_or_else(count), 3);
```

--------------------------------

### Program::name

Source: https://docs.rs/redbpf/latest/redbpf/enum.Program.html

Returns the name of the BPF program.

```APIDOC
## fn name(&self) -> &str

### Description
Returns the name of the BPF program.

### Returns
- `&str` - The name of the program.
```

--------------------------------

### RelocationInfo::apply

Source: https://docs.rs/redbpf/latest/redbpf/struct.RelocationInfo.html

Applies relocation information to programs, maps, and symbol table entries.

```APIDOC
## RelocationInfo::apply

### Description
Applies relocation information to programs, maps, and symbol table entries.

### Method
`apply`

### Signature
```rust
pub fn apply( &self, programs: &mut RSHashMap<usize, Program>, maps: &RSHashMap<usize, Map>, symtab: &[Sym], ) -> Result<()>
```

### Parameters
- `programs`: A mutable reference to a hash map of programs.
- `maps`: A hash map of maps.
- `symtab`: A slice of symbol table entries.

### Returns
- `Result<()>`: Ok if the relocations were applied successfully, otherwise an error.
```

--------------------------------

### Unwrap or default value

Source: https://docs.rs/redbpf/latest/redbpf/type.Result.html

Use `unwrap_or` to get the contained `Ok` value or a provided default. Arguments are eagerly evaluated.

```rust
let default = 2;
let x: Result<u32, &str> = Ok(9);
assert_eq!(x.unwrap_or(default), 9);

let x: Result<u32, &str> = Err("error");
assert_eq!(x.unwrap_or(default), default);
```

--------------------------------

### Get mem_rsvd from perf_mem_data_src__bindgen_ty_1

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/struct.perf_mem_data_src__bindgen_ty_1.html

Retrieves reserved fields from the perf_mem_data_src__bindgen_ty_1 struct. These fields are typically unused and reserved for future use.

```rust
pub fn mem_rsvd(&self) -> __u64
```

--------------------------------

### New __BindgenBitfieldUnit Instance

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/struct.__BindgenBitfieldUnit.html

Creates a new instance of __BindgenBitfieldUnit, taking ownership of the provided storage.

```rust
pub fn new(storage: Storage) -> Self
```

--------------------------------

### Program::fd

Source: https://docs.rs/redbpf/latest/redbpf/enum.Program.html

Returns the file descriptor of the loaded BPF program, if available.

```APIDOC
## fn fd(&self) -> &Option<RawFd>

### Description
Returns the file descriptor of the loaded BPF program, if available.

### Returns
- `&Option<RawFd>` - An Option containing the raw file descriptor if the program has been loaded, otherwise None.
```

--------------------------------

### Get mem_lvl_num from perf_mem_data_src__bindgen_ty_1

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/struct.perf_mem_data_src__bindgen_ty_1.html

Retrieves the memory level number from the perf_mem_data_src__bindgen_ty_1 struct. This provides a numerical identifier for the memory level.

```rust
pub fn mem_lvl_num(&self) -> __u64
```

--------------------------------

### StreamExt::into_future Example

Source: https://docs.rs/redbpf/latest/redbpf/load/map_io/struct.PerfMessageStream.html

Converts a stream into a future that yields the next item and the rest of the stream. Requires the stream to be Sized and Unpin.

```rust
fn into_future(self) -> StreamFuture<Self>
where Self: Sized + Unpin,
```

--------------------------------

### Clone Implementation for perf_event_mmap_page__bindgen_ty_1

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/union.perf_event_mmap_page__bindgen_ty_1.html

Provides the `clone` and `clone_from` methods for the `perf_event_mmap_page__bindgen_ty_1` union, allowing for the creation of copies of its instances.

```rust
fn clone(&self) -> perf_event_mmap_page__bindgen_ty_1
```

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

--------------------------------

### Convert Option<T> to Slice

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/type.__kernel_sighandler_t.html

Illustrates using as_slice() to get a slice of the contained value, returning an empty slice if the Option is None.

```rust
assert_eq!(
    [Some(1234).as_slice(), None.as_slice()],
    [&[1234][..], &[][..]],
);

```

--------------------------------

### Load BPF Programs from Data

Source: https://docs.rs/redbpf/latest/redbpf/load/struct.Loader.html

Loads BPF programs from a byte slice. This method parses the data into a Module and then loads all programs within it. Ensure the input data is a valid BPF module.

```rust
pub fn load(data: &[u8]) -> Result<Loaded, LoaderError>

```

--------------------------------

### Get mem_remote from perf_mem_data_src__bindgen_ty_1

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/struct.perf_mem_data_src__bindgen_ty_1.html

Retrieves the remote access status from the perf_mem_data_src__bindgen_ty_1 struct. This indicates if the memory access was to a remote memory location.

```rust
pub fn mem_remote(&self) -> __u64
```

--------------------------------

### Get mem_op from perf_mem_data_src__bindgen_ty_1

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/struct.perf_mem_data_src__bindgen_ty_1.html

Retrieves the memory operation type from the perf_mem_data_src__bindgen_ty_1 struct. This is part of the bitfield manipulation for memory access details.

```rust
pub fn mem_op(&self) -> __u64
```

--------------------------------

### Set a Bit Range

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/struct.__BindgenBitfieldUnit.html

Sets a range of bits starting at `bit_offset` with the specified `bit_width` to the given `val`. The value is cast to u64.

```rust
pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64)
```

--------------------------------

### impl<T> Default for Option<T>

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/type.__kernel_sighandler_t.html

Provides a `default` method for `Option<T>`, which returns `None`.

```APIDOC
## impl<T> Default for Option<T>

### Description
Provides a `default` method for `Option<T>`, which returns `None`.

#### fn default() -> Option<T>
Returns `None`.

### Examples
```rust
let opt: Option<u32> = Option::default();
assert!(opt.is_none());
```
```

--------------------------------

### Get Kernel Internal Version

Source: https://docs.rs/redbpf/latest/redbpf/uname/fn.get_kernel_internal_version.html

Call this function to retrieve the internal kernel version. It returns `Some(version)` if successful, or `None` if the version cannot be determined.

```rust
pub fn get_kernel_internal_version() -> Option<u32>
```

--------------------------------

### pub fn zip_with<U, F, R>(self, other: Option<U>, f: F) -> Option<R>

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/type.__kernel_sighandler_t.html

Zips `self` and another `Option` with function `f`. If `self` is `Some(s)` and `other` is `Some(o)`, this method returns `Some(f(s, o))`. Otherwise, `None` is returned. This is a nightly-only experimental API.

```APIDOC
## pub fn zip_with<U, F, R>(self, other: Option<U>, f: F) -> Option<R>

### Description
Zips `self` and another `Option` with function `f`. If `self` is `Some(s)` and `other` is `Some(o)`, this method returns `Some(f(s, o))`. Otherwise, `None` is returned. This is a nightly-only experimental API.

### Method
`zip_with`

### Parameters
* `other` (Option<U>) - The other Option to zip with.
* `f` (F: FnOnce(T, U) -> R) - The function to apply to the contained values if both Options are Some.

### Returns
* `Option<R>` - The result of the function `f` if both Options are Some, otherwise None.

### Examples
```rust
#![feature(option_zip)]

#[derive(Debug, PartialEq)]
struct Point {
    x: f64,
    y: f64,
}

impl Point {
    fn new(x: f64, y: f64) -> Self {
        Self { x, y }
    }
}

let x = Some(17.5);
let y = Some(42.7);

assert_eq!(x.zip_with(y, Point::new), Some(Point { x: 17.5, y: 42.7 }));
assert_eq!(x.zip_with(None, Point::new), None);
```
```

--------------------------------

### Get mem_lock from perf_mem_data_src__bindgen_ty_1

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/struct.perf_mem_data_src__bindgen_ty_1.html

Retrieves the lock status of the memory operation from the perf_mem_data_src__bindgen_ty_1 struct. This indicates if the memory access was part of a locked operation.

```rust
pub fn mem_lock(&self) -> __u64
```

--------------------------------

### Create Map from pinned file

Source: https://docs.rs/redbpf/latest/redbpf/struct.Map.html

Creates a Map instance from a file representing a pinned map. Requires the path to the pinned map file.

```rust
use redbpf::{Array, Map};
let map = Map::from_pin_file("/sys/fs/bpf/persist_map").expect("error on creating map from file");
let array = Array::<u64>::new(&map).expect("error on creating array");
```

--------------------------------

### Get mem_lvl from perf_mem_data_src__bindgen_ty_1

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/struct.perf_mem_data_src__bindgen_ty_1.html

Retrieves the memory level information from the perf_mem_data_src__bindgen_ty_1 struct. This field indicates the level of the memory hierarchy involved in the operation.

```rust
pub fn mem_lvl(&self) -> __u64
```

--------------------------------

### __BindgenBitfieldUnit Methods

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/struct.__BindgenBitfieldUnit.html

This section details the core methods available for interacting with the __BindgenBitfieldUnit struct, allowing for bit-level manipulation.

```APIDOC
## `new(storage: Storage) -> Self`

### Description
Creates a new `__BindgenBitfieldUnit` instance with the provided storage.

### Method
`new`

### Parameters
- **storage** (Storage) - The byte slice to use as storage for the bitfield.
```

```APIDOC
## `get_bit(&self, index: usize) -> bool`

### Description
Retrieves the boolean value of a specific bit at the given index.

### Method
`get_bit`

### Parameters
- **index** (usize) - The index of the bit to retrieve.

### Returns
`bool` - The value of the bit (true if set, false if not).
```

```APIDOC
## `set_bit(&mut self, index: usize, val: bool)`

### Description
Sets the value of a specific bit at the given index.

### Method
`set_bit`

### Parameters
- **index** (usize) - The index of the bit to set.
- **val** (bool) - The boolean value to set the bit to (true or false).
```

```APIDOC
## `get(&self, bit_offset: usize, bit_width: u8) -> u64`

### Description
Retrieves a sequence of bits starting from a given offset with a specified width.

### Method
`get`

### Parameters
- **bit_offset** (usize) - The starting bit offset.
- **bit_width** (u8) - The number of bits to retrieve.

### Returns
`u64` - The value of the specified bit range.
```

```APIDOC
## `set(&mut self, bit_offset: usize, bit_width: u8, val: u64)`

### Description
Sets a sequence of bits starting from a given offset with a specified width to a new value.

### Method
`set`

### Parameters
- **bit_offset** (usize) - The starting bit offset.
- **bit_width** (u8) - The number of bits to set.
- **val** (u64) - The new value to set for the bit range.
```

--------------------------------

### get_online

Source: https://docs.rs/redbpf/latest/redbpf/cpus/fn.get_online.html

Returns a list of online CPU IDs. Error handling is deliberately crashy for invalid kernel data. An error is only reported if `/sys/devices/system/cpu/online` cannot be opened.

```APIDOC
## Function get_online

### Description
Returns a list of online CPU IDs.

Error handling in this function is deliberately crashy. If the kernel returns with invalid data, it’s OK to crash. If the kernel returns with a different data format, it’s OK to crash. If the user is trying to feed us invalid data, it’s OK to crash.
The only time an error is reported is when `/sys/devices/system/cpu/online` can’t be opened.

### Signature
```rust
pub fn get_online() -> Result<Vec<CpuId>, Error>
```
```

--------------------------------

### Bitfield Accessors for perf_event_mmap_page__bindgen_ty_1__bindgen_ty_1

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/struct.perf_event_mmap_page__bindgen_ty_1__bindgen_ty_1.html

Provides methods to get and set individual bits within the `_bitfield_1` field of the performance event mmap page.

```rust
pub fn cap_bit0(&self) -> __u64
```

```rust
pub fn set_cap_bit0(&mut self, val: __u64)
```

```rust
pub fn cap_bit0_is_deprecated(&self) -> __u64
```

```rust
pub fn set_cap_bit0_is_deprecated(&mut self, val: __u64)
```

```rust
pub fn cap_user_rdpmc(&self) -> __u64
```

```rust
pub fn set_cap_user_rdpmc(&mut self, val: __u64)
```

```rust
pub fn cap_user_time(&self) -> __u64
```

```rust
pub fn set_cap_user_time(&mut self, val: __u64)
```

```rust
pub fn cap_user_time_zero(&self) -> __u64
```

```rust
pub fn set_cap_user_time_zero(&mut self, val: __u64)
```

```rust
pub fn cap_____res(&self) -> __u64
```

```rust
pub fn set_cap_____res(&mut self, val: __u64)
```

--------------------------------

### Array Struct

Source: https://docs.rs/redbpf/latest/redbpf/struct.Array.html

The Array struct in redbpf provides userspace access to BPF_MAP_TYPE_ARRAY maps. It allows for getting and setting values at specific indices.

```APIDOC
## Struct Array

This structure is used by userspace programs. For BPF program’s API, see `redbpf_probes::maps::Array`

```rust
pub struct Array<'a, T: Clone> { /* private fields */ }
```

### Example
```rust
use redbpf::{load::Loader, Array};
let loaded = Loader::load(b"biolatpcts.elf").expect("error loading BPF program");
let biolat = Array::<u64>::new(loaded.map("biolat").expect("arr not found")).expect("error creating Array in userspace");
let v = biolat.get(0).unwrap();
```
```

--------------------------------

### PerCpuArray::new

Source: https://docs.rs/redbpf/latest/redbpf/struct.PerCpuArray.html

Creates a new PerCpuArray instance from a base Map.

```APIDOC
## PerCpuArray::new

### Description
Creates a new PerCpuArray instance from a base Map.

### Signature
```rust
pub fn new(base: &Map) -> Result<PerCpuArray<'_, T>>
```

### Parameters
* `base` (*Map*) - The base map to create the PerCpuArray from.

### Returns
* `Result<PerCpuArray<'_, T>>` - A Result containing the PerCpuArray on success, or an error on failure.
```

--------------------------------

### Define PERF_RECORD_ITRACE_START constant

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/constant.perf_event_type_PERF_RECORD_ITRACE_START.html

Defines the PERF_RECORD_ITRACE_START constant for performance event tracing. This value is used to identify instruction trace start events.

```rust
pub const perf_event_type_PERF_RECORD_ITRACE_START: perf_event_type = 12;
```

--------------------------------

### take

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/type.__kernel_sighandler_t.html

Takes the value out of the option, leaving a `None` in its place.

```APIDOC
## pub const fn take(&mut self) -> Option<T>

### Description
Takes the value out of the option, leaving a `None` in its place.

### Returns
- **Option<T>** - The value that was taken from the option.

### Examples
```rust
let mut x = Some(2);
let y = x.take();
assert_eq!(x, None);
assert_eq!(y, Some(2));

let mut x: Option<u32> = None;
let y = x.take();
assert_eq!(x, None);
assert_eq!(y, None);
```
```

--------------------------------

### Loader::load_file

Source: https://docs.rs/redbpf/latest/redbpf/load/struct.Loader.html

Loads BPF programs from a specified file path. This is a convenience method that internally calls `load()` after reading the file content.

```APIDOC
## pub fn load_file<P: AsRef<Path>>(file: P) -> Result<Loaded, LoaderError>

### Description
Loads the BPF programs included in `file`.
See `load()`.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **file** (P: AsRef<Path>) - Required - The path to the file containing BPF program data.

### Request Example
```json
{
  "file": "/path/to/bpf/program.o"
}
```

### Response
#### Success Response (Result<Loaded, LoaderError>)
* **Loaded**: Represents the successfully loaded BPF programs.
* **LoaderError**: Represents an error that occurred during loading.

#### Response Example
```json
{
  "loaded_programs": "..."
}
```
```

--------------------------------

### Unwrap unchecked Err value

Source: https://docs.rs/redbpf/latest/redbpf/type.Result.html

Use `unwrap_err_unchecked` to get the contained `Err` value without checking for `Ok`. Calling on `Ok` is undefined behavior.

```rust
let x: Result<u32, &str> = Ok(2);
unsafe { x.unwrap_err_unchecked() }; // Undefined behavior!
```

```rust
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(unsafe { x.unwrap_err_unchecked() }, "emergency failure");
```

--------------------------------

### BPFIter try_into Method

Source: https://docs.rs/redbpf/latest/redbpf/struct.BPFIter.html

The `try_into` method performs a conversion, returning a `Result` that either contains the converted value or an error.

```APIDOC
#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.
```

--------------------------------

### get_possible_num

Source: https://docs.rs/redbpf/latest/redbpf/cpus/fn.get_possible_num.html

Returns the number of possible CPUs. This value is determined during the system's boot time discovery phase and remains constant.

```APIDOC
## Function get_possible_num

### Description
Returns the number of possible CPUs. The number of possible CPUs is static after it is set during boot time discovery phase.

### Signature
```rust
pub fn get_possible_num() -> usize
```

### Returns
- `usize`: The total number of possible CPUs on the system.
```

--------------------------------

### Unwrap unchecked Ok value

Source: https://docs.rs/redbpf/latest/redbpf/type.Result.html

Use `unwrap_unchecked` to get the contained `Ok` value without checking for `Err`. Calling on `Err` is undefined behavior.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(unsafe { x.unwrap_unchecked() }, 2);
```

```rust
let x: Result<u32, &str> = Err("emergency failure");
unsafe { x.unwrap_unchecked(); } // Undefined behavior!
```

--------------------------------

### Get System Information with uname

Source: https://docs.rs/redbpf/latest/redbpf/uname/fn.uname.html

Call the uname function to retrieve system information. It returns a Result containing the utsname struct on success or an error.

```rust
pub fn uname() -> Result<utsname, ()>
```

--------------------------------

### Clone Implementation for perf_ns_link_info

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/struct.perf_ns_link_info.html

Provides methods for cloning perf_ns_link_info instances.

```APIDOC
### impl Clone for perf_ns_link_info

#### fn clone(&self) -> perf_ns_link_info
Returns a copy of the value.

#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`.
```

--------------------------------

### Get mem_snoop from perf_mem_data_src__bindgen_ty_1

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/struct.perf_mem_data_src__bindgen_ty_1.html

Retrieves the snoop status of the memory operation from the perf_mem_data_src__bindgen_ty_1 struct. This indicates whether the memory access involved cache snooping.

```rust
pub fn mem_snoop(&self) -> __u64
```

--------------------------------

### get_online

Source: https://docs.rs/redbpf/latest/redbpf/cpus/index.html

Retrieves a list of CPU IDs that are currently online.

```APIDOC
## get_online

### Description
Returns a list of online CPU IDs.

### Method
Rust function call

### Endpoint
N/A (Rust function)

### Parameters
None

### Response
- **Vec<CpuId>** - A vector containing the IDs of online CPUs.
```

--------------------------------

### impl<'base, T: Clone> Array<'base, T>

Source: https://docs.rs/redbpf/latest/redbpf/struct.Array.html

Implementations for the Array struct, including methods to create, set, get, and retrieve the length of the array map.

```APIDOC
### impl<'base, T: Clone> Array<'base, T>

#### pub fn new(base: &Map) -> Result<Array<'_, T>>
Create `Array` map from `base`

#### pub fn set(&self, index: u32, value: T) -> Result<()>
Set `value` into this array map at `index`
This method can fail if `index` is out of bound

#### pub fn get(&self, index: u32) -> Option<T>
Get an element at `index` from this array map
This method always returns a `Some(T)` if `index` is valid, but `None` can be returned if `index` is out of bound.

#### pub fn len(&self) -> usize
Get length of this array map.
```

--------------------------------

### Bitfield Constructor for perf_event_mmap_page__bindgen_ty_1__bindgen_ty_1

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/struct.perf_event_mmap_page__bindgen_ty_1__bindgen_ty_1.html

Constructs a new `__BindgenBitfieldUnit` for the `_bitfield_1` field, initializing it with provided values.

```rust
pub fn new_bitfield_1( cap_bit0: __u64, cap_bit0_is_deprecated: __u64, cap_user_rdpmc: __u64, cap_user_time: __u64, cap_user_time_zero: __u64, cap_____res: __u64, ) -> __BindgenBitfieldUnit<[u8; 8], u64>
```

--------------------------------

### Create and Access Array Map - Rust

Source: https://docs.rs/redbpf/latest/redbpf/struct.Array.html

Demonstrates loading a BPF program and accessing an array map named 'biolat' from userspace. Ensure the BPF program contains a map with the specified name.

```rust
use redbpf::{load::Loader, Array};
let loaded = Loader::load(b"biolatpcts.elf").expect("error loading BPF program");
let biolat = Array::<u64>::new(loaded.map("biolat").expect("arr not found")).expect("error creating Array in userspace");
let v = biolat.get(0).unwrap();
```

--------------------------------

### Get Value from Array Map - Rust

Source: https://docs.rs/redbpf/latest/redbpf/struct.Array.html

Retrieves an element from the array map at the specified index. Returns `Some(T)` if the index is valid, and `None` if the index is out of bounds.

```rust
pub fn get(&self, index: u32) -> Option<T>
```

--------------------------------

### Pin Map to BPF FS

Source: https://docs.rs/redbpf/latest/redbpf/struct.Map.html

Pins a map to the BPF filesystem, making it accessible. Requires the path where the map should be pinned.

```rust
use redbpf::Module;
use redbpf::load::Loader;
let mut loaded = Loader::load_file("file.elf").expect("error loading probe");
loaded.map_mut("persist_map").expect("map not found").pin("/sys/fs/bpf/persist_map").expect("error on pinning");
```

--------------------------------

### StreamExt::map Example

Source: https://docs.rs/redbpf/latest/redbpf/load/map_io/struct.PerfMessageStream.html

Maps the items of a stream to a different type using a closure. Returns a new stream of the transformed items. Requires the stream to be Sized.

```rust
fn map<T, F>(self, f: F) -> Map<Self, F>
where F: FnMut(Self::Item) -> T, Self: Sized,
```

--------------------------------

### Get references to Result contents

Source: https://docs.rs/redbpf/latest/redbpf/type.Result.html

Converts `&Result<T, E>` to `Result<&T, &E>`, providing immutable references to the contained values without consuming the original Result.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

--------------------------------

### Clone Implementation for perf_event_attr__bindgen_ty_3

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/union.perf_event_attr__bindgen_ty_3.html

Provides the `clone` and `clone_from` methods for the `perf_event_attr__bindgen_ty_3` union, allowing for the creation of copies.

```rust
impl Clone for perf_event_attr__bindgen_ty_3 {
    fn clone(&self) -> perf_event_attr__bindgen_ty_3
    fn clone_from(&mut self, source: &Self)
}
```

--------------------------------

### Get or Insert with a Closure

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/type.__kernel_sighandler_t.html

Inserts a value computed by a closure if the Option is None, then returns a mutable reference to the contained value. The closure is only called if the Option is None.

```rust
let mut x = None;

{
    let y: &mut u32 = x.get_or_insert_with(|| 5);
    assert_eq!(y, &5);

    *y = 7;
}

assert_eq!(x, Some(7));
```

--------------------------------

### Convert &mut Option<T> to Mutable Slice

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/type.__kernel_sighandler_t.html

Demonstrates using as_mut_slice() to get a mutable slice of the contained value, returning an empty slice if the Option is None.

```rust
assert_eq!(
    [Some(1234).as_mut_slice(), None.as_mut_slice()],
    [&mut [1234][..], &mut [][..]],
);

```

--------------------------------

### Clone Implementation

Source: https://docs.rs/redbpf/latest/redbpf/sys/perf/struct.__BindgenBitfieldUnit.html

Provides a `clone` method for `__BindgenBitfieldUnit` if the `Storage` and `Align` types also implement `Clone`.

```rust
fn clone(&self) -> __BindgenBitfieldUnit<Storage, Align>
```

--------------------------------

### Get Possible CPU IDs

Source: https://docs.rs/redbpf/latest/redbpf/cpus/fn.get_possible.html

Call this function to retrieve a vector of all CPU IDs that the system can utilize. This list is determined during the system's boot process.

```rust
pub fn get_possible() -> Result<Vec<CpuId>, Error>
```
Tokens:
Raw