/// <summary>
/// Load native modules (i.e. DAC, DBI) from the runtime build id.
/// </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="specialKeys">if true, returns the DBI/DAC keys, otherwise the identity key</param>
/// <param name="moduleIndexSize">build id size</param>
/// <param name="moduleIndex">pointer to build id</param>
private void LoadNativeSymbolsFromIndex(
IntPtr self,
SymbolFileCallback callback,
IntPtr parameter,
RuntimeConfiguration config,
string moduleFilePath,
bool specialKeys,
int moduleIndexSize,
IntPtr moduleIndex)
{
if (_symbolService.IsSymbolStoreEnabled)
{
try
{
KeyTypeFlags flags = specialKeys ? KeyTypeFlags.DacDbiKeys : KeyTypeFlags.IdentityKey;
byte[] id = new byte[moduleIndexSize];
Marshal.Copy(moduleIndex, id, 0, moduleIndexSize);
IEnumerable <SymbolStoreKey> keys = null;
switch (config)
{
case RuntimeConfiguration.UnixCore:
keys = ELFFileKeyGenerator.GetKeys(flags, moduleFilePath, id, symbolFile: false, symbolFileName: null);
break;
case RuntimeConfiguration.OSXCore:
keys = MachOFileKeyGenerator.GetKeys(flags, moduleFilePath, id, symbolFile: false, symbolFileName: null);
break;
case RuntimeConfiguration.WindowsCore:
case RuntimeConfiguration.WindowsDesktop:
uint timeStamp = BitConverter.ToUInt32(id, 0);
uint fileSize = BitConverter.ToUInt32(id, 4);
SymbolStoreKey key = PEFileKeyGenerator.GetKey(moduleFilePath, timeStamp, fileSize);
keys = new SymbolStoreKey[] { key };
break;
default:
Trace.TraceError("LoadNativeSymbolsFromIndex: unsupported platform {0}", config);
return;
}
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 BadInputFormatException || ex is InvalidVirtualAddressException || ex is TaskCanceledException)
{
Trace.TraceError("{0} - {1}", ex.Message, moduleFilePath);
}
}
}
/// <summary>
/// Returns the metadata for the assembly
/// </summary>
/// <param name="imagePath">file name and path to module</param>
/// <param name="imageTimestamp">module timestamp</param>
/// <param name="imageSize">size of PE image</param>
/// <returns>metadata</returns>
public ImmutableArray <byte> GetMetadata(string imagePath, uint imageTimestamp, uint imageSize)
{
try
{
Stream peStream = null;
if (imagePath != null && File.Exists(imagePath))
{
peStream = Utilities.TryOpenFile(imagePath);
}
else if (IsSymbolStoreEnabled)
{
SymbolStoreKey key = PEFileKeyGenerator.GetKey(imagePath, imageTimestamp, imageSize);
peStream = GetSymbolStoreFile(key)?.Stream;
}
if (peStream != null)
{
using var peReader = new PEReader(peStream, PEStreamOptions.Default);
if (peReader.HasMetadata)
{
PEMemoryBlock metadataInfo = peReader.GetMetadata();
return(metadataInfo.GetContent());
}
}
}
catch (Exception ex) when
(ex is UnauthorizedAccessException ||
ex is BadImageFormatException ||
ex is InvalidVirtualAddressException ||
ex is IOException)
{
Trace.TraceError($"GetMetaData: {ex.Message}");
}
return(ImmutableArray <byte> .Empty);
}
/// <summary>
/// Creates a key generator for the runtime module pointed to by the address/size.
/// </summary>
/// <param name="memoryService">memory service instance</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>
/// <returns>KeyGenerator or null if error</returns>
public static KeyGenerator GetKeyGenerator(this IMemoryService memoryService, OSPlatform config, string moduleFilePath, ulong address, ulong size)
{
Stream stream = memoryService.CreateMemoryStream(address, size);
KeyGenerator generator = null;
if (config == OSPlatform.Linux)
{
var elfFile = new ELFFile(new StreamAddressSpace(stream), 0, true);
generator = new ELFFileKeyGenerator(Tracer.Instance, elfFile, moduleFilePath);
}
else if (config == OSPlatform.OSX)
{
var machOFile = new MachOFile(new StreamAddressSpace(stream), 0, true);
generator = new MachOFileKeyGenerator(Tracer.Instance, machOFile, moduleFilePath);
}
else if (config == OSPlatform.Windows)
{
var peFile = new PEFile(new StreamAddressSpace(stream), true);
generator = new PEFileKeyGenerator(Tracer.Instance, peFile, moduleFilePath);
}
else
{
Trace.TraceError("GetKeyGenerator: unsupported platform {0}", config);
}
return(generator);
}
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.DacDbiKeys, 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 DownloadFile(string fileName)
{
OSPlatform platform = _target.OperatingSystem;
string filePath = null;
if (SymbolService.IsSymbolStoreEnabled)
{
SymbolStoreKey key = null;
if (platform == OSPlatform.OSX)
{
KeyGenerator generator = MemoryService.GetKeyGenerator(
platform,
RuntimeModule.FileName,
RuntimeModule.ImageBase,
RuntimeModule.ImageSize);
key = generator.GetKeys(KeyTypeFlags.DacDbiKeys).SingleOrDefault((k) => Path.GetFileName(k.FullPathName) == fileName);
}
else if (platform == OSPlatform.Linux)
{
if (!RuntimeModule.BuildId.IsDefaultOrEmpty)
{
IEnumerable <SymbolStoreKey> keys = ELFFileKeyGenerator.GetKeys(
KeyTypeFlags.DacDbiKeys,
RuntimeModule.FileName,
RuntimeModule.BuildId.ToArray(),
symbolFile: false,
symbolFileName: null);
key = keys.SingleOrDefault((k) => Path.GetFileName(k.FullPathName) == fileName);
}
}
else if (platform == OSPlatform.Windows)
{
if (RuntimeModule.IndexTimeStamp.HasValue && RuntimeModule.IndexFileSize.HasValue)
{
// Use the coreclr.dll's id (timestamp/filesize) to download the the dac module.
key = PEFileKeyGenerator.GetKey(fileName, RuntimeModule.IndexTimeStamp.Value, RuntimeModule.IndexFileSize.Value);
}
}
if (key != null)
{
// Now download the DAC module from the symbol server
filePath = SymbolService.DownloadFile(key);
}
else
{
Trace.TraceInformation($"DownloadFile: {fileName}: key not generated");
}
}
else
{
Trace.TraceInformation($"DownLoadFile: {fileName}: symbol store not enabled");
}
return(filePath);
}
private string GetDacFile(ClrInfo clrInfo)
{
if (_dacFilePath == null)
{
string dacFileName = GetDacFileName(clrInfo, out OSPlatform platform);
_dacFilePath = GetLocalDacPath(clrInfo, dacFileName);
if (_dacFilePath == null)
{
if (SymbolReader.IsSymbolStoreEnabled())
{
SymbolStoreKey key = null;
if (platform == OSPlatform.OSX)
{
unsafe
{
var memoryService = _serviceProvider.GetService <MemoryService>();
SymbolReader.ReadMemoryDelegate readMemory = (ulong address, byte *buffer, int count) => {
return(memoryService.ReadMemory(address, new Span <byte>(buffer, count), out int bytesRead) ? bytesRead : 0);
};
KeyGenerator generator = SymbolReader.GetKeyGenerator(
SymbolReader.RuntimeConfiguration.OSXCore, clrInfo.ModuleInfo.FileName, clrInfo.ModuleInfo.ImageBase, unchecked ((int)clrInfo.ModuleInfo.FileSize), readMemory);
key = generator.GetKeys(KeyTypeFlags.DacDbiKeys).SingleOrDefault((k) => Path.GetFileName(k.FullPathName) == dacFileName);
}
}
else if (platform == OSPlatform.Linux)
{
if (clrInfo.ModuleInfo.BuildId != null)
{
IEnumerable <SymbolStoreKey> keys = ELFFileKeyGenerator.GetKeys(
KeyTypeFlags.DacDbiKeys, clrInfo.ModuleInfo.FileName, clrInfo.ModuleInfo.BuildId, symbolFile: false, symbolFileName: null);
key = keys.SingleOrDefault((k) => Path.GetFileName(k.FullPathName) == dacFileName);
}
}
else if (platform == OSPlatform.Windows)
{
// 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);
}
/// <summary>
/// Finds or downloads the module and creates a PEReader for it.
/// </summary>
/// <param name="module">module instance</param>
/// <returns>reader or null</returns>
internal PEReader GetPEReader(IModule module)
{
string downloadFilePath = null;
PEReader reader = null;
if (File.Exists(module.FileName))
{
// TODO - Need to verify the index timestamp/file size matches this local file
downloadFilePath = module.FileName;
}
else
{
if (SymbolService.IsSymbolStoreEnabled)
{
if (module.IndexTimeStamp.HasValue && module.IndexFileSize.HasValue)
{
SymbolStoreKey key = PEFileKeyGenerator.GetKey(Path.GetFileName(module.FileName), module.IndexTimeStamp.Value, module.IndexFileSize.Value);
if (key != null)
{
// Now download the module from the symbol server
downloadFilePath = SymbolService.DownloadFile(key);
}
}
}
}
if (!string.IsNullOrEmpty(downloadFilePath))
{
Trace.TraceInformation("GetPEReader: 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($"GetPEReader: OpenRead exception {ex.Message}");
return(null);
}
try
{
reader = new PEReader(stream);
if (reader.PEHeaders == null || reader.PEHeaders.PEHeader == null)
{
return(null);
}
}
catch (Exception ex) when(ex is BadImageFormatException || ex is IOException)
{
Trace.TraceError($"GetPEReader: PEReader exception {ex.Message}");
return(null);
}
}
return(reader);
}
/// <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="tempDirectory">temp directory unique to this instance of SOS</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>
public static void LoadNativeSymbols(SymbolFileCallback callback, IntPtr parameter, string tempDirectory, string moduleFilePath, ulong address, int size, ReadMemoryDelegate readMemory)
{
if (IsSymbolStoreEnabled())
{
Debug.Assert(s_tracer != null);
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, moduleFilePath);
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
var machOFile = new MachOFile(new StreamAddressSpace(stream), 0, true);
generator = new MachOFileKeyGenerator(s_tracer, machOFile, moduleFilePath);
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
var peFile = new PEFile(new StreamAddressSpace(stream), true);
generator = new PEFileKeyGenerator(s_tracer, peFile, moduleFilePath);
}
else
{
return;
}
try
{
IEnumerable <SymbolStoreKey> keys = generator.GetKeys(flags);
foreach (SymbolStoreKey key in keys)
{
string moduleFileName = 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 (moduleFileName != "SOS.NETCore.dll" && !moduleFileName.StartsWith("libsos."))
{
string downloadFilePath = GetSymbolFile(key, tempDirectory);
if (downloadFilePath != null)
{
s_tracer.Information("{0}: {1}", moduleFileName, downloadFilePath);
callback(parameter, moduleFileName, downloadFilePath);
}
}
}
}
catch (Exception ex) when(ex is BadInputFormatException || ex is InvalidVirtualAddressException)
{
s_tracer.Error("{0}/{1:X16}: {2}", moduleFilePath, address, ex.Message);
}
}
}
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);
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);
}
private string DownloadModule(string moduleName, uint timeStamp, uint sizeOfImage)
{
Assert.True(timeStamp != 0 && sizeOfImage != 0);
SymbolStoreKey key = PEFileKeyGenerator.GetKey(moduleName, timeStamp, sizeOfImage);
Assert.NotNull(key);
string downloadedPath = SymbolService.DownloadFile(key);
Assert.NotNull(downloadedPath);
return(downloadedPath);
}
/// <summary>
/// Metadata locator helper for the DAC.
/// </summary>
/// <param name="imagePath">file name and path to module</param>
/// <param name="imageTimestamp">module timestamp</param>
/// <param name="imageSize">module image</param>
/// <param name="pathBufferSize">output buffer size</param>
/// <param name="pPathBufferSize">native pointer to put actual path size</param>
/// <param name="pwszPathBuffer">native pointer to WCHAR path buffer</param>
/// <returns>HRESULT</returns>
internal int GetICorDebugMetadataLocator(
IntPtr self,
string imagePath,
uint imageTimestamp,
uint imageSize,
uint pathBufferSize,
IntPtr pPathBufferSize,
IntPtr pwszPathBuffer)
{
int hr = HResult.S_OK;
int actualSize = 0;
Debug.Assert(pwszPathBuffer != IntPtr.Zero);
try
{
if (_symbolService.IsSymbolStoreEnabled)
{
SymbolStoreKey key = PEFileKeyGenerator.GetKey(imagePath, imageTimestamp, imageSize);
string localFilePath = _symbolService.DownloadFile(key);
localFilePath += "\0"; // null terminate the string
actualSize = localFilePath.Length;
if (pathBufferSize > actualSize)
{
Trace.TraceInformation($"GetICorDebugMetadataLocator: SUCCEEDED {localFilePath}");
Marshal.Copy(localFilePath.ToCharArray(), 0, pwszPathBuffer, actualSize);
}
else
{
Trace.TraceError("GetICorDebugMetadataLocator: E_INSUFFICIENT_BUFFER");
hr = E_INSUFFICIENT_BUFFER;
}
}
else
{
Trace.TraceError($"GetICorDebugMetadataLocator: {imagePath} {imageTimestamp:X8} {imageSize:X8} symbol store not enabled");
hr = HResult.E_FAIL;
}
}
catch (Exception ex) when
(ex is UnauthorizedAccessException ||
ex is BadImageFormatException ||
ex is InvalidVirtualAddressException ||
ex is IOException)
{
Trace.TraceError($"GetICorDebugMetadataLocator: {imagePath} {imageTimestamp:X8} {imageSize:X8} ERROR {ex.Message}");
hr = HResult.E_FAIL;
}
if (pPathBufferSize != IntPtr.Zero)
{
Marshal.WriteInt32(pPathBufferSize, actualSize);
}
return(hr);
}
/// <summary>
/// Metadata locator helper for the DAC.
/// </summary>
/// <param name="imagePath">file name and path to module</param>
/// <param name="imageTimestamp">module timestamp</param>
/// <param name="imageSize">module image</param>
/// <param name="localFilePath">local file path of the module</param>
/// <returns>HRESULT</returns>
public static int GetICorDebugMetadataLocator(
[MarshalAs(UnmanagedType.LPWStr)] string imagePath,
uint imageTimestamp,
uint imageSize,
uint pathBufferSize,
IntPtr pPathBufferSize,
IntPtr pPathBuffer)
{
int hr = S_OK;
int actualSize = 0;
Debug.Assert(pPathBuffer != IntPtr.Zero);
try
{
if (SymbolReader.IsSymbolStoreEnabled())
{
SymbolStoreKey key = PEFileKeyGenerator.GetKey(imagePath, imageTimestamp, imageSize);
string localFilePath = SymbolReader.GetSymbolFile(key);
localFilePath += "\0"; // null terminate the string
actualSize = localFilePath.Length;
if (pathBufferSize > actualSize)
{
Marshal.Copy(localFilePath.ToCharArray(), 0, pPathBuffer, actualSize);
}
else
{
hr = E_INSUFFICIENT_BUFFER;
}
}
else
{
hr = E_FAIL;
}
}
catch (Exception ex) when
(ex is UnauthorizedAccessException ||
ex is BadImageFormatException ||
ex is InvalidVirtualAddressException ||
ex is IOException)
{
hr = E_FAIL;
}
if (pPathBufferSize != IntPtr.Zero)
{
Marshal.WriteInt32(pPathBufferSize, actualSize);
}
return(hr);
}
public static int GetMetadataLocator(
[MarshalAs(UnmanagedType.LPWStr)] string imagePath,
uint imageTimestamp,
uint imageSize,
[MarshalAs(UnmanagedType.LPArray, SizeConst = 16)] byte[] mvid,
uint mdRva,
uint flags,
uint bufferSize,
IntPtr pMetadata,
IntPtr pMetadataSize)
{
int hr = unchecked ((int)0x80004005);
int dataSize = 0;
Debug.Assert(pMetadata != IntPtr.Zero);
Stream peStream = null;
if (imagePath != null && File.Exists(imagePath))
{
peStream = SymbolReader.TryOpenFile(imagePath);
}
else if (SymbolReader.IsSymbolStoreEnabled())
{
SymbolStoreKey key = PEFileKeyGenerator.GetKey(imagePath, imageTimestamp, imageSize);
peStream = SymbolReader.GetSymbolStoreFile(key)?.Stream;
}
if (peStream != null)
{
using (var peReader = new PEReader(peStream, PEStreamOptions.Default))
{
if (peReader.HasMetadata)
{
PEMemoryBlock metadataInfo = peReader.GetMetadata();
unsafe
{
int size = Math.Min((int)bufferSize, metadataInfo.Length);
Marshal.Copy(metadataInfo.GetContent().ToArray(), 0, pMetadata, size);
}
dataSize = metadataInfo.Length;
hr = 0;
}
}
}
if (pMetadataSize != IntPtr.Zero)
{
Marshal.WriteInt32(pMetadataSize, dataSize);
}
return(hr);
}
private string GetDacFile(ClrInfo clrInfo)
{
if (s_dacFilePath == null)
{
string dac = clrInfo.LocalMatchingDac;
if (dac != null && File.Exists(dac))
{
s_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)
{
if (s_tempDirectory == null)
{
int processId = Process.GetCurrentProcess().Id;
s_tempDirectory = Path.Combine(Path.GetTempPath(), "analyze" + processId.ToString());
}
// Now download the DAC module from the symbol server
s_dacFilePath = SymbolReader.GetSymbolFile(key, s_tempDirectory);
}
}
}
if (s_dacFilePath == null)
{
throw new FileNotFoundException("Could not find matching DAC for this runtime: {0}", clrInfo.ModuleInfo.FileName);
}
}
return(s_dacFilePath);
}
/// <summary>
/// Finds or downloads the module and creates a PEReader for it.
/// </summary>
/// <param name="module">module instance</param>
/// <returns>reader or null</returns>
internal PEReader GetPEReader(IModule module)
{
if (!module.IndexTimeStamp.HasValue || !module.IndexFileSize.HasValue)
{
Trace.TraceWarning($"GetPEReader: module {module.FileName} has no index timestamp/filesize");
return(null);
}
SymbolStoreKey moduleKey = PEFileKeyGenerator.GetKey(Path.GetFileName(module.FileName), module.IndexTimeStamp.Value, module.IndexFileSize.Value);
if (moduleKey is null)
{
Trace.TraceWarning($"GetPEReader: no index generated for module {module.FileName} ");
return(null);
}
if (File.Exists(module.FileName))
{
Stream stream = OpenFile(module.FileName);
if (stream is not null)
{
var peFile = new PEFile(new StreamAddressSpace(stream), false);
var generator = new PEFileKeyGenerator(Tracer.Instance, peFile, module.FileName);
IEnumerable <SymbolStoreKey> keys = generator.GetKeys(KeyTypeFlags.IdentityKey);
foreach (SymbolStoreKey key in keys)
{
if (moduleKey.Equals(key))
{
Trace.TraceInformation("GetPEReader: local file match {0}", module.FileName);
return(OpenPEReader(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 = SymbolService.DownloadFile(moduleKey);
if (!string.IsNullOrEmpty(downloadFilePath))
{
Trace.TraceInformation("GetPEReader: downloaded {0}", downloadFilePath);
return(OpenPEReader(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 PEReader GetPEReader(ModuleInfo module)
{
if (!_pathToPeReader.TryGetValue(module.FileName, out PEReader reader))
{
Stream stream = null;
string downloadFilePath = module.FileName;
if (!File.Exists(downloadFilePath))
{
if (SymbolReader.IsSymbolStoreEnabled())
{
SymbolStoreKey key = PEFileKeyGenerator.GetKey(Path.GetFileName(downloadFilePath), module.TimeStamp, module.FileSize);
if (key != null)
{
// Now download the module from the symbol server
downloadFilePath = SymbolReader.GetSymbolFile(key);
}
}
}
if (!string.IsNullOrEmpty(downloadFilePath))
{
Trace.TraceInformation("GetPEReader: downloading {0}", downloadFilePath);
try
{
stream = File.OpenRead(downloadFilePath);
}
catch (Exception ex) when(ex is DirectoryNotFoundException || ex is FileNotFoundException || ex is UnauthorizedAccessException || ex is IOException)
{
Trace.TraceError("GetPEReader: exception {0}", ex);
}
if (stream != null)
{
reader = new PEReader(stream);
if (reader.PEHeaders == null || reader.PEHeaders.PEHeader == null)
{
reader = null;
}
_pathToPeReader.Add(module.FileName, reader);
}
}
}
return(reader);
}
public string?FindBinary(string fileName, int buildTimeStamp, int imageSize, bool checkProperties)
{
Trace.TraceInformation($"FindBinary: {fileName} buildTimeStamp {buildTimeStamp:X8} imageSize {imageSize:X8}");
if (_symbolService.IsSymbolStoreEnabled)
{
SymbolStoreKey?key = PEFileKeyGenerator.GetKey(fileName, (uint)buildTimeStamp, (uint)imageSize);
if (key != null)
{
// Now download the module from the symbol server, cache or from a directory
return(_symbolService.DownloadFile(key));
}
else
{
Trace.TraceInformation($"DownloadFile: {fileName}: key not generated");
}
}
else
{
Trace.TraceInformation($"DownLoadFile: {fileName}: symbol store not enabled");
}
return(null);
}
/// <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);
}
/// <summary>
/// Metadata locator helper for the DAC.
/// </summary>
/// <param name="imagePath">file name and path to module</param>
/// <param name="imageTimestamp">module timestamp</param>
/// <param name="imageSize">module image</param>
/// <param name="mvid">not used</param>
/// <param name="mdRva">not used</param>
/// <param name="flags">not used</param>
/// <param name="bufferSize">size of incoming buffer (pMetadata)</param>
/// <param name="pMetadata">pointer to buffer</param>
/// <param name="pMetadataSize">size of outgoing metadata</param>
/// <returns>HRESULT</returns>
public static int GetMetadataLocator(
[MarshalAs(UnmanagedType.LPWStr)] string imagePath,
uint imageTimestamp,
uint imageSize,
[MarshalAs(UnmanagedType.LPArray, SizeConst = 16)] byte[] mvid,
uint mdRva,
uint flags,
uint bufferSize,
IntPtr pMetadata,
IntPtr pMetadataSize)
{
int hr = S_OK;
int dataSize = 0;
Debug.Assert(pMetadata != IntPtr.Zero);
try
{
Stream peStream = null;
if (imagePath != null && File.Exists(imagePath))
{
peStream = SymbolReader.TryOpenFile(imagePath);
}
else if (SymbolReader.IsSymbolStoreEnabled())
{
SymbolStoreKey key = PEFileKeyGenerator.GetKey(imagePath, imageTimestamp, imageSize);
peStream = SymbolReader.GetSymbolStoreFile(key)?.Stream;
}
if (peStream != null)
{
using (var peReader = new PEReader(peStream, PEStreamOptions.Default))
{
if (peReader.HasMetadata)
{
PEMemoryBlock metadataInfo = peReader.GetMetadata();
dataSize = metadataInfo.Length;
unsafe
{
int size = Math.Min((int)bufferSize, metadataInfo.Length);
Marshal.Copy(metadataInfo.GetContent().ToArray(), 0, pMetadata, size);
}
}
else
{
hr = E_FAIL;
}
}
}
else
{
hr = E_FAIL;
}
}
catch (Exception ex) when
(ex is UnauthorizedAccessException ||
ex is BadImageFormatException ||
ex is InvalidVirtualAddressException ||
ex is IOException)
{
hr = E_FAIL;
}
if (pMetadataSize != IntPtr.Zero)
{
Marshal.WriteInt32(pMetadataSize, dataSize);
}
return(hr);
}
/// <summary>
/// Finds or downloads the PE module
/// </summary>
/// <param name="module">module instance</param>
/// <param name="flags"></param>
/// <returns>module path or null</returns>
private string DownloadPE(IModule module, KeyTypeFlags flags)
{
SymbolStoreKey fileKey = null;
string fileName = null;
if ((flags & KeyTypeFlags.IdentityKey) != 0)
{
if (!module.IndexTimeStamp.HasValue || !module.IndexFileSize.HasValue)
{
return(null);
}
fileName = module.FileName;
fileKey = PEFileKeyGenerator.GetKey(Path.GetFileName(fileName), module.IndexTimeStamp.Value, module.IndexFileSize.Value);
if (fileKey is null)
{
Trace.TraceWarning($"DownLoadPE: no key generated for module {fileName} ");
return(null);
}
}
else if ((flags & KeyTypeFlags.SymbolKey) != 0)
{
IEnumerable <PdbFileInfo> pdbInfos = module.GetPdbFileInfos();
if (!pdbInfos.Any())
{
return(null);
}
foreach (PdbFileInfo pdbInfo in pdbInfos)
{
if (pdbInfo.IsPortable)
{
fileKey = PortablePDBFileKeyGenerator.GetKey(pdbInfo.Path, pdbInfo.Guid);
if (fileKey is not null)
{
fileName = pdbInfo.Path;
break;
}
}
}
if (fileKey is null)
{
foreach (PdbFileInfo pdbInfo in pdbInfos)
{
if (!pdbInfo.IsPortable)
{
fileKey = PDBFileKeyGenerator.GetKey(pdbInfo.Path, pdbInfo.Guid, pdbInfo.Revision);
if (fileKey is not null)
{
fileName = pdbInfo.Path;
break;
}
}
}
}
if (fileKey is null)
{
Trace.TraceWarning($"DownLoadPE: no key generated for module PDB {module.FileName} ");
return(null);
}
}
else
{
throw new ArgumentException($"Key flag not supported {flags}");
}
// Check if the file is local and the key matches the module
if (File.Exists(fileName))
{
using Stream stream = Utilities.TryOpenFile(fileName);
if (stream is not null)
{
var peFile = new PEFile(new StreamAddressSpace(stream), false);
var generator = new PEFileKeyGenerator(Tracer.Instance, peFile, fileName);
foreach (SymbolStoreKey key in generator.GetKeys(flags))
{
if (fileKey.Equals(key))
{
Trace.TraceInformation($"DownloadPE: local file match {fileName}");
return(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(fileKey);
if (!string.IsNullOrEmpty(downloadFilePath))
{
Trace.TraceInformation("DownloadPE: downloaded {0}", downloadFilePath);
return(downloadFilePath);
}
return(null);
}
