Bump libbpf-rs dependency to 0.24

Signed-off-by: Daiki Ueno <[email protected]>

Cargo.toml

@@ -24,8 +24,8 @@ crypto-auditing = { version = "=0.2.2", path = "crypto-auditing" }
 futures = "0.3"
 hex = "0.4"
 inotify = "0.10.2"
-libbpf-rs = { version = "0.21", features = ["novendor"] }
-libbpf-cargo = { version = "0.21", features = ["novendor"] }
+libbpf-rs = { version = "0.24.4", default-features = false }
+libbpf-cargo = { version = "0.24.4", default-features = false }
 libc = "0.2"
 nix = "0.26"
 openssl = "0.10"

agent/build.rs

@@ -4,6 +4,7 @@
 use libbpf_cargo::SkeletonBuilder;
 use std::{
     env,
+    ffi::OsStr,
     fs::{self, File},
     path::PathBuf,
     process::Command,
@@ -35,7 +36,7 @@ fn main() {
     let src = srcdir.join("src").join("bpf").join("audit.bpf.c");
     SkeletonBuilder::new()
         .source(&src)
-        .clang_args(&format!("-I{}", builddir.display()))
+        .clang_args([OsStr::new("-I"), builddir.as_os_str()])
         .build_and_generate(&builddir.join("audit.skel.rs"))
         .unwrap();
     println!("cargo:rerun-if-changed={}", src.display());

agent/src/main.rs

@@ -11,6 +11,7 @@ use openssl::{
     symm::{Cipher, Crypter, Mode},
 };
 use std::io::prelude::*;
+use std::mem::MaybeUninit;
 use std::path::Path;
 use tokio::io::AsyncReadExt;
 use tokio::time::{timeout, Duration};
@@ -103,60 +104,53 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     bump_memlock_rlimit()?;
 
     let skel_builder = AuditSkelBuilder::default();
-    let open_skel = skel_builder.open()?;
+    let mut storage = MaybeUninit::uninit();
+    let open_skel = skel_builder.open(&mut storage)?;
     let mut skel = open_skel.load()?;
 
-    let mut progs = skel.progs_mut();
-
     let mut links = Vec::new();
     for library in &config.library {
-        let prog = progs.new_context();
-        if let Ok(link) = prog.attach_usdt(
+        if let Ok(link) = skel.progs.new_context.attach_usdt(
             -1, // any process
             library,
             "crypto_auditing",
             "new_context",
         ) {
             links.push(link);
         }
-        let prog = progs.word_data();
-        if let Ok(link) = prog.attach_usdt(
+        if let Ok(link) = skel.progs.word_data.attach_usdt(
             -1, // any process
             library,
             "crypto_auditing",
             "word_data",
         ) {
             links.push(link);
         }
-        let prog = progs.string_data();
-        if let Ok(link) = prog.attach_usdt(
+        if let Ok(link) = skel.progs.string_data.attach_usdt(
             -1, // any process
             library,
             "crypto_auditing",
             "string_data",
         ) {
             links.push(link);
         }
-        let prog = progs.blob_data();
-        if let Ok(link) = prog.attach_usdt(
+        if let Ok(link) = skel.progs.blob_data.attach_usdt(
             -1, // any process
             library,
             "crypto_auditing",
             "blob_data",
         ) {
             links.push(link);
         }
-        let prog = progs.data();
-        if let Ok(link) = prog.attach_usdt(
+        if let Ok(link) = skel.progs.data.attach_usdt(
             -1, // any process
             library,
             "crypto_auditing",
             "data",
         ) {
             links.push(link);
         }
-        let prog = progs.new_context_with_data();
-        if let Ok(link) = prog.attach_usdt(
+        if let Ok(link) = skel.progs.new_context_with_data.attach_usdt(
             -1, // any process
             library,
             "crypto_auditing",
@@ -171,7 +165,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     rand_bytes(&mut encryption_key)?;
 
     start(async {
-        let mut rb = ringbuf::RingBuffer::new(skel.obj.map_mut("ringbuf").unwrap());
+        let mut rb = ringbuf::RingBuffer::new(&skel.maps.ringbuf);
 
         if let Some((ref user, ref group)) = config.user {
             permissions::run_as(user, group)?;

agent/src/ringbuf.rs

@@ -3,7 +3,7 @@
 // Licensed under LGPL-2.1 or BSD-2-Clause.
 
 use core::task::{Context, Poll};
-use libbpf_rs::{query::MapInfoIter, Map};
+use libbpf_rs::{query::MapInfoIter, Map, MapCore};
 use std::io::Result;
 use std::num::NonZeroUsize;
 use std::os::fd::{AsFd, AsRawFd, RawFd};
@@ -26,7 +26,7 @@ impl RingBuffer {
     pub fn new(map: &Map) -> Self {
         let mut max_entries = 0;
         for m in MapInfoIter::default() {
-            if m.name == map.name() {
+            if m.name.as_bytes() == map.info().unwrap().name().unwrap().as_bytes() {
                 max_entries = m.max_entries;
             }
         }

agent/tests/agenttest/build.rs

@@ -4,6 +4,7 @@
 use libbpf_cargo::SkeletonBuilder;
 use std::{
     env,
+    ffi::OsStr,
     fs::{self, File},
     path::PathBuf,
     process::Command,
@@ -35,7 +36,7 @@ fn main() {
     let src = srcdir.join("src").join("bpf").join("agent.bpf.c");
     SkeletonBuilder::new()
         .source(&src)
-        .clang_args(&format!("-I{}", builddir.display()))
+        .clang_args([OsStr::new("-I"), builddir.as_os_str()])
         .build_and_generate(&builddir.join("agent.skel.rs"))
         .unwrap();
     println!("cargo:rerun-if-changed={}", src.display());

agent/tests/agenttest/src/lib.rs

@@ -4,8 +4,9 @@
 use anyhow::{bail, Result};
 use libbpf_rs::{
     skel::{OpenSkel, SkelBuilder},
-    Link, Map, Object, RingBufferBuilder,
+    Link, Map, OpenObject, RingBufferBuilder,
 };
+use std::mem::MaybeUninit;
 use std::path::Path;
 use std::process::Child;
 use std::time::Duration;
@@ -28,15 +29,19 @@ pub fn bump_memlock_rlimit() -> Result<()> {
     Ok(())
 }
 
-pub fn attach_bpf(process: &Child, path: impl AsRef<Path>) -> Result<(Link, Object)> {
+pub fn attach_bpf<'obj>(
+    process: &'obj Child,
+    path: impl AsRef<Path>,
+    storage: &'obj mut MaybeUninit<OpenObject>,
+) -> Result<(Link, AgentSkel<'obj>)> {
     let skel_builder = AgentSkelBuilder::default();
-    let open_skel = skel_builder.open()?;
-    let mut skel = open_skel.load()?;
 
-    let mut progs = skel.progs_mut();
-    let prog = progs.event_group();
+    let open_skel = skel_builder.open(storage)?;
+    let mut skel = open_skel.load()?;
 
-    let link = prog
+    let link = skel
+        .progs
+        .event_group
         .attach_usdt(
             process.id() as i32,
             path.as_ref(),
@@ -45,7 +50,7 @@ pub fn attach_bpf(process: &Child, path: impl AsRef<Path>) -> Result<(Link, Obje
         )
         .expect("unable to attach prog");
 
-    Ok((link, skel.obj))
+    Ok((link, skel))
 }
 
 // Copied from libbpf-rs/libbpf-rs/tests/test.rs

agent/tests/coalesce.rs

@@ -8,6 +8,7 @@ use crypto_auditing::types::EventGroup;
 use probe::probe;
 use serde_cbor::de::Deserializer;
 use std::env;
+use std::mem::MaybeUninit;
 use std::path::PathBuf;
 use std::process::{Child, Command};
 use std::thread;
@@ -77,14 +78,14 @@ fn test_probe_coalesce() {
     let bar = String::from("bar\0");
     let baz = String::from("baz\0");
 
-    let (_link, object) =
-        attach_bpf(&process.0, &agent_path).expect("unable to attach agent.bpf.o");
-    let map = object.map("ringbuf").expect("unable to get ringbuf map");
+    let mut storage = MaybeUninit::uninit();
+    let (_link, skel) =
+        attach_bpf(&process.0, &agent_path, &mut storage).expect("unable to attach agent.bpf.o");
 
     let timeout = Duration::from_secs(10);
 
     let result = with_ringbuffer(
-        map,
+        &skel.maps.ringbuf,
         || {
             probe!(crypto_auditing, new_context, 1, 2);
             probe!(crypto_auditing, word_data, 1, foo.as_ptr(), 3);
@@ -103,7 +104,7 @@ fn test_probe_coalesce() {
     .expect("unable to exercise probe points");
     assert_eq!(result, 4);
     let result = with_ringbuffer(
-        map,
+        &skel.maps.ringbuf,
         || {
             probe!(crypto_auditing, new_context, 4, 5);
         },

agent/tests/composite.rs

@@ -9,6 +9,7 @@ use libc::{c_long, c_uchar, c_void};
 use probe::probe;
 use serde_cbor::de::Deserializer;
 use std::env;
+use std::mem::MaybeUninit;
 use std::path::PathBuf;
 use std::process::{Child, Command};
 use std::thread;
@@ -100,14 +101,14 @@ fn test_probe_composite() {
         },
     ];
 
-    let (_link, object) =
-        attach_bpf(&process.0, &agent_path).expect("unable to attach agent.bpf.o");
-    let map = object.map("ringbuf").expect("unable to get ringbuf map");
+    let mut storage = MaybeUninit::uninit();
+    let (_link, skel) =
+        attach_bpf(&process.0, &agent_path, &mut storage).expect("unable to attach agent.bpf.o");
 
     let timeout = Duration::from_secs(10);
 
     let result = with_ringbuffer(
-        map,
+        &skel.maps.ringbuf,
         || {
             probe!(crypto_auditing, new_context, 1, 2);
         },
@@ -117,7 +118,7 @@ fn test_probe_composite() {
     assert_eq!(result, 1);
 
     let result = with_ringbuffer(
-        map,
+        &skel.maps.ringbuf,
         || {
             probe!(crypto_auditing, data, 1, events.as_ptr(), events.len());
         },
@@ -127,7 +128,7 @@ fn test_probe_composite() {
     assert_eq!(result, 1);
 
     let result = with_ringbuffer(
-        map,
+        &skel.maps.ringbuf,
         || {
             probe!(crypto_auditing, new_context, 4, 5);
         },

agent/tests/no_coalesce.rs

@@ -8,6 +8,7 @@ use crypto_auditing::types::EventGroup;
 use probe::probe;
 use serde_cbor::de::Deserializer;
 use std::env;
+use std::mem::MaybeUninit;
 use std::path::PathBuf;
 use std::process::{Child, Command};
 use std::thread;
@@ -75,14 +76,14 @@ fn test_probe_no_coalesce() {
     let bar = String::from("bar\0");
     let baz = String::from("baz\0");
 
-    let (_link, object) =
-        attach_bpf(&process.0, &agent_path).expect("unable to attach agent.bpf.o");
-    let map = object.map("ringbuf").expect("unable to get ringbuf map");
+    let mut storage = MaybeUninit::uninit();
+    let (_link, skel) =
+        attach_bpf(&process.0, &agent_path, &mut storage).expect("unable to attach agent.bpf.o");
 
     let timeout = Duration::from_secs(10);
 
     let result = with_ringbuffer(
-        map,
+        &skel.maps.ringbuf,
         || {
             probe!(crypto_auditing, new_context, 1, 2);
         },
@@ -91,7 +92,7 @@ fn test_probe_no_coalesce() {
     .expect("unable to exercise probe points");
     assert_eq!(result, 1);
     let result = with_ringbuffer(
-        map,
+        &skel.maps.ringbuf,
         || {
             probe!(crypto_auditing, word_data, 1, foo.as_ptr(), 3);
         },
@@ -100,7 +101,7 @@ fn test_probe_no_coalesce() {
     .expect("unable to exercise probe points");
     assert_eq!(result, 1);
     let result = with_ringbuffer(
-        map,
+        &skel.maps.ringbuf,
         || {
             probe!(crypto_auditing, string_data, 1, bar.as_ptr(), bar.as_ptr());
         },
@@ -109,7 +110,7 @@ fn test_probe_no_coalesce() {
     .expect("unable to exercise probe points");
     assert_eq!(result, 1);
     let result = with_ringbuffer(
-        map,
+        &skel.maps.ringbuf,
         || {
             probe!(
                 crypto_auditing,
@@ -125,7 +126,7 @@ fn test_probe_no_coalesce() {
     .expect("unable to exercise probe points");
     assert_eq!(result, 1);
     let result = with_ringbuffer(
-        map,
+        &skel.maps.ringbuf,
         || {
             probe!(crypto_auditing, new_context, 4, 5);
         },