private static JArray GetThreadTraces(DeadlockException de)
{
using var dataTarget = DataTarget.CreateSnapshotAndAttach(Process.GetCurrentProcess().Id);
var version = dataTarget.ClrVersions[0];
var runtime = version.CreateRuntime();
var ret = new JArray();
var threads = App.RunningDispatchers.Values.Append(App.BaseDispatcher).Where(d => de.ThreadNames.Contains(d.Thread.Name)).Select(d => d.Thread).Append(PacketAnalyzer.AnalysisThread);
foreach (var thread in threads)
{
if (thread.Name == null)
{
continue;
}
var runtimeThread = runtime.Threads.FirstOrDefault(t => t.ManagedThreadId == thread.ManagedThreadId);
if (runtimeThread != null)
{
ret.Add(new JObject
{
{ "thread_name", thread.Name },
{ "stack_trace", GetStackTraceClrmd(runtimeThread) }
});
}
}
return(ret);
}
public static DiagnosticAnalyzer FromSnapshot(int pid, bool cacheObjects = true)
{
var dataTarget = DataTarget.CreateSnapshotAndAttach(pid);
//dataTarget.BinaryLocator.FindBinary()
return(new DiagnosticAnalyzer(dataTarget, cacheObjects));
}
private void LogStackTrace()
{
var pid = Process.GetCurrentProcess().Id;
using (var dataTarget = DataTarget.CreateSnapshotAndAttach(pid))
{
var runtimeInfo = dataTarget.ClrVersions[0];
var runtime = runtimeInfo.CreateRuntime();
_output.WriteLine("Found {0} threads", runtime.Threads.Length);
foreach (var clrThread in runtime.Threads)
{
var methods = string.Join(",", clrThread
.EnumerateStackTrace()
.Where(f => f.Method != null)
.Take(20)
.Select(f => f.Method.Type.Name + "." + f.Method.Name));
if (!string.IsNullOrWhiteSpace(methods))
{
_output.WriteLine("Thread {0} at {1}", clrThread.ManagedThreadId, methods);
}
}
}
}
public DataTarget GetDataTarget()
{
if (_target == null)
{
int pid = Process.GetCurrentProcess().Id;
_target = DataTarget.CreateSnapshotAndAttach(pid);
}
return(_target);
}
private DataTarget CreateDataTarget()
{
try
{
return(DataTarget.CreateSnapshotAndAttach(Process.GetCurrentProcess().Id));
}
catch (Exception e)
{
_logger?.LogError(e, "Unable to create process snapshot");
}
return(null);
}
static void Main()
{
using DataTarget dt = DataTarget.CreateSnapshotAndAttach(Process.GetCurrentProcess().Id);
using ClrRuntime runtime = dt.ClrVersions.Single().CreateRuntime();
foreach (ClrThread thread in runtime.Threads)
{
Console.WriteLine($"{thread.OSThreadId:x}:");
foreach (ClrStackFrame frame in thread.EnumerateStackTrace())
{
Console.WriteLine($" {frame}");
}
}
}
public static ClrMDSession AttachWithSnapshot(Process p)
{
if (s_currentSession != null && s_lastProcessId == p.Id)
{
TestInvalidComObjectException();
return(s_currentSession);
}
Detach();
DataTarget target = DataTarget.CreateSnapshotAndAttach(p.Id);
s_lastProcessId = p.Id;
return(new ClrMDSession(target, null));
}
public static void ShowStackTraceWithSnapshot(int processId, TextWriter outputWriter)
{
if (processId == -1)
{
throw new InvalidOperationException("Uninitialized process id parameter");
}
List <ThreadInfo> threadInfos;
using (var dataTarget = DataTarget.CreateSnapshotAndAttach(processId))
threadInfos = CreateThreadInfos(dataTarget);
var mergedStackTraces = MergeStackTraces(threadInfos);
OutputResult(outputWriter, mergedStackTraces);
}
public void CollectibleTypeTest()
{
CollectibleAssemblyLoadContext context = new CollectibleAssemblyLoadContext();
RuntimeHelpers.RunClassConstructor(context.LoadFromAssemblyPath(Assembly.GetExecutingAssembly().Location)
.GetType(typeof(CollectibleUnmanagedStruct).FullName).TypeHandle);
RuntimeHelpers.RunClassConstructor(Assembly.GetExecutingAssembly()
.GetType(typeof(UncollectibleUnmanagedStruct).FullName).TypeHandle);
using DataTarget dataTarget = DataTarget.CreateSnapshotAndAttach(Process.GetCurrentProcess().Id);
ClrHeap heap = dataTarget.ClrVersions.Single(v => v.ModuleInfo.FileName.EndsWith("coreclr.dll", true, null)).CreateRuntime().Heap;
ClrType[] types = heap.EnumerateObjects().Select(obj => obj.Type).ToArray();
ClrType collectibleType = types.Single(type => type?.Name == typeof(CollectibleUnmanagedStruct).FullName);
Assert.False(collectibleType.ContainsPointers);
Assert.True(collectibleType.IsCollectible);
Assert.NotEqual(default, collectibleType.LoaderAllocatorHandle);
#pragma warning disable 618
private static JObject /*Task<JObject>*/ GetThreadTraces(DeadlockException de)
{
using var dataTarget = DataTarget.CreateSnapshotAndAttach(Process.GetCurrentProcess().Id);
var version = dataTarget.ClrVersions[0];
var runtime = version.CreateRuntime();
var ret = new JObject();
var threads = App.RunningDispatchers.Values.Append(App.BaseDispatcher).Where(d => de.ThreadNames.Contains(d.Thread.Name)).Select(d => d.Thread).Append(PacketAnalyzer.AnalysisThread);
foreach (var thread in threads)
{
if (thread?.Name == null)
{
continue;
}
var runtimeThread = runtime.Threads.FirstOrDefault(t => t.ManagedThreadId == thread.ManagedThreadId);
if (runtimeThread != null)
{
ret[thread.Name] = GetStackTraceClrmd(runtimeThread);
}
//ret[thread.Name] = GetStackTrace(thread).ToString();
}
//App.RunningDispatchers.Values.Append(App.BaseDispatcher).ToList().ForEach(d =>
//{
// var t = d.Thread;
// t.Suspend();
// ret[t.Name] = new StackTrace(t, false).ToString();
// t.Resume();
//});
//if (PacketAnalyzer.AnalysisThread == null) return ret;
//PacketAnalyzer.AnalysisThread.Suspend();
//ret["Analysis"] = new StackTrace(PacketAnalyzer.AnalysisThread, false).ToString();
//PacketAnalyzer.AnalysisThread.Resume();
return(ret);
}
public void CreateSnapshotAndAttach_ThrowsPlatformNotSupportedException()
{
_ = Assert.Throws <PlatformNotSupportedException>(() => DataTarget.CreateSnapshotAndAttach(Process.GetCurrentProcess().Id));
}