/// <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); } } }
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 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); }
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); }
/// <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 (SymbolService.IsSymbolStoreEnabled) { if (!module.BuildId.IsDefaultOrEmpty) { var key = ELFFileKeyGenerator.GetKeys(KeyTypeFlags.IdentityKey, module.FileName, module.BuildId.ToArray(), symbolFile: false, symbolFileName: null).SingleOrDefault(); if (key != null) { // Now download the module from the symbol server downloadFilePath = SymbolService.DownloadFile(key); } } } } 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()) { 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); }
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); }
/// <summary> /// Finds or downloads the ELF module /// </summary> /// <param name="module">module instance</param> /// <param name="flags"></param> /// <returns>module path or null</returns> private string DownloadELF(IModule module, KeyTypeFlags flags) { if ((flags & (KeyTypeFlags.IdentityKey | KeyTypeFlags.SymbolKey)) == 0) { throw new ArgumentException($"Key flag not supported {flags}"); } if (module.BuildId.IsDefaultOrEmpty) { Trace.TraceWarning($"DownloadELF: module {module.FileName} has no build id"); return(null); } SymbolStoreKey fileKey = ELFFileKeyGenerator.GetKeys(flags, module.FileName, module.BuildId.ToArray(), symbolFile: false, module.GetSymbolFileName()).SingleOrDefault(); if (fileKey is null) { Trace.TraceWarning($"DownloadELF: no index generated for module {module.FileName} "); return(null); } // Check if the file is local and the key matches the module string fileName = fileKey.FullPathName; if (File.Exists(fileName)) { using ELFModule elfModule = ELFModule.OpenFile(fileName); if (elfModule is not null) { var generator = new ELFFileKeyGenerator(Tracer.Instance, elfModule, fileName); foreach (SymbolStoreKey key in generator.GetKeys(flags)) { if (fileKey.Equals(key)) { Trace.TraceInformation("DownloadELF: local file match {0}", 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("DownloadELF: downloaded {0}", downloadFilePath); return(downloadFilePath); } return(null); }
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 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) { if (module.BuildId.IsDefaultOrEmpty) { Trace.TraceWarning($"GetELFFile: 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($"GetELFFile: no index generated for module {module.FileName} "); return(null); } if (File.Exists(module.FileName)) { ELFFile elfFile = OpenELFFile(module.FileName); if (elfFile is not null) { var generator = new ELFFileKeyGenerator(Tracer.Instance, elfFile, module.FileName); IEnumerable <SymbolStoreKey> keys = generator.GetKeys(KeyTypeFlags.IdentityKey); foreach (SymbolStoreKey key in keys) { if (moduleKey.Equals(key)) { Trace.TraceInformation("GetELFFile: local file match {0}", module.FileName); return(elfFile); } } } } // 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("GetELFFile: downloaded {0}", downloadFilePath); return(OpenELFFile(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); }
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); }