examples/rust: Store skeletons in $OUT_DIR

examples/rust/profile/build.rs

@@ -1,25 +1,33 @@
-use std::fs::create_dir_all;
+use std::env;
+use std::env::consts::ARCH;
 use std::path::Path;
+use std::path::PathBuf;
 
-extern crate libbpf_cargo;
 use libbpf_cargo::SkeletonBuilder;
 
-const SRC: &str = "./src/bpf/profile.bpf.c";
+const SRC: &str = "src/bpf/profile.bpf.c";
 
 fn main() {
-    // It's unfortunate we cannot use `OUT_DIR` to store the generated skeleton.
-    // Reasons are because the generated skeleton contains compiler attributes
-    // that cannot be `include!()`ed via macro. And we cannot use the `#[path = "..."]`
-    // trick either because you cannot yet `concat!(env!("OUT_DIR"), "/skel.rs")` inside
-    // the path attribute either (see https://github.com/rust-lang/rust/pull/83366).
-    //
-    // However, there is hope! When the above feature stabilizes we can clean this
-    // all up.
-    create_dir_all("./src/bpf/.output").unwrap();
-    let skel = Path::new("./src/bpf/.output/profile.skel.rs");
+    let mut out =
+        PathBuf::from(env::var_os("OUT_DIR").expect("OUT_DIR must be set in build script"));
+    out.push("profile.skel.rs");
+
     SkeletonBuilder::new()
         .source(SRC)
-        .build_and_generate(skel)
+        .clang_args(format!(
+            "-I{}",
+            Path::new("../../../vmlinux")
+                .join(match ARCH {
+                    "aarch64" => "arm64",
+                    "loongarch64" => "loongarch",
+                    "powerpc64" => "powerpc",
+                    "riscv64" => "riscv",
+                    "x86_64" => "x86",
+                    _ => ARCH,
+                })
+                .display()
+        ))
+        .build_and_generate(out)
         .expect("bpf compilation failed");
     println!("cargo:rerun-if-changed={}", SRC);
 }

examples/rust/profile/src/main.rs

@@ -19,8 +19,9 @@ use tracing_subscriber::fmt::format::FmtSpan;
 use tracing_subscriber::fmt::time::SystemTime;
 use tracing_subscriber::FmtSubscriber;
 
-#[path = "bpf/.output/profile.skel.rs"]
-mod profile;
+mod profile {
+    include!(concat!(env!("OUT_DIR"), "/profile.skel.rs"));
+}
 mod syscall;
 
 use profile::*;

examples/rust/tracecon/build.rs

@@ -1,24 +1,33 @@
-use std::fs::create_dir_all;
+use std::env;
+use std::env::consts::ARCH;
 use std::path::Path;
+use std::path::PathBuf;
 
 use libbpf_cargo::SkeletonBuilder;
 
-const SRC: &str = "./src/bpf/tracecon.bpf.c";
+const SRC: &str = "src/bpf/tracecon.bpf.c";
 
 fn main() {
-    // It's unfortunate we cannot use `OUT_DIR` to store the generated skeleton.
-    // Reasons are because the generated skeleton contains compiler attributes
-    // that cannot be `include!()`ed via macro. And we cannot use the `#[path = "..."]`
-    // trick either because you cannot yet `concat!(env!("OUT_DIR"), "/skel.rs")` inside
-    // the path attribute either (see https://github.com/rust-lang/rust/pull/83366).
-    //
-    // However, there is hope! When the above feature stabilizes we can clean this
-    // all up.
-    create_dir_all("./src/bpf/.output").unwrap();
-    let skel = Path::new("./src/bpf/.output/tracecon.skel.rs");
+    let mut out =
+        PathBuf::from(env::var_os("OUT_DIR").expect("OUT_DIR must be set in build script"));
+    out.push("tracecon.skel.rs");
+
     SkeletonBuilder::new()
         .source(SRC)
-        .build_and_generate(&skel)
+        .clang_args(format!(
+            "-I{}",
+            Path::new("../../../vmlinux")
+                .join(match ARCH {
+                    "aarch64" => "arm64",
+                    "loongarch64" => "loongarch",
+                    "powerpc64" => "powerpc",
+                    "riscv64" => "riscv",
+                    "x86_64" => "x86",
+                    _ => ARCH,
+                })
+                .display()
+        ))
+        .build_and_generate(&out)
         .expect("bpf compilation failed");
     println!("cargo:rerun-if-changed={}", SRC);
 }

examples/rust/tracecon/src/main.rs

@@ -11,8 +11,9 @@ use std::sync::atomic::{AtomicBool, Ordering};
 use std::sync::Arc;
 use structopt::StructOpt;
 
-#[path = "bpf/.output/tracecon.skel.rs"]
-mod tracecon;
+mod tracecon {
+    include!(concat!(env!("OUT_DIR"), "/tracecon.skel.rs"));
+}
 use tracecon::*;
 
 type Event = tracecon_bss_types::event;

examples/rust/xdp/build.rs

@@ -1,24 +1,33 @@
-use std::fs::create_dir_all;
+use std::env;
+use std::env::consts::ARCH;
 use std::path::Path;
+use std::path::PathBuf;
 
 use libbpf_cargo::SkeletonBuilder;
 
-const SRC: &str = "./src/bpf/xdppass.bpf.c";
+const SRC: &str = "src/bpf/xdppass.bpf.c";
 
 fn main() {
-    // It's unfortunate we cannot use `OUT_DIR` to store the generated skeleton.
-    // Reasons are because the generated skeleton contains compiler attributes
-    // that cannot be `include!()`ed via macro. And we cannot use the `#[path = "..."]`
-    // trick either because you cannot yet `concat!(env!("OUT_DIR"), "/skel.rs")` inside
-    // the path attribute either (see https://github.com/rust-lang/rust/pull/83366).
-    //
-    // However, there is hope! When the above feature stabilizes we can clean this
-    // all up.
-    create_dir_all("./src/bpf/.output").unwrap();
-    let skel = Path::new("./src/bpf/.output/xdppass.skel.rs");
+    let mut out =
+        PathBuf::from(env::var_os("OUT_DIR").expect("OUT_DIR must be set in build script"));
+    out.push("xdppass.skel.rs");
+
     SkeletonBuilder::new()
         .source(SRC)
-        .build_and_generate(&skel)
+        .clang_args(format!(
+            "-I{}",
+            Path::new("../../../vmlinux")
+                .join(match ARCH {
+                    "aarch64" => "arm64",
+                    "loongarch64" => "loongarch",
+                    "powerpc64" => "powerpc",
+                    "riscv64" => "riscv",
+                    "x86_64" => "x86",
+                    _ => ARCH,
+                })
+                .display()
+        ))
+        .build_and_generate(out)
         .unwrap();
     println!("cargo:rerun-if-changed={}", SRC);
 }

examples/rust/xdp/src/main.rs

@@ -5,8 +5,9 @@ use std::{thread, time};
 use anyhow::{bail, Result};
 use structopt::StructOpt;
 
-#[path = "bpf/.output/xdppass.skel.rs"]
-mod xdppass;
+mod xdppass {
+    include!(concat!(env!("OUT_DIR"), "/xdppass.skel.rs"));
+}
 use xdppass::*;
 
 #[derive(Debug, StructOpt)]