Add a no-cache backed CLRConfig lookup mechanism

src/coreclr/inc/clrconfig.h

@@ -126,10 +126,7 @@ class CLRConfig
  static HRESULT GetConfigValue(const ConfigStringInfo & info, __deref_out_z LPWSTR * outVal);
 
  //
- // Check whether an option is specified (e.g. explicitly listed) in any of the CLRConfig
- // locations: environment or registry (with or without COMPlus_) or any config file.
- // The result is therefore a conservative approximation (some settings do not actually
- // take effect everywhere and no setting is valid both with and without COMPlus_)
+ // Check whether an option is specified (e.g. explicitly listed) in the CLRConfig.
  //
  static BOOL IsConfigOptionSpecified(LPCWSTR name);
 

src/coreclr/inc/clrconfignocache.h

@@ -0,0 +1,94 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+//
+// --------------------------------------------------------------------------------------------------
+// clrconfignocache.h
+//
+// Logic for resolving configuration names.
+//
+
+#ifndef StrLen
+#define StrLen(STR) ((sizeof(STR) / sizeof(STR[0])) - 1)
+#endif // !StrLen
+
+// Config prefixes
+#define COMPLUS_PREFIX_A "COMPlus_"
+#define COMPLUS_PREFIX W("COMPlus_")
+#define LEN_OF_COMPLUS_PREFIX StrLen(COMPLUS_PREFIX_A)
+
+#define DOTNET_PREFIX_A "DOTNET_"
+#define DOTNET_PREFIX W("DOTNET_")
+#define LEN_OF_DOTNET_PREFIX StrLen(DOTNET_PREFIX_A)
+
+class CLRConfigNoCache
+{
+ const char* _value;
+
+ CLRConfigNoCache() = default;
+ CLRConfigNoCache(LPCSTR cfg) : _value { cfg }
+ { }
+
+public:
+ bool IsSet() const { return _value != NULL; }
+
+ LPCSTR AsString() const
+ {
+ _ASSERTE(IsSet());
+ return _value;
+ }
+
+ bool TryAsInteger(int radix, DWORD& result) const
+ {
+ _ASSERTE(IsSet());
+
+ errno = 0;
+ LPSTR endPtr;
+ result = strtoul(_value, &endPtr, radix);
+ bool fSuccess = (errno != ERANGE) && (endPtr != _value);
+ return fSuccess;
+ }
+
+ static CLRConfigNoCache Get(LPCSTR cfg, bool noPrefix = false, char*(*getEnvFptr)(const char*) = nullptr)
+ {
+ char nameBuffer[64];
+ const char* fallbackPrefix = NULL;
+ const size_t namelen = strlen(cfg);
+
+ if (noPrefix)
+ {
+ if (namelen >= _countof(nameBuffer))
+ {
+ _ASSERTE(!"Environment variable name too long.");
+ return {};
+ }
+
+ *nameBuffer = W('\0');
+ }
+ else
+ {
+ bool dotnetValid = namelen < (size_t)(_countof(nameBuffer) - 1 - LEN_OF_DOTNET_PREFIX);
+ bool complusValid = namelen < (size_t)(_countof(nameBuffer) - 1 - LEN_OF_COMPLUS_PREFIX);
+ if (!dotnetValid || !complusValid)
+ {
+ _ASSERTE(!"Environment variable name too long.");
+ return {};
+ }
+
+ // Priority order is DOTNET_ and then COMPlus_.
+ strcpy_s(nameBuffer, _countof(nameBuffer), DOTNET_PREFIX_A);
+ fallbackPrefix = COMPLUS_PREFIX_A;
+ }
+
+ strcat_s(nameBuffer, _countof(nameBuffer), cfg);
+
+ LPCSTR val = getEnvFptr != NULL ? getEnvFptr(nameBuffer) : getenv(nameBuffer);
+ if (val == NULL && fallbackPrefix != NULL)
+ {
+ strcpy_s(nameBuffer, _countof(nameBuffer), fallbackPrefix);
+ strcat_s(nameBuffer, _countof(nameBuffer), cfg);
+ val = getEnvFptr != NULL ? getEnvFptr(nameBuffer) : getenv(nameBuffer);
+ }
+
+ return { val };
+ }
+};

src/coreclr/inc/clrconfigvalues.h

@@ -677,6 +677,11 @@ RETAIL_CONFIG_DWORD_INFO(INTERNAL_EventPipeCircularMB, W("EventPipeCircularMB"),
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_EventPipeProcNumbers, W("EventPipeProcNumbers"), 0, "Enable/disable capturing processor numbers in EventPipe event headers")
 RETAIL_CONFIG_DWORD_INFO(INTERNAL_EventPipeOutputStreaming, W("EventPipeOutputStreaming"), 0, "Enable/disable streaming for trace file set in COMPlus_EventPipeOutputPath. Non-zero values enable streaming.")
 
+#ifdef FEATURE_AUTO_TRACE
+RETAIL_CONFIG_DWORD_INFO_EX(INTERNAL_AutoTrace_N_Tracers, W("AutoTrace_N_Tracers"), 0, "", CLRConfig::LookupOptions::ParseIntegerAsBase10)
+RETAIL_CONFIG_STRING_INFO(INTERNAL_AutoTrace_Command, W("AutoTrace_Command"), "")
+#endif // FEATURE_AUTO_TRACE
+
 //
 // Generational Aware Analysis
 //

src/coreclr/inc/cor.h

@@ -1634,12 +1634,6 @@ DECLARE_INTERFACE_(IMetaDataInfo, IUnknown)
 // Native Link method custom value definitions. This is for N-direct support.
 //
 
-#define COR_NATIVE_LINK_CUSTOM_VALUE L"COMPLUS_NativeLink"
-#define COR_NATIVE_LINK_CUSTOM_VALUE_ANSI "COMPLUS_NativeLink"
-
-// count of chars for COR_NATIVE_LINK_CUSTOM_VALUE(_ANSI)
-#define COR_NATIVE_LINK_CUSTOM_VALUE_CC 18
-
 #include <pshpack1.h>
 typedef struct
 {

src/coreclr/pal/src/exception/signal.cpp

@@ -31,6 +31,8 @@ SET_DEFAULT_DEBUG_CHANNEL(EXCEPT); // some headers have code with asserts, so do
 
 #include "pal/palinternal.h"
 
+#include <clrconfignocache.h>
+
 #include <errno.h>
 #include <signal.h>
 
@@ -145,9 +147,15 @@ BOOL SEHInitializeSignals(CorUnix::CPalThread *pthrCurrent, DWORD flags)
  TRACE("Initializing signal handlers %04x\n", flags);
 
 #if !HAVE_MACH_EXCEPTIONS
-char* enableAlternateStackCheck = getenv("COMPlus_EnableAlternateStackCheck");
+g_enable_alternate_stack_check = false;
 
- g_enable_alternate_stack_check = enableAlternateStackCheck && (strtoul(enableAlternateStackCheck, NULL, 10) != 0);
+ CLRConfigNoCache stackCheck = CLRConfigNoCache::Get("EnableAlternateStackCheck", /*noprefix*/ false, &getenv);
+ if (stackCheck.IsSet())
+ {
+ DWORD value;
+ if (stackCheck.TryAsInteger(10, value))
+ g_enable_alternate_stack_check = (value != 0);
+ }
 #endif
 
  if (flags & PAL_INITIALIZE_REGISTER_SIGNALS)

src/coreclr/pal/src/init/pal.cpp

@@ -89,6 +89,7 @@ int CacheLineSize;
 #endif
 
 #include <algorithm>
+#include <clrconfignocache.h>
 
 using namespace CorUnix;
 
@@ -268,17 +269,13 @@ EnsureStackSize(SIZE_T stackSize)
 void
 InitializeDefaultStackSize()
 {
-char* defaultStackSizeStr = getenv("COMPlus_DefaultStackSize");
- if (defaultStackSizeStr != NULL)
+CLRConfigNoCache defStackSize = CLRConfigNoCache::Get("DefaultStackSize", /*noprefix*/ false, &getenv);
+ if (defStackSize.IsSet())
  {
- errno = 0;
- // Like all numeric values specific by the COMPlus_xxx variables, it is a
- // hexadecimal string without any prefix.
- long int size = strtol(defaultStackSizeStr, NULL, 16);
-
- if (errno == 0)
+ DWORD size;
+ if (defStackSize.TryAsInteger(16, size))
  {
- g_defaultStackSize = std::max(size, (long int)PTHREAD_STACK_MIN);
+ g_defaultStackSize = std::max(size, (DWORD)PTHREAD_STACK_MIN);
  }
  }
 
@@ -406,15 +403,11 @@ Initialize(
 #endif // ENSURE_PRIMARY_STACK_SIZE
 
 #ifdef FEATURE_ENABLE_NO_ADDRESS_SPACE_RANDOMIZATION
-char* useDefaultBaseAddr = getenv("COMPlus_UseDefaultBaseAddr");
- if (useDefaultBaseAddr != NULL)
+CLRConfigNoCache useDefaultBaseAddr = CLRConfigNoCache::Get("UseDefaultBaseAddr", /*noprefix*/ false, &getenv);
+ if (useDefaultBaseAddr.IsSet())
  {
- errno = 0;
- // Like all numeric values specific by the COMPlus_xxx variables, it is a
- // hexadecimal string without any prefix.
- long int flag = strtol(useDefaultBaseAddr, NULL, 16);
-
- if (errno == 0)
+ DWORD flag;
+ if (useDefaultBaseAddr.TryAsInteger(16, flag))
  {
  g_useDefaultBaseAddr = (BOOL) flag;
  }

src/coreclr/pal/src/misc/tracepointprovider.cpp

@@ -30,6 +30,10 @@ Revision History:
 
 SET_DEFAULT_DEBUG_CHANNEL(MISC);
 
+// clrconfignocache.h uses macro _ASSERTE, which needd to use variable
+// defdbgchan defined by SET_DEFAULT_DEBUG_CHANNEL.
+#include <clrconfignocache.h>
+
 /*++
 
 Initialization logic for LTTng tracepoint providers.
@@ -62,10 +66,12 @@ PAL_InitializeTracing(void)
  // Check if loading the LTTng providers should be disabled.
  // Note: this env var is formally declared in clrconfigvalues.h, but
  // this code is executed too early to use the mechanics that come with that definition.
-char *disableValue = getenv("COMPlus_LTTng");
- if (disableValue != NULL)
+CLRConfigNoCache cfgLTTng = CLRConfigNoCache::Get("LTTng", /*noprefix*/ false, &getenv);
+ if (cfgLTTng.IsSet())
  {
- fShouldLoad = strtol(disableValue, NULL, 10);
+ DWORD value;
+ if (cfgLTTng.TryAsInteger(10, value))
+ fShouldLoad = (int)value;
  }
 
  // Get the path to the currently executing shared object (libcoreclr.so).

src/coreclr/pal/src/thread/process.cpp

@@ -37,6 +37,8 @@ SET_DEFAULT_DEBUG_CHANNEL(PROCESS); // some headers have code with asserts, so d
 #include "pal/stackstring.hpp"
 #include "pal/signal.hpp"
 
+#include <clrconfignocache.h>
+
 #include <errno.h>
 #if HAVE_POLL
 #include <poll.h>
@@ -3108,6 +3110,8 @@ PROCFormatInt(ULONG32 value)
  return buffer;
 }
 
+static const INT UndefinedDumpType = 0;
+
 /*++
 Function
  PROCBuildCreateDumpCommandLine
@@ -3124,8 +3128,8 @@ PROCBuildCreateDumpCommandLine(
  std::vector<const char*>& argv,
  char** pprogram,
  char** ppidarg,
- char* dumpName,
-char* dumpType,
+const char* dumpName,
+INT dumpType,
  BOOL diag,
  BOOL crashReport)
 {
@@ -3170,24 +3174,19 @@ PROCBuildCreateDumpCommandLine(
  argv.push_back(dumpName);
  }
 
-if (dumpType != nullptr)
+switch (dumpType)
  {
- if (strcmp(dumpType, "1") == 0)
- {
- argv.push_back("--normal");
- }
- else if (strcmp(dumpType, "2") == 0)
- {
- argv.push_back("--withheap");
- }
- else if (strcmp(dumpType, "3") == 0)
- {
- argv.push_back("--triage");
- }
- else if (strcmp(dumpType, "4") == 0)
- {
- argv.push_back("--full");
- }
+ case 1: argv.push_back("--normal");
+ break;
+ case 2: argv.push_back("--withheap");
+ break;
+ case 3: argv.push_back("--triage");
+ break;
+ case 4: argv.push_back("--full");
+ break;
+ case UndefinedDumpType:
+ default:
+ break;
  }
 
  if (diag)
@@ -3277,19 +3276,37 @@ Return
 BOOL
 PROCAbortInitialize()
 {
- char* enabled = getenv("COMPlus_DbgEnableMiniDump");
- if (enabled != nullptr && _stricmp(enabled, "1") == 0)
+ CLRConfigNoCache enabledCfg= CLRConfigNoCache::Get("DbgEnableMiniDump", /*noprefix*/ false, &getenv);
+
+ DWORD enabled = 0;
+ if (enabledCfg.IsSet()
+ && enabledCfg.TryAsInteger(10, enabled)
+ && enabled)
  {
- char* dumpName = getenv("COMPlus_DbgMiniDumpName");
- char* dumpType = getenv("COMPlus_DbgMiniDumpType");
- char* diagStr = getenv("COMPlus_CreateDumpDiagnostics");
- BOOL diag = diagStr != nullptr && strcmp(diagStr, "1") == 0;
- char* crashReportStr = getenv("COMPlus_EnableCrashReport");
- BOOL crashReport = crashReportStr != nullptr && strcmp(crashReportStr, "1") == 0;
+ CLRConfigNoCache dmpNameCfg = CLRConfigNoCache::Get("DbgMiniDumpName", /*noprefix*/ false, &getenv);
+
+ CLRConfigNoCache dmpTypeCfg = CLRConfigNoCache::Get("DbgMiniDumpType", /*noprefix*/ false, &getenv);
+ DWORD dumpType = UndefinedDumpType;
+ if (dmpTypeCfg.IsSet())
+ {
+ (void)dmpTypeCfg.TryAsInteger(10, dumpType);
+ if (dumpType < 1 || dumpType > 4)
+ {
+ dumpType = UndefinedDumpType;
+ }
+ }
+
+ CLRConfigNoCache createDumpCfg = CLRConfigNoCache::Get("CreateDumpDiagnostics", /*noprefix*/ false, &getenv);
+ DWORD val = 0;
+ BOOL diag = createDumpCfg.IsSet() && createDumpCfg.TryAsInteger(10, val) && val == 1;
+
+ CLRConfigNoCache enabldReportCfg = CLRConfigNoCache::Get("EnableCrashReport", /*noprefix*/ false, &getenv);
+ val = 0;
+ BOOL crashReport = enabldReportCfg.IsSet() && enabldReportCfg.TryAsInteger(10, val) && val == 1;
 
  char* program = nullptr;
  char* pidarg = nullptr;
- if (!PROCBuildCreateDumpCommandLine(g_argvCreateDump, &program, &pidarg, dumpName, dumpType, diag, crashReport))
+ if (!PROCBuildCreateDumpCommandLine(g_argvCreateDump, &program, &pidarg, dmpNameCfg.AsString(), dumpType, diag, crashReport))
  {
  return FALSE;
  }
@@ -3325,23 +3342,18 @@ PAL_GenerateCoreDump(
  BOOL diag)
 {
  std::vector<const char*> argvCreateDump;
- char dumpTypeStr[16];
 
  if (dumpType < 1 || dumpType > 4)
  {
  return FALSE;
  }
- if (_itoa_s(dumpType, dumpTypeStr, sizeof(dumpTypeStr), 10) != 0)
- {
- return FALSE;
- }
  if (dumpName != nullptr && dumpName[0] == '\0')
  {
  dumpName = nullptr;
  }
  char* program = nullptr;
  char* pidarg = nullptr;
- BOOL result = PROCBuildCreateDumpCommandLine(argvCreateDump, &program, &pidarg, (char*)dumpName, dumpTypeStr, diag, false);
+ BOOL result = PROCBuildCreateDumpCommandLine(argvCreateDump, &program, &pidarg, dumpName, dumpType, diag, false);
  if (result)
  {
  result = PROCCreateCrashDump(argvCreateDump);