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.annotation.Annotation;
29 import java.lang.reflect.Constructor;
30 import java.lang.reflect.InvocationTargetException;
31 import java.lang.reflect.Method;
32 import java.lang.reflect.Modifier;
33 import java.util.ArrayList;
34 import java.util.Collections;
35 import java.util.HashMap;
36 import java.util.List;
37 import java.util.Map;
38 import java.util.Map.Entry;
39 import java.util.Set;
40
41 import jdk.internal.module.Modules;
42 import jdk.jfr.AnnotationElement;
43 import jdk.jfr.Enabled;
44 import jdk.jfr.Event;
45 import jdk.jfr.Name;
46 import jdk.jfr.Period;
47 import jdk.jfr.SettingControl;
48 import jdk.jfr.SettingDefinition;
49 import jdk.jfr.StackTrace;
50 import jdk.jfr.Threshold;
51 import jdk.jfr.events.ActiveSettingEvent;
52 import jdk.jfr.internal.EventInstrumentation.SettingInfo;
53 import jdk.jfr.internal.settings.CutoffSetting;
54 import jdk.jfr.internal.settings.EnabledSetting;
55 import jdk.jfr.internal.settings.PeriodSetting;
56 import jdk.jfr.internal.settings.StackTraceSetting;
57 import jdk.jfr.internal.settings.ThresholdSetting;
58
59 // This class can't have a hard reference from PlatformEventType, since it
60 // holds SettingControl instances that need to be released
61 // when a class is unloaded (to avoid memory leaks).
62 public final class EventControl {
63
64 static final String FIELD_SETTING_PREFIX = "setting";
65 private static final Type TYPE_ENABLED = TypeLibrary.createType(EnabledSetting.class);
66 private static final Type TYPE_THRESHOLD = TypeLibrary.createType(ThresholdSetting.class);
67 private static final Type TYPE_STACK_TRACE = TypeLibrary.createType(StackTraceSetting.class);
68 private static final Type TYPE_PERIOD = TypeLibrary.createType(PeriodSetting.class);
69 private static final Type TYPE_CUTOFF = TypeLibrary.createType(CutoffSetting.class);
70
71 private final List<SettingInfo> settingInfos = new ArrayList<>();
72 private final Map<String, Control> eventControls = new HashMap<>(5);
73 private final PlatformEventType type;
74 private final String idName;
75
76 EventControl(PlatformEventType eventType) {
77 eventControls.put(Enabled.NAME, defineEnabled(eventType));
78 if (eventType.hasDuration()) {
79 eventControls.put(Threshold.NAME, defineThreshold(eventType));
80 }
81 if (eventType.hasStackTrace()) {
82 eventControls.put(StackTrace.NAME, defineStackTrace(eventType));
83 }
84 if (eventType.hasPeriod()) {
85 eventControls.put(Period.NAME, definePeriod(eventType));
86 }
87 if (eventType.hasCutoff()) {
88 eventControls.put(Cutoff.NAME, defineCutoff(eventType));
89 }
90
91 ArrayList<AnnotationElement> aes = new ArrayList<>(eventType.getAnnotationElements());
92 remove(eventType, aes, Threshold.class);
93 remove(eventType, aes, Period.class);
94 remove(eventType, aes, Enabled.class);
95 remove(eventType, aes, StackTrace.class);
96 remove(eventType, aes, Cutoff.class);
97 aes.trimToSize();
98 eventType.setAnnotations(aes);
99 this.type = eventType;
100 this.idName = String.valueOf(eventType.getId());
101 }
102
103 static void remove(PlatformEventType type, List<AnnotationElement> aes, Class<? extends java.lang.annotation.Annotation> clazz) {
104 long id = Type.getTypeId(clazz);
105 for (AnnotationElement a : type.getAnnotationElements()) {
106 if (a.getTypeId() == id && a.getTypeName().equals(clazz.getName())) {
107 aes.remove(a);
108 }
109 }
110 }
111
112 EventControl(PlatformEventType es, Class<? extends Event> eventClass) {
113 this(es);
114 defineSettings(eventClass);
115 }
116
117 @SuppressWarnings("unchecked")
118 private void defineSettings(Class<?> eventClass) {
119 // Iterate up the class hierarchy and let
120 // subclasses shadow base classes.
121 boolean allowPrivateMethod = true;
122 while (eventClass != null) {
123 for (Method m : eventClass.getDeclaredMethods()) {
124 boolean isPrivate = Modifier.isPrivate(m.getModifiers());
125 if (m.getReturnType() == Boolean.TYPE && m.getParameterCount() == 1 && (!isPrivate || allowPrivateMethod)) {
126 SettingDefinition se = m.getDeclaredAnnotation(SettingDefinition.class);
127 if (se != null) {
128 Class<?> settingClass = m.getParameters()[0].getType();
129 if (!Modifier.isAbstract(settingClass.getModifiers()) && SettingControl.class.isAssignableFrom(settingClass)) {
130 String name = m.getName();
131 Name n = m.getAnnotation(Name.class);
132 if (n != null) {
133 name = n.value();
134 }
135 if (!eventControls.containsKey(name)) {
136 defineSetting((Class<? extends SettingControl>) settingClass, m, type, name);
137 }
138 }
139 }
140 }
141 }
142 eventClass = eventClass.getSuperclass();
143 allowPrivateMethod = false;
144 }
145 }
146
147 private void defineSetting(Class<? extends SettingControl> settingsClass, Method method, PlatformEventType eventType, String settingName) {
148 try {
149 Module settingModule = settingsClass.getModule();
150 Modules.addReads(settingModule, EventControl.class.getModule());
151 int index = settingInfos.size();
152 SettingInfo si = new SettingInfo(FIELD_SETTING_PREFIX + index, index);
153 si.settingControl = instantiateSettingControl(settingsClass);
154 Control c = si.settingControl;
155 c.setDefault();
156 String defaultValue = c.getValueSafe();
157 if (defaultValue != null) {
158 Type settingType = TypeLibrary.createType(settingsClass);
159 ArrayList<AnnotationElement> aes = new ArrayList<>();
160 for (Annotation a : method.getDeclaredAnnotations()) {
161 AnnotationElement ae = TypeLibrary.createAnnotation(a);
162 if (ae != null) {
163 aes.add(ae);
164 }
165 }
166 aes.trimToSize();
167 eventControls.put(settingName, si.settingControl);
168 eventType.add(PrivateAccess.getInstance().newSettingDescriptor(settingType, settingName, defaultValue, aes));
169 settingInfos.add(si);
170 }
171 } catch (InstantiationException e) {
172 // Programming error by user, fail fast
173 throw new InstantiationError("Could not instantiate setting " + settingsClass.getName() + " for event " + eventType.getLogName() + ". " + e.getMessage());
174 } catch (IllegalAccessException e) {
175 // Programming error by user, fail fast
176 throw new IllegalAccessError("Could not access setting " + settingsClass.getName() + " for event " + eventType.getLogName() + ". " + e.getMessage());
177 }
178 }
179
180 private SettingControl instantiateSettingControl(Class<? extends SettingControl> settingControlClass) throws IllegalAccessException, InstantiationException {
181 SecuritySupport.makeVisibleToJFR(settingControlClass);
182 final Constructor<?> cc;
183 try {
184 cc = settingControlClass.getDeclaredConstructors()[0];
185 } catch (Exception e) {
186 throw (Error) new InternalError("Could not get constructor for " + settingControlClass.getName()).initCause(e);
187 }
188 SecuritySupport.setAccessible(cc);
189 try {
190 return (SettingControl) cc.newInstance();
191 } catch (IllegalArgumentException | InvocationTargetException e) {
192 throw (Error) new InternalError("Could not instantiate setting for class " + settingControlClass.getName());
193 }
194 }
195
196 private static Control defineEnabled(PlatformEventType type) {
197 Enabled enabled = type.getAnnotation(Enabled.class);
198 // Java events are enabled by default,
199 // JVM events are not, maybe they should be? Would lower learning curve
200 // there too.
201 String def = type.isJVM() ? "false" : "true";
202 if (enabled != null) {
203 def = Boolean.toString(enabled.value());
204 }
205 type.add(PrivateAccess.getInstance().newSettingDescriptor(TYPE_ENABLED, Enabled.NAME, def, Collections.emptyList()));
206 return new EnabledSetting(type, def);
207 }
208
209 private static Control defineThreshold(PlatformEventType type) {
210 Threshold threshold = type.getAnnotation(Threshold.class);
211 String def = "0 ns";
212 if (threshold != null) {
213 def = threshold.value();
214 }
215 type.add(PrivateAccess.getInstance().newSettingDescriptor(TYPE_THRESHOLD, Threshold.NAME, def, Collections.emptyList()));
216 return new ThresholdSetting(type, def);
217 }
218
219 private static Control defineStackTrace(PlatformEventType type) {
220 StackTrace stackTrace = type.getAnnotation(StackTrace.class);
221 String def = "true";
222 if (stackTrace != null) {
223 def = Boolean.toString(stackTrace.value());
224 }
225 type.add(PrivateAccess.getInstance().newSettingDescriptor(TYPE_STACK_TRACE, StackTrace.NAME, def, Collections.emptyList()));
226 return new StackTraceSetting(type, def);
227 }
228
229 private static Control defineCutoff(PlatformEventType type) {
230 Cutoff cutoff = type.getAnnotation(Cutoff.class);
231 String def = Cutoff.INIFITY;
232 if (cutoff != null) {
233 def = cutoff.value();
234 }
235 type.add(PrivateAccess.getInstance().newSettingDescriptor(TYPE_CUTOFF, Cutoff.NAME, def, Collections.emptyList()));
236 return new CutoffSetting(type, def);
237 }
238
239
240 private static Control definePeriod(PlatformEventType type) {
241 Period period = type.getAnnotation(Period.class);
242 String def = "everyChunk";
243 if (period != null) {
244 def = period.value();
245 }
246 type.add(PrivateAccess.getInstance().newSettingDescriptor(TYPE_PERIOD, PeriodSetting.NAME, def, Collections.emptyList()));
247 return new PeriodSetting(type, def);
248 }
249
250 void disable() {
251 for (Control c : eventControls.values()) {
252 if (c instanceof EnabledSetting) {
253 c.setValueSafe("false");
254 return;
255 }
256 }
257 }
258
259 void writeActiveSettingEvent() {
260 if (!type.isRegistered()) {
261 return;
262 }
263 for (Map.Entry<String, Control> entry : eventControls.entrySet()) {
264 Control c = entry.getValue();
265 if (Utils.isSettingVisible(c, type.hasEventHook())) {
266 String value = c.getLastValue();
267 if (value == null) {
268 value = c.getDefaultValue();
269 }
270 ActiveSettingEvent ase = new ActiveSettingEvent();
271 ase.id = type.getId();
272 ase.name = entry.getKey();
273 ase.value = value;
274 ase.commit();
275 }
276 }
277 }
278
279 public Set<Entry<String, Control>> getEntries() {
280 return eventControls.entrySet();
281 }
282
283 public PlatformEventType getEventType() {
284 return type;
285 }
286
287 public String getSettingsId() {
288 return idName;
289 }
290
291 public List<SettingInfo> getSettingInfos() {
292 return settingInfos;
293 }
294 }