netcore/corerun/coreruncommon.cpp

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 //
   6 // Code that is used by both the Unix corerun and coreconsole.
   7 //
   8
   9 #include "config.h"
  10
  11 #include <cstdlib>
  12 #include <cstring>
  13 #include <assert.h>
  14 #include <dirent.h>
  15 #include <dlfcn.h>
  16 #include <limits.h>
  17 #include <set>
  18 #include <string>
  19 #include <string.h>
  20 #include <sys/stat.h>
  21 #if defined(__FreeBSD__)
  22 #include <sys/types.h>
  23 #include <sys/param.h>
  24 #endif
  25 #if HAVE_GETAUXVAL
  26 #include <sys/auxv.h>
  27 #endif
  28 #if defined(HAVE_SYS_SYSCTL_H) || defined(__FreeBSD__)
  29 #include <sys/sysctl.h>
  30 #endif
  31 #include "coreruncommon.h"
  32 #include "coreclrhost.h"
  33 #include <unistd.h>
  34 #ifndef SUCCEEDED
  35 #define SUCCEEDED(Status) ((Status) >= 0)
  36 #endif // !SUCCEEDED
  37
  38 // Name of the environment variable controlling server GC.
  39 // If set to 1, server GC is enabled on startup. If 0, server GC is
  40 // disabled. Server GC is off by default.
  41 static const char* serverGcVar = "COMPlus_gcServer";
  42
  43 // Name of environment variable to control "System.Globalization.Invariant"
  44 // Set to 1 for Globalization Invariant mode to be true. Default is false.
  45 static const char* globalizationInvariantVar = "CORECLR_GLOBAL_INVARIANT";
  46
  47 #if defined(__linux__)
  48 #define symlinkEntrypointExecutable "/proc/self/exe"
  49 #elif !defined(__APPLE__)
  50 #define symlinkEntrypointExecutable "/proc/curproc/exe"
  51 #endif
  52
  53 bool GetEntrypointExecutableAbsolutePath(std::string& entrypointExecutable)
  54 {
  55     bool result = false;
  56
  57     entrypointExecutable.clear();
  58
  59     // Get path to the executable for the current process using
  60     // platform specific means.
  61 #if defined(__APPLE__)
  62
  63     // On Mac, we ask the OS for the absolute path to the entrypoint executable
  64     uint32_t lenActualPath = 0;
  65     if (_NSGetExecutablePath(nullptr, &lenActualPath) == -1)
  66     {
  67         // OSX has placed the actual path length in lenActualPath,
  68         // so re-attempt the operation
  69         std::string resizedPath(lenActualPath, '\0');
  70         char *pResizedPath = const_cast<char *>(resizedPath.c_str());
  71         if (_NSGetExecutablePath(pResizedPath, &lenActualPath) == 0)
  72         {
  73             entrypointExecutable.assign(pResizedPath);
  74             result = true;
  75         }
  76     }
  77 #elif defined (__FreeBSD__)
  78     static const int name[] = {
  79         CTL_KERN, KERN_PROC, KERN_PROC_PATHNAME, -1
  80     };
  81     char path[PATH_MAX];
  82     size_t len;
  83
  84     len = sizeof(path);
  85     if (sysctl(name, 4, path, &len, nullptr, 0) == 0)
  86     {
  87         entrypointExecutable.assign(path);
  88         result = true;
  89     }
  90     else
  91     {
  92         // ENOMEM
  93         result = false;
  94     }
  95 #elif defined(__NetBSD__) && defined(KERN_PROC_PATHNAME)
  96     static const int name[] = {
  97         CTL_KERN, KERN_PROC_ARGS, -1, KERN_PROC_PATHNAME,
  98     };
  99     char path[MAXPATHLEN];
 100     size_t len;
 101
 102     len = sizeof(path);
 103     if (sysctl(name, __arraycount(name), path, &len, NULL, 0) != -1)
 104     {
 105         entrypointExecutable.assign(path);
 106         result = true;
 107     }
 108     else
 109     {
 110         result = false;
 111     }
 112 #else
 113
 114 #if HAVE_GETAUXVAL && defined(AT_EXECFN)
 115     const char *execfn = (const char *)getauxval(AT_EXECFN);
 116
 117     if (execfn)
 118     {
 119         entrypointExecutable.assign(execfn);
 120         result = true;
 121     }
 122     else
 123 #endif
 124     // On other OSs, return the symlink that will be resolved by GetAbsolutePath
 125     // to fetch the entrypoint EXE absolute path, inclusive of filename.
 126     result = GetAbsolutePath(symlinkEntrypointExecutable, entrypointExecutable);
 127 #endif
 128
 129     return result;
 130 }
 131
 132 bool GetAbsolutePath(const char* path, std::string& absolutePath)
 133 {
 134     bool result = false;
 135
 136     char realPath[PATH_MAX];
 137     if (realpath(path, realPath) != nullptr && realPath[0] != '\0')
 138     {
 139         absolutePath.assign(realPath);
 140         // realpath should return canonicalized path without the trailing slash
 141         assert(absolutePath.back() != '/');
 142
 143         result = true;
 144     }
 145
 146     return result;
 147 }
 148
 149 bool GetDirectory(const char* absolutePath, std::string& directory)
 150 {
 151     directory.assign(absolutePath);
 152     size_t lastSlash = directory.rfind('/');
 153     if (lastSlash != std::string::npos)
 154     {
 155         directory.erase(lastSlash);
 156         return true;
 157     }
 158
 159     return false;
 160 }
 161
 162 bool GetClrFilesAbsolutePath(const char* currentExePath, const char* clrFilesPath, std::string& clrFilesAbsolutePath)
 163 {
 164     std::string clrFilesRelativePath;
 165     const char* clrFilesPathLocal = clrFilesPath;
 166     if (clrFilesPathLocal == nullptr)
 167     {
 168         // There was no CLR files path specified, use the folder of the corerun/coreconsole
 169         if (!GetDirectory(currentExePath, clrFilesRelativePath))
 170         {
 171             perror("Failed to get directory from argv[0]");
 172             return false;
 173         }
 174
 175         clrFilesPathLocal = clrFilesRelativePath.c_str();
 176
 177         // TODO: consider using an env variable (if defined) as a fall-back.
 178         // The windows version of the corerun uses core_root env variable
 179     }
 180
 181     if (!GetAbsolutePath(clrFilesPathLocal, clrFilesAbsolutePath))
 182     {
 183         perror("Failed to convert CLR files path to absolute path");
 184         return false;
 185     }
 186
 187     return true;
 188 }
 189
 190 void AddFilesFromDirectoryToTpaList(const char* directory, std::string& tpaList)
 191 {
 192     const char * const tpaExtensions[] = {
 193                 ".ni.dll",      // Probe for .ni.dll first so that it's preferred if ni and il coexist in the same dir
 194                 ".dll",
 195                 ".ni.exe",
 196                 ".exe",
 197                 };
 198
 199     DIR* dir = opendir(directory);
 200     if (dir == nullptr)
 201     {
 202         return;
 203     }
 204
 205     std::set<std::string> addedAssemblies;
 206
 207     // Walk the directory for each extension separately so that we first get files with .ni.dll extension,
 208     // then files with .dll extension, etc.
 209     for (size_t extIndex = 0; extIndex < sizeof(tpaExtensions) / sizeof(tpaExtensions[0]); extIndex++)
 210     {
 211         const char* ext = tpaExtensions[extIndex];
 212         int extLength = strlen(ext);
 213
 214         struct dirent* entry;
 215
 216         // For all entries in the directory
 217         while ((entry = readdir(dir)) != nullptr)
 218         {
 219             // We are interested in files only
 220             switch (entry->d_type)
 221             {
 222             case DT_REG:
 223                 break;
 224
 225             // Handle symlinks and file systems that do not support d_type
 226             case DT_LNK:
 227             case DT_UNKNOWN:
 228                 {
 229                     std::string fullFilename;
 230
 231                     fullFilename.append(directory);
 232                     fullFilename.append("/");
 233                     fullFilename.append(entry->d_name);
 234
 235                     struct stat sb;
 236                     if (stat(fullFilename.c_str(), &sb) == -1)
 237                     {
 238                         continue;
 239                     }
 240
 241                     if (!S_ISREG(sb.st_mode))
 242                     {
 243                         continue;
 244                     }
 245                 }
 246                 break;
 247
 248             default:
 249                 continue;
 250             }
 251
 252             std::string filename(entry->d_name);
 253
 254             // Check if the extension matches the one we are looking for
 255             int extPos = filename.length() - extLength;
 256             if ((extPos <= 0) || (filename.compare(extPos, extLength, ext) != 0))
 257             {
 258                 continue;
 259             }
 260
 261             std::string filenameWithoutExt(filename.substr(0, extPos));
 262
 263             // Make sure if we have an assembly with multiple extensions present,
 264             // we insert only one version of it.
 265             if (addedAssemblies.find(filenameWithoutExt) == addedAssemblies.end())
 266             {
 267                 addedAssemblies.insert(filenameWithoutExt);
 268
 269                 tpaList.append(directory);
 270                 tpaList.append("/");
 271                 tpaList.append(filename);
 272                 tpaList.append(":");
 273             }
 274         }
 275
 276         // Rewind the directory stream to be able to iterate over it for the next extension
 277         rewinddir(dir);
 278     }
 279
 280     closedir(dir);
 281 }
 282
 283 const char* GetEnvValueBoolean(const char* envVariable)
 284 {
 285     const char* envValue = std::getenv(envVariable);
 286     if (envValue == nullptr)
 287     {
 288         envValue = "0";
 289     }
 290     // CoreCLR expects strings "true" and "false" instead of "1" and "0".
 291     return (std::strcmp(envValue, "1") == 0 || strcasecmp(envValue, "true") == 0) ? "true" : "false";
 292 }
 293
 294 static void *TryLoadHostPolicy(const char *hostPolicyPath)
 295 {
 296 #if defined(__APPLE__)
 297     static const char LibrarySuffix[] = ".dylib";
 298 #else // Various Linux-related OS-es
 299     static const char LibrarySuffix[] = ".so";
 300 #endif
 301
 302     std::string hostPolicyCompletePath(hostPolicyPath);
 303     hostPolicyCompletePath.append(LibrarySuffix);
 304
 305     void *libraryPtr = dlopen(hostPolicyCompletePath.c_str(), RTLD_LAZY);
 306     if (libraryPtr == nullptr)
 307     {
 308         fprintf(stderr, "Failed to load mock hostpolicy at path '%s'. Error: %s", hostPolicyCompletePath.c_str(), dlerror());
 309     }
 310
 311     return libraryPtr;
 312 }
 313
 314 int ExecuteManagedAssembly(
 315             const char* currentExeAbsolutePath,
 316             const char* clrFilesAbsolutePath,
 317             const char* managedAssemblyAbsolutePath,
 318             int managedAssemblyArgc,
 319             const char** managedAssemblyArgv)
 320 {
 321     // Indicates failure
 322     int exitCode = -1;
 323
 324 #ifdef _ARM_
 325     // libunwind library is used to unwind stack frame, but libunwind for ARM
 326     // does not support ARM vfpv3/NEON registers in DWARF format correctly.
 327     // Therefore let's disable stack unwinding using DWARF information
 328     // See https://github.com/dotnet/coreclr/issues/6698
 329     //
 330     // libunwind use following methods to unwind stack frame.
 331     // UNW_ARM_METHOD_ALL          0xFF
 332     // UNW_ARM_METHOD_DWARF        0x01
 333     // UNW_ARM_METHOD_FRAME        0x02
 334     // UNW_ARM_METHOD_EXIDX        0x04
 335     putenv(const_cast<char *>("UNW_ARM_UNWIND_METHOD=6"));
 336 #endif // _ARM_
 337
 338     std::string coreClrDllPath(clrFilesAbsolutePath);
 339     coreClrDllPath.append("/");
 340     coreClrDllPath.append(coreClrDll);
 341
 342     if (coreClrDllPath.length() >= PATH_MAX)
 343     {
 344         fprintf(stderr, "Absolute path to libcoreclr.so too long\n");
 345         return -1;
 346     }
 347
 348     // Get just the path component of the managed assembly path
 349     std::string appPath;
 350     GetDirectory(managedAssemblyAbsolutePath, appPath);
 351
 352     std::string tpaList;
 353     if (strlen(managedAssemblyAbsolutePath) > 0)
 354     {
 355         // Target assembly should be added to the tpa list. Otherwise corerun.exe
 356         // may find wrong assembly to execute.
 357         // Details can be found at https://github.com/dotnet/coreclr/issues/5631
 358         tpaList = managedAssemblyAbsolutePath;
 359         tpaList.append(":");
 360     }
 361
 362     // Construct native search directory paths
 363     std::string nativeDllSearchDirs(appPath);
 364     char *coreLibraries = getenv("CORE_LIBRARIES");
 365     if (coreLibraries)
 366     {
 367         nativeDllSearchDirs.append(":");
 368         nativeDllSearchDirs.append(coreLibraries);
 369         if (std::strcmp(coreLibraries, clrFilesAbsolutePath) != 0)
 370         {
 371             AddFilesFromDirectoryToTpaList(coreLibraries, tpaList);
 372         }
 373     }
 374
 375     nativeDllSearchDirs.append(":");
 376     nativeDllSearchDirs.append(clrFilesAbsolutePath);
 377
 378     void* hostpolicyLib = nullptr;
 379     char* mockHostpolicyPath = getenv("MOCK_HOSTPOLICY");
 380     if (mockHostpolicyPath)
 381     {
 382         hostpolicyLib = TryLoadHostPolicy(mockHostpolicyPath);
 383         if (hostpolicyLib == nullptr)
 384         {
 385             return -1;
 386         }
 387     }
 388
 389     AddFilesFromDirectoryToTpaList(clrFilesAbsolutePath, tpaList);
 390
 391     void* coreclrLib = dlopen(coreClrDllPath.c_str(), RTLD_NOW | RTLD_LOCAL);
 392     if (coreclrLib != nullptr)
 393     {
 394         coreclr_initialize_ptr initializeCoreCLR = (coreclr_initialize_ptr)dlsym(coreclrLib, "coreclr_initialize");
 395         coreclr_execute_assembly_ptr executeAssembly = (coreclr_execute_assembly_ptr)dlsym(coreclrLib, "coreclr_execute_assembly");
 396         coreclr_shutdown_2_ptr shutdownCoreCLR = (coreclr_shutdown_2_ptr)dlsym(coreclrLib, "coreclr_shutdown_2");
 397
 398         if (initializeCoreCLR == nullptr)
 399         {
 400             fprintf(stderr, "Function coreclr_initialize not found in the libcoreclr.so\n");
 401         }
 402         else if (executeAssembly == nullptr)
 403         {
 404             fprintf(stderr, "Function coreclr_execute_assembly not found in the libcoreclr.so\n");
 405         }
 406         else if (shutdownCoreCLR == nullptr)
 407         {
 408             fprintf(stderr, "Function coreclr_shutdown_2 not found in the libcoreclr.so\n");
 409         }
 410         else
 411         {
 412             // Check whether we are enabling server GC (off by default)
 413             const char* useServerGc = GetEnvValueBoolean(serverGcVar);
 414
 415             // Check Globalization Invariant mode (false by default)
 416             const char* globalizationInvariant = GetEnvValueBoolean(globalizationInvariantVar);
 417
 418             // Allowed property names:
 419             // APPBASE
 420             // - The base path of the application from which the exe and other assemblies will be loaded
 421             //
 422             // TRUSTED_PLATFORM_ASSEMBLIES
 423             // - The list of complete paths to each of the fully trusted assemblies
 424             //
 425             // APP_PATHS
 426             // - The list of paths which will be probed by the assembly loader
 427             //
 428             // APP_NI_PATHS
 429             // - The list of additional paths that the assembly loader will probe for ngen images
 430             //
 431             // NATIVE_DLL_SEARCH_DIRECTORIES
 432             // - The list of paths that will be probed for native DLLs called by PInvoke
 433             //
 434             const char *propertyKeys[] = {
 435                 "TRUSTED_PLATFORM_ASSEMBLIES",
 436                 "APP_PATHS",
 437                 "APP_NI_PATHS",
 438                 "NATIVE_DLL_SEARCH_DIRECTORIES",
 439                 "System.GC.Server",
 440                 "System.Globalization.Invariant",
 441             };
 442             const char *propertyValues[] = {
 443                 // TRUSTED_PLATFORM_ASSEMBLIES
 444                 tpaList.c_str(),
 445                 // APP_PATHS
 446                 appPath.c_str(),
 447                 // APP_NI_PATHS
 448                 appPath.c_str(),
 449                 // NATIVE_DLL_SEARCH_DIRECTORIES
 450                 nativeDllSearchDirs.c_str(),
 451                 // System.GC.Server
 452                 useServerGc,
 453                 // System.Globalization.Invariant
 454                 globalizationInvariant,
 455             };
 456
 457             void* hostHandle;
 458             unsigned int domainId;
 459
 460             int st = initializeCoreCLR(
 461                         currentExeAbsolutePath,
 462                         "unixcorerun",
 463                         sizeof(propertyKeys) / sizeof(propertyKeys[0]),
 464                         propertyKeys,
 465                         propertyValues,
 466                         &hostHandle,
 467                         &domainId);
 468
 469             if (!SUCCEEDED(st))
 470             {
 471                 fprintf(stderr, "coreclr_initialize failed - status: 0x%08x\n", st);
 472                 exitCode = -1;
 473             }
 474             else
 475             {
 476                 st = executeAssembly(
 477                         hostHandle,
 478                         domainId,
 479                         managedAssemblyArgc,
 480                         managedAssemblyArgv,
 481                         managedAssemblyAbsolutePath,
 482                         (unsigned int*)&exitCode);
 483
 484                 if (!SUCCEEDED(st))
 485                 {
 486                     fprintf(stderr, "coreclr_execute_assembly failed - status: 0x%08x\n", st);
 487                     exitCode = -1;
 488                 }
 489
 490                 int latchedExitCode = 0;
 491                 st = shutdownCoreCLR(hostHandle, domainId, &latchedExitCode);
 492                 if (!SUCCEEDED(st))
 493                 {
 494                     fprintf(stderr, "coreclr_shutdown failed - status: 0x%08x\n", st);
 495                     exitCode = -1;
 496                 }
 497
 498                 if (exitCode != -1)
 499                 {
 500                     exitCode = latchedExitCode;
 501                 }
 502             }
 503         }
 504     }
 505     else
 506     {
 507         const char* error = dlerror();
 508         fprintf(stderr, "dlopen failed to open the libcoreclr.so with error %s\n", error);
 509     }
 510
 511     if (hostpolicyLib)
 512     {
 513         if(dlclose(hostpolicyLib) != 0)
 514         {
 515             fprintf(stderr, "Warning - dlclose of mock hostpolicy failed.\n");
 516         }
 517     }
 518
 519     return exitCode;
 520 }