libbpf-rs: Add support for tracepoint opts

Similar to what we did in commit a160b60 ("libbpf-rs: Plumb through
support for USDT options"), this change adds support for providing
additional options when attaching a program to a kernel tracepoint.

Closes: #315
Signed-off-by: Daniel Müller <deso@posteo.net>

Author: d-e-s-o

libbpf-rs/src/lib.rs

@@ -97,7 +97,9 @@ pub use crate::map::{Map, MapFlags, MapType, OpenMap};
 pub use crate::object::{Object, ObjectBuilder, OpenObject};
 pub use crate::perf_buffer::{PerfBuffer, PerfBufferBuilder};
 pub use crate::print::{get_print, set_print, PrintCallback, PrintLevel};
-pub use crate::program::{OpenProgram, Program, ProgramAttachType, ProgramType, UsdtOpts};
+pub use crate::program::{
+    OpenProgram, Program, ProgramAttachType, ProgramType, TracepointOpts, UsdtOpts,
+};
 pub use crate::ringbuf::{RingBuffer, RingBufferBuilder};
 pub use crate::tc::{
     TcAttachPoint, TcHook, TcHookBuilder, TC_CUSTOM, TC_EGRESS, TC_H_CLSACT, TC_H_INGRESS,

libbpf-rs/src/program.rs

@@ -32,6 +32,29 @@ impl From<UsdtOpts> for libbpf_sys::bpf_usdt_opts {
     }
 }
 
+/// Options to optionally be provided when attaching to a tracepoint.
+#[derive(Clone, Debug, Default)]
+pub struct TracepointOpts {
+    /// Custom user-provided value accessible through `bpf_get_attach_cookie`.
+    pub cookie: u64,
+    #[doc(hidden)]
+    pub _non_exhaustive: (),
+}
+
+impl From<TracepointOpts> for libbpf_sys::bpf_tracepoint_opts {
+    fn from(opts: TracepointOpts) -> Self {
+        let TracepointOpts {
+            cookie,
+            _non_exhaustive,
+        } = opts;
+
+        libbpf_sys::bpf_tracepoint_opts {
+            sz: mem::size_of::<Self>() as u64,
+            bpf_cookie: cookie,
+        }
+    }
+}
+
 /// Represents a parsed but not yet loaded BPF program.
 ///
 /// This object exposes operations that need to happen before the program is loaded.
@@ -428,20 +451,33 @@ impl Program {
         }
     }
 
-    /// Attach this program to a [kernel
-    /// tracepoint](https://www.kernel.org/doc/html/latest/trace/tracepoints.html).
-    pub fn attach_tracepoint(
+    fn attach_tracepoint_impl(
         &mut self,
-        tp_category: impl AsRef<str>,
-        tp_name: impl AsRef<str>,
+        tp_category: &str,
+        tp_name: &str,
+        tp_opts: Option<TracepointOpts>,
     ) -> Result<Link> {
-        let tp_category = util::str_to_cstring(tp_category.as_ref())?;
+        let tp_category = util::str_to_cstring(tp_category)?;
         let tp_category_ptr = tp_category.as_ptr();
-        let tp_name = util::str_to_cstring(tp_name.as_ref())?;
+        let tp_name = util::str_to_cstring(tp_name)?;
         let tp_name_ptr = tp_name.as_ptr();
-        let ptr = unsafe {
-            libbpf_sys::bpf_program__attach_tracepoint(self.ptr, tp_category_ptr, tp_name_ptr)
+
+        let ptr = if let Some(tp_opts) = tp_opts {
+            let tp_opts = libbpf_sys::bpf_tracepoint_opts::from(tp_opts);
+            unsafe {
+                libbpf_sys::bpf_program__attach_tracepoint_opts(
+                    self.ptr,
+                    tp_category_ptr,
+                    tp_name_ptr,
+                    &tp_opts as *const _,
+                )
+            }
+        } else {
+            unsafe {
+                libbpf_sys::bpf_program__attach_tracepoint(self.ptr, tp_category_ptr, tp_name_ptr)
+            }
         };
+
         let err = unsafe { libbpf_sys::libbpf_get_error(ptr as *const _) };
         if err != 0 {
             Err(Error::System(err as i32))
@@ -450,6 +486,28 @@ impl Program {
         }
     }
 
+    /// Attach this program to a [kernel
+    /// tracepoint](https://www.kernel.org/doc/html/latest/trace/tracepoints.html).
+    pub fn attach_tracepoint(
+        &mut self,
+        tp_category: impl AsRef<str>,
+        tp_name: impl AsRef<str>,
+    ) -> Result<Link> {
+        self.attach_tracepoint_impl(tp_category.as_ref(), tp_name.as_ref(), None)
+    }
+
+    /// Attach this program to a [kernel
+    /// tracepoint](https://www.kernel.org/doc/html/latest/trace/tracepoints.html),
+    /// providing additional options.
+    pub fn attach_tracepoint_with_opts(
+        &mut self,
+        tp_category: impl AsRef<str>,
+        tp_name: impl AsRef<str>,
+        tp_opts: TracepointOpts,
+    ) -> Result<Link> {
+        self.attach_tracepoint_impl(tp_category.as_ref(), tp_name.as_ref(), Some(tp_opts))
+    }
+
     /// Attach this program to a [raw kernel
     /// tracepoint](https://lwn.net/Articles/748352/).
     pub fn attach_raw_tracepoint<T: AsRef<str>>(&mut self, tp_name: T) -> Result<Link> {

libbpf-rs/tests/bin/src/tracepoint.bpf.c

@@ -23,4 +23,18 @@ int handle__tracepoint(void *ctx)
     return 0;
 }
 
+SEC("tracepoint/syscalls/sys_enter_getpid")
+int handle__tracepoint_with_cookie(void *ctx)
+{
+    int *value;
+
+    value = bpf_ringbuf_reserve(&ringbuf, sizeof(int), 0);
+    if (value) {
+        *value = bpf_get_attach_cookie(ctx);
+        bpf_ringbuf_submit(value, 0);
+    }
+
+    return 0;
+}
+
 char LICENSE[] SEC("license") = "GPL";

libbpf-rs/tests/bin/tracepoint.bpf.o

@@ -14,7 +14,7 @@ use scopeguard::defer;
 
 use libbpf_rs::{
     num_possible_cpus, Iter, Map, MapFlags, MapType, Object, ObjectBuilder, OpenObject,
-    ProgramType, UsdtOpts,
+    ProgramType, TracepointOpts, UsdtOpts,
 };
 
 fn get_test_object_path(filename: &str) -> PathBuf {
@@ -661,14 +661,7 @@ fn test_object_map_create_and_pin() {
     let opts = libbpf_sys::bpf_map_create_opts {
         sz: std::mem::size_of::<libbpf_sys::bpf_map_create_opts>() as libbpf_sys::size_t,
         map_flags: libbpf_sys::BPF_F_NO_PREALLOC,
-        btf_fd: 0,
-        btf_key_type_id: 0,
-        btf_value_type_id: 0,
-        btf_vmlinux_value_type_id: 0,
-        inner_map_fd: 0,
-        map_extra: 0,
-        numa_node: 0,
-        map_ifindex: 0,
+        ..Default::default()
     };
 
     let mut map = Map::create(
@@ -936,3 +929,47 @@ fn test_object_tracepoint() {
 
     unsafe { assert_eq!(V, 1) };
 }
+
+/// Check that we can attach a BPF program to a kernel tracepoint, providing
+/// additional options.
+#[test]
+fn test_object_tracepoint_with_opts() {
+    bump_rlimit_mlock();
+
+    let cookie_val = 42u16;
+    let mut obj = get_test_object("tracepoint.bpf.o");
+    let prog = obj
+        .prog_mut("handle__tracepoint_with_cookie")
+        .expect("Failed to find program");
+
+    let opts = TracepointOpts {
+        cookie: cookie_val.into(),
+        ..TracepointOpts::default()
+    };
+    let _link = prog
+        .attach_tracepoint_with_opts("syscalls", "sys_enter_getpid", opts)
+        .expect("Failed to attach prog");
+
+    let mut builder = libbpf_rs::RingBufferBuilder::new();
+    let map = obj.map("ringbuf").expect("Failed to get ringbuf map");
+
+    static mut V: i32 = 0;
+    fn callback(data: &[u8]) -> i32 {
+        let mut value: i32 = 0;
+        plain::copy_from_bytes(&mut value, data).expect("Wrong size");
+
+        unsafe {
+            V = value;
+        }
+
+        0
+    }
+
+    builder.add(map, callback).expect("Failed to add ringbuf");
+    let mgr = builder.build().expect("Failed to build");
+
+    let _pid = unsafe { libc::getpid() };
+    mgr.consume().expect("Failed to consume ringbuf");
+
+    unsafe { assert_eq!(V, cookie_val.into()) };
+}