public Runtime(ITarget target, IRuntimeService runtimeService, ClrInfo clrInfo, int id)
{
Trace.TraceInformation($"Creating runtime #{id} {clrInfo.Flavor} {clrInfo}");
_target = target;
_runtimeService = runtimeService;
_clrInfo = clrInfo;
Id = id;
RuntimeType = RuntimeType.Unknown;
if (clrInfo.Flavor == ClrFlavor.Core)
{
RuntimeType = RuntimeType.NetCore;
}
else if (clrInfo.Flavor == ClrFlavor.Desktop)
{
RuntimeType = RuntimeType.Desktop;
}
RuntimeModule = target.Services.GetService <IModuleService>().GetModuleFromBaseAddress(clrInfo.ModuleInfo.ImageBase);
ServiceProvider = new ServiceProvider();
ServiceProvider.AddService <ClrInfo>(clrInfo);
ServiceProvider.AddServiceFactoryWithNoCaching <ClrRuntime>(() => CreateRuntime());
target.OnFlushEvent.Register(() => {
_clrRuntime?.DacLibrary.DacPrivateInterface.Flush();
_metadataMappingMemoryService?.Flush();
});
// This is a special memory service that maps the managed assemblies' metadata into
// the address space. The lldb debugger returns zero's (instead of failing the memory
// read) for missing pages in core dumps that older (less than 5.0) createdumps generate
// so it needs this special metadata mapping memory service. dotnet-dump needs this logic
// for clrstack -i (uses ICorDebug data targets).
if (target.IsDump &&
(target.OperatingSystem != OSPlatform.Windows) &&
(target.Host.HostType == HostType.Lldb ||
target.Host.HostType == HostType.DotnetDump))
{
ServiceProvider.AddServiceFactoryWithNoCaching <IMemoryService>(() => {
if (_metadataMappingMemoryService == null)
{
_metadataMappingMemoryService = new MetadataMappingMemoryService(this, MemoryService, SymbolService);
target.DisposeOnClose(SymbolService.OnChangeEvent.Register(_metadataMappingMemoryService.Flush));
}
return(_metadataMappingMemoryService);
});
}
}
/// <summary>
/// Create a target instance from IDataReader
/// </summary>
/// <param name="dataReader">IDataReader</param>
/// <param name="targetOS">target operating system</param>
/// <param name="host">the host instance</param>
/// <param name="id">target id</param>
/// <param name="dumpPath">path of dump for this target</param>
public TargetFromDataReader(IDataReader dataReader, OSPlatform targetOS, IHost host, int id, string dumpPath)
: base(host, id, dumpPath)
{
_dataReader = dataReader;
OperatingSystem = targetOS;
IsDump = true;
OnFlushEvent.Register(dataReader.FlushCachedData);
Architecture = dataReader.Architecture switch
{
Microsoft.Diagnostics.Runtime.Architecture.Amd64 => Architecture.X64,
Microsoft.Diagnostics.Runtime.Architecture.X86 => Architecture.X86,
Microsoft.Diagnostics.Runtime.Architecture.Arm => Architecture.Arm,
Microsoft.Diagnostics.Runtime.Architecture.Arm64 => Architecture.Arm64,
_ => throw new PlatformNotSupportedException($"{dataReader.Architecture}"),
};
if (dataReader.ProcessId != -1)
{
ProcessId = (uint)dataReader.ProcessId;
}
// Add the thread, memory, and module services
IMemoryService rawMemoryService = new MemoryServiceFromDataReader(_dataReader);
ServiceProvider.AddServiceFactory <IThreadService>(() => new ThreadServiceFromDataReader(this, _dataReader));
ServiceProvider.AddServiceFactory <IModuleService>(() => new ModuleServiceFromDataReader(this, rawMemoryService, _dataReader));
ServiceProvider.AddServiceFactory <IMemoryService>(() => {
IMemoryService memoryService = rawMemoryService;
if (IsDump)
{
memoryService = new ImageMappingMemoryService(this, memoryService);
// Any dump created for a MacOS target does not have managed assemblies in the module service so
// we need to use the metadata mapping memory service to make sure the metadata is available.
if (targetOS == OSPlatform.OSX)
{
memoryService = new MetadataMappingMemoryService(this, memoryService);
}
}
return(memoryService);
});
}
internal MetadataRegion(MetadataMappingMemoryService memoryService, ClrModule module)
{
_memoryService = memoryService;
_module = module;
}
