Drop tunables without a value and read hex and octal reserves

- glibc ignores the whole GLIBC_TUNABLES string if one entry has no value, so such entries are dropped and trigger a rewrite.
- Reserves in hex (0x) or octal (leading 0) are read as glibc reads them, so a larger one is kept.

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

Author: sawenzel

Detectors/gconfig/include/SimSetup/StaticTLSReserve.h

@@ -29,34 +29,48 @@ namespace o2
 constexpr unsigned long Geant4StaticTLSReserve = 32768;
 
 /// The GLIBC_TUNABLES value with a static TLS reserve of at least `reserve` bytes, or an empty string if
-/// `tunables` already has one. As in glibc, the last well-formed reserve counts. Other tunables are kept.
+/// `tunables` already has one. As in glibc, the last reserve counts and numbers may be hex (0x) or octal (0).
+/// Other tunables are kept; entries without a value are dropped, since glibc then ignores the whole string.
 inline std::string withStaticTLSReserve(const char* tunables, unsigned long reserve = Geant4StaticTLSReserve)
 {
   constexpr std::string_view name = "glibc.rtld.optional_static_tls";
   std::string kept;
   bool haveReserve = false;
+  bool malformed = false;
   unsigned long current = 0;
   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);
     const auto equal = entry.find('=');
+    if (equal == std::string_view::npos || equal == 0) {
+      malformed = true; // also the truncated reserve as it arrives in GRID jobs
+      continue;
+    }
     if (entry.substr(0, equal) == name) {
-      const std::string_view value = equal == std::string_view::npos ? std::string_view{} : entry.substr(equal + 1);
+      std::string_view value = entry.substr(equal + 1);
+      int base = 10;
+      if (value.size() > 2 && value[0] == '0' && (value[1] == 'x' || value[1] == 'X')) {
+        base = 16;
+        value.remove_prefix(2);
+      } else if (value.size() > 1 && value[0] == '0') {
+        base = 8;
+        value.remove_prefix(1);
+      }
       unsigned long bytes = 0;
-      const auto [end, ec] = std::from_chars(value.data(), value.data() + value.size(), bytes);
+      const auto [end, ec] = std::from_chars(value.data(), value.data() + value.size(), bytes, base);
       if (!value.empty() && ec == std::errc() && end == value.data() + value.size()) {
         haveReserve = true;
         current = bytes;
+      } else {
+        haveReserve = false; // a broken last value leaves no reserve
       }
       continue; // our own entry replaces all of them
     }
-    if (!entry.empty()) {
-      kept += (kept.empty() ? "" : ":") + std::string(entry);
-    }
+    kept += (kept.empty() ? "" : ":") + std::string(entry);
   }
-  if (haveReserve && current >= reserve) {
+  if (!malformed && haveReserve && current >= reserve) {
     return {};
   }
   return std::string(name) + "=" + std::to_string(reserve) + (kept.empty() ? "" : ":" + kept);

Detectors/gconfig/test/testStaticTLSReserve.cxx

@@ -35,6 +35,19 @@ BOOST_AUTO_TEST_CASE(sufficient_reserve_is_kept)
   BOOST_CHECK_EQUAL(withStaticTLSReserve("glibc.rtld.optional_static_tls=32768", 32768), "");
   BOOST_CHECK_EQUAL(withStaticTLSReserve("glibc.rtld.optional_static_tls=1048576", 32768), "");
   BOOST_CHECK_EQUAL(withStaticTLSReserve("glibc.malloc.arena_max=4:glibc.rtld.optional_static_tls=65536", 32768), "");
+  // glibc also takes hex and octal
+  BOOST_CHECK_EQUAL(withStaticTLSReserve("glibc.rtld.optional_static_tls=0x100000", 32768), "");
+  BOOST_CHECK_EQUAL(withStaticTLSReserve("glibc.rtld.optional_static_tls=0100000", 32768), "");
+  BOOST_CHECK_EQUAL(withStaticTLSReserve("glibc.rtld.optional_static_tls=0x200", 32768), "glibc.rtld.optional_static_tls=32768");
+}
+
+BOOST_AUTO_TEST_CASE(malformed_entries_are_dropped)
+{
+  // glibc ignores the whole string if one entry has no value, so a good reserve next to it does not count
+  BOOST_CHECK_EQUAL(withStaticTLSReserve("glibc.rtld.optional_static_tls=32768:glibc.malloc.arena_max", 32768),
+                    "glibc.rtld.optional_static_tls=32768");
+  BOOST_CHECK_EQUAL(withStaticTLSReserve("glibc.malloc.arena_max:glibc.malloc.tcache_count=0", 32768),
+                    "glibc.rtld.optional_static_tls=32768:glibc.malloc.tcache_count=0");
 }
 
 BOOST_AUTO_TEST_CASE(other_tunables_are_kept)