public UnifiedStackFrame ConvertToUnified(ClrStackFrame frame, SourceLocation sourceLocation, ThreadInfo info) { var result = new UnifiedStackFrame(frame, sourceLocation); result.ThreadContext = info.ContextStruct; return result; }
public UnifiedThread(ThreadInfo info) { this.IsManagedThread = info.IsManagedThread; this.Index = info.Index; this.EngineThreadId = info.EngineThreadId; this.OSThreadId = info.OSThreadId; this.Detail = info.Detail; }
public override async Task<List<UnifiedBlockingObject>> GetUnmanagedBlockingObjects(ThreadInfo thread, List<UnifiedStackFrame> unmanagedStack, ClrRuntime runtime) { return await Task<List<UnifiedBlockingObject>>.Run(() => { ThreadWCTInfo wct_threadInfo = _wctApi.GetBlockingObjects(thread.OSThreadId); return _unmanagedBlockingObjectsHandler.GetUnmanagedBlockingObjects(wct_threadInfo, unmanagedStack); }); }
public UnifiedManagedThread(ThreadInfo info, List<UnifiedStackFrame> managedStack, List<UnifiedStackFrame> unManagedStack, List<UnifiedBlockingObject> blockingObjects) : base(info) { StackTrace = new List<UnifiedStackFrame>(); if (managedStack != null) { StackTrace.AddRange(managedStack); } if (unManagedStack != null) { StackTrace.AddRange(unManagedStack); } BlockingObjects = blockingObjects; }
internal List<UnifiedStackFrame> ConvertToUnified(IEnumerable<DEBUG_STACK_FRAME> stackFrames, ClrRuntime runtime, IDebugClient debugClient, ThreadInfo info, uint pid = Constants.INVALID_PID) { bool waitFound = false; var reversed = stackFrames.Reverse(); List<UnifiedStackFrame> stackTrace = new List<UnifiedStackFrame>(); foreach (var frame in reversed) { var unified_frame = new UnifiedStackFrame(frame, (IDebugSymbols2)debugClient); unified_frame.ThreadContext = info.ContextStruct; if (!waitFound) { waitFound = Inpsect(unified_frame, runtime, pid); } stackTrace.Add(unified_frame); } return stackTrace; }
public override bool SetThreadContext(ThreadInfo threadInfo, IDebugAdvanced debugClient, IDataReader dataReader) { bool result = false; var plat = dataReader.GetArchitecture(); if (plat == Architecture.Amd64) { throw new InvalidOperationException("Unexpected architecture."); } byte[] contextBytes = new byte[GetThreadContextSize(dataReader)]; if (SetCurrentThreadId(threadInfo.EngineThreadId, debugClient) == DbgEng.S_OK) { var gch = GCHandle.Alloc(contextBytes, GCHandleType.Pinned); var h_result = ((IDebugAdvanced)debugClient).GetThreadContext(gch.AddrOfPinnedObject(), (uint)contextBytes.Length); if (h_result == DbgEng.S_OK) { try { var structure = Marshal.PtrToStructure<CONTEXT_X86>(gch.AddrOfPinnedObject()); threadInfo.ContextStruct = new Model.UnifiedThreadContext(structure, threadInfo); result = true; } finally { gch.Free(); } } } return result; }
public UnifiedThreadContext(CONTEXT_AMD64 context, ThreadInfo threadInfo) : this(true) { Context_amd64 = context; OSThreadId = threadInfo.OSThreadId; }
public UnifiedThreadContext(CONTEXT_X86 context, ThreadInfo threadInfo) : this(false) { Context = context; }
public List<UnifiedStackFrame> ConvertToUnified(IEnumerable<DEBUG_STACK_FRAME> stackFrames, ClrRuntime runtime, ThreadInfo info, uint pID) { var result = _unmanagedStackWalkerStrategy.ConvertToUnified(stackFrames, runtime, _debugClient, info, pID); return result; }
public void SetThreadContext(ThreadInfo specific_info) { _threadContextStrategy.SetThreadContext(specific_info, (IDebugAdvanced)_debugClient, _dataReader); }
public abstract Task<List<UnifiedBlockingObject>> GetUnmanagedBlockingObjects(ThreadInfo thread, List<UnifiedStackFrame> unmanagedStack, ClrRuntime runtime);
public abstract bool SetThreadContext(ThreadInfo threadInfo, IDebugAdvanced debugClient, IDataReader dataReader);
public UnifiedUnManagedThread(ThreadInfo info, List<UnifiedStackFrame> unmanagedStack, List<UnifiedBlockingObject> blockingObjects) : base(info) { BlockingObjects = blockingObjects; StackTrace = unmanagedStack; }
internal List<UnifiedBlockingObject> GetUnmanagedBlockingObjects(ThreadInfo thread, List<UnifiedStackFrame> unmanagedStack, ClrRuntime runtime, List<MiniDumpHandle> DumpHandles) { List<UnifiedBlockingObject> result = new List<UnifiedBlockingObject>(); result.AddRange(GetUnmanagedBlockingObjects(unmanagedStack)); foreach (var item in DumpHandles) { result.Add(new UnifiedBlockingObject(item)); } CheckForCriticalSections(result, unmanagedStack, runtime); return result; }
public override async Task<List<UnifiedBlockingObject>> GetUnmanagedBlockingObjects(ThreadInfo thread, List<UnifiedStackFrame> unmanagedStack, ClrRuntime runtime) { var handles = await _miniDump.GetHandles(); return _unmanagedBlockingObjectsHandler.GetUnmanagedBlockingObjects(thread, unmanagedStack, runtime, handles); }