--- /dev/null 2019-02-07 20:54:51.336000000 +0300 +++ new/src/share/classes/jdk/jfr/internal/EventHandlerCreator.java 2019-02-08 18:32:30.230368064 +0300 @@ -0,0 +1,337 @@ +/* + * Copyright (c) 2016, 2018, 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 jdk.jfr.internal; + +import java.lang.reflect.Constructor; +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Modifier; +import java.util.ArrayList; +import java.util.List; +import java.util.StringJoiner; + +import jdk.internal.org.objectweb.asm.ClassWriter; +import jdk.internal.org.objectweb.asm.Label; +import jdk.internal.org.objectweb.asm.MethodVisitor; +import jdk.internal.org.objectweb.asm.Opcodes; +import jdk.internal.org.objectweb.asm.Type; +import jdk.internal.org.objectweb.asm.commons.Method; +import jdk.jfr.Event; +import jdk.jfr.EventType; +import jdk.jfr.SettingControl; +import jdk.jfr.ValueDescriptor; +import jdk.jfr.internal.EventInstrumentation.FieldInfo; +import jdk.jfr.internal.EventInstrumentation.SettingInfo; +import jdk.jfr.internal.handlers.EventHandler; + +final class EventHandlerCreator { + // TODO: + // How can we find out class version without loading a + // class as resource in a privileged block and use ASM to inspect + // the contents. Using '52' even though we know later versions + // are available. The reason for this is compatibility aspects + // with for example WLS. + private static final int CLASS_VERSION = 52; + + // This is needed so a new EventHandler is automatically generated in MetadataRespoistory + // if a user Event class is loaded using APPCDS/CDS. + private static final String SUFFIX = "_" + System.currentTimeMillis() + "-" + JVM.getJVM().getPid(); + + private static final String FIELD_EVENT_TYPE = "platformEventType"; + private static final String FIELD_PREFIX_STRING_POOL = "stringPool"; + + private final static Type TYPE_STRING_POOL = Type.getType(StringPool.class); + private final static Type TYPE_EVENT_WRITER = Type.getType(EventWriter.class); + private final static Type TYPE_PLATFORM_EVENT_TYPE = Type.getType(PlatformEventType.class); + private final static Type TYPE_EVENT_HANDLER = Type.getType(EventHandler.class); + private final static Type TYPE_SETTING_CONTROL = Type.getType(SettingControl.class); + private final static Type TYPE_EVENT_TYPE = Type.getType(EventType.class); + private final static Type TYPE_EVENT_CONTROL = Type.getType(EventControl.class); + private final static String DESCRIPTOR_EVENT_HANDLER = "(" + Type.BOOLEAN_TYPE.getDescriptor() + TYPE_EVENT_TYPE.getDescriptor() + TYPE_EVENT_CONTROL.getDescriptor() + ")V"; + private final static Method METHOD_GET_EVENT_WRITER = new Method("getEventWriter", "()" + TYPE_EVENT_WRITER.getDescriptor()); + private final static Method METHOD_EVENT_HANDLER_CONSTRUCTOR = new Method("", DESCRIPTOR_EVENT_HANDLER); + private final static Method METHOD_RESET = new Method("reset", "()V"); + + private final ClassWriter classWriter; + private final String className; + private final String internalClassName; + private final List settingInfos; + private final List fields; + + public EventHandlerCreator(long id, List settingInfos, List fields) { + this.classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS); + this.className = makeEventHandlerName(id); + this.internalClassName = ASMToolkit.getInternalName(className); + this.settingInfos = settingInfos; + this.fields = fields; + } + + public static String makeEventHandlerName(long id) { + return EventHandler.class.getName() + id + SUFFIX; + } + + public EventHandlerCreator(long id, List settingInfos, EventType type, Class eventClass) { + this(id, settingInfos, createFieldInfos(eventClass, type)); + } + + private static List createFieldInfos(Class eventClass, EventType type) throws Error { + List fieldInfos = new ArrayList<>(); + for (ValueDescriptor v : type.getFields()) { + // Only value descriptors that are not fields on the event class. + if (v != TypeLibrary.STACK_TRACE_FIELD && v != TypeLibrary.THREAD_FIELD) { + String fieldName = PrivateAccess.getInstance().getFieldName(v); + String fieldDescriptor = ASMToolkit.getDescriptor(v.getTypeName()); + Class c = eventClass; + String internalName = null; + while (c != Event.class) { + try { + Field field = c.getDeclaredField(fieldName); + if (c == eventClass || !Modifier.isPrivate(field.getModifiers())) { + internalName = ASMToolkit.getInternalName(c.getName()); + break; + } + } catch (NoSuchFieldException | SecurityException e) { + // ignore + } + c = c.getSuperclass(); + } + if (internalName != null) { + fieldInfos.add(new FieldInfo(fieldName, fieldDescriptor, internalName)); + } else { + throw new InternalError("Could not locate field " + fieldName + " for event type" + type.getName()); + } + } + } + return fieldInfos; + } + + public Class makeEventHandlerClass() { + buildClassInfo(); + buildConstructor(); + buildWriteMethod(); + byte[] bytes = classWriter.toByteArray(); + ASMToolkit.logASM(className, bytes); + return SecuritySupport.defineClass(className, bytes, Event.class.getClassLoader()).asSubclass(EventHandler.class); + } + + public static EventHandler instantiateEventHandler(Class handlerClass, boolean registered, EventType eventType, EventControl eventControl) throws Error { + final Constructor cc; + try { + cc = handlerClass.getDeclaredConstructors()[0]; + } catch (Exception e) { + throw (Error) new InternalError("Could not get handler constructor for " + eventType.getName()).initCause(e); + } + // Users should not be allowed to create instances of the event handler + // so we need to unlock it here. + SecuritySupport.setAccessible(cc); + try { + List settingInfos = eventControl.getSettingInfos(); + Object[] arguments = new Object[3 + settingInfos.size()]; + arguments[0] = registered; + arguments[1] = eventType; + arguments[2] = eventControl; + for (SettingInfo si : settingInfos) { + arguments[si.index + 3] = si.settingControl; + } + return (EventHandler) cc.newInstance(arguments); + } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) { + throw (Error) new InternalError("Could not instantiate event handler for " + eventType.getName() + ". " + e.getMessage()).initCause(e); + } + } + + private void buildConstructor() { + MethodVisitor mv = classWriter.visitMethod(Opcodes.ACC_PRIVATE, METHOD_EVENT_HANDLER_CONSTRUCTOR.getName(), makeConstructorDescriptor(settingInfos), null, null); + mv.visitVarInsn(Opcodes.ALOAD, 0); // this + mv.visitVarInsn(Opcodes.ILOAD, 1); // registered + mv.visitVarInsn(Opcodes.ALOAD, 2); // event type + mv.visitVarInsn(Opcodes.ALOAD, 3); // event control + mv.visitMethodInsn(Opcodes.INVOKESPECIAL, Type.getInternalName(EventHandler.class), METHOD_EVENT_HANDLER_CONSTRUCTOR.getName(), METHOD_EVENT_HANDLER_CONSTRUCTOR.getDescriptor(), false); + for (SettingInfo si : settingInfos) { + mv.visitVarInsn(Opcodes.ALOAD, 0); // this + mv.visitVarInsn(Opcodes.ALOAD, si.index + 4); // Setting Control + mv.visitFieldInsn(Opcodes.PUTFIELD, internalClassName, si.fieldName, TYPE_SETTING_CONTROL.getDescriptor()); + } + // initialized string field writers + int fieldIndex = 0; + for (FieldInfo field : fields) { + if (field.isString()) { + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitVarInsn(Opcodes.ALOAD, 0); + mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, Type.getInternalName(EventHandler.class), "createStringFieldWriter", "()" + TYPE_STRING_POOL.getDescriptor(), false); + mv.visitFieldInsn(Opcodes.PUTFIELD, internalClassName, FIELD_PREFIX_STRING_POOL + fieldIndex, TYPE_STRING_POOL.getDescriptor()); + } + fieldIndex++; + } + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + private void buildClassInfo() { + String internalSuperName = ASMToolkit.getInternalName(EventHandler.class.getName()); + classWriter.visit(CLASS_VERSION, Opcodes.ACC_PUBLIC + Opcodes.ACC_FINAL + Opcodes.ACC_SUPER, internalClassName, null, internalSuperName, null); + for (SettingInfo si : settingInfos) { + classWriter.visitField(Opcodes.ACC_PUBLIC + Opcodes.ACC_FINAL, si.fieldName, TYPE_SETTING_CONTROL.getDescriptor(), null, null); + } + int fieldIndex = 0; + for (FieldInfo field : fields) { + if (field.isString()) { + classWriter.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL, FIELD_PREFIX_STRING_POOL+ fieldIndex, TYPE_STRING_POOL.getDescriptor(), null, null); + } + fieldIndex++; + } + } + + private void visitMethod(final MethodVisitor mv, final int opcode, final Type type, final Method method) { + mv.visitMethodInsn(opcode, type.getInternalName(), method.getName(), method.getDescriptor(), false); + } + + private void buildWriteMethod() { + int argIndex = 0; // // indexes the argument type array, the argument type array does not include 'this' + int slotIndex = 1; // indexes the proper slot in the local variable table, takes type size into account, therefore sometimes argIndex != slotIndex + int fieldIndex = 0; + Method desc = ASMToolkit.makeWriteMethod(fields); + Type[] argumentTypes = Type.getArgumentTypes(desc.getDescriptor()); + MethodVisitor mv = classWriter.visitMethod(Opcodes.ACC_PUBLIC, desc.getName(), desc.getDescriptor(), null, null); + mv.visitCode(); + Label start = new Label(); + Label endTryBlock = new Label(); + Label exceptionHandler = new Label(); + mv.visitTryCatchBlock(start, endTryBlock, exceptionHandler, "java/lang/Throwable"); + mv.visitLabel(start); + visitMethod(mv, Opcodes.INVOKESTATIC, TYPE_EVENT_WRITER, METHOD_GET_EVENT_WRITER); + // stack: [BW] + mv.visitInsn(Opcodes.DUP); + // stack: [BW], [BW] + // write begin event + mv.visitVarInsn(Opcodes.ALOAD, 0); + // stack: [BW], [BW], [this] + mv.visitFieldInsn(Opcodes.GETFIELD, TYPE_EVENT_HANDLER.getInternalName(), FIELD_EVENT_TYPE, TYPE_PLATFORM_EVENT_TYPE.getDescriptor()); + // stack: [BW], [BW], [BS] + visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, EventWriterMethod.BEGIN_EVENT.asASM()); + // stack: [BW], [integer] + Label recursive = new Label(); + mv.visitJumpInsn(Opcodes.IFEQ, recursive); + // stack: [BW] + // write startTime + mv.visitInsn(Opcodes.DUP); + // stack: [BW], [BW] + mv.visitVarInsn(argumentTypes[argIndex].getOpcode(Opcodes.ILOAD), slotIndex); + // stack: [BW], [BW], [long] + slotIndex += argumentTypes[argIndex++].getSize(); + visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, EventWriterMethod.PUT_LONG.asASM()); + // stack: [BW] + fieldIndex++; + // write duration + mv.visitInsn(Opcodes.DUP); + // stack: [BW], [BW] + mv.visitVarInsn(argumentTypes[argIndex].getOpcode(Opcodes.ILOAD), slotIndex); + // stack: [BW], [BW], [long] + slotIndex += argumentTypes[argIndex++].getSize(); + visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, EventWriterMethod.PUT_LONG.asASM()); + // stack: [BW] + fieldIndex++; + // write eventThread + mv.visitInsn(Opcodes.DUP); + // stack: [BW], [BW] + visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, EventWriterMethod.PUT_EVENT_THREAD.asASM()); + // stack: [BW] + // write stackTrace + mv.visitInsn(Opcodes.DUP); + // stack: [BW], [BW] + visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, EventWriterMethod.PUT_STACK_TRACE.asASM()); + // stack: [BW] + // write custom fields + while (fieldIndex < fields.size()) { + mv.visitInsn(Opcodes.DUP); + // stack: [BW], [BW] + mv.visitVarInsn(argumentTypes[argIndex].getOpcode(Opcodes.ILOAD), slotIndex); + // stack:[BW], [BW], [field] + slotIndex += argumentTypes[argIndex++].getSize(); + FieldInfo field = fields.get(fieldIndex); + if (field.isString()) { + mv.visitVarInsn(Opcodes.ALOAD, 0); + // stack:[BW], [BW], [field], [this] + mv.visitFieldInsn(Opcodes.GETFIELD, this.internalClassName, FIELD_PREFIX_STRING_POOL + fieldIndex, TYPE_STRING_POOL.getDescriptor()); + // stack:[BW], [BW], [field], [string] + } + EventWriterMethod eventMethod = EventWriterMethod.lookupMethod(field); + visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, eventMethod.asASM()); + // stack: [BW] + fieldIndex++; + } + // stack: [BW] + // write end event (writer already on stack) + visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, EventWriterMethod.END_EVENT.asASM()); + // stack [integer] + // notified -> restart event write attempt + mv.visitJumpInsn(Opcodes.IFEQ, start); + // stack: + mv.visitLabel(endTryBlock); + Label end = new Label(); + mv.visitJumpInsn(Opcodes.GOTO, end); + mv.visitLabel(exceptionHandler); + // stack: [ex] + mv.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {"java/lang/Throwable"}); + visitMethod(mv, Opcodes.INVOKESTATIC, TYPE_EVENT_WRITER, METHOD_GET_EVENT_WRITER); + // stack: [ex] [BW] + mv.visitInsn(Opcodes.DUP); + // stack: [ex] [BW] [BW] + Label rethrow = new Label(); + mv.visitJumpInsn(Opcodes.IFNULL, rethrow); + // stack: [ex] [BW] + mv.visitInsn(Opcodes.DUP); + // stack: [ex] [BW] [BW] + visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, METHOD_RESET); + mv.visitLabel(rethrow); + // stack:[ex] [BW] + mv.visitFrame(Opcodes.F_SAME, 0, null, 2, new Object[] {"java/lang/Throwable", TYPE_EVENT_WRITER.getInternalName()}); + mv.visitInsn(Opcodes.POP); + // stack:[ex] + mv.visitInsn(Opcodes.ATHROW); + mv.visitLabel(recursive); + // stack: [BW] + mv.visitFrame(Opcodes.F_SAME, 0, null, 1, new Object[] { TYPE_EVENT_WRITER.getInternalName()} ); + mv.visitInsn(Opcodes.POP); + mv.visitLabel(end); + // stack: + mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null); + mv.visitInsn(Opcodes.RETURN); + mv.visitMaxs(0, 0); + mv.visitEnd(); + } + + private static String makeConstructorDescriptor(List settingsInfos) { + StringJoiner constructordescriptor = new StringJoiner("", "(", ")V"); + constructordescriptor.add(Type.BOOLEAN_TYPE.getDescriptor()); + constructordescriptor.add(Type.getType(EventType.class).getDescriptor()); + constructordescriptor.add(Type.getType(EventControl.class).getDescriptor()); + for (int i = 0; i < settingsInfos.size(); i++) { + constructordescriptor.add(TYPE_SETTING_CONTROL.getDescriptor()); + } + return constructordescriptor.toString(); + } +}