libbpf-cargo: Strip DWARF information from generated object files

Clang generated BPF object files may contain DWARF information that
references paths to temporary directories, for example. That ends up
rendering our generated skeleton unstable, as it potentially changes
between invocations [0]. That can be unfortunate if the skeleton is
meant to be checked into version control.
Andrii suggested [1] stripping said DWARF information by linking the
object file, which strips it as a side effect. This change does so.

[0] #163
[1] #169 (comment)

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

Author: d-e-s-o

.github/workflows/rust.yml

@@ -44,14 +44,15 @@ jobs:
         override: true
     - name: Install deps
       run: |
-        sudo apt-get install -y clang-14 libelf-dev zlib1g-dev
+        sudo apt-get install -y clang-14 libelf-dev zlib1g-dev linux-headers-$(uname -r)
+        sudo ln -s /usr/include/asm-generic /usr/include/asm
         sudo rm -f /bin/clang && sudo ln -s /usr/bin/clang-14 /bin/clang
     - uses: Swatinem/rust-cache@v2.2.0
     - name: Build
       run: cargo build --verbose --workspace --exclude runqslower
     - name: Run tests
       # Skip BTF tests which require sudo
-      run: cargo test --verbose --workspace --exclude runqslower -- --skip test_object --skip test_tc
+      run: cargo test --verbose --workspace --exclude runqslower -- --skip test_object --skip test_tc --include-ignored
     - name: Run BTF tests
       run: cd libbpf-rs && cargo test --verbose -- test_object test_tc
 

Cargo.lock

@@ -33,6 +33,7 @@ novendor = ["libbpf-sys/novendor"]
 anyhow = "1.0.1"
 cargo_metadata = "0.15.0"
 libbpf-sys = { version = "1.0.3" }
+libbpf-rs = { path = "../libbpf-rs" }
 memmap2 = "0.5"
 num_enum = "0.5"
 regex = { version = "1.6.0", default-features = false, features = ["std", "unicode-perl"] }

libbpf-cargo/Cargo.toml

@@ -105,6 +105,25 @@ fn check_clang(debug: bool, clang: &Path, skip_version_checks: bool) -> Result<(
     Ok(())
 }
 
+/// Strip DWARF information from the provided BPF object file.
+///
+/// We rely on the `libbpf` linker here, which removes debug information as a
+/// side-effect.
+fn strip_dwarf_info(file: &Path) -> Result<()> {
+    let mut temp_file = file.as_os_str().to_os_string();
+    temp_file.push(".tmp");
+
+    fs::rename(file, &temp_file).context("Failed to rename compiled BPF object file")?;
+
+    let mut linker =
+        libbpf_rs::Linker::new(file).context("Failed to instantiate libbpf object file linker")?;
+    linker
+        .add(temp_file)
+        .context("Failed to add object file to BPF linker")?;
+    linker.link().context("Failed to link object file")?;
+    Ok(())
+}
+
 /// We're essentially going to run:
 ///
 ///   clang -g -O2 -target bpf -c -D__TARGET_ARCH_$(ARCH) runqslower.bpf.c -o runqslower.bpf.o
@@ -154,7 +173,11 @@ fn compile_one(debug: bool, source: &Path, out: &Path, clang: &Path, options: &s
         );
     }
 
-    Ok(())
+    // Compilation with clang may contain DWARF information that references
+    // system specific and temporary paths. That can render our generated
+    // skeletons unstable, potentially rendering them unsuitable for inclusion
+    // in version control systems. So strip this information.
+    strip_dwarf_info(out).with_context(|| format!("Failed to strip object file {}", out.display()))
 }
 
 fn compile(debug: bool, objs: &[UnprocessedObj], clang: &Path, target_dir: &Path) -> Result<()> {

libbpf-cargo/src/build.rs

@@ -1,6 +1,6 @@
 use std::{
     convert::TryInto,
-    fs::{create_dir, read, File, OpenOptions},
+    fs::{create_dir, read, read_to_string, write, File, OpenOptions},
     io::Write,
     path::{Path, PathBuf},
     process::Command,
@@ -918,6 +918,56 @@ fn test_skeleton_builder_arrays_ptrs() {
     assert!(status.success());
 }
 
+/// Check that skeleton creation is deterministic, i.e., that no temporary paths
+/// change the output between invocations.
+#[test]
+#[ignore = "may fail on some systems; depends on kernel headers that have been seen to be broken"]
+fn test_skeleton_builder_deterministic() {
+    let (_dir, proj_dir, _cargo_toml) = setup_temp_project();
+
+    create_dir(proj_dir.join("src/bpf")).expect("failed to create prog dir");
+    write(
+        proj_dir.join("src/bpf/prog.bpf.c"),
+        r#"
+            #include <linux/bpf.h>
+            #include <bpf/bpf_helpers.h>
+
+            struct {
+                __uint(type, BPF_MAP_TYPE_REUSEPORT_SOCKARRAY);
+            } sock_map SEC(".maps");
+
+            SEC("sk_reuseport/reuse_pass")
+            long prog_select_sk(struct sk_reuseport_md *reuse_md)
+            {
+                unsigned int index = 0;
+                bpf_sk_select_reuseport(reuse_md, &sock_map, &index, 0);
+                return SK_PASS;
+            }
+        "#,
+    )
+    .expect("failed to write prog.bpf.c");
+
+    let skel1 = NamedTempFile::new().unwrap();
+    SkeletonBuilder::new()
+        .source(proj_dir.join("src/bpf/prog.bpf.c"))
+        .debug(true)
+        .clang("clang")
+        .build_and_generate(skel1.path())
+        .unwrap();
+    let skel1 = read_to_string(skel1.path()).unwrap();
+
+    let skel2 = NamedTempFile::new().unwrap();
+    SkeletonBuilder::new()
+        .source(proj_dir.join("src/bpf/prog.bpf.c"))
+        .debug(true)
+        .clang("clang")
+        .build_and_generate(skel2.path())
+        .unwrap();
+    let skel2 = read_to_string(skel2.path()).unwrap();
+
+    assert_eq!(skel1, skel2);
+}
+
 // -- TEST RUST GENERATION OF BTF PROGRAMS --
 
 /// Searches the Btf struct for a BtfType