private JvmtiEnvironment(JavaVM virtualMachine, jvmtiEnvHandle handle) { Contract.Requires<ArgumentNullException>(virtualMachine != null, "virtualMachine"); _virtualMachine = virtualMachine; _handle = handle; _rawInterface = (jvmtiInterface)Marshal.PtrToStructure(Marshal.ReadIntPtr(handle.Handle), typeof(jvmtiInterface)); jvmtiCapabilities previousCapabilities; JvmtiErrorHandler.ThrowOnFailure(RawInterface.GetCapabilities(this, out previousCapabilities)); jvmtiCapabilities potentialCapabilities; JvmtiErrorHandler.ThrowOnFailure(RawInterface.GetPotentialCapabilities(this, out potentialCapabilities)); var capabilities = new jvmtiCapabilities( jvmtiCapabilities.CapabilityFlags1.CanTagObjects | jvmtiCapabilities.CapabilityFlags1.CanGetSourceFileName | jvmtiCapabilities.CapabilityFlags1.CanGetLineNumbers | jvmtiCapabilities.CapabilityFlags1.CanGetSourceDebugExtension | jvmtiCapabilities.CapabilityFlags1.CanAccessLocalVariables | jvmtiCapabilities.CapabilityFlags1.CanGenerateSingleStepEvents | jvmtiCapabilities.CapabilityFlags1.CanGenerateExceptionEvents | jvmtiCapabilities.CapabilityFlags1.CanGenerateBreakpointEvents | jvmtiCapabilities.CapabilityFlags1.CanGenerateFramePopEvents | jvmtiCapabilities.CapabilityFlags1.CanGenerateAllClassHookEvents | jvmtiCapabilities.CapabilityFlags1.CanGetBytecodes | jvmtiCapabilities.CapabilityFlags1.CanSuspend, jvmtiCapabilities.CapabilityFlags2.CanGetConstantPool ); JvmtiErrorHandler.ThrowOnFailure(RawInterface.AddCapabilities(this, ref capabilities)); jvmtiCapabilities newCapabilities; JvmtiErrorHandler.ThrowOnFailure(RawInterface.GetCapabilities(this, out newCapabilities)); }
private void HandleResourceExhausted(jvmtiEnvHandle env, JNIEnvHandle jniEnv, JvmResourceExhaustedFlags flags, IntPtr reserved, ModifiedUTF8StringData description) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); foreach (var processor in _processors) { processor.HandleResourceExhausted(environment, flags, reserved, description.GetString()); } }
private void HandleObjectFree(jvmtiEnvHandle env, long tag) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); foreach (var processor in _processors) { processor.HandleObjectFree(environment, tag); } }
private void HandleGarbageCollectionFinish(jvmtiEnvHandle env) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); foreach (var processor in _processors) { processor.HandleGarbageCollectionFinish(environment); } }
private void HandleDynamicCodeGenerated(jvmtiEnvHandle env, ModifiedUTF8StringData name, IntPtr address, int length) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); foreach (var processor in _processors) { processor.HandleDynamicCodeGenerated(environment, name.GetString(), address, length); } }
private void HandleVMStart(jvmtiEnvHandle env, JNIEnvHandle jniEnv) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); foreach (var processor in _processors) { processor.HandleVMStart(environment); } }
private void HandleDataDumpRequest(jvmtiEnvHandle env) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); foreach (var processor in _processors) { processor.HandleDataDumpRequest(environment); } }
private void HandleCompiledMethodUnload(jvmtiEnvHandle env, jmethodID methodId, IntPtr codeAddress) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmMethod method = new JvmMethod(environment, methodId); foreach (var processor in _processors) { processor.HandleCompiledMethodUnload(environment, method, codeAddress); } }
private void HandleThreadEnd(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); foreach (var processor in _processors) { processor.HandleThreadEnd(environment, thread); } }
private void HandleCompiledMethodLoad(jvmtiEnvHandle env, jmethodID method, int codeSize, IntPtr codeAddress, int mapLength, jvmtiAddressLocationMap[] map, IntPtr compileInfo) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); foreach (var processor in _processors) { throw new NotImplementedException(); //processor.HandleCompiledMethodLoad(environment, method, codeSize, codeAddress, map2, compileInfo); } }
private void HandleBreakpoint(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID method, jlocation jlocation) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); JvmLocation location = new JvmLocation(environment, method, jlocation); foreach (var processor in _processors) { processor.HandleBreakpoint(environment, thread, location); } }
private void HandleClassLoad(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jclass classHandle) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); JvmClassReference @class = JvmClassReference.FromHandle(environment, jniEnv, classHandle, true); foreach (var processor in _processors) { processor.HandleClassLoad(environment, thread, @class); } }
private void HandleMethodExit(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, bool wasPoppedByException, jvalue returnValue) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); JvmMethod method = new JvmMethod(environment, methodId); foreach (var processor in _processors) { processor.HandleMethodExit(environment, thread, method, wasPoppedByException, returnValue); } }
private void HandleMethodEntry(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); JvmMethod method = new JvmMethod(environment, methodId); foreach (var processor in _processors) { processor.HandleMethodEntry(environment, thread, method); } }
private void HandleVMDeath(jvmtiEnvHandle env, JNIEnvHandle jniEnv) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); foreach (var processor in _processors) { processor.HandleVMDeath(environment); } environment.VirtualMachine.ShutdownAgentDispatchers(); }
private void HandleMonitorContendedEntered(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jobject objectHandle) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); JvmObjectReference @object = JvmObjectReference.FromHandle(environment, jniEnv, objectHandle, true); foreach (var processor in _processors) { processor.HandleMonitorContendedEntered(environment, thread, @object); } }
private void HandleMonitorWait(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jobject objectHandle, long millisecondsTimeout) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); JvmObjectReference @object = JvmObjectReference.FromHandle(environment, jniEnv, objectHandle, true); foreach (var processor in _processors) { processor.HandleMonitorWait(environment, thread, @object, millisecondsTimeout); } }
private void HandleClassFileLoadHook(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jclass classBeingRedefinedHandle, jobject loaderHandle, ModifiedUTF8StringData name, jobject protectionDomainHandle, int classDataLength, IntPtr classData, ref int newClassDataLength, ref IntPtr newClassData) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmClassReference classBeingRedefined = JvmClassReference.FromHandle(environment, jniEnv, classBeingRedefinedHandle, true); JvmObjectReference loader = JvmObjectReference.FromHandle(environment, jniEnv, loaderHandle, true); JvmObjectReference protectionDomain = JvmObjectReference.FromHandle(environment, jniEnv, protectionDomainHandle, true); foreach (var processor in _processors) { processor.HandleClassFileLoadHook(environment, classBeingRedefined, loader, name.GetString(), protectionDomain); } }
private void HandleExceptionCatch(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID method, jlocation jlocation, jobject exceptionHandle) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); JvmLocation location = new JvmLocation(environment, method, jlocation); JvmObjectReference exception = JvmObjectReference.FromHandle(environment, jniEnv, exceptionHandle, true); foreach (var processor in _processors) { processor.HandleExceptionCatch(environment, thread, location, exception); } }
private void HandleNativeMethodBind(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, IntPtr address, ref IntPtr newAddressPtr) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); JvmMethod method = new JvmMethod(environment, methodId); foreach (var processor in _processors) { IntPtr?newAddress = null; processor.HandleNativeMethodBind(environment, thread, method, address, ref newAddress); } }
private void HandleVMInit(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); jvmtiError result = environment.RawInterface.RunAgentThread(env, alloc_thread(jniEnv), DispatchJvmEvents, IntPtr.Zero, JvmThreadPriority.Maximum); foreach (var processor in _processors) { processor.HandleVMInitialization(environment, thread); } }
private void HandleVMObjectAlloc(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jobject objectHandle, jclass objectClassHandle, long size) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); JvmObjectReference @object = JvmObjectReference.FromHandle(environment, jniEnv, objectHandle, true); JvmClassReference objectClass = JvmClassReference.FromHandle(environment, jniEnv, objectClassHandle, true); foreach (var processor in _processors) { processor.HandleVMObjectAllocation(environment, thread, @object, objectClass, size); } }
internal static JvmEnvironment GetOrCreateEnvironment(JavaVM virtualMachine, jvmtiEnvHandle env) { Contract.Requires <ArgumentNullException>(virtualMachine != null, "virtualMachine"); JvmEnvironment environment = _environments.GetOrAdd(env, CreateEnvironment); if (environment.VirtualMachine == null) { environment.VirtualMachine = virtualMachine; } return(environment); }
private void HandleFieldModification(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID method, jlocation jlocation, jclass fieldClassHandle, jobject @objectHandle, jfieldID fieldId, byte signatureType, jvalue newValue) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); JvmLocation location = new JvmLocation(environment, method, jlocation); JvmClassReference fieldClass = JvmClassReference.FromHandle(environment, jniEnv, fieldClassHandle, true); JvmObjectReference @object = JvmObjectReference.FromHandle(environment, jniEnv, objectHandle, true); JvmField field = new JvmField(environment, fieldId); foreach (var processor in _processors) { processor.HandleFieldModification(environment, thread, location, fieldClass, @object, field, signatureType, newValue); } }
private void HandleCompiledMethodUnload(jvmtiEnvHandle env, jmethodID methodId, IntPtr codeAddress) { if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread Action<jvmtiEnvHandle, jmethodID, IntPtr> method = HandleCompiledMethodUnload; AgentEventDispatcher.Invoke(method, env, methodId, codeAddress); return; } //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //JvmMethod method = new JvmMethod(environment, methodId); //foreach (var processor in _processors) //{ // processor.HandleCompiledMethodUnload(environment, method, codeAddress); //} }
private void HandleCompiledMethodLoad(jvmtiEnvHandle env, jmethodID methodId, int codeSize, IntPtr codeAddress, int mapLength, jvmtiAddressLocationMap[] map, IntPtr compileInfo) { if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread Action<jvmtiEnvHandle, jmethodID, int, IntPtr, int, jvmtiAddressLocationMap[], IntPtr> method = HandleCompiledMethodLoad; AgentEventDispatcher.Invoke(method, env, methodId, codeSize, codeAddress, mapLength, map, compileInfo); return; } //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //foreach (var processor in _processors) //{ // throw new NotImplementedException(); // //processor.HandleCompiledMethodLoad(environment, method, codeSize, codeAddress, map2, compileInfo); //} }
private void HandleThreadEnd(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle) { /* This event is always sent on the thread that's starting. if it's an agent thread, just * ignore the event to hide it from the IDE. */ if (VirtualMachine.IsAgentThread.Value) return; // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread Action<jvmtiEnvHandle, JNIEnvHandle, jthread> method = HandleThreadEndImpl; AgentEventDispatcher.Invoke(method, env, jniEnv, threadHandle); return; }
private void AgentDispatcherThread(jvmtiEnvHandle env, JNIEnvHandle jniEnv, IntPtr arg) { JniEnvironment nativeEnvironment; VirtualMachine.AttachCurrentThreadAsDaemon(Environment, out nativeEnvironment, true); _agentEventDispatcher = Dispatcher.CurrentDispatcher; _agentStartedEvent.Set(); Dispatcher.Run(); }
private void HandleVMObjectAlloc(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jobject objectHandle, jclass objectClassHandle, long size) { if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread Action<jvmtiEnvHandle, JNIEnvHandle, jthread, jobject, jclass, long> method = HandleVMObjectAlloc; AgentEventDispatcher.Invoke(method, env, jniEnv, threadHandle, objectHandle, objectClassHandle, size); return; } //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); //JvmObjectReference @object = JvmObjectReference.FromHandle(environment, jniEnv, objectHandle, true); //JvmClassReference objectClass = JvmClassReference.FromHandle(environment, jniEnv, objectClassHandle, true); //foreach (var processor in _processors) //{ // processor.HandleVMObjectAllocation(environment, thread, @object, objectClass, size); //} }
private void HandleResourceExhausted(jvmtiEnvHandle env, JNIEnvHandle jniEnv, JvmResourceExhaustedFlags flags, IntPtr reserved, IntPtr description) { if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread Action<jvmtiEnvHandle, JNIEnvHandle, JvmResourceExhaustedFlags, IntPtr, IntPtr> method = HandleResourceExhausted; AgentEventDispatcher.Invoke(method, env, jniEnv, flags, reserved, description); return; } //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //foreach (var processor in _processors) //{ // processor.HandleResourceExhausted(environment, flags, reserved, description.GetString()); //} }
private static JvmEnvironment CreateEnvironment(jvmtiEnvHandle env) { return(new JvmEnvironment(env)); }
private static void DispatchJvmEvents(jvmtiEnvHandle env, JNIEnvHandle jniEnv, IntPtr arg) { JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); environment.VirtualMachine.PushAgentDispatcherFrame(new DispatcherFrame(true), environment); }
private void HandleSingleStep(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, jlocation jlocation) { JvmtiEnvironment environment = JvmtiEnvironment.GetOrCreateInstance(_service.VirtualMachine, env); JniEnvironment nativeEnvironment = JniEnvironment.GetOrCreateInstance(jniEnv); ThreadId threadId = VirtualMachine.TrackLocalThreadReference(threadHandle, environment, nativeEnvironment, false); TaggedReferenceTypeId declaringClass; MethodId method = new MethodId(methodId.Handle); ulong index = (ulong)jlocation.Value; JvmtiErrorHandler.ThrowOnFailure(environment.GetMethodDeclaringClass(nativeEnvironment, method, out declaringClass)); Location location = new Location(declaringClass, method, index); EventFilter[] filters = GetEventFilters(EventKind.SingleStep); foreach (var filter in filters) { if (filter.ProcessEvent(environment, nativeEnvironment, this, threadId, default(TaggedReferenceTypeId), location)) { SendSingleStepEvent(environment, filter, threadId, location); } } }
private void HandleException(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, jlocation jlocation, jobject exceptionHandle, jmethodID catchMethodId, jlocation catchjLocation) { // don't send exception events from an agent thread if (VirtualMachine.IsAgentThread.Value) return; JvmtiEnvironment environment = JvmtiEnvironment.GetOrCreateInstance(_service.VirtualMachine, env); JniEnvironment nativeEnvironment = JniEnvironment.GetOrCreateInstance(jniEnv); TaggedReferenceTypeId declaringClass; MethodId method = new MethodId(methodId.Handle); ulong index = (ulong)jlocation.Value; JvmtiErrorHandler.ThrowOnFailure(environment.GetMethodDeclaringClass(nativeEnvironment, method, out declaringClass)); Location location = new Location(declaringClass, method, index); Location catchLocation; method = new MethodId(catchMethodId.Handle); index = (ulong)catchjLocation.Value; if (catchMethodId.Handle != IntPtr.Zero) { JvmtiErrorHandler.ThrowOnFailure(environment.GetMethodDeclaringClass(nativeEnvironment, method, out declaringClass)); catchLocation = new Location(declaringClass, method, index); } else { catchLocation = default(Location); } TaggedObjectId exceptionId = VirtualMachine.TrackLocalObjectReference(exceptionHandle, environment, nativeEnvironment, false); ThreadId threadId = VirtualMachine.TrackLocalThreadReference(threadHandle, environment, nativeEnvironment, false); EventFilter[] filters = GetEventFilters(EventKind.Exception); foreach (var filter in filters) { if (filter.ProcessEvent(environment, nativeEnvironment, this, threadId, default(TaggedReferenceTypeId), location)) { SendExceptionEvent(environment, filter, threadId, location, exceptionId, catchLocation); } } ////Location location = new Location(); ////Location catchLocation = new Location(); //throw new NotImplementedException(); #if false ThreadId threadId = GetObjectId(ref threadHandle); TaggedObjectId exception = GetObjectId(ref exceptionHandle); EventFilter[] filters = GetEventFilters(EventKind.Exception); foreach (var filter in filters) { if (filter.ProcessEvent(threadId, default(TaggedReferenceTypeId))) { ApplySuspendPolicy(environment, filter.SuspendPolicy, threadId); Callback.HandleException(filter.SuspendPolicy, filter.RequestId, threadId, location, exception, catchLocation); } } #endif //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); //JvmLocation location = new JvmLocation(environment, method, jlocation); //JvmObjectReference exception = JvmObjectReference.FromHandle(environment, jniEnv, exceptionHandle, true); //JvmLocation catchLocation = new JvmLocation(environment, catchMethod, catchjLocation); //foreach (var processor in _processors) //{ // processor.HandleException(environment, thread, location, exception, catchLocation); //} }
private void HandleClassPrepare(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jclass classHandle) { bool preventSuspend = VirtualMachine.IsAgentThread.Value; JvmtiEnvironment environment = JvmtiEnvironment.GetOrCreateInstance(_service.VirtualMachine, env); JniEnvironment nativeEnvironment = JniEnvironment.GetOrCreateInstance(jniEnv); string signature; IntPtr signaturePtr; IntPtr genericPtr; JvmtiErrorHandler.ThrowOnFailure(RawInterface.GetClassSignature(env, classHandle, out signaturePtr, out genericPtr)); try { unsafe { signature = ModifiedUTF8Encoding.GetString((byte*)signaturePtr); } } finally { RawInterface.Deallocate(env, signaturePtr); RawInterface.Deallocate(env, genericPtr); } ClassStatus classStatus = 0; jvmtiClassStatus internalClassStatus; JvmtiErrorHandler.ThrowOnFailure(RawInterface.GetClassStatus(env, classHandle, out internalClassStatus)); if ((internalClassStatus & jvmtiClassStatus.Error) != 0) classStatus |= ClassStatus.Error; if ((internalClassStatus & jvmtiClassStatus.Initialized) != 0) classStatus |= ClassStatus.Initialized; if ((internalClassStatus & jvmtiClassStatus.Prepared) != 0) classStatus |= ClassStatus.Prepared; if ((internalClassStatus & jvmtiClassStatus.Verified) != 0) classStatus |= ClassStatus.Verified; ThreadId threadId = VirtualMachine.TrackLocalThreadReference(threadHandle, environment, nativeEnvironment, false); TaggedReferenceTypeId classId = VirtualMachine.TrackLocalClassReference(classHandle, environment, nativeEnvironment, false); EventFilter[] filters = GetEventFilters(EventKind.ClassPrepare); foreach (var filter in filters) { if (filter.ProcessEvent(environment, nativeEnvironment, this, threadId, classId, default(Location?))) { SendClassPrepareEvent(environment, filter, threadId, classId, signature, classStatus, preventSuspend); } } }
private void HandleClassFileLoadHook(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jclass classBeingRedefinedHandle, jobject loaderHandle, IntPtr name, jobject protectionDomainHandle, int classDataLength, IntPtr classData, ref int newClassDataLength, ref IntPtr newClassData) { // need to extract the exception_table for each method ClassFile classFile = ClassFile.FromMemory(classData, 0); ConstantClass constantClass = classFile.ThisClass; ConstantUtf8 constantClassSignature = (ConstantUtf8)classFile.ConstantPool[constantClass.NameIndex - 1]; string classSignature = constantClassSignature.Value; if (classSignature[0] != '[') classSignature = 'L' + classSignature + ';'; long classLoaderTag; JvmtiErrorHandler.ThrowOnFailure(Environment.TagClassLoader(loaderHandle, out classLoaderTag)); foreach (var methodInfo in classFile.Methods) { if ((methodInfo.Modifiers & (AccessModifiers.Abstract | AccessModifiers.Native)) != 0) continue; Code codeAttribute = methodInfo.Attributes.OfType<Code>().SingleOrDefault(); if (codeAttribute == null) continue; ConstantUtf8 constantMethodName = (ConstantUtf8)classFile.ConstantPool[methodInfo.NameIndex - 1]; string methodName = constantMethodName.Value; ConstantUtf8 constantMethodSignature = (ConstantUtf8)classFile.ConstantPool[methodInfo.DescriptorIndex - 1]; string methodSignature = constantMethodSignature.Value; VirtualMachine.SetExceptionTable(classLoaderTag, classSignature, methodName, methodSignature, codeAttribute.ExceptionTable); } #if false if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread //Action<jvmtiEnvHandle, JNIEnvHandle, jclass, jobject, ModifiedUTF8StringData, jobject, int, IntPtr> method = HandleClassFileLoadHook; //AgentEventDispatcher.Invoke(method, env, jniEnv); //return; throw new NotImplementedException(); } //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //JvmClassReference classBeingRedefined = JvmClassReference.FromHandle(environment, jniEnv, classBeingRedefinedHandle, true); //JvmObjectReference loader = JvmObjectReference.FromHandle(environment, jniEnv, loaderHandle, true); //JvmObjectReference protectionDomain = JvmObjectReference.FromHandle(environment, jniEnv, protectionDomainHandle, true); //foreach (var processor in _processors) //{ // processor.HandleClassFileLoadHook(environment, classBeingRedefined, loader, name.GetString(), protectionDomain); //} #endif }
private void HandleDynamicCodeGenerated(jvmtiEnvHandle env, IntPtr name, IntPtr address, int length) { if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread Action<jvmtiEnvHandle, IntPtr, IntPtr, int> method = HandleDynamicCodeGenerated; AgentEventDispatcher.Invoke(method, env, name, address, length); return; } //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //foreach (var processor in _processors) //{ // processor.HandleDynamicCodeGenerated(environment, name.GetString(), address, length); //} }
private void HandleMonitorContendedEntered(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jobject objectHandle) { if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread Action<jvmtiEnvHandle, JNIEnvHandle, jthread, jobject> method = HandleMonitorContendedEntered; AgentEventDispatcher.Invoke(method, env, jniEnv, threadHandle, objectHandle); return; } //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); //JvmObjectReference @object = JvmObjectReference.FromHandle(environment, jniEnv, objectHandle, true); //foreach (var processor in _processors) //{ // processor.HandleMonitorContendedEntered(environment, thread, @object); //} }
private void HandleBreakpoint(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, jlocation jlocation) { if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread Action<jvmtiEnvHandle, JNIEnvHandle, jthread, jmethodID, jlocation> invokeMethod = HandleBreakpoint; AgentEventDispatcher.Invoke(invokeMethod, env, jniEnv, threadHandle, methodId, jlocation); return; } JvmtiEnvironment environment = JvmtiEnvironment.GetOrCreateInstance(_service.VirtualMachine, env); JniEnvironment nativeEnvironment; JniErrorHandler.ThrowOnFailure(VirtualMachine.AttachCurrentThreadAsDaemon(environment, out nativeEnvironment, false)); ThreadId threadId = VirtualMachine.TrackLocalThreadReference(threadHandle, environment, nativeEnvironment, false); TaggedReferenceTypeId declaringClass; MethodId method = new MethodId(methodId.Handle); ulong index = (ulong)jlocation.Value; JvmtiErrorHandler.ThrowOnFailure(environment.GetMethodDeclaringClass(nativeEnvironment, method, out declaringClass)); Location location = new Location(declaringClass, method, index); EventFilter[] filters = GetEventFilters(EventKind.Breakpoint); foreach (var filter in filters) { if (filter.ProcessEvent(environment, nativeEnvironment, this, threadId, default(TaggedReferenceTypeId), location)) { ApplySuspendPolicy(environment, nativeEnvironment, filter.SuspendPolicy, threadId); Callback.Breakpoint(filter.SuspendPolicy, filter.RequestId, threadId, location); } } }
private void HandleObjectFree(jvmtiEnvHandle env, long tag) { if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread Action<jvmtiEnvHandle, long> method = HandleObjectFree; AgentEventDispatcher.Invoke(method, env, tag); return; } //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //foreach (var processor in _processors) //{ // processor.HandleObjectFree(environment, tag); //} }
private void HandleFieldModification(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, jlocation jlocation, jclass fieldClassHandle, jobject objectHandle, jfieldID fieldId, byte signatureType, jvalue newValue) { if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread Action<jvmtiEnvHandle, JNIEnvHandle, jthread, jmethodID, jlocation, jclass, jobject, jfieldID, byte, jvalue> method = HandleFieldModification; AgentEventDispatcher.Invoke(method, env, jniEnv, threadHandle, methodId, jlocation, fieldClassHandle, objectHandle, fieldId, signatureType, newValue); return; } //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); //JvmLocation location = new JvmLocation(environment, method, jlocation); //JvmClassReference fieldClass = JvmClassReference.FromHandle(environment, jniEnv, fieldClassHandle, true); //JvmObjectReference @object = JvmObjectReference.FromHandle(environment, jniEnv, objectHandle, true); //JvmField field = new JvmField(environment, fieldId); //foreach (var processor in _processors) //{ // processor.HandleFieldModification(environment, thread, location, fieldClass, @object, field, signatureType, newValue); //} }
private void HandleVMInit(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle) { JvmtiEnvironment environment = JvmtiEnvironment.GetOrCreateInstance(_service.VirtualMachine, env); JniEnvironment nativeEnvironment; if (AgentEventDispatcher == null) { if (VirtualMachine.IsAgentThread.Value) throw new InvalidOperationException(); nativeEnvironment = JniEnvironment.GetOrCreateInstance(jniEnv); VirtualMachine.HandleVMInit(environment, nativeEnvironment, threadHandle); InitializeAgentThread(environment, nativeEnvironment); } if (!VirtualMachine.IsAgentThread.Value) { // dispatch this call to an agent thread Action<jvmtiEnvHandle, JNIEnvHandle, jthread> method = HandleVMInit; AgentEventDispatcher.Invoke(method, env, jniEnv, threadHandle); return; } JniErrorHandler.ThrowOnFailure(VirtualMachine.AttachCurrentThreadAsDaemon(environment, out nativeEnvironment, false)); ThreadId threadId = VirtualMachine.TrackLocalThreadReference(threadHandle, environment, nativeEnvironment, false); bool sent = false; EventFilter[] filters = GetEventFilters(EventKind.VirtualMachineStart); foreach (var filter in filters) { if (filter.ProcessEvent(environment, nativeEnvironment, this, threadId, default(TaggedReferenceTypeId), default(Location?))) { ApplySuspendPolicy(environment, nativeEnvironment, filter.SuspendPolicy, threadId); Callback.VirtualMachineStart(filter.SuspendPolicy, filter.RequestId, threadId); sent = true; } } if (!sent) { ApplySuspendPolicy(environment, nativeEnvironment, SuspendPolicy.All, threadId); Callback.VirtualMachineStart(SuspendPolicy.All, default(RequestId), threadId); } }
private void HandleMethodExit(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, bool wasPoppedByException, jvalue returnValue) { if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread Action<jvmtiEnvHandle, JNIEnvHandle, jthread, jmethodID, bool, jvalue> method = HandleMethodExit; AgentEventDispatcher.Invoke(method, env, jniEnv, threadHandle, methodId, wasPoppedByException, returnValue); return; } //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); //JvmMethod method = new JvmMethod(environment, methodId); //foreach (var processor in _processors) //{ // processor.HandleMethodExit(environment, thread, method, wasPoppedByException, returnValue); //} }
private void HandleVMDeath(jvmtiEnvHandle env, JNIEnvHandle jniEnv) { if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread Action<jvmtiEnvHandle, JNIEnvHandle> method = HandleVMDeath; AgentEventDispatcher.Invoke(method, env, jniEnv); return; } JvmtiEnvironment environment = JvmtiEnvironment.GetOrCreateInstance(_service.VirtualMachine, env); JniEnvironment nativeEnvironment; JniErrorHandler.ThrowOnFailure(VirtualMachine.AttachCurrentThreadAsDaemon(environment, out nativeEnvironment, false)); EventFilter[] filters = GetEventFilters(EventKind.VirtualMachineDeath); foreach (var filter in filters) { if (filter.ProcessEvent(environment, nativeEnvironment, this, default(ThreadId), default(TaggedReferenceTypeId), default(Location?))) { ApplySuspendPolicy(environment, nativeEnvironment, filter.SuspendPolicy, default(ThreadId)); Callback.VirtualMachineDeath(filter.SuspendPolicy, filter.RequestId); } } //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //foreach (var processor in _processors) //{ // processor.HandleVMDeath(environment); //} //environment.VirtualMachine.ShutdownAgentDispatchers(); }
private void HandleNativeMethodBind(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, IntPtr address, ref IntPtr newAddressPtr) { if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread //Action<jvmtiEnvHandle, JNIEnvHandle, jthread, jmethodID, IntPtr, ReferenceTypeData intptr> method = HandleNativeMethodBind; //AgentEventDispatcher.Invoke(method, env, jniEnv); //return; throw new NotImplementedException(); } //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); //JvmMethod method = new JvmMethod(environment, methodId); //foreach (var processor in _processors) //{ // IntPtr? newAddress = null; // processor.HandleNativeMethodBind(environment, thread, method, address, ref newAddress); //} }
private void HandleThreadEndImpl(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle) { JvmtiEnvironment environment = JvmtiEnvironment.GetOrCreateInstance(_service.VirtualMachine, env); JniEnvironment nativeEnvironment; JniErrorHandler.ThrowOnFailure(VirtualMachine.AttachCurrentThreadAsDaemon(environment, out nativeEnvironment, false)); ThreadId threadId = VirtualMachine.TrackLocalThreadReference(threadHandle, environment, nativeEnvironment, false); EventFilter[] filters = GetEventFilters(EventKind.ThreadEnd); foreach (var filter in filters) { if (filter.ProcessEvent(environment, nativeEnvironment, this, threadId, default(TaggedReferenceTypeId), default(Location?))) { ApplySuspendPolicy(environment, nativeEnvironment, filter.SuspendPolicy, threadId); Callback.ThreadDeath(filter.SuspendPolicy, filter.RequestId, threadId); } } }
private void AttachImpl(jvmtiEnvHandle env) { JvmtiEnvironment environment = JvmtiEnvironment.GetOrCreateInstance(VirtualMachine, env); JvmtiErrorHandler.ThrowOnFailure(environment.SetEventCallbacks(_eventCallbacks)); JvmtiErrorHandler.ThrowOnFailure(environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.VMStart)); JvmtiErrorHandler.ThrowOnFailure(environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.VMInit)); JvmtiErrorHandler.ThrowOnFailure(environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.VMDeath)); JvmtiErrorHandler.ThrowOnFailure(environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.ThreadStart)); JvmtiErrorHandler.ThrowOnFailure(environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.ThreadEnd)); JvmtiErrorHandler.ThrowOnFailure(environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.ClassLoad)); JvmtiErrorHandler.ThrowOnFailure(environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.ClassPrepare)); JvmtiErrorHandler.ThrowOnFailure(environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.ClassFileLoadHook)); #if false jvmtiCapabilities capabilities; JvmtiErrorHandler.ThrowOnFailure(environment.GetCapabilities(out capabilities)); environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.ClassFileLoadHook); environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.DynamicCodeGenerated); environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.DataDumpRequest); environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.ResourceExhausted); //environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.DataResetRequest); if (capabilities.CanGenerateExceptionEvents) environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.Exception); if (capabilities.CanGenerateExceptionEvents) environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.ExceptionCatch); if (capabilities.CanGenerateSingleStepEvents) environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.SingleStep); if (capabilities.CanGenerateFramePopEvents) environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.FramePop); if (capabilities.CanGenerateBreakpointEvents) environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.Breakpoint); if (capabilities.CanGenerateFieldAccessEvents) environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.FieldAccess); if (capabilities.CanGenerateFieldModificationEvents) environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.FieldModification); if (capabilities.CanGenerateMethodEntryEvents) environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.MethodEntry); if (capabilities.CanGenerateMethodExitEvents) environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.MethodExit); if (capabilities.CanGenerateNativeMethodBindEvents) environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.NativeMethodBind); if (capabilities.CanGenerateCompiledMethodLoadEvents) environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.CompiledMethodLoad); if (capabilities.CanGenerateCompiledMethodLoadEvents) environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.CompiledMethodUnload); if (capabilities.CanGenerateMonitorEvents) environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.MonitorWait); if (capabilities.CanGenerateMonitorEvents) environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.MonitorWaited); if (capabilities.CanGenerateMonitorEvents) environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.MonitorContendedEnter); if (capabilities.CanGenerateMonitorEvents) environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.MonitorContendedEntered); if (capabilities.CanGenerateGarbageCollectionEvents) environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.GarbageCollectionStart); if (capabilities.CanGenerateGarbageCollectionEvents) environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.GarbageCollectionFinish); if (capabilities.CanGenerateObjectFreeEvents) environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.ObjectFree); if (capabilities.CanGenerateVmObjectAllocEvents) environment.SetEventNotificationMode(JvmEventMode.Enable, JvmEventType.VMObjectAlloc); #endif }
private void HandleClassLoad(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jclass classHandle) { //JvmtiEnvironment environment = JvmtiEnvironment.GetOrCreateInstance(_service.VirtualMachine, env); //JniEnvironment nativeEnvironment; //JniErrorHandler.ThrowOnFailure(VirtualMachine.AttachCurrentThreadAsDaemon(environment, out nativeEnvironment, false)); //VirtualMachine.HandleClassLoad(environment, nativeEnvironment, classHandle); }
internal static JvmtiEnvironment GetOrCreateInstance(JavaVM virtualMachine, jvmtiEnvHandle handle) { return _instances.GetOrAdd(handle, i => CreateVirtualMachine(virtualMachine, i)); }
private void HandleVMStart(jvmtiEnvHandle env, JNIEnvHandle jniEnv) { /********************** * Note: there are no dispatchers available at this point. */ }
private static JvmtiEnvironment CreateVirtualMachine(JavaVM virtualMachine, jvmtiEnvHandle handle) { return new JvmtiEnvironment(virtualMachine, handle); }
private void HandleExceptionCatch(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, jlocation jlocation, jobject exceptionHandle) { if (!VirtualMachine.IsAgentThread.Value) { // ignore events before VMInit if (AgentEventDispatcher == null) return; // dispatch this call to an agent thread Action<jvmtiEnvHandle, JNIEnvHandle, jthread, jmethodID, jlocation, jobject> method = HandleExceptionCatch; AgentEventDispatcher.Invoke(method, env, jniEnv, threadHandle, methodId, jlocation, exceptionHandle); return; } //JvmEnvironment environment = JvmEnvironment.GetEnvironment(env); //JvmThreadReference thread = JvmThreadReference.FromHandle(environment, jniEnv, threadHandle, true); //JvmLocation location = new JvmLocation(environment, method, jlocation); //JvmObjectReference exception = JvmObjectReference.FromHandle(environment, jniEnv, exceptionHandle, true); //foreach (var processor in _processors) //{ // processor.HandleExceptionCatch(environment, thread, location, exception); //} }
private JvmEnvironment(jvmtiEnvHandle env) { Contract.Requires <ArgumentException>(env != jvmtiEnvHandle.Null); jvmtiInterface rawInterface = (jvmtiInterface)Marshal.PtrToStructure(Marshal.ReadIntPtr(env.Handle), typeof(jvmtiInterface)); Contract.Assert(rawInterface.GetCapabilities != null); Contract.Assert(rawInterface.Allocate != null); Contract.Assert(rawInterface.Deallocate != null); Contract.Assert(rawInterface.GetThreadState != null); Contract.Assert(rawInterface.GetCurrentThread != null); Contract.Assert(rawInterface.GetAllThreads != null); Contract.Assert(rawInterface.GetThreadInfo != null); Contract.Assert(rawInterface.RunAgentThread != null); Contract.Assert(rawInterface.SetThreadLocalStorage != null); Contract.Assert(rawInterface.GetThreadLocalStorage != null); Contract.Assert(rawInterface.GetTopThreadGroups != null); Contract.Assert(rawInterface.GetThreadGroupInfo != null); Contract.Assert(rawInterface.GetThreadGroupChildren != null); Contract.Assert(rawInterface.GetStackTrace != null); Contract.Assert(rawInterface.GetAllStackTraces != null); Contract.Assert(rawInterface.GetThreadListStackTraces != null); Contract.Assert(rawInterface.GetFrameCount != null); Contract.Assert(rawInterface.GetFrameLocation != null); Contract.Assert(rawInterface.ForceGarbageCollection != null); Contract.Assert(rawInterface.GetLoadedClasses != null); Contract.Assert(rawInterface.GetClassLoaderClasses != null); Contract.Assert(rawInterface.GetClassSignature != null); Contract.Assert(rawInterface.GetClassStatus != null); Contract.Assert(rawInterface.GetClassModifiers != null); Contract.Assert(rawInterface.GetClassMethods != null); Contract.Assert(rawInterface.GetClassFields != null); Contract.Assert(rawInterface.GetImplementedInterfaces != null); Contract.Assert(rawInterface.GetClassVersionNumbers != null); Contract.Assert(rawInterface.IsInterface != null); Contract.Assert(rawInterface.IsArrayClass != null); Contract.Assert(rawInterface.IsModifiableClass != null); Contract.Assert(rawInterface.GetClassLoader != null); Contract.Assert(rawInterface.GetObjectSize != null); Contract.Assert(rawInterface.GetObjectHashCode != null); Contract.Assert(rawInterface.GetFieldName != null); Contract.Assert(rawInterface.GetFieldDeclaringClass != null); Contract.Assert(rawInterface.GetFieldModifiers != null); Contract.Assert(rawInterface.GetMethodName != null); Contract.Assert(rawInterface.GetMethodDeclaringClass != null); Contract.Assert(rawInterface.GetMethodModifiers != null); Contract.Assert(rawInterface.GetMaxLocals != null); Contract.Assert(rawInterface.GetArgumentsSize != null); Contract.Assert(rawInterface.GetMethodLocation != null); Contract.Assert(rawInterface.IsMethodNative != null); Contract.Assert(rawInterface.IsMethodObsolete != null); Contract.Assert(rawInterface.CreateRawMonitor != null); Contract.Assert(rawInterface.DestroyRawMonitor != null); Contract.Assert(rawInterface.RawMonitorEnter != null); Contract.Assert(rawInterface.RawMonitorExit != null); Contract.Assert(rawInterface.RawMonitorWait != null); Contract.Assert(rawInterface.RawMonitorNotify != null); Contract.Assert(rawInterface.RawMonitorNotifyAll != null); Contract.Assert(rawInterface.SetJNIFunctionTable != null); Contract.Assert(rawInterface.GetJNIFunctionTable != null); Contract.Assert(rawInterface.SetEventCallbacks != null); Contract.Assert(rawInterface.SetEventNotificationMode != null); Contract.Assert(rawInterface.GenerateEvents != null); Contract.Assert(rawInterface.GetExtensionFunctions != null); Contract.Assert(rawInterface.GetExtensionEvents != null); Contract.Assert(rawInterface.SetExtensionEventCallback != null); Contract.Assert(rawInterface.GetPotentialCapabilities != null); Contract.Assert(rawInterface.AddCapabilities != null); Contract.Assert(rawInterface.RelinquishCapabilities != null); Contract.Assert(rawInterface.GetCapabilities != null); Contract.Assert(rawInterface.GetTimerInfo != null); Contract.Assert(rawInterface.GetTime != null); Contract.Assert(rawInterface.GetAvailableProcessors != null); Contract.Assert(rawInterface.AddToBootstrapClassLoaderSearch != null); Contract.Assert(rawInterface.AddToSystemClassLoaderSearch != null); Contract.Assert(rawInterface.GetSystemProperties != null); Contract.Assert(rawInterface.GetSystemProperty != null); Contract.Assert(rawInterface.SetSystemProperty != null); Contract.Assert(rawInterface.GetPhase != null); Contract.Assert(rawInterface.DisposeEnvironment != null); Contract.Assert(rawInterface.SetEnvironmentLocalStorage != null); Contract.Assert(rawInterface.GetEnvironmentLocalStorage != null); Contract.Assert(rawInterface.GetVersionNumber != null); Contract.Assert(rawInterface.GetErrorName != null); Contract.Assert(rawInterface.SetVerboseFlag != null); Contract.Assert(rawInterface.GetJLocationFormat != null); jvmtiCapabilities capabilities; if (rawInterface.GetPotentialCapabilities(env, out capabilities) != jvmtiError.None) { throw new InvalidOperationException(); } Contract.Assert(!capabilities.CanSuspend || rawInterface.SuspendThread != null); Contract.Assert(!capabilities.CanSuspend || rawInterface.SuspendThreadList != null); Contract.Assert(!capabilities.CanSuspend || rawInterface.ResumeThread != null); Contract.Assert(!capabilities.CanSuspend || rawInterface.ResumeThreadList != null); Contract.Assert(!capabilities.CanSignalThread || rawInterface.StopThread != null); Contract.Assert(!capabilities.CanSignalThread || rawInterface.InterruptThread != null); Contract.Assert(!capabilities.CanGetOwnedMonitorInfo || rawInterface.GetOwnedMonitorInfo != null); Contract.Assert(!capabilities.CanGetOwnedMonitorStackDepthInfo || rawInterface.GetOwnedMonitorStackDepthInfo != null); Contract.Assert(!capabilities.CanGetCurrentContendedMonitor || rawInterface.GetCurrentContendedMonitor != null); Contract.Assert(!capabilities.CanPopFrame || rawInterface.PopFrame != null); Contract.Assert(!capabilities.CanGenerateFramePopEvents || rawInterface.NotifyFramePop != null); Contract.Assert(!capabilities.CanForceEarlyReturn || rawInterface.ForceEarlyReturnObject != null); Contract.Assert(!capabilities.CanForceEarlyReturn || rawInterface.ForceEarlyReturnInt != null); Contract.Assert(!capabilities.CanForceEarlyReturn || rawInterface.ForceEarlyReturnLong != null); Contract.Assert(!capabilities.CanForceEarlyReturn || rawInterface.ForceEarlyReturnFloat != null); Contract.Assert(!capabilities.CanForceEarlyReturn || rawInterface.ForceEarlyReturnDouble != null); Contract.Assert(!capabilities.CanForceEarlyReturn || rawInterface.ForceEarlyReturnVoid != null); Contract.Assert(!capabilities.CanTagObjects || rawInterface.FollowReferences != null); Contract.Assert(!capabilities.CanTagObjects || rawInterface.IterateThroughHeap != null); Contract.Assert(!capabilities.CanTagObjects || rawInterface.GetTag != null); Contract.Assert(!capabilities.CanTagObjects || rawInterface.SetTag != null); Contract.Assert(!capabilities.CanTagObjects || rawInterface.GetObjectsWithTags != null); Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.GetLocalObject != null); Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.GetLocalInstance != null); Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.GetLocalInt != null); Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.GetLocalLong != null); Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.GetLocalFloat != null); Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.GetLocalDouble != null); Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.SetLocalObject != null); Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.SetLocalInt != null); Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.SetLocalLong != null); Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.SetLocalFloat != null); Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.SetLocalDouble != null); Contract.Assert(!capabilities.CanGenerateBreakpointEvents || rawInterface.SetBreakpoint != null); Contract.Assert(!capabilities.CanGenerateBreakpointEvents || rawInterface.ClearBreakpoint != null); Contract.Assert(!capabilities.CanGenerateFieldAccessEvents || rawInterface.SetFieldAccessWatch != null); Contract.Assert(!capabilities.CanGenerateFieldAccessEvents || rawInterface.ClearFieldAccessWatch != null); Contract.Assert(!capabilities.CanGenerateFieldModificationEvents || rawInterface.SetFieldModificationWatch != null); Contract.Assert(!capabilities.CanGenerateFieldModificationEvents || rawInterface.ClearFieldModificationWatch != null); Contract.Assert(!capabilities.CanGetSourceFileName || rawInterface.GetSourceFileName != null); Contract.Assert(!capabilities.CanGetConstantPool || rawInterface.GetConstantPool != null); Contract.Assert(!capabilities.CanGetSourceDebugExtension || rawInterface.GetSourceDebugExtension != null); Contract.Assert(!capabilities.CanRetransformClasses || rawInterface.RetransformClasses != null); Contract.Assert(!capabilities.CanRedefineClasses || rawInterface.RedefineClasses != null); Contract.Assert(!capabilities.CanGetMonitorInfo || rawInterface.GetObjectMonitorUsage != null); Contract.Assert(!capabilities.CanGetSyntheticAttribute || rawInterface.IsFieldSynthetic != null); Contract.Assert(!capabilities.CanGetLineNumbers || rawInterface.GetLineNumberTable != null); Contract.Assert(!capabilities.CanAccessLocalVariables || rawInterface.GetLocalVariableTable != null); Contract.Assert(!capabilities.CanGetBytecodes || rawInterface.GetBytecodes != null); Contract.Assert(!capabilities.CanGetSyntheticAttribute || rawInterface.IsMethodSynthetic != null); Contract.Assert(!capabilities.CanSetNativeMethodPrefix || rawInterface.SetNativeMethodPrefix != null); Contract.Assert(!capabilities.CanSetNativeMethodPrefix || rawInterface.SetNativeMethodPrefixes != null); Contract.Assert(!capabilities.CanGetCurrentThreadCpuTime || rawInterface.GetCurrentThreadCpuTimerInfo != null); Contract.Assert(!capabilities.CanGetCurrentThreadCpuTime || rawInterface.GetCurrentThreadCpuTime != null); Contract.Assert(!capabilities.CanGetThreadCpuTime || rawInterface.GetCurrentThreadCpuTimerInfo != null); Contract.Assert(!capabilities.CanGetThreadCpuTime || rawInterface.GetCurrentThreadCpuTime != null); capabilities = new jvmtiCapabilities( jvmtiCapabilities.CapabilityFlags1.CanTagObjects | jvmtiCapabilities.CapabilityFlags1.CanGetSourceFileName | jvmtiCapabilities.CapabilityFlags1.CanGetLineNumbers ); rawInterface.AddCapabilities(env, ref capabilities); _env = env; _rawInterface = rawInterface; _eventManager = new JvmEventManager(this); _eventManager.Attach(); }
private void HandleFramePop(jvmtiEnvHandle env, JNIEnvHandle jniEnv, jthread threadHandle, jmethodID methodId, bool wasPoppedByException) { try { JvmtiEnvironment environment = JvmtiEnvironment.GetOrCreateInstance(_service.VirtualMachine, env); JniEnvironment nativeEnvironment = JniEnvironment.GetOrCreateInstance(jniEnv); TaggedReferenceTypeId declaringClass; MethodId method = new MethodId(methodId.Handle); jlocation jlocation; JvmtiErrorHandler.ThrowOnFailure(environment.GetFrameLocation(threadHandle, 1, out methodId, out jlocation)); ulong index = (ulong)jlocation.Value; JvmtiErrorHandler.ThrowOnFailure(environment.GetMethodDeclaringClass(nativeEnvironment, method, out declaringClass)); Location location = new Location(declaringClass, method, index); ThreadId threadId = VirtualMachine.TrackLocalThreadReference(threadHandle, environment, nativeEnvironment, false); EventFilter[] filters = GetEventFilters(EventKind.FramePop); foreach (var filter in filters) { if (filter.ProcessEvent(environment, nativeEnvironment, this, threadId, default(TaggedReferenceTypeId), location)) { if (filter.InternalEventKind == EventKind.SingleStep) { // remove the frame pop event JvmtiErrorHandler.ThrowOnFailure((jvmtiError)ClearEventInternal(EventKind.FramePop, filter.RequestId)); // set an actual step filter to respond when the thread arrives in the parent frame JvmtiErrorHandler.ThrowOnFailure((jvmtiError)SetEventInternal(environment, nativeEnvironment, EventKind.SingleStep, filter)); } else { SendFramePopEvent(environment, filter, threadId, location, wasPoppedByException); } } } } catch (Exception e) { string caption = "Exception while handling a frame pop event"; System.Windows.Forms.MessageBox.Show(e.Message + System.Environment.NewLine + System.Environment.NewLine + e.StackTrace, caption, MessageBoxButtons.OK, MessageBoxIcon.Error, MessageBoxDefaultButton.Button1); throw; } }
internal static JvmEnvironment GetEnvironment(jvmtiEnvHandle env) { return(_environments[env]); }