Struct FailureDumpMap 

#[non_exhaustive]
pub struct FailureDumpMap {

    pub name: String,
    pub map_kva: u64,
    pub map_type: u32,
    pub value_size: u32,
    pub max_entries: u32,
    pub value: Option<RenderedValue>,
    pub entries: Vec<FailureDumpEntry>,
    pub array_entries: Vec<FailureDumpArrayEntry>,
    pub percpu_entries: Vec<FailureDumpPercpuEntry>,
    pub percpu_hash_entries: Vec<FailureDumpPercpuHashEntry>,
    pub arena: Option<ArenaSnapshot>,
    pub ringbuf: Option<FailureDumpRingbuf>,
    pub stack_trace: Option<FailureDumpStackTrace>,
    pub fd_array: Option<FailureDumpFdArray>,
    pub error: Option<String>,
}

Rendering of one BPF map’s contents.

Unifies the map-type rendering paths under a single representation: single-entry ARRAY maps (incl. the .bss/.data/.rodata global sections) populate value; multi-entry ARRAY maps populate array_entries; keyed HASH maps populate entries; per-CPU maps populate percpu_entries. Exactly one of these is non-empty for a successful render; on failure error is set and the rest empty.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

name: String

Map name as registered with the kernel. Truncated to BPF_OBJ_NAME_LEN (16) by the kernel; libbpf composes "<obj_name>.<section>" for global-section maps.

map_kva: u64

Guest-KVA of this map’s struct bpf_map allocation. Unique per loaded map instance — two map copies sharing the same name (e.g. two <obj>.bss maps from two scheduler instances loaded from the same binary post- crate::scenario::ops::Op::ReplaceScheduler) have distinct KVAs and are distinguishable on this field alone.

Sourced from crate::monitor::bpf_map::BpfMapInfo::map_kva at capture time. Within-run stable (the kernel does not relocate struct bpf_map); not comparable across runs (KASLR slide differs).

0 when capture did not record a KVA (e.g., synthetic test fixtures constructed via ..Default::default()); consumers treating 0 as “no kernel identity” gracefully fall back to name-based matching.

map_type: u32

Raw map_type from struct bpf_map (e.g. BPF_MAP_TYPE_ARRAY). Kept as u32 rather than an enum to avoid bumping a serde schema each time the kernel adds a kind.

value_size: u32

Declared per-entry value size. Captured even when rendering fails so the operator can see the map shape.

max_entries: u32

Declared maximum entry count from struct bpf_map.max_entries. Surfaces alongside the rendered slice so a consumer can spot when the dump shows fewer entries than the map declares (e.g. ARRAY / HASH truncated at MAX_ARRAY_KEYS / MAX_HASH_ENTRIES; PERCPU_ARRAY truncated at MAX_PERCPU_KEYS).

value: Option<RenderedValue>

Single-value render for a single-entry ARRAY map (max_entries <= 1, incl. the .bss/.data/.rodata global sections). Multi-entry ARRAY maps use array_entries.

entries: Vec<FailureDumpEntry>

(key, value) entries for HASH maps.

array_entries: Vec<FailureDumpArrayEntry>

Per-entry values for a multi-entry BPF_MAP_TYPE_ARRAY map, indexed by the array key (u32). Populated for max_entries > 1; the single-entry case uses value, so exactly one of value / array_entries is set for an ARRAY render. Capped at MAX_ARRAY_KEYS; truncation and per-key read failures surface in error.

percpu_entries: Vec<FailureDumpPercpuEntry>

Per-CPU slots for PERCPU_ARRAY maps. Outer Vec indexed by key, inner Vec indexed by CPU id.

percpu_hash_entries: Vec<FailureDumpPercpuHashEntry>

Per-key per-CPU slots for PERCPU_HASH / LRU_PERCPU_HASH maps. Same shape as percpu_entries but the outer key is arbitrary bytes (rendered via BTF when a key type id is available, hex otherwise) instead of the implicit u32 key of a per-CPU array.

arena: Option<ArenaSnapshot>

Page snapshot for BPF_MAP_TYPE_ARENA maps. None for all other map types.

ringbuf: Option<FailureDumpRingbuf>

Position counters and capacity for BPF_MAP_TYPE_RINGBUF / BPF_MAP_TYPE_USER_RINGBUF maps. Surfaces stuck-consumer diagnostics — pending bytes far below the watermark plus non-zero pending_pos indicates a producer holding a reservation; pending bytes near capacity indicates a stalled consumer. None for non-ringbuf maps or when the BTF offsets for bpf_ringbuf_map / bpf_ringbuf weren’t resolvable.

stack_trace: Option<FailureDumpStackTrace>

Per-bucket trace summary for BPF_MAP_TYPE_STACK_TRACE maps. None for non-STACK_TRACE maps or when the BTF offsets for bpf_stack_map / stack_map_bucket weren’t resolvable.

fd_array: Option<FailureDumpFdArray>

Populated-slot summary for FD-array families (PROG_ARRAY, PERF_EVENT_ARRAY, CGROUP_ARRAY, ARRAY_OF_MAPS, HASH_OF_MAPS, DEVMAP*, SOCKMAP*, CPUMAP, XSKMAP, REUSEPORT_SOCKARRAY). None for non-FD-array maps.

error: Option<String>

Reason this map’s contents are missing or partial. Empty on successful render.

Trait Implementations

impl Clone for FailureDumpMap

fn clone(&self) -> FailureDumpMap

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for FailureDumpMap

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

Formats the value using the given formatter.

impl Default for FailureDumpMap

fn default() -> FailureDumpMap

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for FailureDumpMap

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for FailureDumpMap

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

Formats the value using the given formatter.

impl Serialize for FailureDumpMap

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.