/// <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>
public static int GetICorDebugMetadataLocator(
this ISymbolService symbolService,
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);
}
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)
{
OSPlatform platform;
switch (config)
{
case RuntimeConfiguration.UnixCore:
platform = OSPlatform.Linux;
break;
case RuntimeConfiguration.OSXCore:
platform = OSPlatform.OSX;
break;
case RuntimeConfiguration.WindowsCore:
case RuntimeConfiguration.WindowsDesktop:
platform = OSPlatform.Windows;
break;
default:
Trace.TraceError($"Invalid runtime config {config}");
return;
}
try
{
KeyGenerator generator = MemoryService.GetKeyGenerator(platform, moduleFilePath, address, size);
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);
}
}
}
/// <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);
}
}
}