internal TaggedReferenceTypeId TrackLocalClassReference(jclass classHandle, JvmtiEnvironment environment, JniEnvironment nativeEnvironment, bool freeLocalReference) { if (classHandle == jclass.Null) { return(default(TaggedReferenceTypeId)); } bool isArrayClass; JvmtiErrorHandler.ThrowOnFailure(environment.IsArrayClass(classHandle, out isArrayClass)); bool isInterface; JvmtiErrorHandler.ThrowOnFailure(environment.IsInterface(classHandle, out isInterface)); TypeTag typeTag = isArrayClass ? TypeTag.Array : (isInterface ? TypeTag.Interface : TypeTag.Class); int hashCode; JvmtiErrorHandler.ThrowOnFailure(environment.GetObjectHashCode(classHandle, out hashCode)); ReferenceTypeId typeId = new ReferenceTypeId(hashCode); TaggedReferenceTypeId taggedTypeId = new TaggedReferenceTypeId(typeTag, typeId); lock (_classes) { if (!_classes.ContainsKey(typeId)) { jweak weak = nativeEnvironment.NewWeakGlobalReference(classHandle); bool added = false; if (!_classes.ContainsKey(typeId)) { _classes.Add(typeId, new jclass(weak.Handle)); added = true; } if (!added) { nativeEnvironment.DeleteWeakGlobalReference(weak); } } } if (freeLocalReference) { nativeEnvironment.DeleteLocalReference(classHandle); } return(taggedTypeId); }
public int AttachCurrentThreadAsDaemon(JvmtiEnvironment environment, out JniEnvironment nativeEnvironment, bool agentThread) { JavaVMAttachArgs args = new JavaVMAttachArgs(jniVersion.Version1_6, IntPtr.Zero, jthreadGroup.Null); bool alreadyAgent = IsAgentThread.Value; if (agentThread && !alreadyAgent) { IsAgentThread.Value = true; } JNIEnvHandle jniEnv; int error = RawInterface.AttachCurrentThreadAsDaemon(this, out jniEnv, ref args); if (error == 0) { bool created; nativeEnvironment = JniEnvironment.GetOrCreateInstance(jniEnv, out created); if (agentThread && !alreadyAgent) { if (environment == null) { GetEnvironment(out environment); } jthread thread; JvmtiErrorHandler.ThrowOnFailure(environment.RawInterface.GetCurrentThread(environment, out thread)); if (thread != jthread.Null) { ThreadId threadId = TrackLocalThreadReference(thread, environment, nativeEnvironment, true); lock (_agentThreads) { _agentThreads.Add(threadId); } } } } else { nativeEnvironment = null; } return(error); }
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)); }
internal ThreadId TrackLocalThreadReference(jthread thread, JvmtiEnvironment environment, JniEnvironment nativeEnvironment, bool freeLocalReference) { if (thread == jthread.Null) { return(default(ThreadId)); } int hashCode; JvmtiErrorHandler.ThrowOnFailure(environment.RawInterface.GetObjectHashCode(environment, thread, out hashCode)); ThreadId threadId = new ThreadId(hashCode); lock (_threads) { if (!_threads.ContainsKey(threadId)) { jweak weak = nativeEnvironment.NewWeakGlobalReference(thread); bool added = false; if (!_threads.ContainsKey(threadId)) { _threads.Add(threadId, new jthread(weak.Handle)); added = true; } if (!added) { nativeEnvironment.DeleteWeakGlobalReference(weak); } } } if (freeLocalReference) { nativeEnvironment.DeleteLocalReference(thread); } return(threadId); }
internal jclass FindBaseClass(JvmtiEnvironment environment, JniEnvironment nativeEnvironment, jclass classHandle, string signature) { string currentSignature; string genericSignature; JvmtiErrorHandler.ThrowOnFailure(environment.GetClassSignature(classHandle, out currentSignature, out genericSignature)); if (currentSignature == signature) { return((jclass)nativeEnvironment.NewGlobalReference(classHandle)); } jclass superClass = nativeEnvironment.GetSuperclass(classHandle); if (superClass == jclass.Null) { return(jclass.Null); } jclass result = FindBaseClass(environment, nativeEnvironment, superClass, signature); nativeEnvironment.DeleteLocalReference(superClass); return(result); }
internal void HandleVMInit(JvmtiEnvironment environment, JniEnvironment nativeEnvironment, jthread thread) { jclass threadClass = nativeEnvironment.GetObjectClass(thread); _threadClass = FindBaseClass(environment, nativeEnvironment, threadClass, "Ljava/lang/Thread;"); { jclass classClass = nativeEnvironment.GetObjectClass(threadClass); _classClass = FindBaseClass(environment, nativeEnvironment, classClass, "Ljava/lang/Class;"); nativeEnvironment.DeleteLocalReference(classClass); } { jvmtiThreadInfo threadInfo; JvmtiErrorHandler.ThrowOnFailure(environment.GetThreadInfo(thread, out threadInfo)); jclass threadGroupClass = nativeEnvironment.GetObjectClass(threadInfo._threadGroup); _threadGroupClass = FindBaseClass(environment, nativeEnvironment, threadGroupClass, "Ljava/lang/ThreadGroup;"); jclass classLoaderClass = nativeEnvironment.GetObjectClass(threadInfo._contextClassLoader); _classLoaderClass = FindBaseClass(environment, nativeEnvironment, classLoaderClass, "Ljava/lang/ClassLoader;"); nativeEnvironment.DeleteLocalReference(classLoaderClass); nativeEnvironment.DeleteLocalReference(threadGroupClass); nativeEnvironment.DeleteLocalReference(threadInfo._contextClassLoader); nativeEnvironment.DeleteLocalReference(threadInfo._threadGroup); environment.Deallocate(threadInfo._name); } nativeEnvironment.DeleteLocalReference(threadClass); jobject stringObject = nativeEnvironment.NewString(string.Empty); jclass stringClass = nativeEnvironment.GetObjectClass(stringObject); _stringClass = FindBaseClass(environment, nativeEnvironment, stringClass, "Ljava/lang/String;"); nativeEnvironment.DeleteLocalReference(stringObject); nativeEnvironment.DeleteLocalReference(stringClass); }
internal TaggedObjectId TrackLocalObjectReference(jobject @object, JvmtiEnvironment environment, JniEnvironment nativeEnvironment, bool freeLocalReference) { if (@object == jobject.Null) { return(new TaggedObjectId(Tag.Object, new ObjectId(0), default(TaggedReferenceTypeId))); } long tag; JvmtiErrorHandler.ThrowOnFailure(environment.GetTag(@object, out tag)); TaggedReferenceTypeId type = default(TaggedReferenceTypeId); Tag objectKind; if (tag == 0) { long uniqueTag = Interlocked.Increment(ref _nextTag); /* first figure out what type of object we're dealing with. could be: * - String * - Thread * - ThreadGroup * - ClassLoader * - ClassObject * - Array * - Object */ // check for array jclass objectClass = nativeEnvironment.GetObjectClass(@object); try { type = TrackLocalClassReference(objectClass, environment, nativeEnvironment, false); bool isArray = type.TypeTag == TypeTag.Array; if (isArray) { objectKind = Tag.Array; } else { if (_stringClass != jclass.Null && nativeEnvironment.IsInstanceOf(@object, _stringClass)) { objectKind = Tag.String; } else if (_threadClass != jclass.Null && nativeEnvironment.IsInstanceOf(@object, _threadClass)) { objectKind = Tag.Thread; } else if (_threadGroupClass != jclass.Null && nativeEnvironment.IsInstanceOf(@object, _threadGroupClass)) { objectKind = Tag.ThreadGroup; } else if (_classClass != jclass.Null && nativeEnvironment.IsInstanceOf(@object, _classClass)) { objectKind = Tag.ClassObject; } else if (_classLoaderClass != jclass.Null && nativeEnvironment.IsInstanceOf(@object, _classLoaderClass)) { objectKind = Tag.ClassLoader; } else { objectKind = Tag.Object; } } } finally { nativeEnvironment.DeleteLocalReference(objectClass); } tag = (uniqueTag << 8) | (uint)objectKind; JvmtiErrorHandler.ThrowOnFailure(environment.SetTag(@object, tag)); lock (_objects) { _objects.Add(new ObjectId(tag), nativeEnvironment.NewWeakGlobalReference(@object)); } } else { jclass objectClass = nativeEnvironment.GetObjectClass(@object); type = TrackLocalClassReference(objectClass, environment, nativeEnvironment, true); } if (freeLocalReference) { nativeEnvironment.DeleteLocalReference(@object); } objectKind = (Tag)(tag & 0xFF); return(new TaggedObjectId(objectKind, new ObjectId(tag), type)); }