Set the static TLS reserve for Geant4 inside the sim executables

This fixes o2-sim on the GRID, where Geant4 cannot be loaded since it uses the initial-exec TLS model.

- A Geant4 loaded by dlopen needs a glibc static TLS reserve, which the Geant4 environment sets in GLIBC_TUNABLES.
- In GRID jobs the variable arrives truncated as glibc.rtld.optional_static_tls, without its value, and is ignored.
- The executables that load Geant4 now check the reserve first in main and, if it is missing, malformed or too
  small, restart themselves once with it set.
- Other tunables are kept, and a larger reserve set by the user is left as is.

https://its.cern.ch/jira/browse/O2-7305

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: sawenzel

Detectors/gconfig/include/SimSetup/StaticTLSReserve.h

@@ -0,0 +1,81 @@
+// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
+// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
+// All rights not expressly granted are reserved.
+//
+// This software is distributed under the terms of the GNU General Public
+// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
+//
+// In applying this license CERN does not waive the privileges and immunities
+// granted to it by virtue of its status as an Intergovernmental Organization
+// or submit itself to any jurisdiction.
+
+#ifndef O2_SIMSETUP_STATICTLSRESERVE_H
+#define O2_SIMSETUP_STATICTLSRESERVE_H
+
+#include <cstdlib>
+#include <string>
+#include <string_view>
+#include <unistd.h>
+
+namespace o2
+{
+
+/// The GLIBC_TUNABLES value with a static TLS reserve of at least `reserve` bytes, or an empty string if the
+/// given value already has one. Other tunables are kept; a malformed or smaller reserve is replaced.
+inline std::string withStaticTLSReserve(const char* tunables, unsigned long reserve)
+{
+  constexpr std::string_view name = "glibc.rtld.optional_static_tls";
+  std::string kept;
+  bool sufficient = false;
+  std::string_view rest = tunables ? tunables : "";
+  while (!rest.empty()) {
+    const auto colon = rest.find(':');
+    const std::string_view entry = rest.substr(0, colon);
+    rest = colon == std::string_view::npos ? std::string_view{} : rest.substr(colon + 1);
+    if (entry.substr(0, name.size()) == name) {
+      if (entry.size() > name.size() + 1 && entry[name.size()] == '=') {
+        const std::string value(entry.substr(name.size() + 1));
+        char* end = nullptr;
+        const unsigned long bytes = std::strtoul(value.c_str(), &end, 0);
+        if (end && *end == '\0' && bytes >= reserve) {
+          sufficient = true;
+          break;
+        }
+      }
+      continue; // drop a reserve that is malformed or too small
+    }
+    if (!entry.empty()) {
+      kept += (kept.empty() ? "" : ":") + std::string(entry);
+    }
+  }
+  if (sufficient) {
+    return {};
+  }
+  return std::string(name) + "=" + std::to_string(reserve) + (kept.empty() ? "" : ":" + kept);
+}
+
+/// Restarts the program once with a glibc static TLS reserve, which a Geant4 built with the initial-exec TLS
+/// model needs when it is loaded by dlopen. glibc reads GLIBC_TUNABLES only at program start, so the reserve
+/// cannot be set later. Call this first in main, before any thread is started.
+inline void ensureStaticTLSReserve(char* argv[], unsigned long reserve = 32768)
+{
+#ifdef __linux__
+  constexpr const char* guard = "O2_STATIC_TLS_REEXEC";
+  if (getenv(guard)) {
+    unsetenv(guard); // already restarted once; do not loop if glibc ignores the tunable
+    return;
+  }
+  const auto tunables = withStaticTLSReserve(getenv("GLIBC_TUNABLES"), reserve);
+  if (tunables.empty()) {
+    return;
+  }
+  setenv("GLIBC_TUNABLES", tunables.c_str(), 1);
+  setenv(guard, "1", 1);
+  execv("/proc/self/exe", argv);
+  // if the restart fails we carry on; a failing dlopen reports the cause
+#endif
+}
+
+} // namespace o2
+
+#endif

run/O2SimDeviceRunner.cxx

@@ -39,6 +39,7 @@
 #include "rapidjson/document.h"
 #include "rapidjson/stringbuffer.h"
 #include "rapidjson/filereadstream.h"
+#include <SimSetup/StaticTLSReserve.h>
 namespace bpo = boost::program_options;
 
 std::vector<int> gChildProcesses; // global vector of child pids
@@ -267,6 +268,8 @@ bool waitForControlInput(int workerID)
 
 int main(int argc, char* argv[])
 {
+  // Geant4 is loaded by dlopen and may need a static TLS reserve, which glibc only takes at program start
+  o2::ensureStaticTLSReserve(argv);
   struct sigaction act;
   memset(&act, 0, sizeof act);
   sigemptyset(&act.sa_mask);

run/o2sim.cxx

@@ -13,9 +13,12 @@
 #include <SimConfig/SimConfig.h>
 #include <TStopwatch.h>
 #include <fairlogger/Logger.h>
+#include <SimSetup/StaticTLSReserve.h>
 
 int main(int argc, char* argv[])
 {
+  // Geant4 is loaded by dlopen and may need a static TLS reserve, which glibc only takes at program start
+  o2::ensureStaticTLSReserve(argv);
   TStopwatch timer;
   timer.Start();
   auto& conf = o2::conf::SimConfig::Instance();

run/o2sim_evalmat.cxx

@@ -14,9 +14,12 @@
 #include <SimConfig/MatMapParams.h>
 #include <TStopwatch.h>
 #include <fairlogger/Logger.h>
+#include <SimSetup/StaticTLSReserve.h>
 
 int main(int argc, char* argv[])
 {
+  // Geant4 is loaded by dlopen and may need a static TLS reserve, which glibc only takes at program start
+  o2::ensureStaticTLSReserve(argv);
   TStopwatch timer;
   timer.Start();
 

run/o2sim_mbudget.cxx

@@ -13,9 +13,12 @@
 #include <SimConfig/SimConfig.h>
 #include <TStopwatch.h>
 #include <fairlogger/Logger.h>
+#include <SimSetup/StaticTLSReserve.h>
 
 int main(int argc, char* argv[])
 {
+  // Geant4 is loaded by dlopen and may need a static TLS reserve, which glibc only takes at program start
+  o2::ensureStaticTLSReserve(argv);
   TStopwatch timer;
   timer.Start();
   auto& conf = o2::conf::SimConfig::Instance();