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);
 }