fixup: heaptrack

Author: not-matthias

Cargo.lock

@@ -37,7 +37,7 @@ libbpf-rs = { version = "0.25.0", features = ["vendored"], optional = true }
 
 [build-dependencies]
 libbpf-cargo = { version = "0.25.0", optional = true }
-vmlinux = { git = "https://github.com/libbpf/vmlinux.h.git", optional = true }
+vmlinux = { git = "https://github.com/libbpf/vmlinux.h.git", rev = "991dd4b8dfd8c9d62ce8999521b24f61d9b7fc52", optional = true }
 bindgen = "0.71"
 
 [dev-dependencies]

crates/heaptrack/Cargo.toml

@@ -5,14 +5,14 @@ use std::{env, path::PathBuf};
 fn build_ebpf() {
     use libbpf_cargo::SkeletonBuilder;
 
-    println!("cargo:rerun-if-changed=src/bpf");
+    println!("cargo:rerun-if-changed=src/ebpf/c");
 
     // Build the BPF program
     let arch = env::var("CARGO_CFG_TARGET_ARCH")
         .expect("CARGO_CFG_TARGET_ARCH must be set in build script");
     let heaptrack_out = PathBuf::from(env::var("OUT_DIR").unwrap()).join("heaptrack.skel.rs");
     SkeletonBuilder::new()
-        .source("src/bpf/heaptrack.bpf.c")
+        .source("src/ebpf/c/heaptrack.bpf.c")
         .clang_args([
             "-I",
             &vmlinux::include_path_root().join(arch).to_string_lossy(),

crates/heaptrack/build.rs

@@ -2,7 +2,7 @@ use runner_shared::benchmark_results::{HeaptrackEvent, HeaptrackEventKind};
 use serde::{Deserialize, Serialize};
 
 // Include the bindings for event.h
-mod bindings {
+pub mod bindings {
     #![allow(non_upper_case_globals)]
     #![allow(non_camel_case_types)]
     #![allow(non_snake_case)]
@@ -43,13 +43,14 @@ impl From<u8> for EventType {
     }
 }
 
+// TODO: Can't we use the bindgen generated type?
 #[repr(C)]
 #[derive(Debug, Clone, Copy, Deserialize, Serialize)]
 pub struct Event {
     pub event_type: EventType,
     pub timestamp: u64,
-    pub pid: u32,
-    pub tid: u32,
+    pub pid: i32,
+    pub tid: i32,
     pub addr: u64,
     pub size: u64,
 }

crates/heaptrack/src/bpf/event.h renamed to crates/heaptrack/src/ebpf/c/event.h

@@ -8,7 +8,7 @@ use log::warn;
 use std::mem::MaybeUninit;
 use std::path::Path;
 
-use crate::poller::RingBufferPoller;
+use crate::ebpf::poller::RingBufferPoller;
 
 pub mod heaptrack_skel {
     include!(concat!(env!("OUT_DIR"), "/heaptrack.skel.rs"));
@@ -288,7 +288,7 @@ impl HeaptrackBpf {
         poll_timeout_ms: u64,
     ) -> Result<(
         RingBufferPoller,
-        std::sync::mpsc::Receiver<crate::events::Event>,
+        std::sync::mpsc::Receiver<super::events::Event>,
     )> {
         // Use the syscalls skeleton's ring buffer (both programs share the same one)
         RingBufferPoller::with_channel(&self.skel.maps.events, poll_timeout_ms)

crates/heaptrack/src/bpf/heaptrack.bpf.c renamed to crates/heaptrack/src/ebpf/c/heaptrack.bpf.c

@@ -0,0 +1,8 @@
+mod events;
+mod memtrack;
+mod poller;
+mod tracker;
+
+pub use events::{Event, EventType};
+pub use memtrack::HeaptrackBpf;
+pub use tracker::Tracker;

crates/heaptrack/src/events.rs renamed to crates/heaptrack/src/ebpf/events.rs

@@ -5,7 +5,7 @@ use std::sync::{Arc, mpsc};
 use std::thread::JoinHandle;
 use std::time::Duration;
 
-use crate::events::Event;
+use super::events::Event;
 
 /// A handler function for processing ring buffer events
 pub type EventHandler = Box<dyn Fn(Event) + Send>;
@@ -73,7 +73,7 @@ impl RingBufferPoller {
     }
 
     /// Stop the polling thread and wait for it to finish
-    pub fn shutdown(mut self) {
+    pub fn shutdown(&mut self) {
         self.shutdown.store(true, Ordering::Relaxed);
         if let Some(thread) = self.poll_thread.take() {
             let _ = thread.join();
@@ -83,9 +83,6 @@ impl RingBufferPoller {
 
 impl Drop for RingBufferPoller {
     fn drop(&mut self) {
-        self.shutdown.store(true, Ordering::Relaxed);
-        if let Some(thread) = self.poll_thread.take() {
-            let _ = thread.join();
-        }
+        self.shutdown();
     }
 }

crates/heaptrack/src/bpf.rs renamed to crates/heaptrack/src/ebpf/memtrack.rs

@@ -1,5 +1,4 @@
-use crate::bpf::HeaptrackBpf;
-use crate::events::Event;
+use crate::ebpf::{HeaptrackBpf, Event};
 use anyhow::Result;
 use log::debug;
 use std::sync::mpsc::{self, Receiver};