fix(extension): serialize ClassDataLoader.findClass per class name

Two threads racing findClass for the same name could both reach
defineClass, which the JVM rejects with LinkageError. Guard the
cache-check + defineClass block with synchronized(getClassLoadingLock(name))
so only one thread per name defines, while a lock-free fast path still
handles the warm-cache case for already-loaded classes.

The synchronized block is chosen over registerAsParallelCapable because
it protects direct findClass callers in addition to the standard
loadClass delegation path, and keeps the invariant locally visible in
findClass itself.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: jbachorik

btrace-extension/src/main/java/org/openjdk/btrace/extension/impl/ClassDataLoader.java

@@ -73,26 +73,39 @@ public ClassDataLoader(String extensionId, ClassLoader resourceLoader, ClassLoad
 
   @Override
   protected Class<?> findClass(String name) throws ClassNotFoundException {
-    // Check cache first
+    // Lock-free fast path for warm cache: avoids taking the per-name class-loading lock
+    // when the class has already been defined.
     Class<?> cached = loadedClasses.get(name);
     if (cached != null) {
       return cached;
     }
 
-    String resourcePath = name.replace('.', '/') + CLASSDATA_SUFFIX;
-    byte[] classBytes = loadClassData(resourcePath);
-    if (classBytes == null) {
-      throw new ClassNotFoundException(name + " (no .classdata resource found)");
-    }
+    // Serialize the defineClass path per name so two threads racing on the same class
+    // cannot both reach defineClass and trigger a LinkageError. getClassLoadingLock
+    // returns this when the ClassLoader is not parallel-capable, giving us a single
+    // lock that still works correctly under all JVM delegation paths (including any
+    // direct findClass callers that bypass loadClass).
+    synchronized (getClassLoadingLock(name)) {
+      cached = loadedClasses.get(name);
+      if (cached != null) {
+        return cached;
+      }
 
-    // Validate bytecode before defining - ensures we're loading a valid class file
-    if (!isValidClassFile(classBytes)) {
-      throw new ClassNotFoundException(name + " (invalid class file format)");
-    }
+      String resourcePath = name.replace('.', '/') + CLASSDATA_SUFFIX;
+      byte[] classBytes = loadClassData(resourcePath);
+      if (classBytes == null) {
+        throw new ClassNotFoundException(name + " (no .classdata resource found)");
+      }
 
-    Class<?> clazz = defineClass(name, classBytes, 0, classBytes.length);
-    Class<?> existing = loadedClasses.putIfAbsent(name, clazz);
-    return existing != null ? existing : clazz;
+      // Validate bytecode before defining - ensures we're loading a valid class file
+      if (!isValidClassFile(classBytes)) {
+        throw new ClassNotFoundException(name + " (invalid class file format)");
+      }
+
+      Class<?> clazz = defineClass(name, classBytes, 0, classBytes.length);
+      loadedClasses.put(name, clazz);
+      return clazz;
+    }
   }
 
   private byte[] loadClassData(String resourcePath) {