add comment and test for relaxation

Author: cataphract

libdd-otel-thread-ctx-ffi/build.rs

@@ -8,6 +8,9 @@ use std::env;
 fn main() {
     generate_and_configure_header("otel-thread-ctx.h");
 
+    let cross_compiling = env::var("HOST").unwrap() != env::var("TARGET").unwrap();
+    println!("cargo:rustc-env=LIBDD_OTEL_THREAD_CTX_FFI_CROSS_COMPILING={cross_compiling}");
+
     let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap();
     if target_os != "linux" {
         return;

libdd-otel-thread-ctx-ffi/tests/elf_properties.rs

@@ -1,55 +1,133 @@
 // Copyright 2026-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
 
-//! Verify ELF properties of the built cdylib on Linux.
+//! Verify ELF properties of the built artifacts on Linux.
 //!
 //! These tests check that:
 //! - `otel_thread_ctx_v1` is exported in the dynamic symbol table as a TLS GLOBAL symbol.
 //! - `otel_thread_ctx_v1` is accessed via TLSDESC relocations (R_X86_64_TLSDESC or
 //!   R_AARCH64_TLSDESC), as required by the OTel thread-level context sharing spec.
+//! - A native executable that statically links libdd-otel-thread-ctx-ffi without exporting
+//!   `otel_thread_ctx_v1` has libdd's TLSDESC access relaxed to local-exec TLS.
 //!
-//! The cdylib path is derived at runtime from the test executable location.
-//! Both the test binary and the cdylib live in `target/<[triple/]profile>/deps/`.
+//! Library artifact paths are derived at runtime from the test executable location.
+//! The test binary and crate artifacts live in `target/<[triple/]profile>/deps/`.
 
 #![cfg(target_os = "linux")]
 
-use std::path::PathBuf;
-use std::process::Command;
+use std::{
+    io::ErrorKind,
+    path::{Path, PathBuf},
+    process::{Command, Stdio},
+};
 
 const SYMBOL: &str = "otel_thread_ctx_v1";
 
-fn cdylib_path() -> PathBuf {
+fn deps_dir() -> PathBuf {
     // test binary: target/<[triple/]profile>/deps/<name>
-    // cdylib:      target/<[triple/]profile>/deps/liblibdd_otel_thread_ctx_ffi.so
     let exe = std::env::current_exe().expect("failed to read current executable path");
     exe.parent()
         .expect("unexpected test executable path structure")
-        .join("liblibdd_otel_thread_ctx_ffi.so")
+        .to_owned()
+}
+
+fn artifact_path(name: &str) -> PathBuf {
+    deps_dir().join(name)
+}
+
+fn cdylib_path() -> PathBuf {
+    artifact_path("liblibdd_otel_thread_ctx_ffi.so")
+}
+
+fn staticlib_path() -> PathBuf {
+    artifact_path("liblibdd_otel_thread_ctx_ffi.a")
 }
 
-fn check_cdylib_readable(path: &PathBuf) {
+fn check_readable(path: &Path) {
     assert!(
         std::fs::File::open(path).is_ok(),
-        "cdylib at {} could not be opened for reading",
+        "{} could not be opened for reading",
         path.display()
     );
 }
 
-fn readelf(args: &[&str], path: &PathBuf) -> String {
-    let out = Command::new("readelf")
-        .args(args)
-        .arg(path)
+fn tool_available(tool: &str) -> bool {
+    match Command::new(tool)
+        .arg("--version")
+        .stdout(Stdio::null())
+        .stderr(Stdio::null())
+        .status()
+    {
+        Ok(_) => true,
+        Err(e) if e.kind() == ErrorKind::NotFound => {
+            eprintln!("skipping test: required tool `{tool}` is not available");
+            false
+        }
+        Err(e) => panic!("failed to check whether `{tool}` is available: {e}"),
+    }
+}
+
+fn required_tools_available(tools: &[&str]) -> bool {
+    tools.iter().all(|tool| tool_available(tool))
+}
+
+fn native_target() -> bool {
+    let cross_compiling = option_env!("LIBDD_OTEL_THREAD_CTX_FFI_CROSS_COMPILING") == Some("true");
+    if cross_compiling {
+        eprintln!("skipping test: cross-compiling");
+    }
+    !cross_compiling
+}
+
+fn command_output(command: &mut Command) -> String {
+    let out = command
         .output()
-        .expect("failed to run readelf. Is binutils installed?");
+        .unwrap_or_else(|e| panic!("failed to run {command:?}: {e}"));
+    assert!(
+        out.status.success(),
+        "{command:?} failed with status {}\nstdout:\n{}\nstderr:\n{}",
+        out.status,
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr)
+    );
     String::from_utf8_lossy(&out.stdout).into_owned()
 }
 
-#[test]
-#[cfg_attr(miri, ignore)]
-fn otel_thread_ctx_v1_in_dynsym() {
-    let path = cdylib_path();
-    check_cdylib_readable(&path);
-    let output = readelf(&["-W", "--dyn-syms"], &path);
+fn readelf(args: &[&str], path: &Path) -> String {
+    let mut command = Command::new("readelf");
+    command.args(args).arg(path);
+    command_output(&mut command)
+}
+
+fn objdump(args: &[&str], path: &Path) -> String {
+    let mut command = Command::new("objdump");
+    command.args(args).arg(path);
+    command_output(&mut command)
+}
+
+fn assert_command_success(command: &mut Command) {
+    let out = command
+        .output()
+        .unwrap_or_else(|e| panic!("failed to run {command:?}: {e}"));
+    assert!(
+        out.status.success(),
+        "{command:?} failed with status {}\nstdout:\n{}\nstderr:\n{}",
+        out.status,
+        String::from_utf8_lossy(&out.stdout),
+        String::from_utf8_lossy(&out.stderr)
+    );
+}
+
+fn build_dir(name: &str) -> PathBuf {
+    let dir = deps_dir().join(format!("{name}-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir)
+        .unwrap_or_else(|e| panic!("failed to create {}: {e}", dir.display()));
+    dir
+}
+
+fn assert_symbol_is_tls_global_in_dynsym(path: &Path) {
+    let output = readelf(&["-W", "--dyn-syms"], path);
     let line = output
         .lines()
         .find(|l| l.contains(SYMBOL))
@@ -60,11 +138,88 @@ fn otel_thread_ctx_v1_in_dynsym() {
     );
 }
 
+fn disassembled_functions(output: &str, name: &str) -> Vec<String> {
+    let marker = format!("<{name}>:");
+    let mut functions = Vec::new();
+    let mut current_function = Vec::new();
+
+    for line in output.lines() {
+        if line.contains(&marker) {
+            if !current_function.is_empty() {
+                functions.push(current_function.join("\n"));
+                current_function.clear();
+            }
+            current_function.push(line);
+            continue;
+        }
+
+        if !current_function.is_empty() {
+            if line.is_empty() {
+                functions.push(current_function.join("\n"));
+                current_function.clear();
+                continue;
+            }
+            current_function.push(line);
+        }
+    }
+
+    if !current_function.is_empty() {
+        functions.push(current_function.join("\n"));
+    }
+
+    assert!(
+        !functions.is_empty(),
+        "could not find disassembly for {name} in:\n{output}"
+    );
+    functions
+}
+
+#[cfg(target_arch = "aarch64")]
+fn disassembly_window_around_line(
+    function: &str,
+    needle: &str,
+    before: usize,
+    after: usize,
+) -> String {
+    let lines = function.lines().collect::<Vec<_>>();
+    let line_index = lines
+        .iter()
+        .position(|line| line.contains(needle))
+        .unwrap_or_else(|| panic!("could not find {needle:?} in:\n{function}"));
+    let start = line_index.saturating_sub(before);
+    let end = usize::min(line_index + after + 1, lines.len());
+    lines[start..end].join("\n")
+}
+
+#[test]
+#[cfg_attr(miri, ignore)]
+fn otel_thread_ctx_v1_in_dynsym() {
+    if !native_target() {
+        return;
+    }
+
+    if !required_tools_available(&["readelf"]) {
+        return;
+    }
+
+    let path = cdylib_path();
+    check_readable(&path);
+    assert_symbol_is_tls_global_in_dynsym(&path);
+}
+
 #[test]
 #[cfg_attr(miri, ignore)]
 fn otel_thread_ctx_v1_tlsdesc_reloc() {
+    if !native_target() {
+        return;
+    }
+
+    if !required_tools_available(&["readelf"]) {
+        return;
+    }
+
     let path = cdylib_path();
-    check_cdylib_readable(&path);
+    check_readable(&path);
     let output = readelf(&["-W", "--relocs"], &path);
     let found = output.lines().any(|l| {
         l.contains(SYMBOL) && (l.contains("R_X86_64_TLSDESC") || l.contains("R_AARCH64_TLSDESC"))
@@ -82,3 +237,136 @@ fn otel_thread_ctx_v1_tlsdesc_reloc() {
             .join("\n")
     );
 }
+
+#[test]
+#[cfg_attr(miri, ignore)]
+#[cfg(any(target_arch = "x86_64", target_arch = "aarch64"))]
+fn statically_linked_executable_relaxes_libdd_tls_slot_to_local_exec() {
+    if !native_target() {
+        return;
+    }
+
+    if !required_tools_available(&["cc", "readelf", "objdump"]) {
+        return;
+    }
+
+    let staticlib = staticlib_path();
+    check_readable(&staticlib);
+
+    let dir = build_dir("otel-thread-ctx-local-exec");
+    let source = dir.join("consumer.c");
+    let object = dir.join("consumer.o");
+    let executable = dir.join("consumer");
+    std::fs::write(
+        &source,
+        r#"
+#include <stdint.h>
+
+void ddog_otel_thread_ctx_update(
+    const uint8_t (*trace_id)[16],
+    const uint8_t (*span_id)[8],
+    const uint8_t (*local_root_span_id)[8]);
+void *ddog_otel_thread_ctx_detach(void);
+void ddog_otel_thread_ctx_free(void *ctx);
+
+int main(void) {
+    uint8_t trace_id[16] = {1};
+    uint8_t span_id[8] = {2};
+    uint8_t local_root_span_id[8] = {3};
+
+    ddog_otel_thread_ctx_update(&trace_id, &span_id, &local_root_span_id);
+    void *ctx = ddog_otel_thread_ctx_detach();
+    ddog_otel_thread_ctx_free(ctx);
+
+    return ctx == 0 ? 1 : 0;
+}
+"#,
+    )
+    .unwrap_or_else(|e| panic!("failed to write {}: {e}", source.display()));
+
+    let mut compile_object = Command::new("cc");
+    compile_object.args(["-O2", "-ffunction-sections", "-fdata-sections"]);
+    compile_object.arg("-c").arg(&source).arg("-o").arg(&object);
+    assert_command_success(&mut compile_object);
+
+    // the static library should have a TLSDESC relocation for the symbol
+    let staticlib_relocs = readelf(&["-W", "--relocs"], &staticlib);
+    assert!(staticlib_relocs
+        .lines()
+        .any(|l| l.contains(SYMBOL) && l.contains("TLSDESC")));
+
+    // the object file only imports ddog_otel_*
+    let object_relocs = readelf(&["-W", "--relocs"], &object);
+    assert!(!object_relocs.lines().any(|l| l.contains(SYMBOL)));
+
+    let mut link_executable = Command::new("cc");
+    link_executable
+        .arg(&object)
+        .arg(&staticlib)
+        .args([
+            "-Wl,--gc-sections",
+            "-lpthread",
+            "-ldl",
+            "-lm",
+            "-lrt",
+            "-lutil",
+        ])
+        .arg("-o")
+        .arg(&executable);
+    assert_command_success(&mut link_executable);
+
+    // Run the generated executable so the test validates the relaxed TLS access at runtime too.
+    let mut run_executable = Command::new(&executable);
+    assert_command_success(&mut run_executable);
+
+    let executable_relocs = readelf(&["-W", "--relocs"], &executable);
+    assert!(
+        !executable_relocs
+            .lines()
+            .any(|l| l.contains(SYMBOL) && l.contains("TLSDESC")),
+        "expected TLSDESC relocations for {SYMBOL} to be relaxed in the executable"
+    );
+
+    let disassembly = objdump(&["-drwC"], &executable);
+    let tls_slot_functions =
+        disassembled_functions(&disassembly, "libdd_otel_thread_ctx::linux::with_tls_slot");
+
+    #[cfg(target_arch = "x86_64")]
+    {
+        assert!(
+            tls_slot_functions
+                .iter()
+                .any(|function| function.contains("%fs:0x0")),
+            "expected tls_slot() in libdd-otel-thread-ctx to be relaxed to local-exec x86-64 \
+             TLS access through %fs:0x0\n{}",
+            tls_slot_functions.join("\n\n")
+        );
+        assert!(
+            tls_slot_functions
+                .iter()
+                .all(|function| !function.contains("tlsdesc")),
+            "expected linker-relaxed local-exec TLS code without TLSDESC operands:\n{}",
+            tls_slot_functions.join("\n\n")
+        );
+    }
+
+    #[cfg(target_arch = "aarch64")]
+    {
+        let function = tls_slot_functions
+            .iter()
+            .find(|function| function.contains("tpidr_el0"))
+            .unwrap_or_else(|| {
+                panic!(
+                    "expected tls_slot() in libdd-otel-thread-ctx to use tpidr_el0 after \
+                     relaxation\n{}",
+                    tls_slot_functions.join("\n\n")
+                )
+            });
+        let window = disassembly_window_around_line(function, "tpidr_el0", 4, 3);
+        assert!(
+            !window.contains("tlsdesc") && !window.contains("\tblr"),
+            "expected linker-relaxed local-exec TLS code around tpidr_el0 without a TLSDESC call:\n\
+             {window}"
+        );
+    }
+}