1 /*
2 * Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package jdk.jfr.internal;
27
28 import java.lang.reflect.Constructor;
29 import java.lang.reflect.Field;
30 import java.lang.reflect.InvocationTargetException;
31 import java.lang.reflect.Modifier;
32 import java.util.ArrayList;
33 import java.util.List;
34 import java.util.StringJoiner;
35
36 import jdk.internal.org.objectweb.asm.ClassWriter;
37 import jdk.internal.org.objectweb.asm.Label;
38 import jdk.internal.org.objectweb.asm.MethodVisitor;
39 import jdk.internal.org.objectweb.asm.Opcodes;
40 import jdk.internal.org.objectweb.asm.Type;
41 import jdk.internal.org.objectweb.asm.commons.Method;
42 import jdk.jfr.Event;
43 import jdk.jfr.EventType;
44 import jdk.jfr.SettingControl;
45 import jdk.jfr.ValueDescriptor;
46 import jdk.jfr.internal.EventInstrumentation.FieldInfo;
47 import jdk.jfr.internal.EventInstrumentation.SettingInfo;
48 import jdk.jfr.internal.handlers.EventHandler;
49
50 final class EventHandlerCreator {
51 // TODO:
52 // How can we find out class version without loading a
53 // class as resource in a privileged block and use ASM to inspect
54 // the contents. Using '52' even though we know later versions
55 // are available. The reason for this is compatibility aspects
56 // with for example WLS.
57 private static final int CLASS_VERSION = 52;
58
59 // This is needed so a new EventHandler is automatically generated in MetadataRespoistory
60 // if a user Event class is loaded using APPCDS/CDS.
61 private static final String SUFFIX = "_" + System.currentTimeMillis() + "-" + JVM.getJVM().getPid();
62
63 private static final String FIELD_EVENT_TYPE = "platformEventType";
64 private static final String FIELD_PREFIX_STRING_POOL = "stringPool";
65
66 private final static Class<? extends EventHandler> eventHandlerProxy = EventHandlerProxyCreator.proxyClass;
67 private final static Type TYPE_STRING_POOL = Type.getType(StringPool.class);
68 private final static Type TYPE_EVENT_WRITER = Type.getType(EventWriter.class);
69 private final static Type TYPE_PLATFORM_EVENT_TYPE = Type.getType(PlatformEventType.class);
70 private final static Type TYPE_EVENT_HANDLER = Type.getType(eventHandlerProxy);
71 private final static Type TYPE_SETTING_CONTROL = Type.getType(SettingControl.class);
72 private final static Type TYPE_EVENT_TYPE = Type.getType(EventType.class);
73 private final static Type TYPE_EVENT_CONTROL = Type.getType(EventControl.class);
74 private final static String DESCRIPTOR_EVENT_HANDLER = "(" + Type.BOOLEAN_TYPE.getDescriptor() + TYPE_EVENT_TYPE.getDescriptor() + TYPE_EVENT_CONTROL.getDescriptor() + ")V";
75 private final static Method METHOD_GET_EVENT_WRITER = new Method("getEventWriter", "()" + TYPE_EVENT_WRITER.getDescriptor());
76 private final static Method METHOD_EVENT_HANDLER_CONSTRUCTOR = new Method("<init>", DESCRIPTOR_EVENT_HANDLER);
77 private final static Method METHOD_RESET = new Method("reset", "()V");
78
79 private final ClassWriter classWriter;
80 private final String className;
81 private final String internalClassName;
82 private final List<SettingInfo> settingInfos;
83 private final List<FieldInfo> fields;
84
85 public EventHandlerCreator(long id, List<SettingInfo> settingInfos, List<FieldInfo> fields) {
86 this.classWriter = new ClassWriter(ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS);
87 this.className = makeEventHandlerName(id);
88 this.internalClassName = ASMToolkit.getInternalName(className);
89 this.settingInfos = settingInfos;
90 this.fields = fields;
91 }
92
93 public static String makeEventHandlerName(long id) {
94 return eventHandlerProxy.getName() + id + SUFFIX;
95 }
96
97 public EventHandlerCreator(long id, List<SettingInfo> settingInfos, EventType type, Class<? extends Event> eventClass) {
98 this(id, settingInfos, createFieldInfos(eventClass, type));
99 }
100
101 private static List<FieldInfo> createFieldInfos(Class<? extends Event> eventClass, EventType type) throws Error {
102 List<FieldInfo> fieldInfos = new ArrayList<>();
103 for (ValueDescriptor v : type.getFields()) {
104 // Only value descriptors that are not fields on the event class.
105 if (v != TypeLibrary.STACK_TRACE_FIELD && v != TypeLibrary.THREAD_FIELD) {
106 String fieldName = PrivateAccess.getInstance().getFieldName(v);
107 String fieldDescriptor = ASMToolkit.getDescriptor(v.getTypeName());
108 Class<?> c = eventClass;
109 String internalName = null;
110 while (c != Event.class) {
111 try {
112 Field field = c.getDeclaredField(fieldName);
113 if (c == eventClass || !Modifier.isPrivate(field.getModifiers())) {
114 internalName = ASMToolkit.getInternalName(c.getName());
115 break;
116 }
117 } catch (NoSuchFieldException | SecurityException e) {
118 // ignore
119 }
120 c = c.getSuperclass();
121 }
122 if (internalName != null) {
123 fieldInfos.add(new FieldInfo(fieldName, fieldDescriptor, internalName));
124 } else {
125 throw new InternalError("Could not locate field " + fieldName + " for event type" + type.getName());
126 }
127 }
128 }
129 return fieldInfos;
130 }
131
132 public Class<? extends EventHandler> makeEventHandlerClass() {
133 buildClassInfo();
134 buildConstructor();
135 buildWriteMethod();
136 byte[] bytes = classWriter.toByteArray();
137 ASMToolkit.logASM(className, bytes);
138 return SecuritySupport.defineClass(className, bytes, Event.class.getClassLoader()).asSubclass(EventHandler.class);
139 }
140
141 public static EventHandler instantiateEventHandler(Class<? extends EventHandler> handlerClass, boolean registered, EventType eventType, EventControl eventControl) throws Error {
142 final Constructor<?> cc;
143 try {
144 cc = handlerClass.getDeclaredConstructors()[0];
145 } catch (Exception e) {
146 throw (Error) new InternalError("Could not get handler constructor for " + eventType.getName()).initCause(e);
147 }
148 // Users should not be allowed to create instances of the event handler
149 // so we need to unlock it here.
150 SecuritySupport.setAccessible(cc);
151 try {
152 List<SettingInfo> settingInfos = eventControl.getSettingInfos();
153 Object[] arguments = new Object[3 + settingInfos.size()];
154 arguments[0] = registered;
155 arguments[1] = eventType;
156 arguments[2] = eventControl;
157 for (SettingInfo si : settingInfos) {
158 arguments[si.index + 3] = si.settingControl;
159 }
160 return (EventHandler) cc.newInstance(arguments);
161 } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
162 throw (Error) new InternalError("Could not instantiate event handler for " + eventType.getName() + ". " + e.getMessage()).initCause(e);
163 }
164 }
165
166 private void buildConstructor() {
167 MethodVisitor mv = classWriter.visitMethod(Opcodes.ACC_PRIVATE, METHOD_EVENT_HANDLER_CONSTRUCTOR.getName(), makeConstructorDescriptor(settingInfos), null, null);
168 mv.visitVarInsn(Opcodes.ALOAD, 0); // this
169 mv.visitVarInsn(Opcodes.ILOAD, 1); // registered
170 mv.visitVarInsn(Opcodes.ALOAD, 2); // event type
171 mv.visitVarInsn(Opcodes.ALOAD, 3); // event control
172 mv.visitMethodInsn(Opcodes.INVOKESPECIAL, Type.getInternalName(eventHandlerProxy), METHOD_EVENT_HANDLER_CONSTRUCTOR.getName(), METHOD_EVENT_HANDLER_CONSTRUCTOR.getDescriptor(), false);
173 for (SettingInfo si : settingInfos) {
174 mv.visitVarInsn(Opcodes.ALOAD, 0); // this
175 mv.visitVarInsn(Opcodes.ALOAD, si.index + 4); // Setting Control
176 mv.visitFieldInsn(Opcodes.PUTFIELD, internalClassName, si.fieldName, TYPE_SETTING_CONTROL.getDescriptor());
177 }
178 // initialized string field writers
179 int fieldIndex = 0;
180 for (FieldInfo field : fields) {
181 if (field.isString()) {
182 mv.visitVarInsn(Opcodes.ALOAD, 0);
183 mv.visitVarInsn(Opcodes.ALOAD, 0);
184 mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, Type.getInternalName(eventHandlerProxy), "createStringFieldWriter", "()" + TYPE_STRING_POOL.getDescriptor(), false);
185 mv.visitFieldInsn(Opcodes.PUTFIELD, internalClassName, FIELD_PREFIX_STRING_POOL + fieldIndex, TYPE_STRING_POOL.getDescriptor());
186 }
187 fieldIndex++;
188 }
189 mv.visitInsn(Opcodes.RETURN);
190 mv.visitMaxs(0, 0);
191 mv.visitEnd();
192 }
193
194 private void buildClassInfo() {
195 String internalSuperName = ASMToolkit.getInternalName(eventHandlerProxy.getName());
196 classWriter.visit(CLASS_VERSION, Opcodes.ACC_PUBLIC + Opcodes.ACC_FINAL + Opcodes.ACC_SUPER, internalClassName, null, internalSuperName, null);
197 for (SettingInfo si : settingInfos) {
198 classWriter.visitField(Opcodes.ACC_PUBLIC + Opcodes.ACC_FINAL, si.fieldName, TYPE_SETTING_CONTROL.getDescriptor(), null, null);
199 }
200 int fieldIndex = 0;
201 for (FieldInfo field : fields) {
202 if (field.isString()) {
203 classWriter.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_FINAL, FIELD_PREFIX_STRING_POOL+ fieldIndex, TYPE_STRING_POOL.getDescriptor(), null, null);
204 }
205 fieldIndex++;
206 }
207 }
208
209 private void visitMethod(final MethodVisitor mv, final int opcode, final Type type, final Method method) {
210 mv.visitMethodInsn(opcode, type.getInternalName(), method.getName(), method.getDescriptor(), false);
211 }
212
213 private void buildWriteMethod() {
214 int argIndex = 0; // // indexes the argument type array, the argument type array does not include 'this'
215 int slotIndex = 1; // indexes the proper slot in the local variable table, takes type size into account, therefore sometimes argIndex != slotIndex
216 int fieldIndex = 0;
217 Method desc = ASMToolkit.makeWriteMethod(fields);
218 Type[] argumentTypes = Type.getArgumentTypes(desc.getDescriptor());
219 MethodVisitor mv = classWriter.visitMethod(Opcodes.ACC_PUBLIC, desc.getName(), desc.getDescriptor(), null, null);
220 mv.visitCode();
221 Label start = new Label();
222 Label endTryBlock = new Label();
223 Label exceptionHandler = new Label();
224 mv.visitTryCatchBlock(start, endTryBlock, exceptionHandler, "java/lang/Throwable");
225 mv.visitLabel(start);
226 visitMethod(mv, Opcodes.INVOKESTATIC, TYPE_EVENT_WRITER, METHOD_GET_EVENT_WRITER);
227 // stack: [BW]
228 mv.visitInsn(Opcodes.DUP);
229 // stack: [BW], [BW]
230 // write begin event
231 mv.visitVarInsn(Opcodes.ALOAD, 0);
232 // stack: [BW], [BW], [this]
233 mv.visitFieldInsn(Opcodes.GETFIELD, TYPE_EVENT_HANDLER.getInternalName(), FIELD_EVENT_TYPE, TYPE_PLATFORM_EVENT_TYPE.getDescriptor());
234 // stack: [BW], [BW], [BS]
235 visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, EventWriterMethod.BEGIN_EVENT.asASM());
236 // stack: [BW], [integer]
237 Label recursive = new Label();
238 mv.visitJumpInsn(Opcodes.IFEQ, recursive);
239 // stack: [BW]
240 // write startTime
241 mv.visitInsn(Opcodes.DUP);
242 // stack: [BW], [BW]
243 mv.visitVarInsn(argumentTypes[argIndex].getOpcode(Opcodes.ILOAD), slotIndex);
244 // stack: [BW], [BW], [long]
245 slotIndex += argumentTypes[argIndex++].getSize();
246 visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, EventWriterMethod.PUT_LONG.asASM());
247 // stack: [BW]
248 fieldIndex++;
249 // write duration
250 mv.visitInsn(Opcodes.DUP);
251 // stack: [BW], [BW]
252 mv.visitVarInsn(argumentTypes[argIndex].getOpcode(Opcodes.ILOAD), slotIndex);
253 // stack: [BW], [BW], [long]
254 slotIndex += argumentTypes[argIndex++].getSize();
255 visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, EventWriterMethod.PUT_LONG.asASM());
256 // stack: [BW]
257 fieldIndex++;
258 // write eventThread
259 mv.visitInsn(Opcodes.DUP);
260 // stack: [BW], [BW]
261 visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, EventWriterMethod.PUT_EVENT_THREAD.asASM());
262 // stack: [BW]
263 // write stackTrace
264 mv.visitInsn(Opcodes.DUP);
265 // stack: [BW], [BW]
266 visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, EventWriterMethod.PUT_STACK_TRACE.asASM());
267 // stack: [BW]
268 // write custom fields
269 while (fieldIndex < fields.size()) {
270 mv.visitInsn(Opcodes.DUP);
271 // stack: [BW], [BW]
272 mv.visitVarInsn(argumentTypes[argIndex].getOpcode(Opcodes.ILOAD), slotIndex);
273 // stack:[BW], [BW], [field]
274 slotIndex += argumentTypes[argIndex++].getSize();
275 FieldInfo field = fields.get(fieldIndex);
276 if (field.isString()) {
277 mv.visitVarInsn(Opcodes.ALOAD, 0);
278 // stack:[BW], [BW], [field], [this]
279 mv.visitFieldInsn(Opcodes.GETFIELD, this.internalClassName, FIELD_PREFIX_STRING_POOL + fieldIndex, TYPE_STRING_POOL.getDescriptor());
280 // stack:[BW], [BW], [field], [string]
281 }
282 EventWriterMethod eventMethod = EventWriterMethod.lookupMethod(field);
283 visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, eventMethod.asASM());
284 // stack: [BW]
285 fieldIndex++;
286 }
287 // stack: [BW]
288 // write end event (writer already on stack)
289 visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, EventWriterMethod.END_EVENT.asASM());
290 // stack [integer]
291 // notified -> restart event write attempt
292 mv.visitJumpInsn(Opcodes.IFEQ, start);
293 // stack:
294 mv.visitLabel(endTryBlock);
295 Label end = new Label();
296 mv.visitJumpInsn(Opcodes.GOTO, end);
297 mv.visitLabel(exceptionHandler);
298 // stack: [ex]
299 mv.visitFrame(Opcodes.F_SAME1, 0, null, 1, new Object[] {"java/lang/Throwable"});
300 visitMethod(mv, Opcodes.INVOKESTATIC, TYPE_EVENT_WRITER, METHOD_GET_EVENT_WRITER);
301 // stack: [ex] [BW]
302 mv.visitInsn(Opcodes.DUP);
303 // stack: [ex] [BW] [BW]
304 Label rethrow = new Label();
305 mv.visitJumpInsn(Opcodes.IFNULL, rethrow);
306 // stack: [ex] [BW]
307 mv.visitInsn(Opcodes.DUP);
308 // stack: [ex] [BW] [BW]
309 visitMethod(mv, Opcodes.INVOKEVIRTUAL, TYPE_EVENT_WRITER, METHOD_RESET);
310 mv.visitLabel(rethrow);
311 // stack:[ex] [BW]
312 mv.visitFrame(Opcodes.F_SAME, 0, null, 2, new Object[] {"java/lang/Throwable", TYPE_EVENT_WRITER.getInternalName()});
313 mv.visitInsn(Opcodes.POP);
314 // stack:[ex]
315 mv.visitInsn(Opcodes.ATHROW);
316 mv.visitLabel(recursive);
317 // stack: [BW]
318 mv.visitFrame(Opcodes.F_SAME, 0, null, 1, new Object[] { TYPE_EVENT_WRITER.getInternalName()} );
319 mv.visitInsn(Opcodes.POP);
320 mv.visitLabel(end);
321 // stack:
322 mv.visitFrame(Opcodes.F_SAME, 0, null, 0, null);
323 mv.visitInsn(Opcodes.RETURN);
324 mv.visitMaxs(0, 0);
325 mv.visitEnd();
326 }
327
328 private static String makeConstructorDescriptor(List<SettingInfo> settingsInfos) {
329 StringJoiner constructordescriptor = new StringJoiner("", "(", ")V");
330 constructordescriptor.add(Type.BOOLEAN_TYPE.getDescriptor());
331 constructordescriptor.add(Type.getType(EventType.class).getDescriptor());
332 constructordescriptor.add(Type.getType(EventControl.class).getDescriptor());
333 for (int i = 0; i < settingsInfos.size(); i++) {
334 constructordescriptor.add(TYPE_SETTING_CONTROL.getDescriptor());
335 }
336 return constructordescriptor.toString();
337 }
338 }