bcc 0.0.34

Idiomatic Rust bindings for BPF Compiler Collection (BCC)
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

use crate::core::BPF;
use crate::error::BccError;
use bcc_sys::bccapi::bpf_prog_type_BPF_PROG_TYPE_TRACEPOINT as BPF_PROG_TYPE_TRACEPOINT;

#[derive(Default)]
pub struct Tracepoint {
    handler: Option<String>,
    subsystem: Option<String>,
    tracepoint: Option<String>,
}

impl Tracepoint {
    /// Create a new probe with the defaults. Further initialization is required
    /// before attaching.
    pub fn new() -> Self {
        Default::default()
    }

    /// Specify the name of the probe handler within the BPF code. This is a
    /// required item.
    pub fn handler(mut self, name: &str) -> Self {
        self.handler = Some(name.to_owned());
        self
    }

    /// Specify the name of the tracepoint subsystem. This is a required item.
    pub fn subsystem(mut self, name: &str) -> Self {
        self.subsystem = Some(name.to_owned());
        self
    }

    /// Specify the specific tracepoint for this probe. This is a required item.
    pub fn tracepoint(mut self, name: &str) -> Self {
        self.tracepoint = Some(name.to_owned());
        self
    }

    /// Consumes the probe and attaches it. May return an error if there is a
    /// incomplete or invalid configuration or other error while loading or
    /// attaching the probe.
    pub fn attach(self, bpf: &mut BPF) -> Result<(), BccError> {
        if self.handler.is_none() {
            return Err(BccError::InvalidTracepoint {
                message: "handler is required".to_string(),
            });
        }
        if self.subsystem.is_none() {
            return Err(BccError::InvalidTracepoint {
                message: "subsystem is required".to_string(),
            });
        }
        if self.tracepoint.is_none() {
            return Err(BccError::InvalidTracepoint {
                message: "tracepoint is required".to_string(),
            });
        }
        let handler = self.handler.unwrap();
        let subsystem = self.subsystem.unwrap();
        let tracepoint = self.tracepoint.unwrap();

        let code_fd = bpf.load(&handler, BPF_PROG_TYPE_TRACEPOINT, 0, 0)?;
        let tracepoint = crate::core::Tracepoint::new(&subsystem, &tracepoint, code_fd)?;
        bpf.tracepoints.insert(tracepoint);
        Ok(())
    }
}