query: add kprobe_multi second info call fields

Author: ver-nyan

libbpf-rs/CHANGELOG.md

@@ -1,3 +1,8 @@
+Unreleased
+----------
+- Added `KprobeMultiLinkInfo` fields that required a second info call.
+
+
 0.26.2
 ------
 - Added `ProgramMut::assoc_struct_ops` for associating non-struct_ops programs

libbpf-rs/src/query.rs

@@ -720,6 +720,10 @@ pub struct KprobeMultiLinkInfo {
     pub flags: u32,
     /// Missed probes count.
     pub missed: u64,
+    /// Addresses of the probe.
+    pub addrs: Vec<u64>,
+    /// Cookies corresponding to the attach addresses.
+    pub cookies: Vec<u64>,
 }
 
 /// Information about a multi-uprobe link.
@@ -940,10 +944,27 @@ impl LinkInfo {
                 map_id: unsafe { s.__bindgen_anon_1.struct_ops.map_id },
             }),
             libbpf_sys::BPF_LINK_TYPE_KPROBE_MULTI => {
+                let count = unsafe { s.__bindgen_anon_1.kprobe_multi.count } as usize;
+                let mut addrs = vec![0; count];
+                let mut cookies = vec![0; count];
+
+                s.__bindgen_anon_1.kprobe_multi.addrs = addrs.as_mut_ptr() as u64;
+                s.__bindgen_anon_1.kprobe_multi.cookies = cookies.as_mut_ptr() as u64;
+                let item_ptr: *mut libbpf_sys::bpf_link_info = &mut s;
+                let mut len = size_of_val(&s) as u32;
+                let ret = unsafe {
+                    libbpf_sys::bpf_obj_get_info_by_fd(fd.as_raw_fd(), item_ptr.cast(), &mut len)
+                };
+                if ret != 0 {
+                    return None;
+                }
+
                 LinkTypeInfo::KprobeMulti(KprobeMultiLinkInfo {
                     count: unsafe { s.__bindgen_anon_1.kprobe_multi.count },
                     flags: unsafe { s.__bindgen_anon_1.kprobe_multi.flags },
                     missed: unsafe { s.__bindgen_anon_1.kprobe_multi.missed },
+                    addrs,
+                    cookies,
                 })
             }
             libbpf_sys::BPF_LINK_TYPE_UPROBE_MULTI => {

libbpf-rs/tests/common/mod.rs

@@ -143,3 +143,28 @@ fn check_symbol_offset(elf: &Elf, sym: &sym::Sym) -> Option<usize> {
     }
     None
 }
+
+pub(crate) fn resolve_ksym_addr(sym_name: &str) -> Option<u64> {
+    let kallsyms = fs::read_to_string("/proc/kallsyms").ok()?;
+
+    for line in kallsyms.split('\n') {
+        let mut parts = line.split_whitespace();
+        let Some(addr) = parts.next() else {
+            continue;
+        };
+        if parts.next().is_none() {
+            continue;
+        }
+        let Some(sym) = parts.next() else {
+            continue;
+        };
+
+        if sym_name == sym {
+            return Some(
+                u64::from_str_radix(addr, 16).expect("ksym found but could not resolve addr"),
+            );
+        }
+    }
+
+    None
+}

libbpf-rs/tests/test.rs

@@ -19,6 +19,7 @@ use std::fs;
 use std::hint;
 use std::io;
 use std::io::Read;
+use std::iter::zip;
 use std::mem::size_of;
 use std::mem::size_of_val;
 use std::os::unix::io::AsFd;
@@ -37,6 +38,7 @@ use std::sync::mpsc::channel;
 use std::time::Duration;
 
 use libbpf_rs::num_possible_cpus;
+use libbpf_rs::query::KprobeMultiLinkInfo;
 use libbpf_rs::query::LinkTypeInfo;
 use libbpf_rs::query::PerfEventType;
 use libbpf_rs::query::ProgInfoIter;
@@ -1854,16 +1856,47 @@ fn test_object_kprobe_multi_with_opts() {
     let mut obj = open_obj.load().expect("failed to load object");
     let prog = get_prog_mut(&mut obj, "handle__kprobe");
 
+    let syms_opt = vec![
+        "bpf_fentry_test1".to_string(),
+        "bpf_fentry_test2".to_string(),
+    ];
+    let cookies_opt = vec![6, 7];
     let opts = KprobeMultiOpts {
-        symbols: vec![
-            "bpf_fentry_test1".to_string(),
-            "bpf_fentry_test2".to_string(),
-        ],
+        symbols: syms_opt.clone(),
+        cookies: cookies_opt.clone(),
         ..Default::default()
     };
-    let _link = prog
+
+    let link = prog
         .attach_kprobe_multi_with_opts(opts)
         .expect("failed to attach prog");
+
+    let link_info = link.info().expect("failed to get kprobe_multi link info");
+    let LinkTypeInfo::KprobeMulti(kprobe_multi) = link_info.info else {
+        panic!(
+            "Expected LinkTypeInfo::KprobeMulti for kprobe_multi, got: {:?}",
+            link_info.info
+        );
+    };
+
+    let KprobeMultiLinkInfo {
+        count,
+        addrs,
+        cookies,
+        ..
+    } = kprobe_multi;
+    assert_eq!(count, syms_opt.len() as u32);
+    for (actual, sym) in zip(addrs, syms_opt) {
+        let Some(expected) = common::resolve_ksym_addr(&sym) else {
+            // requires reading `/proc/kallsyms`
+            break;
+        };
+
+        assert_eq!(actual, expected);
+    }
+    for (actual, expected) in zip(cookies, cookies_opt) {
+        assert_eq!(actual, expected);
+    }
 }
 
 /// Check that we can attach a BPF program to a kernel tracepoint.