private Dictionary<int, ThreadInfo> processThreads; //has relating thread id to its threadInfo object #endregion Fields #region Constructors /// <summary> /// Constructor for ProcessInfo /// </summary> /// <param name="procID">The id of the process</param> /// <param name="debugger">The debugger</param> public ProcessInfo(Process process, CorDebugger debug) { if (debug == null) { throw new ArgumentException("Null Debugger Exception"); } processThreads = new Dictionary<int, ThreadInfo>(); processCorThreads = new List<CorThread>(); generalThreadInfos = new Dictionary<int, ProcessThread>(); attachedCompletedProcessEvent = new ManualResetEvent(false); debugger = debug; processId = process.Id; generalProcessInfo = Process.GetProcessById(processId); //CorPublish cp = new CorPublish(); //cpp = cp.GetProcess(processId); processFullName = process.MainModule.FileName; processShortName = System.IO.Path.GetFileName(process.MainModule.FileName); FileVersionInfo fileInfo = FileVersionInfo.GetVersionInfo(processFullName); description = fileInfo.FileDescription; company = fileInfo.CompanyName; //debuggerProcessInfo will be set when the updateInfo function is called //the reason for this is that the process must be stopped for this to take place //this happen only when we want it to }
private void prepareDebugger(string arguments) { var debugger = new CorDebugger(CorDebugger.GetDefaultDebuggerVersion()); _process = debugger.CreateProcess(_assembly, arguments); _process.OnCreateAppDomain += new CorAppDomainEventHandler(process_OnCreateAppDomain); _process.OnProcessExit += new CorProcessEventHandler(process_OnProcessExit); _process.OnBreakpoint += new BreakpointEventHandler(process_OnBreakpoint); _process.OnStepComplete += new StepCompleteEventHandler(_process_OnStepComplete); _process.OnModuleLoad += new CorModuleEventHandler(_process_OnModuleLoad); _process.OnDebuggerError += new DebuggerErrorEventHandler(_process_OnDebuggerError); }
public void Debug(int processID) { debugger = new CorDebugger(CorDebugger.GetDefaultDebuggerVersion()); process = debugger.DebugActiveProcess(processID, false); process.OnException += OnException; process.OnCreateAppDomain += OnNewAppDomain; process.OnProcessExit += OnExit; process.OnModuleLoad += OnModuleLoad; process.OnBreakpoint += OnBreakpoint; process.OnStepComplete += OnStepComplete; process.Continue(false); state = ProcessState.Started; subscriber.Published(string.Format("Successfully attached to Process with ID [{0}]", processID)); }
public ManagedCallback (CorDebugger outer) { m_outer = outer; }
void OnProcessExit (object sender, CorProcessEventArgs e) { TargetEventArgs args = new TargetEventArgs (TargetEventType.TargetExited); // If the main thread stopped, terminate the debugger session if (e.Process.Id == process.Id) { lock (terminateLock) { process = null; ThreadPool.QueueUserWorkItem (delegate { // The Terminate call will fail if called in the event handler dbg.Terminate (); dbg = null; GC.Collect (); }); } } OnTargetEvent (args); }
protected override void OnRun (DebuggerStartInfo startInfo) { // Create the debugger string dversion; try { dversion = CorDebugger.GetDebuggerVersionFromFile (startInfo.Command); } catch { dversion = CorDebugger.GetDefaultDebuggerVersion (); } dbg = new CorDebugger (dversion); Dictionary<string, string> env = new Dictionary<string, string> (); foreach (DictionaryEntry de in Environment.GetEnvironmentVariables ()) env[(string) de.Key] = (string) de.Value; foreach (KeyValuePair<string, string> var in startInfo.EnvironmentVariables) env[var.Key] = var.Value; // The second parameter of CreateProcess is the command line, and it includes the application being launched string cmdLine = "\"" + startInfo.Command + "\" " + startInfo.Arguments; int flags = 0; if (!startInfo.UseExternalConsole) { flags = 0x08000000; /* CREATE_NO_WINDOW*/ flags |= CorDebugger.CREATE_REDIRECT_STD; } process = dbg.CreateProcess (startInfo.Command, cmdLine, startInfo.WorkingDirectory, env, flags); processId = process.Id; process.OnCreateProcess += new CorProcessEventHandler (OnCreateProcess); process.OnCreateAppDomain += new CorAppDomainEventHandler (OnCreateAppDomain); process.OnAssemblyLoad += new CorAssemblyEventHandler (OnAssemblyLoad); process.OnAssemblyUnload += new CorAssemblyEventHandler (OnAssemblyUnload); process.OnCreateThread += new CorThreadEventHandler (OnCreateThread); process.OnThreadExit += new CorThreadEventHandler (OnThreadExit); process.OnModuleLoad += new CorModuleEventHandler (OnModuleLoad); process.OnModuleUnload += new CorModuleEventHandler (OnModuleUnload); process.OnProcessExit += new CorProcessEventHandler (OnProcessExit); process.OnUpdateModuleSymbols += new UpdateModuleSymbolsEventHandler (OnUpdateModuleSymbols); process.OnDebuggerError += new DebuggerErrorEventHandler (OnDebuggerError); process.OnBreakpoint += new BreakpointEventHandler (OnBreakpoint); process.OnStepComplete += new StepCompleteEventHandler (OnStepComplete); process.OnBreak += new CorThreadEventHandler (OnBreak); process.OnNameChange += new CorThreadEventHandler (OnNameChange); process.OnEvalComplete += new EvalEventHandler (OnEvalComplete); process.OnEvalException += new EvalEventHandler (OnEvalException); process.OnLogMessage += new LogMessageEventHandler (OnLogMessage); process.OnStdOutput += new CorTargetOutputEventHandler (OnStdOutput); process.Continue (false); OnStarted (); }
////////////////////////////////////////////////////////////////////////////////// // // Controlling Commands // ////////////////////////////////////////////////////////////////////////////////// /// <summary> /// creates a new debugged process. /// </summary> /// <param name="commandLine">The command to run.</param> /// <param name="commandArguments">The arguments for the command.</param> /// <param name="debugMode">The debug mode to run with.</param> /// <param name="deeVersion">The version of debugging interfaces that should be used for /// debugging of the started program. If this value is null, the default (latest) version /// of interface is used. /// </param> /// <returns>The resulting MDbgProcess.</returns> public MDbgProcess CreateProcess(string commandLine, string commandArguments, DebugModeFlag debugMode, string deeVersion) { CorDebugger debugger; if (deeVersion == null) { debugger = new CorDebugger(CorDebugger.GetDefaultDebuggerVersion()); } else { debugger = new CorDebugger(deeVersion); } MDbgProcess p = m_processMgr.CreateLocalProcess(debugger); p.DebugMode = debugMode; p.CreateProcess(commandLine, commandArguments); return p; }
/// <summary> /// Refreshes the processes hash which stores info on all managed process running /// </summary> public void RefreshProcessList() { processes.Clear(); foreach (var process in Process.GetProcesses()) { if (Process.GetCurrentProcess().Id == process.Id) { // let's hide our process continue; } // list the loaded runtimes in each process, if the ClrMetaHost APIs are available CLRMetaHost mh; try { mh = new CLRMetaHost(); } catch (Exception) { continue; } IEnumerable<CLRRuntimeInfo> runtimes; try { runtimes = mh.EnumerateLoadedRuntimes(process.Id); } catch (Exception) { continue; } // TODO: only one CLR version for now... if (runtimes.Any()) { var version = MdbgVersionPolicy.GetDefaultAttachVersion(process.Id); var debugger = new CorDebugger(version); processes[process.Id] = new ProcessInfo(process, debugger); } } }
static private MDbgProcess GetProcessFromCordb(ICorDebug cordbg) { Debugger.Processes.FreeStaleUnmanagedResources(); CorDebugger cordebugger = new CorDebugger(cordbg); Debugger.Processes.RegisterDebuggerForCleanup(cordebugger); return new MDbgProcess(Debugger, cordebugger); }
public override void Dispose ( ) { if (dbg != null && !terminated) { // The Terminate call will fail if this Dispose is being called from the handler // of a debugger event. Just in case, we run it in a separate thread. CorDebugger dd = dbg; ThreadPool.QueueUserWorkItem (delegate { if (!terminated) dd.Terminate (); }); } base.Dispose (); // There is no explicit way of disposing the metadata objects, so we have // to rely on the GC to do it. modules = null; documents = null; threads = null; process = null; processes = null; dbg = null; activeThread = null; GC.Collect (); }
/// <summary>Creates an empty process object. /// This object can be used to start a debugging session by calling /// CreateProcess or Attach method on it. /// </summary> /// <param name="engine">Root engine object that manages this process.</param> /// <param name="debugger">CorDebugger object that will be used to do an actual /// debugging</param> public MDbgProcess(MDbgEngine engine, CorDebugger debugger) { Debug.Assert(debugger != null); if (debugger == null) throw new ArgumentNullException("debugger"); m_corDebugger = debugger; CommonInit(engine); }
/// <summary> /// Adds the specified CorDebugger object to the cleanup list /// </summary> /// <param name="debugger"></param> public void RegisterDebuggerForCleanup(CorDebugger debugger) { if (null == debugger) throw new ArgumentNullException(); lock (m_CleanupList) { m_CleanupList.Add(debugger, false); } }
/// <summary> /// Creates a new process which can be debugged using the given ICorDebug instance /// </summary> /// <param name="debugger">CorDebugger to use for the process</param> /// <returns>The Process that got created.</returns> public MDbgProcess CreateLocalProcess(CorDebugger debugger) { Debug.Assert(debugger != null); // This is called on the Main thread so it's safe to flush FreeStaleUnmanagedResources(); RegisterDebuggerForCleanup(debugger); return new MDbgProcess(m_engine, debugger); }