public MDANotificationDebugCallbackEventArgs(ICorDebugController pController, ICorDebugThread pThread, ICorDebugMDA pMDA) : base(pController) { Controller = pController; Thread = pThread; MDA = pMDA; }
private DebuggeeProcess GetProcessWrapper(ICorDebugController controller) { if (controller is ICorDebugAppDomain) return GetProcessWrapper(controller as ICorDebugAppDomain); else if (controller is ICorDebugProcess) return GetProcessWrapper(controller as ICorDebugProcess); return null; }
internal IDebuggerController GetController(ICorDebugController controller) { if (controller is ICorDebugAppDomain) { return(GetAppDomain(controller as ICorDebugAppDomain)); } return(this); }
public void MDANotification(ICorDebugController c, ICorDebugThread t, ICorDebugMDA mda) { ManagedCallback managedCallback = GetProcessCallbackInterface(c); if (managedCallback != null) { managedCallback.MDANotification(c, t, mda); } }
public ManagedCallback GetProcessCallbackInterface(string name, ICorDebugController c) { if (c is ICorDebugAppDomain) { return GetProcessCallbackInterface(name, (ICorDebugAppDomain)c); } else if (c is ICorDebugProcess){ return GetProcessCallbackInterface(name, (ICorDebugProcess)c); } else { throw new System.Exception("Unknown callback argument"); } }
public ManagedCallback GetProcessCallbackInterface(string name, ICorDebugController c) { if (c.Is<ICorDebugAppDomain>()) { return GetProcessCallbackInterface(name, c.CastTo<ICorDebugAppDomain>()); } else if (c.Is<ICorDebugProcess>()){ return GetProcessCallbackInterface(name, c.CastTo<ICorDebugProcess>()); } else { throw new System.Exception("Unknown callback argument"); } }
private void HandleEvent(ICorDebugController controller, bool finalize = true) { var process = GetProcessWrapper(controller); var eventArgs = new DebuggerEventArgs(process.GetController(controller), true); process.DispatchEvent(eventArgs); if (finalize) FinalizeEvent(eventArgs); }
void ICorDebugManagedCallback2.MDANotification( ICorDebugController pController, ICorDebugThread thread, ICorDebugMDA pMDA) { if (DebugOutput) { Console.WriteLine("info: MDANotification2"); } pController.Continue(0); }
private DebuggeeProcess GetProcessWrapper(ICorDebugController controller) { if (controller is ICorDebugAppDomain) { return(GetProcessWrapper(controller as ICorDebugAppDomain)); } else if (controller is ICorDebugProcess) { return(GetProcessWrapper(controller as ICorDebugProcess)); } return(null); }
private void HandleEvent(ICorDebugController controller, bool finalize = true) { var process = GetProcessWrapper(controller); var eventArgs = new DebuggerEventArgs(process.GetController(controller), true); process.DispatchEvent(eventArgs); if (finalize) { FinalizeEvent(eventArgs); } }
public ManagedCallback GetProcessCallbackInterface(ICorDebugController c) { if (c.Is <ICorDebugAppDomain>()) { return(GetProcessCallbackInterface(c.CastTo <ICorDebugAppDomain>())); } else if (c.Is <ICorDebugProcess>()) { return(GetProcessCallbackInterface(c.CastTo <ICorDebugProcess>())); } else { throw new System.Exception("Unknown callback argument"); } }
public ManagedCallback GetProcessCallbackInterface(string name, ICorDebugController c) { if (c is ICorDebugAppDomain) { return(GetProcessCallbackInterface(name, (ICorDebugAppDomain)c)); } else if (c is ICorDebugProcess) { return(GetProcessCallbackInterface(name, (ICorDebugProcess)c)); } else { throw new System.Exception("Unknown callback argument"); } }
/// <exception cref="Exception">Unknown callback argument</exception> public void MDANotification(ICorDebugController c, ICorDebugThread t, ICorDebugMDA mda) { if (c is ICorDebugAppDomain) { EnterCallback(PausedReason.Other, "MDANotification", (ICorDebugAppDomain)c); } else if (c is ICorDebugProcess) { EnterCallback(PausedReason.Other, "MDANotification", (ICorDebugProcess)c); } else { throw new System.Exception("Unknown callback argument"); } ExitCallback(); }
public void MDANotification(ICorDebugController c, ICorDebugThread t, ICorDebugMDA mda) { if (c.Is <ICorDebugAppDomain>()) { EnterCallback(PausedReason.Other, "MDANotification", c.CastTo <ICorDebugAppDomain>()); } else if (c.Is <ICorDebugProcess>()) { EnterCallback(PausedReason.Other, "MDANotification", c.CastTo <ICorDebugProcess>()); } else { throw new System.Exception("Unknown callback argument"); } ExitCallback_Continue(); }
public void MDANotification(ICorDebugController pController, ICorDebugThread pThread, ICorDebugMDA pMDA) { try { _EnterCallback(); lock (dbgproc) { string desc; { uint len = 0; pMDA.GetDescription(len, out len, IntPtr.Zero); IntPtr pdesc = Marshal.AllocHGlobal((int)len * 2); pMDA.GetDescription(len, out len, pdesc); desc = Marshal.PtrToStringUni(pdesc, (int)len); if (desc.EndsWith("\0")) { desc = desc.Substring(0, desc.Length - 1); } Marshal.FreeHGlobal(pdesc); } dbgproc.dout.WriteLine("MDA notification: {0}", desc); } _CallbackEvent("MDANotification", true); } catch (Exception e) { _CallbackException(e); } }
public virtual void MDANotification(ICorDebugController controller, ICorDebugThread thread, ICorDebugMDA mda) { this.DefaultHandler(controller); }
public void MDANotification(ICorDebugController pController, ICorDebugThread pThread, ICorDebugMDA pMDA) { pController.Continue(0); }
int ICorDebugAppDomain.SetAllThreadsDebugState(CorDebugThreadState state, ICorDebugThread pExceptThisThread) { return(ICorDebugController.SetAllThreadsDebugState(state, pExceptThisThread)); }
//This need to be called in Process Creaded notification public static void SetStateObj(ICorDebugController value) { if (stateObj != null) { throw new Exception("Already initialized"); } stateObj = new ControllerStateObject(value); }
int ICorDebugAppDomain.HasQueuedCallbacks(ICorDebugThread pThread, out int pbQueued) { return(ICorDebugController.HasQueuedCallbacks(pThread, out pbQueued)); }
int ICorDebugAppDomain.Continue(int fIsOutOfBand) { return(ICorDebugController.Continue(fIsOutOfBand)); }
public void CreateProcess(ICorDebugProcess pProcess) { controller = pProcess; controller.Continue(0); }
bool Continue(ICorDebugController controller) { Debug.Assert(controller != null); if (controller == null) return false; int hr = controller.Continue(0); continueCounter++; bool success = hr >= 0 || hr == CordbgErrors.CORDBG_E_PROCESS_TERMINATED || hr == CordbgErrors.CORDBG_E_OBJECT_NEUTERED; Debug.WriteLineIf(!success, string.Format("dndbg: ICorDebugController::Continue() failed: 0x{0:X8}", hr)); return success; }
int ICorDebugAppDomain.CommitChanges(uint cSnapshots, ref ICorDebugEditAndContinueSnapshot pSnapshots, out ICorDebugErrorInfoEnum pError) { return(ICorDebugController.CommitChanges(cSnapshots, ref pSnapshots, out pError)); }
int ICorDebugAppDomain.Terminate(uint exitCode) { return(ICorDebugController.Terminate(exitCode)); }
int ICorDebugAppDomain.Detach() { return(ICorDebugController.Detach()); }
/// <exception cref="Exception">Unknown callback argument</exception> public void MDANotification(ICorDebugController c, ICorDebugThread t, ICorDebugMDA mda) { if (c is ICorDebugAppDomain) { EnterCallback("MDANotification", (ICorDebugAppDomain)c); } else if (c is ICorDebugProcess){ EnterCallback("MDANotification", (ICorDebugProcess)c); } else { throw new System.Exception("Unknown callback argument"); } ExitCallback(); }
internal IDebuggerController GetController(ICorDebugController controller) { if (controller is ICorDebugAppDomain) return GetAppDomain(controller as ICorDebugAppDomain); return this; }
// Get process from controller static private CorProcess GetProcessFromController(ICorDebugController pController) { CorProcess p; ICorDebugProcess p2 = pController as ICorDebugProcess; if (p2 != null) { p = CorProcess.GetCorProcess(p2); } else { ICorDebugAppDomain a2 = (ICorDebugAppDomain)pController; p = new CorAppDomain(a2).Process; } return p; }
int ICorDebugAppDomain.IsRunning(out int pbRunning) { return(ICorDebugController.IsRunning(out pbRunning)); }
internal CorController(ICorDebugController controller) : base(controller) { m_controller = controller; }
public void MDANotification([In, MarshalAs(UnmanagedType.Interface)] ICorDebugController pController, [In, MarshalAs(UnmanagedType.Interface)] ICorDebugThread pThread, [In, MarshalAs(UnmanagedType.Interface)] ICorDebugMDA pMDA) { throw new NotImplementedException(); }
/// <summary> /// Creates an instance of the controller. /// </summary> /// <param name="cocntrl">ICorDebugController instance</param> internal CorController(ICorDebugController cocntrl, CorDebuggerOptions options) : base(cocntrl, options) { this.cocntrl = cocntrl; }
protected DebugCallbackEventArgs(ICorDebugController ctrl) { this.ctrl = ctrl; }
public void MDANotification(ICorDebugController pController, ICorDebugThread pThread, ICorDebugMDA pMDA) { throw new NotImplementedException(); }
int ICorDebugAppDomain.EnumerateThreads(out ICorDebugThreadEnum ppThreads) { return(ICorDebugController.EnumerateThreads(out ppThreads)); }
public void HandleEvent(ICorDebugController controller) { Console.WriteLine("event received"); controller.Continue(0); }
public void MDANotification(ICorDebugController pController, ICorDebugThread pThread, ICorDebugMDA pMDA) { HandleEvent(pController); }
public void MDANotification(ICorDebugController c, ICorDebugThread t, ICorDebugMDA mda) { ManagedCallback managedCallback = GetProcessCallbackInterface("MDANotification", c); if (managedCallback != null) { managedCallback.MDANotification(c, t, mda); } }
public virtual void MDANotification(ICorDebugController pController, ICorDebugThread pThread, ICorDebugMDA pMDA) { pController.Continue(0); }
public MDANotificationDebugCallbackEventArgs(ICorDebugController pController, ICorDebugThread pThread, ICorDebugMDA pMDA) : base(pController) { this.Controller = pController; this.Thread = pThread; this.MDA = pMDA; }
public void MDANotification(ICorDebugController c, ICorDebugThread t, ICorDebugMDA mda) { if (c.Is<ICorDebugAppDomain>()) { EnterCallback(PausedReason.Other, "MDANotification", c.CastTo<ICorDebugAppDomain>()); } else if (c.Is<ICorDebugProcess>()){ EnterCallback(PausedReason.Other, "MDANotification", c.CastTo<ICorDebugProcess>()); } else { throw new System.Exception("Unknown callback argument"); } ExitCallback_Continue(); }
internal Controller(ICorDebugController controller) { m_controller = controller; }
public void MDANotification(ICorDebugController pController, ICorDebugThread pThread, ICorDebugMDA pMDA) { Console.WriteLine("MDANotification"); pController.Continue(0); }
protected virtual void DefaultHandler(ICorDebugController controller) { controller.Continue(false); }
void ICorDebugManagedCallback2.MDANotification(ICorDebugController pController, ICorDebugThread pThread, ICorDebugMDA pMDA) { // TODO nothing for now }
protected DebugCallbackEventArgs(ICorDebugController ctrl) { CorDebugController = ctrl; }
// This method must be called just before returning to the caller. No fields can be accessed // and no methods can be called because the CLR debugger could call us before this method // returns. bool Continue(ICorDebugController controller, bool callOnProcessStateChanged) { Debug.Assert(controller != null); if (controller == null) return false; if (callOnProcessStateChanged && managedCallbackCounter == 1) { try { continuing = true; CallOnProcessStateChanged(); } finally { continuing = false; } } managedCallbackCounter--; continueCounter++; if (callOnProcessStateChanged && managedCallbackCounter == 0) CallOnProcessStateChanged(); // As soon as we call Continue(), the CLR debugger could send us another message so it's // important that we don't access any of our fields and don't call any methods after // Continue() has been called! int hr = controller.Continue(0); bool success = hr >= 0 || hr == CordbgErrors.CORDBG_E_PROCESS_TERMINATED || hr == CordbgErrors.CORDBG_E_OBJECT_NEUTERED; Debug.WriteLineIf(!success, string.Format("dndbg: ICorDebugController::Continue() failed: 0x{0:X8}", hr)); return success; }
internal ControllerStateObject(ICorDebugController contoller) { m_Controller = contoller; }
void ICorDebugManagedCallback2.MDANotification(ICorDebugController pController, ICorDebugThread thread, ICorDebugMDA pMDA) { CorMDA c = new CorMDA(pMDA); string szName = c.Name; CorDebugMDAFlags f = c.Flags; CorProcess p = GetProcessFromController(pController); HandleEvent(ManagedCallbackType.OnMDANotification, new CorMDAEventArgs(c, thread == null ? null : new CorThread(thread), p, ManagedCallbackType.OnMDANotification)); }
int ICorDebugAppDomain.Stop(uint dwTimeout) { return(ICorDebugController.Stop(dwTimeout)); }