fix(server): make the glibc single-threaded shim writable (#15)

codegraph-server segfaulted at startup on Linux/aarch64 - every
invocation, including --version and --help, before main() ever ran.

The shim defined __libc_single_threaded as an immutable static, which
lands in .rodata, and its comment claimed "on newer glibc the real symbol
shadows this at runtime". That is the opposite of how ELF resolves it: a
definition in the executable takes precedence over the one in libc. On
aarch64 the symbol is also emitted into .dynsym, so glibc bound its own
startup write of the flag to our read-only byte and took SIGSEGV. x86_64
escaped it only because the symbol is not dynamically exported there, so
glibc kept using its own copy - which is why this looked environment-
specific and why the shipped x86_64 binaries were fine.

glibc owns the value: it sets the flag at startup and clears it on thread
creation. We only supply storage, wrapped in an UnsafeCell so it lands in
writable memory, and never read it. On a glibc too old to maintain it the
byte stays 0, the conservative "not single threaded" answer, so the
SLES 15 SP4 / glibc 2.31 case the shim exists for still links and runs.

Verified on aarch64 Ubuntu 24.04 (glibc 2.39), built from these sources:
before, --version and --help both exited 139 and the symbol was `R`;
after, the symbol is `B` and --version, --help and --info all exit 0.

codegraph-pro-server carries the same shim and needs the same change.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017rVbt7rENTwXkdHt3Bpgb5

Author: anvanster

crates/codegraph-server/src/main.rs

@@ -14,11 +14,38 @@ use std::sync::atomic::{AtomicUsize, Ordering};
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 
 // glibc 2.31 compat: __libc_single_threaded was added in glibc 2.32 but ONNX
-// Runtime references it. Provide a fallback for SLES 15 SP4 and similar.
-// On newer glibc the real symbol shadows this at runtime.
+// Runtime references it, so a build for SLES 15 SP4 and similar needs a
+// definition to link against.
+//
+// The storage must be WRITABLE. This was previously `pub static ... : u8 = 0`,
+// which lands in .rodata, and the comment claimed "on newer glibc the real
+// symbol shadows this at runtime" - the opposite of how ELF resolves it. A
+// definition in the executable takes precedence over the one in libc, and on
+// aarch64 this symbol is also emitted into .dynsym, so glibc bound its own
+// startup write of the flag to our read-only byte and took SIGSEGV before
+// main(): every invocation died, including `--version` and `--help`
+// (issue #15). x86_64 escaped only because the symbol is not dynamically
+// exported there, so glibc kept using its own copy.
+//
+// glibc owns the value: it sets the flag at startup and clears it when a
+// thread is created. We only supply the storage, and never read it. On a glibc
+// too old to maintain it, the byte stays 0, which is the conservative
+// "not single threaded" answer.
 #[cfg(target_os = "linux")]
-#[no_mangle]
-pub static __libc_single_threaded: u8 = 0;
+mod glibc_compat {
+    use std::cell::UnsafeCell;
+
+    #[repr(transparent)]
+    pub struct SingleThreaded(UnsafeCell<u8>);
+
+    // SAFETY: glibc is the only writer, from its own startup and
+    // thread-creation paths, and this process never reads the byte. The
+    // UnsafeCell is what places it in writable memory rather than .rodata.
+    unsafe impl Sync for SingleThreaded {}
+
+    #[no_mangle]
+    pub static __libc_single_threaded: SingleThreaded = SingleThreaded(UnsafeCell::new(0));
+}
 
 #[derive(Parser)]
 #[command(name = "codegraph-server")]