bpf-loader-lib 0.2.1

A library to load json-described ebpf programs, and automatically poll outputs from the program
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

//!  SPDX-License-Identifier: MIT
//!
//! Copyright (c) 2023, eunomia-bpf
//! All rights reserved.
//!

use serde_json::{json, Value};

use crate::{
    meta::{
        DataSectionMeta, DataSectionVariableMeta, ExportedTypesStructMemberMeta,
        ExportedTypesStructMeta, MapExportConfig, MapMeta, ProgMeta,
    },
    tests::get_assets_dir,
};

use super::ComposedObject;

#[test]
fn test_deserialize_meta() {
    let json_str = std::fs::read_to_string(get_assets_dir().join("bootstrap.json")).unwrap();
    let json_val: Value = serde_json::from_str(&json_str).unwrap();
    let decoded: ComposedObject = serde_json::from_value(json_val).unwrap();
    assert_eq!(decoded.bpf_object.len(), 47496);
    let bpf_skel = &decoded.meta.bpf_skel;
    let data_section = &bpf_skel.data_sections;
    assert_eq!(data_section.len(), 2);
    assert!(data_section.contains(&DataSectionMeta {
        name: ".rodata".into(),
        variables: vec![DataSectionVariableMeta {
            name: "min_duration_ns".into(),
            ty: "unsigned long long".into(),
            value: None,
            others: json!({}),
            cmdarg: Default::default(),
            description: None
        }]
    }));
    assert!(data_section.contains(&DataSectionMeta {
        name: ".bss".into(),
        variables: vec![DataSectionVariableMeta {
            name: "__eunomia_dummy_event_ptr".into(),
            ty: "struct event *".into(),
            value: None,
            others: json!({}),
            cmdarg: Default::default(),
            description: None
        }]
    }));
    let maps = &bpf_skel.maps;
    assert_eq!(maps.len(), 4);
    assert!(maps.contains(&MapMeta {
        ident: "exec_start".into(),
        name: "exec_start".into(),
        mmaped: false,
        sample: None,
        export_config: MapExportConfig::NoExport,
        intepreter: crate::meta::BufferValueInterpreter::DefaultStruct
    }));
    assert!(maps.contains(&MapMeta {
        ident: "rb".into(),
        name: "rb".into(),
        mmaped: false,
        sample: None,
        export_config: MapExportConfig::NoExport,
        intepreter: crate::meta::BufferValueInterpreter::DefaultStruct
    }));
    assert!(maps.contains(&MapMeta {
        ident: "rodata".into(),
        name: "client_b.rodata".into(),
        mmaped: true,
        sample: None,
        export_config: MapExportConfig::NoExport,
        intepreter: crate::meta::BufferValueInterpreter::DefaultStruct
    }));
    assert!(maps.contains(&MapMeta {
        ident: "bss".into(),
        name: "client_b.bss".into(),
        mmaped: true,
        sample: None,
        export_config: MapExportConfig::NoExport,
        intepreter: crate::meta::BufferValueInterpreter::DefaultStruct
    }));
    assert_eq!(bpf_skel.obj_name, "client_bpf");
    let progs = &bpf_skel.progs;
    assert_eq!(progs.len(), 2);
    assert!(progs.contains(&ProgMeta {
        name: "handle_exec".into(),
        link: true,
        attach: "tp/sched/sched_process_exec".into(),
        others: json!({})
    }));
    assert!(progs.contains(&ProgMeta {
        name: "handle_exit".into(),
        link: true,
        attach: "tp/sched/sched_process_exit".into(),
        others: json!({})
    }));
    let export_types = &decoded.meta.export_types;
    assert_eq!(export_types.len(), 1);
    assert!(export_types.contains(&ExportedTypesStructMeta {
        name: "event".into(),
        members: vec![
            ExportedTypesStructMemberMeta {
                name: "pid".into(),
                ty: "int".into()
            },
            ExportedTypesStructMemberMeta {
                name: "ppid".into(),
                ty: "int".into()
            },
            ExportedTypesStructMemberMeta {
                name: "exit_code".into(),
                ty: "unsigned int".into()
            },
            ExportedTypesStructMemberMeta {
                name: "duration_ns".into(),
                ty: "unsigned long long".into()
            },
            ExportedTypesStructMemberMeta {
                name: "comm".into(),
                ty: "char[16]".into()
            },
            ExportedTypesStructMemberMeta {
                name: "filename".into(),
                ty: "char[127]".into()
            },
            ExportedTypesStructMemberMeta {
                name: "exit_event".into(),
                ty: "bool".into()
            },
            ExportedTypesStructMemberMeta {
                name: "et".into(),
                ty: "enum event_type".into()
            },
        ],
        size: 176,
        type_id: 613
    }));
}