UnityMixedCallstackFilter.cs

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using Microsoft.VisualStudio;
using Microsoft.VisualStudio.Debugger;
using Microsoft.VisualStudio.Debugger.CallStack;
using Microsoft.VisualStudio.Debugger.ComponentInterfaces;
using Microsoft.VisualStudio.Shell;
using Microsoft.VisualStudio.Shell.Interop;
using UnityMixedCallStack;

namespace UnityMixedCallstack
{
 public class UnityMixedCallstackFilter : IDkmCallStackFilter, IDkmLoadCompleteNotification, IDkmModuleInstanceLoadNotification
 {
 private static bool _enabled;
 public static IVsOutputWindowPane _debugPane;
 private static Dictionary<int, PmipFile> _currentFiles = new Dictionary<int, PmipFile>();

 struct PmipFile
 {
 public int count;
 public int pid;
 public string path;
 }

 public void OnLoadComplete(DkmProcess process, DkmWorkList workList, DkmEventDescriptor eventDescriptor)
 {
 PmipReader.DisposeStreams();

 if (_debugPane == null)
 {
 IVsOutputWindow outWindow = Package.GetGlobalService(typeof(SVsOutputWindow)) as IVsOutputWindow;
 Guid debugPaneGuid = VSConstants.GUID_OutWindowDebugPane;
 outWindow?.GetPane(ref debugPaneGuid, out _debugPane);
 }
 }

 public DkmStackWalkFrame[] FilterNextFrame(DkmStackContext stackContext, DkmStackWalkFrame input)
 {
 if (input == null) // after last frame
 return null;

 if (input.InstructionAddress == null) // error case
 return new[] { input };

 if (input.InstructionAddress.ModuleInstance != null && input.InstructionAddress.ModuleInstance.Module != null) // code in existing module
 return new[] { input };

 if (!_enabled) // environment variable not set
 return new[] { input };

 try
 {
 DkmStackWalkFrame[] retVal = new[] { UnityMixedStackFrame(stackContext, input) };
 return retVal;
 } catch (Exception ex)
 {
 _debugPane?.OutputString("UNITYMIXEDCALLSTACK :: ip : " + input.Process.LivePart.Id + " threw exception: " + ex.Message + "\n" + ex.StackTrace);
 }
 return new[] { input };
 }

 private static DkmStackWalkFrame UnityMixedStackFrame(DkmStackContext stackContext, DkmStackWalkFrame frame)
 {
 RefreshStackData(frame.Process.LivePart.Id);
#if DEBUG
 _debugPane?.OutputString($"UNITYMIXEDCALLSTACK :: done refreshing data for pid({frame.Process.LivePart.Id}) :: looking for address: {frame.InstructionAddress.CPUInstructionPart.InstructionPointer:X16}\n");
#endif

 string name = null;
 if (PmipReader.TryGetDescriptionForIp(frame.InstructionAddress.CPUInstructionPart.InstructionPointer, out name))
 {
#if DEBUG
 _debugPane?.OutputString($"ip: {frame.InstructionAddress.CPUInstructionPart.InstructionPointer:X16} ### {name}\n");
#endif
 return DkmStackWalkFrame.Create(
 stackContext.Thread,
 frame.InstructionAddress,
 frame.FrameBase,
 frame.FrameSize,
 frame.Flags,
 name,
 frame.Registers,
 frame.Annotations);
 }
#if DEBUG
 else
 _debugPane?.OutputString($"IP not found: {frame.InstructionAddress.CPUInstructionPart.InstructionPointer:X16}\n");
#endif

 return frame;
 }

 private static int GetFileNameSequenceNum(string path)
 {
 var name = Path.GetFileNameWithoutExtension(path);
 const char delemiter = '_';
 var tokens = name.Split(delemiter);

 if (tokens.Length != 3)
 return -1;

 return int.Parse(tokens[2]);
 }

 private static bool CheckForUpdatedFiles(FileInfo[] taskFiles)
 {
 bool retVal = false;
 try
 {
 foreach (FileInfo taskFile in taskFiles)
 {
 string fName = Path.GetFileNameWithoutExtension(taskFile.Name);
 string[] tokens = fName.Split('_');
 PmipFile pmipFile = new PmipFile()
 {
 count = int.Parse(tokens[2]),
 pid = int.Parse(tokens[1]),
 path = taskFile.FullName
 };

 // 3 is legacy and treat everything as root domain
 if (tokens.Length == 3 &&
 (!_currentFiles.TryGetValue(0, out PmipFile curFile) ||
 curFile.count < pmipFile.count || curFile.pid != pmipFile.pid))
 {
 _currentFiles[0] = pmipFile;
 retVal = true;
 }
 else if (tokens.Length == 4)
 {
 int domainID = int.Parse(tokens[3]);
 if (!_currentFiles.TryGetValue(domainID, out PmipFile cFile) || cFile.count < pmipFile.count ||
 cFile.pid != pmipFile.pid)
 {
 _currentFiles[domainID] = pmipFile;
 retVal = true;
 }
 }
 }
 } catch (Exception e)
 {
 _debugPane?.OutputString("MIXEDCALLSTACK :: Exception thrown during CheckForUpdatedFiles: " + e.Message + "\n");
 _enabled = false;
 }
 return retVal;
 }

 private static void RefreshStackData(int pid)
 {
 DirectoryInfo taskDirectory = new DirectoryInfo(Path.GetTempPath());
 FileInfo[] taskFiles = taskDirectory.GetFiles("pmip_" + pid + "_*.txt");

 if (taskFiles.Length < 1)
 return;

 if (CheckForUpdatedFiles(taskFiles))
 PmipReader.DisposeStreams();

 foreach (PmipFile pmipFile in _currentFiles.Values)
 {

 _enabled = PmipReader.ReadPmipFile(pmipFile.path);
 if (!_enabled)
 {
 _debugPane?.OutputString($"Unable to read file: {pmipFile.path}\n");
 }
 }

 PmipReader.Sort();
 }

 public void OnModuleInstanceLoad(DkmModuleInstance moduleInstance, DkmWorkList workList, DkmEventDescriptorS eventDescriptor)
 {
 if (moduleInstance.Name.Contains("mono-2.0") && moduleInstance.MinidumpInfoPart == null)
 _enabled = true;
 }
 }
}