JVM_getAllEventClasses support

Signed-off-by: Gengchen Tuo <gengchen.tuo@ibm.com>

Author: thallium

runtime/jcl/common/jdk_jfr_internal_JVM_common.cpp

@@ -23,6 +23,7 @@
 #include "j9.h"
 #include "jni.h"
 #include "jclprots.h"
+#include "ut_j9jcl.h"
 
 #include "ObjectAccessBarrierAPI.hpp"
 #include "VMHelpers.hpp"
@@ -100,10 +101,86 @@ Java_jdk_jfr_internal_JVM_getAllEventClasses(JNIEnv *env, jobject obj)
 	J9VMThread *currentThread = (J9VMThread*) env;
 	J9JavaVM *vm = currentThread->javaVM;
 	J9InternalVMFunctions *vmFuncs = vm->internalVMFunctions;
+	J9MemoryManagerFunctions *mmFuncs = vm->memoryManagerFunctions;
 	jobject result = NULL;
 
 	vmFuncs->internalEnterVMFromJNI(currentThread);
-	result = vmFuncs->j9jni_createLocalRef(env, vmFuncs->jvmUpcallTransformArrayToList(currentThread, NULL));
+
+	omrthread_monitor_enter(vm->jfrState.typeIDMonitor);
+
+	/* First pass: count event classes with valid eventClass pointers across all classloaders. */
+	UDATA eventCount = 0;
+	J9ClassLoaderWalkState walkState;
+	J9ClassLoader *classLoader = vmFuncs->allClassLoadersStartDo(&walkState, vm, 0);
+
+	while (NULL != classLoader) {
+		J9HashTable *typeIDTable = classLoader->typeIDs;
+		if (NULL != typeIDTable) {
+			J9HashTableState hashTableState = {0};
+			J9JFRTypeID *entry = (J9JFRTypeID *)hashTableStartDo(typeIDTable, &hashTableState);
+
+			while (NULL != entry) {
+				if (entry->isEvent && (NULL != entry->eventClass)) {
+					eventCount += 1;
+				}
+				entry = (J9JFRTypeID *)hashTableNextDo(&hashTableState);
+			}
+		}
+		classLoader = vmFuncs->allClassLoadersNextDo(&walkState);
+	}
+	vmFuncs->allClassLoadersEndDo(&walkState);
+
+	/* Get the Class class and create Class[] array class. */
+	J9Class *javaLangClass = J9VMJAVALANGCLASS_OR_NULL(vm);
+	UDATA arrayIndex = 0;
+	j9array_t classArray = NULL;
+	Assert_JCL_notNull(javaLangClass);
+
+	J9Class *classArrayClass = javaLangClass->arrayClass;
+	if (NULL == classArrayClass) {
+		J9ROMArrayClass *arrayOfObjectsROMClass = (J9ROMArrayClass*)J9ROMIMAGEHEADER_FIRSTCLASS(vm->arrayROMClasses);
+		classArrayClass = vmFuncs->internalCreateArrayClass(currentThread, arrayOfObjectsROMClass, javaLangClass);
+		if (NULL == classArrayClass) {
+			goto done;
+		}
+	}
+
+	/* Allocate the Class[] array. */
+	classArray = (j9array_t)mmFuncs->J9AllocateIndexableObject(
+		currentThread, classArrayClass, (U_32)eventCount, J9_GC_ALLOCATE_OBJECT_NON_INSTRUMENTABLE);
+	if (NULL == classArray) {
+		vmFuncs->setNativeOutOfMemoryError(currentThread, 0, 0);
+		goto done;
+	}
+
+	/* Second pass: populate the array with event classes from all classloaders */
+	classLoader = vmFuncs->allClassLoadersStartDo(&walkState, vm, 0);
+
+	while (NULL != classLoader) {
+		J9HashTable *typeIDTable = classLoader->typeIDs;
+		if (NULL != typeIDTable) {
+			J9HashTableState hashTableState = {0};
+			J9JFRTypeID *entry = (J9JFRTypeID *)hashTableStartDo(typeIDTable, &hashTableState);
+
+			while (NULL != entry) {
+				if (entry->isEvent && (NULL != entry->eventClass)) {
+					/* Use the stored eventClass pointer directly */
+					j9object_t classObject = J9VM_J9CLASS_TO_HEAPCLASS(entry->eventClass);
+					J9JAVAARRAYOFOBJECT_STORE(currentThread, classArray, arrayIndex, classObject);
+					arrayIndex += 1;
+				}
+				entry = (J9JFRTypeID *)hashTableNextDo(&hashTableState);
+			}
+		}
+		classLoader = vmFuncs->allClassLoadersNextDo(&walkState);
+	}
+	vmFuncs->allClassLoadersEndDo(&walkState);
+
+	/* Convert array to list and create local ref */
+	result = vmFuncs->j9jni_createLocalRef(env, vmFuncs->jvmUpcallTransformArrayToList(currentThread, (j9object_t)classArray));
+
+done:
+	omrthread_monitor_exit(vm->jfrState.typeIDMonitor);
 	vmFuncs->internalExitVMToJNI(currentThread);
 
 	return result;

runtime/oti/j9nonbuilder.h

@@ -554,6 +554,8 @@ typedef struct J9JFRTypeID {
 	jlong id;
 	struct J9UTF8 *className;
 	BOOLEAN free;
+	BOOLEAN isEvent;
+	struct J9Class *eventClass;
 } J9JFRTypeID;
 
 typedef struct J9JFRNetworkUtilization {

runtime/vm/jfr.cpp

@@ -75,6 +75,8 @@ static bool addEventIds(J9JavaVM *vm);
 static bool addTypeIds(J9JavaVM *vm);
 #endif /* JAVA_SPEC_VERSION >= 17 */
 static void jfrShutdownInternalStructures(J9HookInterface **hook, UDATA eventNum, void *eventData, void *userData);
+static void addEventClass(J9VMThread *currentThread, J9Class *clazz);
+static void jfrClassInitialize(J9HookInterface **hook, UDATA eventNum, void *eventData, void *userData);
 
 static void
 freeThreadIDs(J9VMThread *currentThread)
@@ -1152,6 +1154,7 @@ stopJFRRecording(J9JavaVM *vm)
 	(*vmHooks)->J9HookUnregister(vmHooks, J9HOOK_VM_MONITOR_CONTENDED_ENTERED, jfrVMMonitorEntered, NULL);
 	(*vmHooks)->J9HookUnregister(vmHooks, J9HOOK_VM_UNPARKED, jfrVMThreadParked, NULL);
 	(*vmHooks)->J9HookUnregister(vmHooks, J9HOOK_SYSTEM_GC_CALLED, jfrSystemGC, NULL);
+
 	/* Deregister GC-related hooks via gc_base */
 	vm->memoryManagerFunctions->j9gc_deregister_jfr_hooks(vm);
 }
@@ -1706,24 +1709,21 @@ getTypeId(J9VMThread *currentThread, J9Class *clazz)
 	return getTypeIdImpl(currentThread, clazz->classLoader, J9ROMCLASS_CLASSNAME(clazz->romClass), FALSE);
 }
 
-static jlong
-getTypeIdImpl(J9VMThread *currentThread, J9ClassLoader *classLoader, J9UTF8 *className, BOOLEAN freeName)
-{
-	J9JavaVM *vm = currentThread->javaVM;
-	jlong result = INVALID_TYPE_ID;
-	J9JFRTypeID entry = {0};
-	J9JFRTypeID *jfrTypeID = &entry;
-
-	Assert_VM_mustHaveVMAccess(currentThread);
-
-	omrthread_monitor_enter(vm->jfrState.typeIDMonitor);
-
-	J9HashTable *typeIDTable = classLoader->typeIDs;
-
-	if (NULL == typeIDTable) {
-		PORT_ACCESS_FROM_JAVAVM(vm);
+/**
+ * Create and initialize a JFR TypeID hash table for the given class loader.
+ * Caller must hold vm->jfrState.typeIDMonitor.
+ *
+ * @param vm[in] Java VM
+ * @param classLoader[in] the class loader whose TypeID hash table will be created
+ *
+ * @returns the created hash table, NULL if error happened during table creation and/or initialization
+ */
 
-		typeIDTable = hashTableNew(OMRPORT_FROM_J9PORT(privatePortLibrary),
+static J9HashTable *
+createJFRTypeIDHashTable(J9JavaVM *vm, J9ClassLoader *classLoader)
+{
+	PORT_ACCESS_FROM_JAVAVM(vm);
+	J9HashTable *typeIDTable = hashTableNew(OMRPORT_FROM_J9PORT(privatePortLibrary),
 								J9_GET_CALLSITE(),
 								0,
 								sizeof(J9JFRTypeID),
@@ -1734,32 +1734,54 @@ getTypeIdImpl(J9VMThread *currentThread, J9ClassLoader *classLoader, J9UTF8 *cla
 								jfrTypeIDHashEqualFn,
 								NULL,
 								NULL);
-
-		if (NULL == typeIDTable) {
-			setNativeOutOfMemoryError(currentThread, 0, 0);
-			goto done;
-		}
-		classLoader->typeIDs = typeIDTable;
+	if (NULL == typeIDTable) {
+		goto done;
+	}
 
 #if JAVA_SPEC_VERSION >= 17
 		if (vm->systemClassLoader == classLoader) {
 			/* Pre-populate table with known JFR event IDs */
 			if (!addEventIds(vm)) {
 				hashTableFree(typeIDTable);
 				classLoader->typeIDs = NULL;
-				setNativeOutOfMemoryError(currentThread, 0, 0);
 				goto done;
 			}
 
 			/* Pre-populate table with known JFR type IDs */
 			if (!addTypeIds(vm)) {
 				hashTableFree(typeIDTable);
 				classLoader->typeIDs = NULL;
-				setNativeOutOfMemoryError(currentThread, 0, 0);
 				goto done;
 			}
 		}
 #endif /* JAVA_SPEC_VERSION >= 17 */
+
+	classLoader->typeIDs = typeIDTable;
+done:
+	return typeIDTable;
+}
+
+static jlong
+getTypeIdImpl(J9VMThread *currentThread, J9ClassLoader *classLoader, J9UTF8 *className, BOOLEAN freeName)
+{
+	J9JavaVM *vm = currentThread->javaVM;
+	jlong result = INVALID_TYPE_ID;
+	J9JFRTypeID entry = {0};
+	J9JFRTypeID *jfrTypeID = &entry;
+
+	Assert_VM_mustHaveVMAccess(currentThread);
+
+	omrthread_monitor_enter(vm->jfrState.typeIDMonitor);
+
+	J9HashTable *typeIDTable = classLoader->typeIDs;
+
+	if (NULL == typeIDTable) {
+		typeIDTable = createJFRTypeIDHashTable(vm, classLoader);
+
+		if (NULL == typeIDTable) {
+			setNativeOutOfMemoryError(currentThread, 0, 0);
+			goto done;
+		}
 	}
 
 	jfrTypeID->className = className;
@@ -1770,6 +1792,8 @@ getTypeIdImpl(J9VMThread *currentThread, J9ClassLoader *classLoader, J9UTF8 *cla
 		jfrTypeID = &entry;
 		jfrTypeID->id = vm->jfrState.typeIDcount;
 		jfrTypeID->free = freeName;
+		jfrTypeID->isEvent = FALSE;
+		jfrTypeID->eventClass = NULL;
 
 		vm->jfrState.typeIDcount += 1;
 		Assert_VM_true(vm->jfrState.typeIDcount > 0);
@@ -1802,6 +1826,12 @@ initializeJFRv2(J9JavaVM *vm)
 		goto done;
 	}
 
+	if (J9_ARE_ALL_BITS_SET(vm->extendedRuntimeFlags3, J9_EXTENDED_RUNTIME3_JFR_V2_SUPPORT)) {
+		if ((*vmHooks)->J9HookRegisterWithCallSite(vmHooks, J9HOOK_VM_CLASS_INITIALIZE, jfrClassInitialize, OMR_GET_CALLSITE(), NULL)) {
+			goto done;
+		}
+	}
+
 	if (0 != initializeJFRIDs(vm)) {
 		goto done;
 	}
@@ -1853,6 +1883,9 @@ jfrShutdownInternalStructures(J9HookInterface **hook, UDATA eventNum, void *even
 	internalReleaseVMAccess(currentThread);
 	vm->jfrState.jfrEventClassRef = NULL;
 	vm->jfrState.jfrInternalEventClassRef = NULL;
+	if (J9_ARE_ALL_BITS_SET(vm->extendedRuntimeFlags3, J9_EXTENDED_RUNTIME3_JFR_V2_SUPPORT)) {
+		(*hook)->J9HookUnregister(hook, J9HOOK_VM_CLASS_INITIALIZE, jfrClassInitialize, NULL);
+	}
 }
 
 static void
@@ -2017,6 +2050,8 @@ addType(J9JavaVM *vm, const char *eventOrTypeName, UDATA id, bool isEvent)
 	entry.id = id;
 	entry.className = className;
 	entry.free = TRUE;
+	entry.isEvent = isEvent;
+	entry.eventClass = NULL;
 
 	/* Add to hash table */
 	if (NULL == hashTableAdd(typeIDTable, &entry)) {
@@ -2332,6 +2367,84 @@ requestJFREvent(J9VMThread *currentThread, jlong id)
 #endif /* JAVA_SPEC_VERSION >= 17 */
 }
 
+void
+jfrClassInitialize(J9HookInterface **hook, UDATA eventNum, void *eventData, void *userData)
+{
+	J9VMClassInitializeEvent *event = (J9VMClassInitializeEvent *)eventData;
+	J9VMThread *currentThread = event->currentThread;
+	J9Class *clazz = event->clazz;
+
+	addEventClass(currentThread, clazz);
+}
+
+/**
+ * Add an event class to the typeIDs table after it has been loaded.
+ * This function is called from the class loading hook to register event classes.
+ *
+ * @param currentThread[in] the current J9VMThread
+ * @param clazz[in] the loaded class to check and potentially add
+ */
+static void
+addEventClass(J9VMThread *currentThread, J9Class *clazz)
+{
+	J9JavaVM *vm = currentThread->javaVM;
+	J9UTF8 *className = J9ROMCLASS_CLASSNAME(clazz->romClass);
+	J9ClassLoader *classLoader = clazz->classLoader;
+
+	if (NULL == vm->jfrState.jfrEventClassRef) {
+		return;
+	}
+
+	/* Check if this class is a subclass of jdk.jfr.Event and not an abstract class */
+	J9Class *eventClass = J9VMJAVALANGCLASS_VMREF(currentThread, J9_JNI_UNWRAP_REFERENCE(vm->jfrState.jfrEventClassRef));
+	if (isSameOrSuperClassOf(eventClass, clazz)
+		&& J9_ARE_NO_BITS_SET(clazz->romClass->modifiers, J9AccAbstract)
+	) {
+		omrthread_monitor_enter(vm->jfrState.typeIDMonitor);
+
+		J9HashTable *typeIDTable = classLoader->typeIDs;
+		J9JFRTypeID query = {0};
+		J9JFRTypeID *existingEntry = NULL;
+
+		/* Create typeIDs table if it doesn't exist */
+		if (NULL == typeIDTable) {
+			typeIDTable = createJFRTypeIDHashTable(vm, classLoader);
+
+			if (NULL == typeIDTable) {
+				goto done;
+			}
+		}
+
+		/* Check if entry already exists */
+		query.className = className;
+		existingEntry = (J9JFRTypeID *)hashTableFind(typeIDTable, &query);
+
+		if (NULL != existingEntry) {
+			/* Update existing entry with event class pointer */
+			existingEntry->isEvent = TRUE;
+			existingEntry->eventClass = clazz;
+		} else {
+			/* Create new entry */
+			J9JFRTypeID newEntry = {0};
+			newEntry.id = vm->jfrState.typeIDcount;
+			newEntry.className = className;
+			newEntry.free = FALSE;
+			newEntry.isEvent = TRUE;
+			newEntry.eventClass = clazz;
+
+			vm->jfrState.typeIDcount += 1;
+			Assert_VM_true(vm->jfrState.typeIDcount > 0);
+
+			if (NULL == hashTableAdd(typeIDTable, &newEntry)) {
+				setNativeOutOfMemoryError(currentThread, 0, 0);
+				goto done;
+			}
+		}
+done:
+		omrthread_monitor_exit(vm->jfrState.typeIDMonitor);
+	}
+}
+
 } /* extern "C" */
 
 #endif /* defined(J9VM_OPT_JFR) */