SSI execsolib impl

Author: cataphract

Cargo.lock

@@ -53,6 +53,7 @@ hashbrown = "0.15"
 
 [build-dependencies]
 cbindgen = "0.27"
+cc = "1"
 
 [lints.rust]
 unexpected_cfgs = { level = "warn", check-cfg = ['cfg(php_shared_build)'] }

components-rs/Cargo.toml

@@ -0,0 +1,18 @@
+fn main() {
+    let target_os = std::env::var("CARGO_CFG_TARGET_OS").unwrap_or_default();
+    // SHARED=1 is set by config.m4 when building in rust-library-split (SSI) mode.
+    // In that mode this crate is the cdylib that carries the Rust code.
+    // We compile ssi_entry.c into it to make libddtrace_php.so directly executable
+    // via the dynamic loader (ld.so).
+    let shared_build = std::env::var("SHARED").as_deref() == Ok("1");
+
+    if target_os == "linux" && shared_build {
+        let manifest_dir = std::env::var("CARGO_MANIFEST_DIR").unwrap();
+        cc::Build::new()
+            .file(format!("{manifest_dir}/ssi_entry.c"))
+            .flag("-fvisibility=hidden")
+            .compile("ssi_entry");
+
+        println!("cargo:rustc-link-arg=-Wl,-e,_dd_ssi_entry");
+    }
+}

components-rs/build.rs

@@ -0,0 +1,80 @@
+// SSI entry point for libddtrace_php.so executed directly.
+//
+// The spawner invokes libddtrace_php.so via the dynamic loader explicitly:
+//   execve(ld_path, [ld_path, lib_path, process_name, "", lib_path, deps..., symbol], envp)
+// ld.so loads libc and all other dependencies, then jumps to _dd_ssi_entry.
+// By that time the process is fully initialised (TLS, libc, allocator) so we
+// can use ordinary C library calls.
+//
+// argv layout as seen by _dd_ssi_entry (from the kernel stack):
+//   argv[0] = ld_path       ← skip
+//   argv[1] = lib_path      ← skip
+//   argv[2] = process_name  ← standard trampoline argv[0]
+//   argv[3] = ""            ← standard trampoline argv[1]
+//   argv[4] = lib_path      ← standard trampoline argv[2]
+//   ...
+//   argv[argc-1] = symbol_name
+//
+// In fact, this file's like a simplified version of trampoline.c. We ignore
+// everything but the symbol name, which we assume lives in libddtrace_php.so.
+
+#define _GNU_SOURCE
+#include <dlfcn.h>
+#include <unistd.h>
+
+struct trampoline_data {
+    int    argc;
+    char **argv;
+    char **dependency_paths;
+};
+
+__attribute__((noreturn, used))
+static void ssi_main(int argc, char **argv)
+{
+    if (argc < 4) _exit(1);
+    argc -= 2;
+    argv += 2;
+
+    const char *symbol = argv[argc - 1];
+
+    void (*fn)(struct trampoline_data *) =
+        (void (*)(struct trampoline_data *))dlsym(RTLD_DEFAULT, symbol);
+
+    if (!fn) _exit(2);
+
+    struct trampoline_data td = { argc, argv, NULL };
+    fn(&td);
+    _exit(0);
+}
+
+// Architecture-specific _start-like stub: read argc/argv from the kernel
+// stack and tail-call ssi_main.
+
+#if defined(__aarch64__)
+__asm__(
+    ".text\n"
+    ".global _dd_ssi_entry\n"
+    ".type   _dd_ssi_entry, @function\n"
+    "_dd_ssi_entry:\n"
+    "    mov  x29, #0\n"
+    "    mov  x30, #0\n"
+    "    ldr  x0,  [sp]\n"       /* argc */
+    "    add  x1,  sp, #8\n"     /* argv */
+    "    b    ssi_main\n"        /* noreturn tail call */
+    ".size _dd_ssi_entry, .-_dd_ssi_entry\n"
+);
+#elif defined(__x86_64__)
+__asm__(
+    ".text\n"
+    ".global _dd_ssi_entry\n"
+    ".type   _dd_ssi_entry, @function\n"
+    "_dd_ssi_entry:\n"
+    "    xor  %ebp, %ebp\n"
+    "    movl (%rsp), %edi\n"    /* argc */
+    "    lea  8(%rsp), %rsi\n"   /* argv */
+    "    jmp  ssi_main\n"        /* noreturn tail call */
+    ".size _dd_ssi_entry, .-_dd_ssi_entry\n"
+);
+#else
+# error "ssi_entry.c: unsupported architecture"
+#endif

components-rs/ssi_entry.c

@@ -228,11 +228,16 @@ if test "$PHP_DDTRACE" != "no"; then
   DD_TRACE_PHP_SOURCES="$DD_TRACE_PHP_SOURCES \
     ext/compat_getrandom.c"
 
-  dnl On Linux, add the solib bootstrap (makes ddtrace.so directly executable)
+  dnl On Linux, add the solib bootstrap (makes the library directly executable).
+  dnl In rust-library-split (SSI) mode the bootstrap goes into libddtrace_php.so
+  dnl via components-rs/build.rs instead, because that is the library that
+  dnl carries the Rust code (and therefore DD_TRAMPOLINE_BIN).
   case $host_os in
     linux*)
-      DD_TRACE_PHP_SOURCES="$DD_TRACE_PHP_SOURCES \
-        ext/solib_bootstrap.c"
+      if test "$PHP_DDTRACE_RUST_LIBRARY_SPLIT" = "no"; then
+        DD_TRACE_PHP_SOURCES="$DD_TRACE_PHP_SOURCES \
+          ext/solib_bootstrap.c"
+      fi
       ;;
   esac
 
@@ -286,15 +291,19 @@ if test "$PHP_DDTRACE" != "no"; then
     EXTRA_CFLAGS="$EXTRA_CFLAGS -fvisibility=hidden"
     EXTRA_LDFLAGS="$EXTRA_LDFLAGS -export-symbols $ext_srcdir/ddtrace.sym -flto -fuse-linker-plugin"
 
-    dnl On Linux, set the ELF entry point so ddtrace.so can be executed directly
+    dnl On Linux, set the ELF entry point so ddtrace.so can be executed directly.
+    dnl In rust-library-split (SSI) mode the entry point is set on libddtrace_php.so
+    dnl via components-rs/build.rs instead.
     case $host_os in
       linux*)
-        EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-e,_dd_solib_start"
-        dnl ExecSolib requires execute permission; PHP's make install defaults to
-        dnl INSTALL_DATA = install -m 644. Override to 0755 so execve() works.
-        cat <<'EOT' >> Makefile.fragments
+        if test "$PHP_DDTRACE_RUST_LIBRARY_SPLIT" = "no"; then
+          EXTRA_LDFLAGS="$EXTRA_LDFLAGS -Wl,-e,_dd_solib_start"
+          dnl ExecSolib requires execute permission; PHP's make install defaults to
+          dnl INSTALL_DATA = install -m 644. Override to 0755 so execve() works.
+          cat <<'EOT' >> Makefile.fragments
 INSTALL_DATA = $(INSTALL) -m 0755
 EOT
+        fi
         ;;
     esac