no-mistakes(review): share writable glibc_single_threaded shim with test target

Author: anvanster

crates/codegraph-server/src/glibc_compat.rs

@@ -0,0 +1,43 @@
+// Copyright 2025-2026 Andrey Vasilevsky <anvanster@gmail.com>
+// SPDX-License-Identifier: Apache-2.0
+
+//! glibc 2.31 compatibility storage for `__libc_single_threaded`.
+//!
+//! `__libc_single_threaded` was added in glibc 2.32 but ONNX Runtime
+//! references it, so a build for SLES 15 SP4 and similar needs a definition to
+//! link against. Every target that links ONNX Runtime - the binary and the
+//! test executables, which do not include `main.rs` - has to supply one.
+//!
+//! The storage must be WRITABLE. It was previously `pub static ...: u8 = 0`,
+//! which lands in .rodata, under a comment claiming "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 the 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.
+//!
+//! Every definition of the symbol must use [`SingleThreaded`] so the writable
+//! storage cannot drift back to a plain `u8` in one target and not another.
+
+use std::cell::UnsafeCell;
+
+/// Writable single-byte storage for glibc's `__libc_single_threaded` flag.
+#[repr(transparent)]
+pub struct SingleThreaded(UnsafeCell<u8>);
+
+impl SingleThreaded {
+    /// The initial value of the flag: "not single threaded".
+    pub const ZERO: Self = Self(UnsafeCell::new(0));
+}
+
+// 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 {}

crates/codegraph-server/src/lib.rs

@@ -12,15 +12,18 @@
 //! - **LSP** (default): Standard Language Server Protocol for IDE integration
 //! - **MCP** (`--mcp` flag): Model Context Protocol for AI client integration
 
-// glibc 2.31 compat (test builds): the production shim lives in main.rs
-// for the binary target. `cargo test --lib` builds a separate test
-// executable that doesn't include main.rs, so ONNX Runtime's reference
-// to `__libc_single_threaded` (added in glibc 2.32) goes unresolved
-// when linking tests on SLES 15-SP4. This duplicate is gated on
-// `cfg(test)` so the binary target never sees two definitions.
+// glibc 2.31 compat (test builds): the production shim lives in main.rs for
+// the binary target. `cargo test --lib` builds a separate test executable that
+// doesn't include main.rs, so ONNX Runtime's reference to
+// `__libc_single_threaded` (added in glibc 2.32) goes unresolved when linking
+// tests on SLES 15-SP4. This definition is gated on `cfg(test)` so the binary
+// target never sees two of them; see `glibc_compat` for why the storage has to
+// be writable.
 #[cfg(all(target_os = "linux", test))]
 #[no_mangle]
-pub static __libc_single_threaded: u8 = 0;
+#[allow(non_upper_case_globals)]
+pub static __libc_single_threaded: glibc_compat::SingleThreaded =
+    glibc_compat::SingleThreaded::ZERO;
 
 pub mod ai_query;
 pub mod backend;
@@ -33,6 +36,7 @@ pub mod domain;
 pub mod embed_queue;
 pub mod error;
 pub mod git_mining;
+pub mod glibc_compat;
 pub mod handlers;
 pub mod index;
 pub mod index_state;

crates/codegraph-server/src/main.rs

@@ -13,39 +13,16 @@ use std::path::PathBuf;
 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, 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.
+// glibc 2.31 compat: ONNX Runtime references `__libc_single_threaded`, which
+// glibc only defines from 2.32 on, so a build for SLES 15 SP4 and similar
+// needs a definition to link against. The storage has to be writable - glibc
+// writes the flag at startup - which is what `SingleThreaded` provides; see
+// `codegraph_server::glibc_compat` for the full story (issue #15).
 #[cfg(target_os = "linux")]
-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));
-}
+#[no_mangle]
+#[allow(non_upper_case_globals)]
+pub static __libc_single_threaded: codegraph_server::glibc_compat::SingleThreaded =
+    codegraph_server::glibc_compat::SingleThreaded::ZERO;
 
 #[derive(Parser)]
 #[command(name = "codegraph-server")]