stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8023524: Mechanism to dump generated lambda classes / log lambda code generation

Browse Source 
Co-authored-by: Brian Goetz <brian.goetz@oracle.com>
Reviewed-by: plevart, mchung, forax, jjb
This commit is contained in:
Henry Jen 2013-10-09 09:41:40 -07:00
parent 242f0dd3c2
commit 1f02e9968e
3 changed files with 393 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
jdk/src/share/classes/java/lang/invoke/InnerClassLambdaMetafactory.java
View File

@ -27,12 +27,15 @@ package java.lang.invoke;
import jdk.internal.org.objectweb.asm.*;
import sun.misc.Unsafe;
import sun.security.action.GetPropertyAction;
import java.io.FilePermission;
import java.lang.reflect.Constructor;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.security.ProtectionDomain;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.PropertyPermission;
import static jdk.internal.org.objectweb.asm.Opcodes.*;
@ -66,12 +69,23 @@ import static jdk.internal.org.objectweb.asm.Opcodes.*;
// Used to ensure that each spun class name is unique
private static final AtomicInteger counter = new AtomicInteger(0);
// For dumping generated classes to disk, for debugging purposes
private static final ProxyClassesDumper dumper;
static {
final String key = "jdk.internal.lambda.dumpProxyClasses";
String path = AccessController.doPrivileged(
new GetPropertyAction(key), null,
new PropertyPermission(key , "read"));
dumper = (null == path) ? null : ProxyClassesDumper.getInstance(path);
}
// See context values in AbstractValidatingLambdaMetafactory
private final String implMethodClassName; // Name of type containing implementation "CC"
private final String implMethodName; // Name of implementation method "impl"
private final String implMethodDesc; // Type descriptor for implementation methods "(I)Ljava/lang/String;"
private final Type[] implMethodArgumentTypes; // ASM types for implementaion method parameters
private final Type implMethodReturnType; // ASM type for implementaion method return type "Ljava/lang/String;"
private final Type[] implMethodArgumentTypes; // ASM types for implementation method parameters
private final Type implMethodReturnType; // ASM type for implementation method return type "Ljava/lang/String;"
private final MethodType constructorType; // Generated class constructor type "(CC)void"
private final String constructorDesc; // Type descriptor for constructor "(LCC;)V"
private final ClassWriter cw; // ASM class writer
@ -259,29 +273,31 @@ import static jdk.internal.org.objectweb.asm.Opcodes.*;
final byte[] classBytes = cw.toByteArray();
/*** Uncomment to dump the generated file
System.out.printf("Loaded: %s (%d bytes) %n", lambdaClassName,
classBytes.length);
try (FileOutputStream fos = new FileOutputStream(lambdaClassName
.replace('/', '.') + ".class")) {
fos.write(classBytes);
} catch (IOException ex) {
PlatformLogger.getLogger(InnerClassLambdaMetafactory.class
.getName()).severe(ex.getMessage(), ex);
}
***/
// If requested, dump out to a file for debugging purposes
if (dumper != null) {
AccessController.doPrivileged(new PrivilegedAction<Void>() {
@Override
public Void run() {
dumper.dumpClass(lambdaClassName, classBytes);
return null;
}
}, null,
new FilePermission("<<ALL FILES>>", "read, write"),
// createDirectories may need it
new PropertyPermission("user.dir", "read"));
}
ClassLoader loader = targetClass.getClassLoader();
ProtectionDomain pd = (loader == null)
? null
: AccessController.doPrivileged(
new PrivilegedAction<ProtectionDomain>() {
@Override
public ProtectionDomain run() {
return targetClass.getProtectionDomain();
}
}
);
? null
: AccessController.doPrivileged(
new PrivilegedAction<ProtectionDomain>() {
@Override
public ProtectionDomain run() {
return targetClass.getProtectionDomain();
}
}
);
return UNSAFE.defineClass(lambdaClassName,
classBytes, 0, classBytes.length,

147
jdk/src/share/classes/java/lang/invoke/ProxyClassesDumper.java Normal file
View File

@ -0,0 +1,147 @@
/*
* Copyright (c) 2013, Oracle and/or its affiliates. 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. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* 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.
*/
package java.lang.invoke;
import sun.util.logging.PlatformLogger;
import java.io.FilePermission;
import java.nio.file.Files;
import java.nio.file.InvalidPathException;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Objects;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* Helper class used by InnerClassLambdaMetafactory to log generated classes
*
* @implNote
* <p> Because this class is called by LambdaMetafactory, make use
* of lambda lead to recursive calls cause stack overflow.
*/
final class ProxyClassesDumper {
private static final char[] HEX = {
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
};
private static final char[] BAD_CHARS = {
'\\', ':', '*', '?', '"', '<', '>', '|'
};
private static final String[] REPLACEMENT = {
"%5C", "%3A", "%2A", "%3F", "%22", "%3C", "%3E", "%7C"
};
private final Path dumpDir;
public static ProxyClassesDumper getInstance(String path) {
if (null == path) {
return null;
}
try {
path = path.trim();
final Path dir = Paths.get(path.length() == 0 ? "." : path);
AccessController.doPrivileged(new PrivilegedAction<Void>() {
@Override
public Void run() {
validateDumpDir(dir);
return null;
}
}, null, new FilePermission("<<ALL FILES>>", "read, write"));
return new ProxyClassesDumper(dir);
} catch (InvalidPathException ex) {
PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
.warning("Path " + path + " is not valid - dumping disabled", ex);
} catch (IllegalArgumentException iae) {
PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
.warning(iae.getMessage() + " - dumping disabled");
}
return null;
}
private ProxyClassesDumper(Path path) {
dumpDir = Objects.requireNonNull(path);
}
private static void validateDumpDir(Path path) {
if (!Files.exists(path)) {
throw new IllegalArgumentException("Directory " + path + " does not exist");
} else if (!Files.isDirectory(path)) {
throw new IllegalArgumentException("Path " + path + " is not a directory");
} else if (!Files.isWritable(path)) {
throw new IllegalArgumentException("Directory " + path + " is not writable");
}
}
public static String encodeForFilename(String className) {
final int len = className.length();
StringBuilder sb = new StringBuilder(len);
for (int i = 0; i < len; i++) {
char c = className.charAt(i);
// control characters
if (c <= 31) {
sb.append('%');
sb.append(HEX[c >> 4 & 0x0F]);
sb.append(HEX[c & 0x0F]);
} else {
int j = 0;
for (; j < BAD_CHARS.length; j++) {
if (c == BAD_CHARS[j]) {
sb.append(REPLACEMENT[j]);
break;
}
}
if (j >= BAD_CHARS.length) {
sb.append(c);
}
}
}
return sb.toString();
}
public void dumpClass(String className, final byte[] classBytes) {
Path file;
try {
file = dumpDir.resolve(encodeForFilename(className) + ".class");
} catch (InvalidPathException ex) {
PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
.warning("Invalid path for class " + className);
return;
}
try {
Path dir = file.getParent();
Files.createDirectories(dir);
Files.write(file, classBytes);
} catch (Exception ignore) {
PlatformLogger.getLogger(ProxyClassesDumper.class.getName())
.warning("Exception writing to path at " + file.toString());
// simply don't care if this operation failed
}
}
}

208
jdk/test/java/lang/invoke/lambda/LogGeneratedClassesTest.java Normal file
View File

@ -0,0 +1,208 @@
/*
* Copyright (c) 2013, Oracle and/or its affiliates. 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.
*/
/*
* @test
* @bug 8023524
* @summary tests logging generated classes for lambda
* @library /java/nio/file
* @run testng LogGeneratedClassesTest
*/
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.attribute.PosixFileAttributeView;
import java.util.stream.Stream;
import org.testng.annotations.AfterClass;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
import org.testng.SkipException;
import static java.nio.file.attribute.PosixFilePermissions.*;
import static org.testng.Assert.assertEquals;
import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
public class LogGeneratedClassesTest extends LUtils {
String longFQCN;
@BeforeClass
public void setup() throws IOException {
final List<String> scratch = new ArrayList<>();
scratch.clear();
scratch.add("package com.example;");
scratch.add("public class TestLambda {");
scratch.add(" interface I {");
scratch.add(" int foo();");
scratch.add(" }");
scratch.add(" public static void main(String[] args) {");
scratch.add(" I lam = () -> 10;");
scratch.add(" Runnable r = () -> {");
scratch.add(" System.out.println(\"Runnable\");");
scratch.add(" };");
scratch.add(" r.run();");
scratch.add(" System.out.println(\"Finish\");");
scratch.add(" }");
scratch.add("}");
File test = new File("TestLambda.java");
createFile(test, scratch);
compile("-d", ".", test.getName());
scratch.remove(0);
scratch.remove(0);
scratch.add(0, "public class LongPackageName {");
StringBuilder sb = new StringBuilder("com.example.");
// longer than 255 which exceed max length of most filesystems
for (int i = 0; i < 30; i++) {
sb.append("nonsense.");
}
sb.append("enough");
longFQCN = sb.toString() + ".LongPackageName";
sb.append(";");
sb.insert(0, "package ");
scratch.add(0, sb.toString());
test = new File("LongPackageName.java");
createFile(test, scratch);
compile("-d", ".", test.getName());
// create target
Files.createDirectory(Paths.get("dump"));
Files.createDirectories(Paths.get("dumpLong/com/example/nonsense"));
Files.createFile(Paths.get("dumpLong/com/example/nonsense/nonsense"));
Files.createFile(Paths.get("file"));
}
@AfterClass
public void cleanup() throws IOException {
Files.delete(Paths.get("TestLambda.java"));
Files.delete(Paths.get("LongPackageName.java"));
Files.delete(Paths.get("file"));
TestUtil.removeAll(Paths.get("com"));
TestUtil.removeAll(Paths.get("dump"));
TestUtil.removeAll(Paths.get("dumpLong"));
}
@Test
public void testNotLogging() {
TestResult tr = doExec(JAVA_CMD.getAbsolutePath(),
"-cp", ".",
"-Djava.security.manager",
"com.example.TestLambda");
tr.assertZero("Should still return 0");
}
@Test
public void testLogging() throws IOException {
assertTrue(Files.exists(Paths.get("dump")));
TestResult tr = doExec(JAVA_CMD.getAbsolutePath(),
"-cp", ".",
"-Djdk.internal.lambda.dumpProxyClasses=dump",
"-Djava.security.manager",
"com.example.TestLambda");
// dump/com/example + 2 class files
assertEquals(Files.walk(Paths.get("dump")).count(), 5, "Two lambda captured");
tr.assertZero("Should still return 0");
}
@Test
public void testDumpDirNotExist() throws IOException {
assertFalse(Files.exists(Paths.get("notExist")));
TestResult tr = doExec(JAVA_CMD.getAbsolutePath(),
"-cp", ".",
"-Djdk.internal.lambda.dumpProxyClasses=notExist",
"-Djava.security.manager",
"com.example.TestLambda");
assertEquals(tr.testOutput.stream()
.filter(s -> s.startsWith("WARNING"))
.peek(s -> assertTrue(s.contains("does not exist")))
.count(),
1, "only show error once");
tr.assertZero("Should still return 0");
}
@Test
public void testDumpDirIsFile() throws IOException {
assertTrue(Files.isRegularFile(Paths.get("file")));
TestResult tr = doExec(JAVA_CMD.getAbsolutePath(),
"-cp", ".",
"-Djdk.internal.lambda.dumpProxyClasses=file",
"-Djava.security.manager",
"com.example.TestLambda");
assertEquals(tr.testOutput.stream()
.filter(s -> s.startsWith("WARNING"))
.peek(s -> assertTrue(s.contains("not a directory")))
.count(),
1, "only show error once");
tr.assertZero("Should still return 0");
}
@Test
public void testDumpDirNotWritable() throws IOException {
if (! Files.getFileStore(Paths.get("."))
.supportsFileAttributeView(PosixFileAttributeView.class)) {
// No easy way to setup readonly directory
throw new SkipException("Posix not supported");
}
Files.createDirectory(Paths.get("readOnly"),
asFileAttribute(fromString("r-xr-xr-x")));
TestResult tr = doExec(JAVA_CMD.getAbsolutePath(),
"-cp", ".",
"-Djdk.internal.lambda.dumpProxyClasses=readOnly",
"-Djava.security.manager",
"com.example.TestLambda");
assertEquals(tr.testOutput.stream()
.filter(s -> s.startsWith("WARNING"))
.peek(s -> assertTrue(s.contains("not writable")))
.count(),
1, "only show error once");
tr.assertZero("Should still return 0");
TestUtil.removeAll(Paths.get("readOnly"));
}
@Test
public void testLoggingException() throws IOException {
assertTrue(Files.exists(Paths.get("dumpLong")));
TestResult tr = doExec(JAVA_CMD.getAbsolutePath(),
"-cp", ".",
"-Djdk.internal.lambda.dumpProxyClasses=dumpLong",
"-Djava.security.manager",
longFQCN);
assertEquals(tr.testOutput.stream()
.filter(s -> s.startsWith("WARNING: Exception"))
.count(),
2, "show error each capture");
// dumpLong/com/example/nosense/nosense
assertEquals(Files.walk(Paths.get("dumpLong")).count(), 5, "Two lambda captured failed to log");
tr.assertZero("Should still return 0");
}
}