internal IEnumerable <ulong> EnumerateModules(IAppDomainData appDomain)
{
if (appDomain != null)
{
ulong[] assemblies = GetAssemblyList(appDomain.Address, appDomain.AssemblyCount);
if (assemblies != null)
{
foreach (ulong assembly in assemblies)
{
IAssemblyData data = GetAssemblyData(appDomain.Address, assembly);
if (data == null)
{
continue;
}
ulong[] moduleList = GetModuleList(assembly, data.ModuleCount);
if (moduleList != null)
{
foreach (ulong module in moduleList)
{
yield return(module);
}
}
}
}
}
}
public IEnumerable <MemoryRegion> EnumerateHeaps(IAppDomainData appDomain)
{
Debug.Assert(appDomain != null);
_appDomain = appDomain.Address;
_regions.Clear();
// Standard heaps.
_type = ClrMemoryRegionType.LowFrequencyLoaderHeap;
_runtime.TraverseHeap(appDomain.LowFrequencyHeap, _delegate);
_type = ClrMemoryRegionType.HighFrequencyLoaderHeap;
_runtime.TraverseHeap(appDomain.HighFrequencyHeap, _delegate);
_type = ClrMemoryRegionType.StubHeap;
_runtime.TraverseHeap(appDomain.StubHeap, _delegate);
// Stub heaps.
_type = ClrMemoryRegionType.IndcellHeap;
_runtime.TraverseStubHeap(_appDomain, (int)InternalHeapTypes.IndcellHeap, _delegate);
_type = ClrMemoryRegionType.LookupHeap;
_runtime.TraverseStubHeap(_appDomain, (int)InternalHeapTypes.LookupHeap, _delegate);
_type = ClrMemoryRegionType.ResolveHeap;
_runtime.TraverseStubHeap(_appDomain, (int)InternalHeapTypes.ResolveHeap, _delegate);
_type = ClrMemoryRegionType.DispatchHeap;
_runtime.TraverseStubHeap(_appDomain, (int)InternalHeapTypes.DispatchHeap, _delegate);
_type = ClrMemoryRegionType.CacheEntryHeap;
_runtime.TraverseStubHeap(_appDomain, (int)InternalHeapTypes.CacheEntryHeap, _delegate);
return(_regions);
}
private ClrModule GetMscorlib()
{
ClrModule mscorlib = null;
string moduleName = ClrInfo.Flavor == ClrFlavor.Core
? "system.private.corelib"
: "mscorlib";
foreach (ClrModule module in _modules.Values)
{
if (module.Name.ToLowerInvariant().Contains(moduleName))
{
mscorlib = module;
break;
}
}
if (mscorlib == null)
{
IAppDomainStoreData ads = GetAppDomainStoreData();
IAppDomainData sharedDomain = GetAppDomainData(ads.SharedDomain);
foreach (ulong assembly in GetAssemblyList(ads.SharedDomain, sharedDomain.AssemblyCount))
{
string name = GetAssemblyName(assembly);
if (name.ToLowerInvariant().Contains(moduleName))
{
IAssemblyData assemblyData = GetAssemblyData(ads.SharedDomain, assembly);
ulong module = GetModuleList(assembly, assemblyData.ModuleCount).Single();
mscorlib = GetModule(module);
}
}
}
return(mscorlib);
}
public IEnumerable<MemoryRegion> EnumerateHeaps(IAppDomainData appDomain)
{
Debug.Assert(appDomain != null);
mAppDomain = appDomain.Address;
mRegions.Clear();
// Standard heaps.
mType = ClrMemoryRegionType.LowFrequencyLoaderHeap;
mRuntime.TraverseHeap(appDomain.LowFrequencyHeap, mDelegate);
mType = ClrMemoryRegionType.HighFrequencyLoaderHeap;
mRuntime.TraverseHeap(appDomain.HighFrequencyHeap, mDelegate);
mType = ClrMemoryRegionType.StubHeap;
mRuntime.TraverseHeap(appDomain.StubHeap, mDelegate);
// Stub heaps.
mType = ClrMemoryRegionType.IndcellHeap;
mRuntime.TraverseStubHeap(mAppDomain, (int)InternalHeapTypes.IndcellHeap, mDelegate);
mType = ClrMemoryRegionType.LookupHeap;
mRuntime.TraverseStubHeap(mAppDomain, (int)InternalHeapTypes.LookupHeap, mDelegate);
mType = ClrMemoryRegionType.ResolveHeap;
mRuntime.TraverseStubHeap(mAppDomain, (int)InternalHeapTypes.ResolveHeap, mDelegate);
mType = ClrMemoryRegionType.DispatchHeap;
mRuntime.TraverseStubHeap(mAppDomain, (int)InternalHeapTypes.DispatchHeap, mDelegate);
mType = ClrMemoryRegionType.CacheEntryHeap;
mRuntime.TraverseStubHeap(mAppDomain, (int)InternalHeapTypes.CacheEntryHeap, mDelegate);
return mRegions;
}
internal DesktopAppDomain(DesktopRuntimeBase runtime, IAppDomainData data, string name)
{
_address = data.Address;
_id = data.Id;
_name = name;
_runtime = runtime;
}
internal DesktopAppDomain(DesktopRuntimeBase runtime, IAppDomainData data, string name)
{
_address = data.Address;
Id = data.Id;
Name = name;
InternalId = s_internalId++;
_runtime = runtime;
}
internal DesktopAppDomain(DesktopRuntimeBase runtime, IAppDomainData data, string name)
{
_address = data.Address;
_id = data.Id;
_name = name;
_internalId = s_internalId++;
_runtime = runtime;
}
internal DesktopAppDomain(DesktopRuntimeBase runtime, IAppDomainData data, string name)
{
m_address = data.Address;
m_id = data.Id;
m_name = name;
m_internalId = s_internalId++;
m_runtime = runtime;
}
public ClrmdAppDomain(ClrRuntime runtime, IAppDomainData data)
{
if (data is null)
{
throw new ArgumentNullException(nameof(data));
}
_helpers = data.Helpers;
Runtime = runtime;
Id = data.Id;
Address = data.Address;
Name = data.Name;
Runtime = runtime;
Modules = _helpers.EnumerateModules(this).ToImmutableArray();
}
public IEnumerable<MemoryRegion> EnumerateModuleHeaps(IAppDomainData appDomain, ulong addr)
{
Debug.Assert(appDomain != null);
mAppDomain = appDomain.Address;
mRegions.Clear();
if (addr == 0)
return mRegions;
IModuleData module = mRuntime.GetModuleData(addr);
if (module != null)
{
mType = ClrMemoryRegionType.ModuleThunkHeap;
mRuntime.TraverseHeap(module.ThunkHeap, mDelegate);
mType = ClrMemoryRegionType.ModuleLookupTableHeap;
mRuntime.TraverseHeap(module.LookupTableHeap, mDelegate);
}
return mRegions;
}
public IEnumerable<MemoryRegion> EnumerateModuleHeaps(IAppDomainData appDomain, ulong addr)
{
Debug.Assert(appDomain != null);
_appDomain = appDomain.Address;
_regions.Clear();
if (addr == 0)
return _regions;
IModuleData module = _runtime.GetModuleData(addr);
if (module != null)
{
_type = ClrMemoryRegionType.ModuleThunkHeap;
_runtime.TraverseHeap(module.ThunkHeap, _delegate);
_type = ClrMemoryRegionType.ModuleLookupTableHeap;
_runtime.TraverseHeap(module.LookupTableHeap, _delegate);
}
return _regions;
}
private DesktopAppDomain InitDomain(ulong domain, string name = null)
{
ulong[] bases = new ulong[1];
IAppDomainData domainData = GetAppDomainData(domain);
if (domainData == null)
{
return(null);
}
DesktopAppDomain appDomain = new DesktopAppDomain(this, domainData, name ?? GetAppDomaminName(domain));
if (domainData.AssemblyCount > 0)
{
foreach (ulong assembly in GetAssemblyList(domain, domainData.AssemblyCount))
{
IAssemblyData assemblyData = GetAssemblyData(domain, assembly);
if (assemblyData == null)
{
continue;
}
if (assemblyData.ModuleCount > 0)
{
foreach (ulong module in GetModuleList(assembly, assemblyData.ModuleCount))
{
DesktopModule clrModule = GetModule(module);
if (clrModule != null)
{
clrModule.AddMapping(appDomain, module);
appDomain.AddModule(clrModule);
}
}
}
}
}
return(appDomain);
}
public IEnumerable <MemoryRegion> EnumerateModuleHeaps(IAppDomainData appDomain, ulong addr)
{
Debug.Assert(appDomain != null);
mAppDomain = appDomain.Address;
mRegions.Clear();
if (addr == 0)
{
return(mRegions);
}
IModuleData module = mRuntime.GetModuleData(addr);
if (module != null)
{
mType = ClrMemoryRegionType.ModuleThunkHeap;
mRuntime.TraverseHeap(module.ThunkHeap, mDelegate);
mType = ClrMemoryRegionType.ModuleLookupTableHeap;
mRuntime.TraverseHeap(module.LookupTableHeap, mDelegate);
}
return(mRegions);
}
/// <summary>
/// Enumerates regions of memory which CLR has allocated with a description of what data
/// resides at that location. Note that this does not return every chunk of address space
/// that CLR allocates.
/// </summary>
/// <returns>An enumeration of memory regions in the process.</returns>
public override IEnumerable <ClrMemoryRegion> EnumerateMemoryRegions()
{
// Enumerate GC Segment regions.
IHeapDetails[] heaps;
if (ServerGC)
{
heaps = new IHeapDetails[HeapCount];
int i = 0;
ulong[] heapList = GetServerHeapList();
if (heapList != null)
{
foreach (ulong addr in heapList)
{
heaps[i++] = GetSvrHeapDetails(addr);
if (i == heaps.Length)
{
break;
}
}
}
else
{
heaps = new IHeapDetails[0];
}
}
else
{
Debug.Assert(HeapCount == 1);
heaps = new IHeapDetails[1];
heaps[0] = GetWksHeapDetails();
}
HashSet <ulong> addresses = new HashSet <ulong>();
for (int i = 0; i < heaps.Length; ++i)
{
// Small heap
ISegmentData segment = GetSegmentData(heaps[i].FirstHeapSegment);
while (segment != null)
{
Debug.Assert(segment.Start < segment.Committed);
GCSegmentType type = segment.Address == heaps[i].EphemeralSegment ? GCSegmentType.Ephemeral : GCSegmentType.Regular;
yield return(new MemoryRegion(this, segment.Start, segment.Committed - segment.Start, ClrMemoryRegionType.GCSegment, (uint)i, type));
if (segment.Committed <= segment.Reserved)
{
yield return(new MemoryRegion(this, segment.Committed, segment.Reserved - segment.Committed, ClrMemoryRegionType.ReservedGCSegment, (uint)i, type));
}
if (segment.Address == segment.Next || segment.Address == 0)
{
break;
}
if (!addresses.Add(segment.Next))
{
break;
}
segment = GetSegmentData(segment.Next);
}
segment = GetSegmentData(heaps[i].FirstLargeHeapSegment);
while (segment != null)
{
Debug.Assert(segment.Start < segment.Committed);
yield return(new MemoryRegion(this, segment.Start, segment.Committed - segment.Start, ClrMemoryRegionType.GCSegment, (uint)i, GCSegmentType.LargeObject));
if (segment.Committed <= segment.Reserved)
{
yield return(new MemoryRegion(
this,
segment.Committed,
segment.Reserved - segment.Committed,
ClrMemoryRegionType.ReservedGCSegment,
(uint)i,
GCSegmentType.LargeObject));
}
if (segment.Address == segment.Next || segment.Address == 0)
{
break;
}
if (!addresses.Add(segment.Next))
{
break;
}
segment = GetSegmentData(segment.Next);
}
}
// Enumerate handle table regions.
HashSet <ulong> regions = new HashSet <ulong>();
foreach (ClrHandle handle in EnumerateHandles())
{
if (!_dataReader.VirtualQuery(handle.Address, out VirtualQueryData vq))
{
continue;
}
if (regions.Contains(vq.BaseAddress))
{
continue;
}
regions.Add(vq.BaseAddress);
yield return(new MemoryRegion(this, vq.BaseAddress, vq.Size, ClrMemoryRegionType.HandleTableChunk, handle.AppDomain));
}
// Enumerate each AppDomain and Module specific heap.
AppDomainHeapWalker adhw = new AppDomainHeapWalker(this);
IAppDomainData ad = GetAppDomainData(SystemDomainAddress);
foreach (MemoryRegion region in adhw.EnumerateHeaps(ad))
{
yield return(region);
}
foreach (ulong module in EnumerateModules(ad))
{
foreach (MemoryRegion region in adhw.EnumerateModuleHeaps(ad, module))
{
yield return(region);
}
}
ad = GetAppDomainData(SharedDomainAddress);
foreach (MemoryRegion region in adhw.EnumerateHeaps(ad))
{
yield return(region);
}
foreach (ulong module in EnumerateModules(ad))
{
foreach (MemoryRegion region in adhw.EnumerateModuleHeaps(ad, module))
{
yield return(region);
}
}
IAppDomainStoreData ads = GetAppDomainStoreData();
if (ads != null)
{
ulong[] appDomains = GetAppDomainList(ads.Count);
if (appDomains != null)
{
foreach (ulong addr in appDomains)
{
ad = GetAppDomainData(addr);
foreach (MemoryRegion region in adhw.EnumerateHeaps(ad))
{
yield return(region);
}
foreach (ulong module in EnumerateModules(ad))
{
foreach (MemoryRegion region in adhw.EnumerateModuleHeaps(ad, module))
{
yield return(region);
}
}
}
}
}
// Enumerate each JIT code heap.
regions.Clear();
foreach (ICodeHeap jitHeap in EnumerateJitHeaps())
{
if (jitHeap.Type == CodeHeapType.Host)
{
if (_dataReader.VirtualQuery(jitHeap.Address, out VirtualQueryData vq))
{
yield return(new MemoryRegion(this, vq.BaseAddress, vq.Size, ClrMemoryRegionType.JitHostCodeHeap));
}
else
{
yield return(new MemoryRegion(this, jitHeap.Address, 0, ClrMemoryRegionType.JitHostCodeHeap));
}
}
else if (jitHeap.Type == CodeHeapType.Loader)
{
foreach (MemoryRegion region in adhw.EnumerateJitHeap(jitHeap.Address))
{
yield return(region);
}
}
}
}
internal IEnumerable<ulong> EnumerateModules(IAppDomainData appDomain)
{
if (appDomain != null)
{
ulong[] assemblies = GetAssemblyList(appDomain.Address, appDomain.AssemblyCount);
if (assemblies != null)
{
foreach (ulong assembly in assemblies)
{
IAssemblyData data = GetAssemblyData(appDomain.Address, assembly);
if (data == null)
continue;
Address[] moduleList = GetModuleList(assembly, (int)data.ModuleCount);
if (moduleList != null)
foreach (ulong module in moduleList)
yield return module;
}
}
}
}
