issue-655: use safe getenv for aggressive decommit mode flag

Because otherwise we risk deadlock due to too early use of getenv on
windows.

2 files changed, 46 insertions, 5 deletions

diff --git a/src/base/commandlineflags.h b/src/base/commandlineflags.h
index 04d0ae9..f54776a 100644
--- a/src/base/commandlineflags.h
+++ b/src/base/commandlineflags.h
@@ -111,6 +111,40 @@
   }                                                                           \
   using FLAG__namespace_do_not_use_directly_use_DECLARE_string_instead::FLAGS_##name
 
+// implemented in sysinfo.cc
+namespace tcmalloc {
+  namespace commandlineflags {
+
+    inline bool StringToBool(const char *value, bool def) {
+      if (!value) {
+        return def;
+      }
+      return memchr("tTyY1\0", value[0], 6) != NULL;
+    }
+
+    inline int StringToInt(const char *value, int def) {
+      if (!value) {
+        return def;
+      }
+      return strtol(value, NULL, 10);
+    }
+
+    inline long long StringToLongLong(const char *value, long long def) {
+      if (!value) {
+        return def;
+      }
+      return strtoll(value, NULL, 10);
+    }
+
+    inline double StringToDouble(const char *value, double def) {
+      if (!value) {
+        return def;
+      }
+      return strtod(value, NULL);
+    }
+  }
+}
+
 // These macros (could be functions, but I don't want to bother with a .cc
 // file), make it easier to initialize flags from the environment.
 
@@ -118,15 +152,15 @@
   (!getenv(envname) ? (dflt) : getenv(envname))
 
 #define EnvToBool(envname, dflt)   \
-  (!getenv(envname) ? (dflt) : memchr("tTyY1\0", getenv(envname)[0], 6) != NULL)
+  tcmalloc::commandlineflags::StringToBool(getenv(envname), dflt)
 
 #define EnvToInt(envname, dflt)  \
-  (!getenv(envname) ? (dflt) : strtol(getenv(envname), NULL, 10))
+  tcmalloc::commandlineflags::StringToInt(getenv(envname), dflt)
 
 #define EnvToInt64(envname, dflt)  \
-  (!getenv(envname) ? (dflt) : strtoll(getenv(envname), NULL, 10))
+  tcmalloc::commandlineflags::StringToLongLong(getenv(envname), dflt)
 
 #define EnvToDouble(envname, dflt)  \
-  (!getenv(envname) ? (dflt) : strtod(getenv(envname), NULL))
+  tcmalloc::commandlineflags::StringToDouble(getenv(envname), dflt)
 
 #endif  // BASE_COMMANDLINEFLAGS_H_
diff --git a/src/static_vars.cc b/src/static_vars.cc
index 6d08ca1..558aa7d 100644
--- a/src/static_vars.cc
+++ b/src/static_vars.cc
@@ -41,6 +41,7 @@
 #include "internal_logging.h"  // for CHECK_CONDITION
 #include "common.h"
 #include "sampler.h"           // for Sampler
+#include "getenv_safe.h"       // TCMallocGetenvSafe
 #include "base/googleinit.h"
 
 namespace tcmalloc {
@@ -96,7 +97,13 @@ void Static::InitStaticVars() {
   // in is caches as pointers that are sources of heap object liveness,
   // which leads to it missing some memory leaks.
   pageheap_ = new (MetaDataAlloc(sizeof(PageHeap))) PageHeap;
-  pageheap_->SetAggressiveDecommit(EnvToBool("TCMALLOC_AGGRESSIVE_DECOMMIT", false));
+
+  bool aggressive_decommit =
+    tcmalloc::commandlineflags::StringToBool(
+      TCMallocGetenvSafe("TCMALLOC_AGGRESSIVE_DECOMMIT"), false);
+
+  pageheap_->SetAggressiveDecommit(aggressive_decommit);
+
   DLL_Init(&sampled_objects_);
   Sampler::InitStatics();
 }