public int ChangeEngineState(DEBUG_CES Flags, ulong Argument)
{
if (Flags == DEBUG_CES.EXECUTION_STATUS && Argument == (ulong)DEBUG_STATUS.BREAK)
{
BreakHappened?.Invoke(this, new EventArgs());
}
return(HResult.Ok);
}
public override int ChangeEngineState(DEBUG_CES flags, UInt64 argument)
{
if ((flags & DEBUG_CES.EXECUTION_STATUS) != 0)
{
ExecutionStatus = (((DEBUG_STATUS)argument) & DEBUG_STATUS.MASK);
if ((((DEBUG_CES_EXECUTION_STATUS)argument) & DEBUG_CES_EXECUTION_STATUS.INSIDE_WAIT) == 0)
{
_utilities.DebugClient.ExitDispatch(_utilities.DebugClient);
}
}
return(S_OK);
}
int IDebugEventCallbacksWide.ChangeEngineState(DEBUG_CES Flags, ulong Argument)
{
Debug.WriteLine("IDebugEventCallbacksWide.ChangeEngineState");
if (Flags.HasFlag(DEBUG_CES.BREAKPOINTS))
{
// some breakpoints changed
OnBreakpointChanged(new BreakpointChangedEventArgs((uint)Argument));
}
_stateChanged = true;
UpdateStatus(Flags.HasFlag(DEBUG_CES.CURRENT_THREAD));
return((int)DEBUG_STATUS.NO_CHANGE);
}
} // end ChangeDebuggeeState()
public int ChangeEngineState(DEBUG_CES Flags, ulong Argument)
{
LogManager.Trace("ChangeEngineState: {0}, 0x{1:x}", Flags, Argument);
try
{
var eventArgs = new EngineStateChangedEventArgs(m_debugger, Flags, Argument);
if (eventArgs.Flags.HasFlag(DEBUG_CES.EVENT_FILTERS))
{
// Need to refresh our filters.
if (eventArgs.Argument == DbgEventArgs.DEBUG_ANY_ID)
{
m_debugger._ResetFilters();
}
else
{
m_debugger._RefreshSingleFilter((uint)eventArgs.Argument);
}
}
if (eventArgs.Flags.HasFlag(DEBUG_CES.BREAKPOINTS))
{
// Need to refresh our breakpoints.
m_debugger.FixupBpStuff(eventArgs.Argument);
}
if ((eventArgs.Flags.HasFlag(DEBUG_CES.SYSTEMS)))
{
// DbgEng doesn't seem to set up its symbol path until you first
// attach to something, but it doesn't raise the event saying that
// the symbol path has changed when that happens. As a workaround,
// we'll dump our cached symbol path here.
m_debugger.m_sympath = null;
// Another oddity with the symbol path: before attaching to any
// system, dbgeng will say that the symbol path is blank. Then,
// once it gets attached to something, it will append the value of
// the environment variable _NT_SYMBOL_PATH to it.
if ((DEBUG_ANY_ID != (uint)eventArgs.Argument))
{
// We're adding a system. This might be a handy spot to do
// something, so I'm leaving the condition here even though I'm
// not currently using it.
// (this gets traced by the eventArgs constructor)
}
else
{
// Removing a system. (this gets traced by the eventArgs
// constructor)
}
}
if (eventArgs.Flags.HasFlag(DEBUG_CES.EFFECTIVE_PROCESSOR))
{
//DbgProvider.ForceRebuildNamespace();
LogManager.Trace("Effective processor changed; queueing request to rebuild namespace.");
DbgProvider.RequestExecuteBeforeNextPrompt("[MS.Dbg.DbgProvider]::ForceRebuildNamespace()");
}
if (eventArgs.Flags.HasFlag(DEBUG_CES.EXECUTION_STATUS))
{
m_executionStatusCookie++;
}
int retVal = _RaiseEvent(m_debugger.EngineStateChanged, eventArgs);
if (_ShouldOutput(retVal, eventArgs))
{
_PsPipe.WriteObject(eventArgs);
}
if (DEBUG_CES.EXECUTION_STATUS == Flags)
{
var status = (DEBUG_STATUS)(Argument & (ulong)DEBUG_STATUS.MASK);
bool insideWait = false;
bool waitTimedOut = false;
if (status != (DEBUG_STATUS)Argument)
{
insideWait = 0 != (Argument & (ulong)DEBUG_STATUS_FLAGS.INSIDE_WAIT);
waitTimedOut = 0 != (Argument & (ulong)DEBUG_STATUS_FLAGS.WAIT_TIMEOUT);
}
LogManager.Trace("EXECUTION_STATUS changed. Argument: 0x{0:x} ({1}{2}{3})",
Argument,
status,
insideWait ? " + INSIDE_WAIT" : "",
waitTimedOut ? " + WAIT_TIMEOUT" : "");
DbgEngDebugger._GlobalDebugger.DbgEngCookie++;
if (0 == ((ulong)DEBUG_STATUS_FLAGS.INSIDE_WAIT & Argument))
{
// Formerly, we would use this code to signal the currently-
// running cmdlet to exit its message loop. The idea was that
// there had been problems with more notification events arriving
// /after/ WaitForEvent returned. But I can't currently repro
// that. (There /are/ some notifications that occur after
// WaitForEvent returns, but they are caused by my own actions--
// setting assembly options and text aliases.)
//
// There is also the difference that now I call WaitForEvent on
// the dbgeng thread, whereas originally I had been calling it on
// a threadpool thread. I'm not sure how that would have made a
// difference, though.
//
// For now, I'm going to get rid of this stuff. It seems fragile
// and horribly complicated--I really hope I don't have to bring
// it back.
//
// // TODO: This seems terribly fragile. But I don't see how else to make
// // sure we process all callbacks before exiting ProcessRecord. I'm probably
// // going to have to add more cases... :(
// if( DEBUG_STATUS.BREAK == (DEBUG_STATUS) Argument )
// {
// if( _SignalPipeOnBreak )
// {
// LogManager.Trace( "EXECUTION_STATUS is BREAK; signaling pipeline." );
// _PsPipe.SignalDone();
// }
// else
// {
// LogManager.Trace( "EXECUTION_STATUS is BREAK, but we're ignoring it." );
// }
// }
if (DEBUG_STATUS.NO_DEBUGGEE == (DEBUG_STATUS)Argument)
{
// We have no target. This might be a handy spot to do
// something, so I'm leaving the condition here even
// though I'm not currently using it.
LogManager.Trace("No debuggee.");
}
} // end if( inside wait )
} // end if( exec status )
return(retVal);
}
catch (Exception e)
{
Util.FailFast("Unexpected exception during event callback.", e);
return(0);
}
} // end ChangeEngineState()
public int ChangeEngineState(DEBUG_CES Flags, ulong Argument)
{
throw new NotImplementedException();
}
public virtual int ChangeEngineState(DEBUG_CES Flags, UInt64 Argument)
{
return 0;
}
public Int32 ChangeEngineState([In] DEBUG_CES Flags, [In] ulong Argument)
{
// Output.Output.Log(Output.LogLevel.Debug, "Change engine State: " + Flags.ToString());
return((Int32)DEBUG_STATUS.BREAK);
}
public virtual int ChangeEngineState(DEBUG_CES flags, UInt64 argument)
{
return(0);
}
public int ChangeEngineState(DEBUG_CES Flags, ulong Argument)
{
throw new NotImplementedException();
}
public int ChangeEngineState(DEBUG_CES Flags, ulong Argument)
{
return((int)DEBUG_STATUS.NO_CHANGE);
}
public int ChangeEngineState([In] DEBUG_CES Flags, [In] ulong Argument)
{
return(0);
}
public int ChangeEngineState(DEBUG_CES Flags, ulong Argument)
{
DebugApi.DebugWriteLine("Change Enginee State: {0} - {1:x}", Flags, Argument);
return(0); // BitConverter.ToInt32(BitConverter.GetBytes((uint)HRESULT.E_NOTIMPL),0);
}
