// ClsComplaint version of SetThreadContext. // Caller must ensure that the context is valid, and for the right architecture. public void SetContext(CorDebugSetContextFlag flag, INativeContext context) { using (IContextDirectAccessor w = context.OpenForDirectAccess()) { // context buffer is now locked SetThreadContext(flag, w.Size, w.RawBuffer); } }
public void SetThreadContext(int threadId, INativeContext context) { using (IContextDirectAccessor w = context.OpenForDirectAccess()) { // context buffer is now locked SetThreadContext(threadId, w.RawBuffer, w.Size); } }
public void ClearContext() { // make sure that we have access to the buffer using (IContextDirectAccessor w = this.OpenForDirectAccess()) { for (int i = 0; i < w.Size; i++) { Marshal.WriteByte(w.RawBuffer, i, (byte)0); } } }
public INativeContext GetThreadContext(int threadId) { INativeContext context = ContextAllocator.GenerateContext(); using (IContextDirectAccessor w = context.OpenForDirectAccess()) { // context buffer is now locked // We initialize to a HUGE number so that we make sure GetThreadContext is updating the size variable. If it doesn't, // then we will hit the assert statement below. this.GetThreadContext(threadId, w.RawBuffer, w.Size); } return(context); }
// ClsComplaint version of GetThreadContext. // Caller must ensure that the context is valid, and for the right architecture. public void GetContext(INativeContext context) { using (IContextDirectAccessor w = context.OpenForDirectAccess()) { // context buffer is now locked // We initialize to a HUGE number so that we make sure GetThreadContext is updating the size variable. If it doesn't, // then we will hit the assert statement below. int size = Int32.MaxValue; this.GetThreadContext((ContextFlags)context.Flags, w.Size, out size, w.RawBuffer); // We should only assert when the buffer is insufficient. Since the runtime only keeps track of CONTEXT_CONTROL and CONTEXT_INTEGER // we will expect to create a larger buffer than absolutely necessary. The context buffer will be the size of a FULL machine // context. Debug.Assert(size <= w.Size, String.Format("Insufficient Buffer: Expected {0} bytes, but received {1}", w.Size, size)); } }
// compare a chuck of the context record contained between the two offsets private bool CheckContextChunk(IA64Context a1, IA64Context a2, int startOffset, int endOffset) { using (IContextDirectAccessor c1 = a1.OpenForDirectAccess()) { using (IContextDirectAccessor c2 = a2.OpenForDirectAccess()) { for (int i = startOffset; i < endOffset; i++) { if (Marshal.ReadByte(c1.RawBuffer, i) != Marshal.ReadByte(c2.RawBuffer, i)) { return(false); } } } } return(true); }
/// <summary> /// Writes back the Thread Context of the thread that the CreateThreadNativeEvent was generated on /// </summary> /// <remarks>Setting a thread's context is very dangerous operation and must be used properly.</remarks> public void WriteContext(INativeContext context) { IntPtr hThread = IntPtr.Zero; try { hThread = NativeMethods.OpenThread(ThreadAccess.THREAD_ALL_ACCESS, true, (uint)this.ThreadId); using (IContextDirectAccessor w = context.OpenForDirectAccess()) { // context buffer is now locked NativeMethods.SetThreadContext(hThread, w.RawBuffer); } // w is disposed, this unlocks the context buffer. } finally { if (hThread != IntPtr.Zero) { NativeMethods.CloseHandle(hThread); } } }
// This is a private contstructor for cloning Context objects. It should not be used outside of this class. private IA64Context(INativeContext ctx) { this.m_size = ctx.Size; this.m_platform = ctx.Platform; this.m_imageFileMachine = ctx.ImageFileMachine; this.m_rawPtr = Marshal.AllocHGlobal(this.Size); using (IContextDirectAccessor w = ctx.OpenForDirectAccess()) { // The fact that Marshal.Copy cannot copy between to native memory locations is stupid. for (int i = 0; i < this.m_size; i++) { // In theory, we could make this faster by copying larger units (i.e. Int64). We get our sizes in bytes // so for now we'll just copy bytes to keep our units straight. byte chunk = Marshal.ReadByte(w.RawBuffer, i); Marshal.WriteByte(this.RawPtr, i, chunk); } } }