/// <summary>
/// Finds or downloads the ELF module
/// </summary>
/// <param name="module">module instance</param>
/// <returns>module path or null</returns>
private string DownloadELF(IModule module)
{
if (module.BuildId.IsDefaultOrEmpty)
{
Trace.TraceWarning($"DownloadELF: module {module.FileName} has no build id");
return(null);
}
SymbolStoreKey moduleKey = ELFFileKeyGenerator.GetKeys(KeyTypeFlags.IdentityKey, module.FileName, module.BuildId.ToArray(), symbolFile: false, symbolFileName: null).SingleOrDefault();
if (moduleKey is null)
{
Trace.TraceWarning($"DownloadELF: no index generated for module {module.FileName} ");
return(null);
}
if (File.Exists(module.FileName))
{
using Utilities.ELFModule elfModule = Utilities.OpenELFFile(module.FileName);
if (elfModule is not null)
{
var generator = new ELFFileKeyGenerator(Tracer.Instance, elfModule, module.FileName);
IEnumerable <SymbolStoreKey> keys = generator.GetKeys(KeyTypeFlags.IdentityKey);
foreach (SymbolStoreKey key in keys)
{
if (moduleKey.Equals(key))
{
Trace.TraceInformation("DownloadELF: local file match {0}", module.FileName);
return(module.FileName);
}
}
}
}
// Now download the module from the symbol server if local file doesn't exists or doesn't have the right key
string downloadFilePath = DownloadFile(moduleKey);
if (!string.IsNullOrEmpty(downloadFilePath))
{
Trace.TraceInformation("DownloadELF: downloaded {0}", downloadFilePath);
return(downloadFilePath);
}
return(null);
}
private string GetDacFile(ClrInfo clrInfo)
{
if (_dacFilePath == null)
{
string dac = clrInfo.LocalMatchingDac;
if (dac != null && File.Exists(dac))
{
_dacFilePath = dac;
}
else if (SymbolReader.IsSymbolStoreEnabled())
{
string dacFileName = Path.GetFileName(dac ?? clrInfo.DacInfo.FileName);
if (dacFileName != null)
{
SymbolStoreKey key = null;
if (clrInfo.ModuleInfo.BuildId != null)
{
IEnumerable <SymbolStoreKey> keys = ELFFileKeyGenerator.GetKeys(
KeyTypeFlags.ClrKeys, clrInfo.ModuleInfo.FileName, clrInfo.ModuleInfo.BuildId, symbolFile: false, symbolFileName: null);
key = keys.SingleOrDefault((k) => Path.GetFileName(k.FullPathName) == dacFileName);
}
else
{
// Use the coreclr.dll's id (timestamp/filesize) to download the the dac module.
key = PEFileKeyGenerator.GetKey(dacFileName, clrInfo.ModuleInfo.TimeStamp, clrInfo.ModuleInfo.FileSize);
}
if (key != null)
{
// Now download the DAC module from the symbol server
_dacFilePath = SymbolReader.GetSymbolFile(key);
}
}
}
if (_dacFilePath == null)
{
throw new FileNotFoundException($"Could not find matching DAC for this runtime: {clrInfo.ModuleInfo.FileName}");
}
_isDesktop = clrInfo.Flavor == ClrFlavor.Desktop;
}
return(_dacFilePath);
}
private string DownloadModule(string moduleName, byte[] buildId)
{
Assert.True(buildId.Length > 0);
SymbolStoreKey key = null;
OSPlatform platform;
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
// This is the cross-DAC case when OpenVirtualProcess calls on a Linux/MacOS dump. Should never
// get here for a Windows dump or for live sessions (RegisterForRuntimeStartup, etc).
platform = _targetOS;
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
platform = OSPlatform.Linux;
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
platform = OSPlatform.OSX;
}
else
{
throw new NotSupportedException($"OS not supported {RuntimeInformation.OSDescription}");
}
if (platform == OSPlatform.Linux)
{
key = ELFFileKeyGenerator.GetKeys(KeyTypeFlags.IdentityKey, moduleName, buildId, symbolFile: false, symbolFileName: null).SingleOrDefault();
}
else if (platform == OSPlatform.OSX)
{
key = MachOFileKeyGenerator.GetKeys(KeyTypeFlags.IdentityKey, moduleName, buildId, symbolFile: false, symbolFileName: null).SingleOrDefault();
}
Assert.NotNull(key);
string downloadedPath = SymbolService.DownloadFile(key);
Assert.NotNull(downloadedPath);
return(downloadedPath);
}
/// <summary>
/// Finds or downloads the ELF module and creates a ELFFile instance for it.
/// </summary>
/// <param name="module">module instance</param>
/// <returns>ELFFile instance or null</returns>
internal ELFFile GetELFFile(IModule module)
{
string downloadFilePath = null;
ELFFile elfFile = null;
if (File.Exists(module.FileName))
{
// TODO - Need to verify the build id matches this local file
downloadFilePath = module.FileName;
}
else
{
if (!module.BuildId.IsDefaultOrEmpty)
{
SymbolStoreKey key = ELFFileKeyGenerator.GetKeys(KeyTypeFlags.IdentityKey, module.FileName, module.BuildId.ToArray(), symbolFile: false, symbolFileName: null).SingleOrDefault();
if (key is not null)
{
// Now download the module from the symbol server
downloadFilePath = SymbolService.DownloadFile(key);
}
else
{
Trace.TraceWarning($"GetELFFile: no index generated for module {module.FileName} ");
}
}
else
{
Trace.TraceWarning($"GetELFFile: module {module.FileName} has no build id");
}
}
if (!string.IsNullOrEmpty(downloadFilePath))
{
Trace.TraceInformation("GetELFFile: downloaded {0}", downloadFilePath);
Stream stream;
try
{
stream = File.OpenRead(downloadFilePath);
}
catch (Exception ex) when(ex is DirectoryNotFoundException || ex is FileNotFoundException || ex is UnauthorizedAccessException || ex is IOException)
{
Trace.TraceError($"GetELFFile: OpenRead exception {ex.Message}");
return(null);
}
try
{
elfFile = new ELFFile(new StreamAddressSpace(stream), position: 0, isDataSourceVirtualAddressSpace: false);
if (!elfFile.IsValid())
{
Trace.TraceError($"GetELFFile: not a valid file");
return(null);
}
}
catch (Exception ex) when(ex is InvalidVirtualAddressException || ex is BadInputFormatException || ex is IOException)
{
Trace.TraceError($"GetELFFile: exception {ex.Message}");
return(null);
}
}
return(elfFile);
}
/// <summary>
/// Load native symbols and modules (i.e. dac, dbi).
/// </summary>
/// <param name="callback">called back for each symbol file loaded</param>
/// <param name="parameter">callback parameter</param>
/// <param name="moduleDirectory">module path</param>
/// <param name="moduleFileName">module file name</param>
/// <param name="address">module base address</param>
/// <param name="size">module size</param>
/// <param name="readMemory">read memory callback delegate</param>
internal static void LoadNativeSymbols(SymbolFileCallback callback, IntPtr parameter, string tempDirectory, string moduleDirectory, string moduleFileName,
ulong address, int size, ReadMemoryDelegate readMemory)
{
if (s_symbolStore != null)
{
Debug.Assert(s_tracer != null);
string path = Path.Combine(moduleDirectory, moduleFileName);
Stream stream = new TargetStream(address, size, readMemory);
KeyTypeFlags flags = KeyTypeFlags.SymbolKey | KeyTypeFlags.ClrKeys;
KeyGenerator generator = null;
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
var elfFile = new ELFFile(new StreamAddressSpace(stream), 0, true);
generator = new ELFFileKeyGenerator(s_tracer, elfFile, path);
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
var machOFile = new MachOFile(new StreamAddressSpace(stream), 0, true);
generator = new MachOFileKeyGenerator(s_tracer, machOFile, path);
}
else
{
return;
}
try
{
IEnumerable <SymbolStoreKey> keys = generator.GetKeys(flags);
foreach (SymbolStoreKey key in keys)
{
string symbolFileName = Path.GetFileName(key.FullPathName);
s_tracer.Verbose("{0} {1}", key.FullPathName, key.Index);
// Don't download the sos binaries that come with the runtime
if (symbolFileName != "SOS.NETCore.dll" && !symbolFileName.StartsWith("libsos."))
{
using (SymbolStoreFile file = GetSymbolStoreFile(key))
{
if (file != null)
{
try
{
string downloadFileName = file.FileName;
// If the downloaded doesn't already exists on disk in the cache, then write it to a temporary location.
if (!File.Exists(downloadFileName))
{
downloadFileName = Path.Combine(tempDirectory, symbolFileName);
using (Stream destinationStream = File.OpenWrite(downloadFileName)) {
file.Stream.CopyTo(destinationStream);
}
s_tracer.WriteLine("Downloaded symbol file {0}", key.FullPathName);
}
s_tracer.Information("{0}: {1}", symbolFileName, downloadFileName);
callback(parameter, symbolFileName, downloadFileName);
}
catch (Exception ex) when(ex is UnauthorizedAccessException || ex is DirectoryNotFoundException)
{
s_tracer.Error("{0}", ex.Message);
}
}
}
}
}
}
catch (Exception ex) when(ex is BadInputFormatException || ex is InvalidVirtualAddressException)
{
s_tracer.Error("Exception: {0}/{1}: {2:X16}", moduleDirectory, moduleFileName, address);
}
}
}
/// <summary>
/// Load native symbols and modules (i.e. DAC, DBI).
/// </summary>
/// <param name="callback">called back for each symbol file loaded</param>
/// <param name="parameter">callback parameter</param>
/// <param name="config">Target configuration: Windows, Linux or OSX</param>
/// <param name="moduleFilePath">module path</param>
/// <param name="address">module base address</param>
/// <param name="size">module size</param>
/// <param name="readMemory">read memory callback delegate</param>
private void LoadNativeSymbols(
IntPtr self,
SymbolFileCallback callback,
IntPtr parameter,
RuntimeConfiguration config,
string moduleFilePath,
ulong address,
uint size)
{
if (_symbolService.IsSymbolStoreEnabled)
{
try
{
Stream stream = MemoryService.CreateMemoryStream(address, size);
KeyGenerator generator = null;
if (config == RuntimeConfiguration.UnixCore)
{
var elfFile = new ELFFile(new StreamAddressSpace(stream), 0, true);
generator = new ELFFileKeyGenerator(Tracer.Instance, elfFile, moduleFilePath);
}
else if (config == RuntimeConfiguration.OSXCore)
{
var machOFile = new MachOFile(new StreamAddressSpace(stream), 0, true);
generator = new MachOFileKeyGenerator(Tracer.Instance, machOFile, moduleFilePath);
}
else if (config == RuntimeConfiguration.WindowsCore || config == RuntimeConfiguration.WindowsDesktop)
{
var peFile = new PEFile(new StreamAddressSpace(stream), true);
generator = new PEFileKeyGenerator(Tracer.Instance, peFile, moduleFilePath);
}
else
{
Trace.TraceError("LoadNativeSymbols: unsupported config {0}", config);
}
if (generator != null)
{
IEnumerable <SymbolStoreKey> keys = generator.GetKeys(KeyTypeFlags.SymbolKey | KeyTypeFlags.DacDbiKeys);
foreach (SymbolStoreKey key in keys)
{
string moduleFileName = Path.GetFileName(key.FullPathName);
Trace.TraceInformation("{0} {1}", key.FullPathName, key.Index);
string downloadFilePath = _symbolService.DownloadFile(key);
if (downloadFilePath != null)
{
Trace.TraceInformation("{0}: {1}", moduleFileName, downloadFilePath);
callback(parameter, moduleFileName, downloadFilePath);
}
}
}
}
catch (Exception ex) when
(ex is DiagnosticsException ||
ex is BadInputFormatException ||
ex is InvalidVirtualAddressException ||
ex is ArgumentOutOfRangeException ||
ex is IndexOutOfRangeException ||
ex is TaskCanceledException)
{
Trace.TraceError("{0} address {1:X16}: {2}", moduleFilePath, address, ex.Message);
}
}
}
private string DownloadFile(string fileName)
{
OSPlatform platform = _target.OperatingSystem;
string filePath = null;
if (SymbolService.IsSymbolStoreEnabled)
{
SymbolStoreKey key = null;
if (platform == OSPlatform.Windows)
{
// It is the coreclr.dll's id (timestamp/filesize) in the DacInfo used to download the the dac module.
if (_clrInfo.DacInfo.IndexTimeStamp != 0 && _clrInfo.DacInfo.IndexFileSize != 0)
{
key = PEFileKeyGenerator.GetKey(fileName, (uint)_clrInfo.DacInfo.IndexTimeStamp, (uint)_clrInfo.DacInfo.IndexFileSize);
}
else
{
Trace.TraceError($"DownloadFile: {fileName}: key not generated - no index timestamp/filesize");
}
}
else
{
// Use the runtime's build id to download the the dac module.
if (!_clrInfo.DacInfo.ClrBuildId.IsDefaultOrEmpty)
{
byte[] buildId = _clrInfo.DacInfo.ClrBuildId.ToArray();
IEnumerable <SymbolStoreKey> keys = null;
if (platform == OSPlatform.Linux)
{
keys = ELFFileKeyGenerator.GetKeys(KeyTypeFlags.DacDbiKeys, "libcoreclr.so", buildId, symbolFile: false, symbolFileName: null);
}
else if (platform == OSPlatform.OSX)
{
keys = MachOFileKeyGenerator.GetKeys(KeyTypeFlags.DacDbiKeys, "libcoreclr.dylib", buildId, symbolFile: false, symbolFileName: null);
}
else
{
Trace.TraceError($"DownloadFile: {fileName}: platform not supported - {platform}");
}
key = keys?.SingleOrDefault((k) => Path.GetFileName(k.FullPathName) == fileName);
}
else
{
Trace.TraceError($"DownloadFile: {fileName}: key not generated - no index time stamp or file size");
}
}
if (key is not null)
{
// Now download the DAC module from the symbol server
filePath = SymbolService.DownloadFile(key);
}
}
else
{
Trace.TraceInformation($"DownLoadFile: {fileName}: symbol store not enabled");
}
return(filePath);
}
private string GetDacFile(ClrInfo clrInfo)
{
if (_dacFilePath == null)
{
Debug.Assert(!string.IsNullOrEmpty(clrInfo.DacInfo.FileName));
var analyzeContext = _serviceProvider.GetService <AnalyzeContext>();
string dacFilePath = null;
if (!string.IsNullOrEmpty(analyzeContext.RuntimeModuleDirectory))
{
dacFilePath = Path.Combine(analyzeContext.RuntimeModuleDirectory, clrInfo.DacInfo.FileName);
if (File.Exists(dacFilePath))
{
_dacFilePath = dacFilePath;
}
}
if (_dacFilePath == null)
{
dacFilePath = clrInfo.LocalMatchingDac;
if (!string.IsNullOrEmpty(dacFilePath) && File.Exists(dacFilePath))
{
_dacFilePath = dacFilePath;
}
else if (SymbolReader.IsSymbolStoreEnabled())
{
string dacFileName = Path.GetFileName(dacFilePath ?? clrInfo.DacInfo.FileName);
if (dacFileName != null)
{
SymbolStoreKey key = null;
if (clrInfo.ModuleInfo.BuildId != null)
{
IEnumerable <SymbolStoreKey> keys = ELFFileKeyGenerator.GetKeys(
KeyTypeFlags.ClrKeys, clrInfo.ModuleInfo.FileName, clrInfo.ModuleInfo.BuildId, symbolFile: false, symbolFileName: null);
key = keys.SingleOrDefault((k) => Path.GetFileName(k.FullPathName) == dacFileName);
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
// We are opening a Linux dump on Windows
// We need to use the Windows index and filename
key = new SymbolStoreKey(key.Index.Replace("libmscordaccore.so", "mscordaccore.dll"),
key.FullPathName.Replace("libmscordaccore.so", "mscordaccore.dll"),
key.IsClrSpecialFile,
key.PdbChecksums);
}
}
else
{
// Use the coreclr.dll's id (timestamp/filesize) to download the the dac module.
key = PEFileKeyGenerator.GetKey(dacFileName, clrInfo.ModuleInfo.TimeStamp, clrInfo.ModuleInfo.FileSize);
}
if (key != null)
{
// Now download the DAC module from the symbol server
_dacFilePath = SymbolReader.GetSymbolFile(key);
}
}
}
if (_dacFilePath == null)
{
throw new FileNotFoundException($"Could not find matching DAC for this runtime: {clrInfo.ModuleInfo.FileName}");
}
}
_isDesktop = clrInfo.Flavor == ClrFlavor.Desktop;
}
return(_dacFilePath);
}