engineering/java-topology
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

undefect. CWE-407 — 63 sites patched across 27 ecosystems

Browse source 
Authors: russell@unturf.com · brackishbert@gmail.com · foxhop.net · TimeHexOn.com

Patches, unit tests, benchmarks, whitepaper, and outreach briefs.
Public domain — no copyright claimed. Use freely.
This commit is contained in:
russell@unturf.com 2026-03-26 17:11:57 -04:00
commit 0a580b313d
70422 changed files with 17213626 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

179
test/jdk/java/lang/ClassLoader/loadLibraryUnload/LoadLibraryUnload.java Normal file
View file

@ -0,0 +1,179 @@
/*
* Copyright (c) 2021, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2021, BELLSOFT. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* LoadLibraryUnload class calls ClassLoader.loadedLibrary from multiple threads
*/
/*
* The driver for this test is LoadLibraryUnloadTest.java.
*
* @bug 8266310
* @summary Loads a native library from multiple class loaders and multiple
* threads. This creates a race for loading the library. The winner
* loads the library in two threads. All threads except two would fail
* with UnsatisfiedLinkError when the class being loaded is already
* loaded in a different class loader that won the race. The test
* checks that the loaded class is GC'ed, that means the class loader
* is GC'ed and the native library is unloaded.
*/
import jdk.test.lib.Asserts;
import jdk.test.lib.Utils;
import java.lang.*;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;
import java.lang.reflect.*;
import java.lang.ref.WeakReference;
import java.net.URL;
import java.net.URLClassLoader;
import java.nio.file.Path;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import jdk.test.lib.util.ForceGC;
import p.Class1;
public class LoadLibraryUnload {
private static class TestLoader extends URLClassLoader {
public TestLoader() throws Exception {
super(new URL[] { Path.of(System.getProperty("test.classes")).toUri().toURL() });
}
@Override
public Class<?> loadClass(String name) throws ClassNotFoundException {
synchronized (getClassLoadingLock(name)) {
Class<?> clazz = findLoadedClass(name);
if (clazz == null) {
try {
clazz = findClass(name);
} catch (ClassNotFoundException ignore) {
}
if (clazz == null) {
clazz = super.loadClass(name);
}
}
return clazz;
}
}
}
private static class LoadLibraryFromClass implements Runnable {
Object object;
Method method;
Object canary;
public LoadLibraryFromClass(Class<?> fromClass, Object canary) {
try {
this.object = fromClass.newInstance();
this.method = fromClass.getDeclaredMethod("loadLibrary", Object.class);
this.canary = canary;
} catch (ReflectiveOperationException roe) {
throw new RuntimeException(roe);
}
}
@Override
public void run() {
try {
method.invoke(object, canary);
} catch (ReflectiveOperationException roe) {
throw new RuntimeException(roe);
}
}
}
public static void main(String[] args) throws Exception {
int LOADER_COUNT = 5;
List<Thread> threads = new ArrayList<>();
Object[] canary = new Object[LOADER_COUNT];
final WeakReference<Object> wCanary[] = new WeakReference[LOADER_COUNT];
for (int i = 0 ; i < LOADER_COUNT ; i++) {
// LOADER_COUNT loaders and 2X threads in total.
// winner loads the library in 2 threads
canary[i] = new Object();
wCanary[i] = new WeakReference<>(canary[i], null);
Class<?> clazz = new TestLoader().loadClass("p.Class1");
threads.add(new Thread(new LoadLibraryFromClass(clazz, canary[i])));
threads.add(new Thread(new LoadLibraryFromClass(clazz, canary[i])));
}
final Set<Throwable> exceptions = ConcurrentHashMap.newKeySet();
threads.forEach( t -> {
t.setUncaughtExceptionHandler((th, ex) -> {
// collect the root cause of each failure
Throwable rootCause = ex;
while((ex = ex.getCause()) != null) {
rootCause = ex;
}
exceptions.add(rootCause);
});
t.start();
});
// wait for all threads to finish
for (Thread t : threads) {
t.join();
}
// expect all errors to be UnsatisfiedLinkError
boolean allAreUnsatisfiedLinkError = exceptions
.stream()
.map(e -> e instanceof UnsatisfiedLinkError)
.reduce(true, (i, a) -> i && a);
// expect exactly 8 errors
int expectedErrorCount = (LOADER_COUNT - 1) * 2;
Asserts.assertTrue(exceptions.size() == expectedErrorCount,
"Expected to see " + expectedErrorCount + " failing threads");
Asserts.assertTrue(allAreUnsatisfiedLinkError,
"All errors have to be UnsatisfiedLinkError");
// release strong refs
threads = null;
canary = null;
exceptions.clear();
// Wait for the canary for each of the libraries to be GC'd (cleared)
boolean allClear = ForceGC.wait(() -> {
for (int i = 0; i < wCanary.length; i++) {
if (!wCanary[i].refersTo(null)) {
return false;
}
}
return true;
});
Asserts.assertTrue(allClear, "Not all WeakReferences cleared");
// Ensure the WeakReferences are strongly referenced until they can be dequeued
Reference.reachabilityFence(wCanary);
}
}

90
test/jdk/java/lang/ClassLoader/loadLibraryUnload/LoadLibraryUnloadTest.java Normal file
View file

@ -0,0 +1,90 @@
/*
* Copyright (c) 2021, 2023, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2021, BELLSOFT. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* LoadLibraryUnloadTest ensures all objects (NativeLibrary) are deallocated
* when loaded in concurrent mode.
*/
/*
* @test
* @bug 8266310 8289919 8293282
* @summary Checks that JNI_OnLoad is invoked only once when multiple threads
* call System.loadLibrary concurrently, and JNI_OnUnload is invoked
* when the native library is loaded from a custom class loader.
* @library /test/lib
* @build LoadLibraryUnload p.Class1
* @run main/othervm/native LoadLibraryUnloadTest
*/
import jdk.test.lib.Asserts;
import jdk.test.lib.process.OutputAnalyzer;
import static jdk.test.lib.process.ProcessTools.*;
public class LoadLibraryUnloadTest {
private static String testClassPath = System.getProperty("test.classes");
private static String testLibraryPath = System.getProperty("test.nativepath");
private final static long countLines(OutputAnalyzer output, String string) {
return output.asLines()
.stream()
.filter(s -> s.contains(string))
.count();
}
private final static void dump(OutputAnalyzer output) {
output.asLines()
.stream()
.forEach(s -> System.out.println(s));
}
public static void main(String[] args) throws Throwable {
OutputAnalyzer outputAnalyzer = executeCommand(createTestJavaProcessBuilder(
"-Dtest.classes=" + testClassPath,
"-Djava.library.path=" + testLibraryPath,
"LoadLibraryUnload"));
dump(outputAnalyzer);
Asserts.assertTrue(
countLines(outputAnalyzer, "Native library loaded from Class1.") == 2,
"Native library expected to be loaded in 2 threads.");
long refCount = countLines(outputAnalyzer, "Native library loaded.");
Asserts.assertTrue(refCount > 0, "Failed to load native library.");
System.out.println("Native library loaded in " + refCount + " threads");
Asserts.assertTrue(refCount == 1, "Native library is loaded more than once.");
Asserts.assertTrue(
countLines(outputAnalyzer, "Native library unloaded.") == refCount,
"Failed to unload native library");
Asserts.assertEquals(0, outputAnalyzer.getExitValue(),
"LoadLibraryUnload exit value not zero");
}
}

67
test/jdk/java/lang/ClassLoader/loadLibraryUnload/libloadLibraryUnload.c Normal file
View file

@ -0,0 +1,67 @@
/*
* Copyright (c) 2021, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2021, BELLSOFT. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
#include <stdio.h>
#include "jni.h"
static volatile jobject ref = NULL;
JNIEXPORT jint JNICALL
JNI_OnLoad(JavaVM *vm, void *reserved)
{
JNIEnv *env;
printf("Native library loaded.\n");
fflush(stdout);
if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_2) != JNI_OK) {
return JNI_EVERSION; /* JNI version not supported */
}
return JNI_VERSION_1_2;
}
JNIEXPORT void JNICALL Java_p_Class1_setRef(JNIEnv *env, jobject this, jobject obj) {
if (ref == NULL) {
// Only create a single GlobalRef
ref = (*env)->NewGlobalRef(env, obj);
printf("GlobalRef created\n");
}
}
JNIEXPORT void JNICALL
JNI_OnUnload(JavaVM *vm, void *reserved) {
if (ref != NULL) {
JNIEnv *env = NULL;
if ((*vm)->GetEnv(vm, (void**) &env, JNI_VERSION_1_2) != JNI_OK) {
return; /* JNI version not supported */
}
(*env)->DeleteGlobalRef(env, ref);
printf("GlobalRef deleted\n");
}
printf("Native library unloaded.\n");
fflush(stdout);
}

50
test/jdk/java/lang/ClassLoader/loadLibraryUnload/p/Class1.java Normal file
View file

@ -0,0 +1,50 @@
/*
* Copyright (c) 2021, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2021, BELLSOFT. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* Class1 loads a native library.
*/
package p;
public class Class1 {
public Class1() {
}
// method called from java threads
public void loadLibrary(Object obj) throws Exception {
System.loadLibrary("loadLibraryUnload");
System.out.println("Native library loaded from Class1.");
synchronized (Class1.class) {
setRef(obj);
}
}
/**
* Native method to store an object ref in a native Global reference
* to be cleared when the library is unloaded.
* @param obj an object
*/
private static native void setRef(Object obj);
}