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.util.ArrayList;
29 import java.util.Collection;
30 import java.util.Collections;
31 import java.util.HashMap;
32 import java.util.HashSet;
33 import java.util.LinkedHashMap;
34 import java.util.List;
35 import java.util.Map;
36 import java.util.Map.Entry;
37 import java.util.Set;
38 import java.util.StringJoiner;
39
40 import jdk.jfr.Event;
41 import jdk.jfr.internal.handlers.EventHandler;
42
43 final class SettingsManager {
44
45 private static class InternalSetting {
46
47 private final String identifier;
48 private Map<String, Set<String>> enabledMap = new LinkedHashMap<>(5);
49 private Map<String, Set<String>> allMap = new LinkedHashMap<>(5);
50 private boolean enabled;
51
52 /**
53 * Settings identifier, for example "com.example.HelloWorld" or "56"
54 * (id of event)
55 *
56 * @param settingsId
57 */
58 public InternalSetting(String settingsId) {
59 this.identifier = settingsId;
60 }
61
62 public Set<String> getValues(String key) {
63 if (enabled) {
64 return enabledMap.get(key);
65 } else {
66 return allMap.get(key);
67 }
68 }
69
70 public void add(String attribute, String value) {
71 if ("enabled".equals(attribute) && "true".equals(value)) {
72 enabled = true;
73 allMap = null; // no need to keep these around
74 }
75 addToMap(enabledMap, attribute, value);
76 if (allMap != null) {
77 addToMap(allMap, attribute, value);
78 }
79 }
80
81 private void addToMap(Map<String, Set<String>> map, String attribute, String value) {
82 Set<String> values = map.get(attribute);
83 if (values == null) {
84 values = new HashSet<String>(5);
85 map.put(attribute, values);
86 }
87 values.add(value);
88
89 }
90
91 public String getSettingsId() {
92 return identifier;
93 }
94
95 public void add(InternalSetting enabled) {
96 for (Map.Entry<String, Set<String>> entry : enabled.enabledMap.entrySet()) {
97 for (String value : entry.getValue()) {
98 add(entry.getKey(), value);
99 }
100 }
101 }
102
103 public boolean isEnabled() {
104 return enabled;
105 }
106
107 @Override
108 public String toString() {
109 StringBuilder sb = new StringBuilder();
110 sb.append(identifier);
111 sb.append(": ");
112 sb.append(enabledMap.toString());
113 return sb.toString();
114 }
115
116 public void finish() {
117 if (!enabled) {
118 // settings from disabled
119 // events should not impact results, but
120 // we can't clear enabledMap since enabled=false
121 // needs be there, so events that are enabled
122 // by default are turned off
123 Map<String, Set<String>> disabledMap = new HashMap<>(2);
124 Set<String> values = new HashSet<>(2);
125 values.add("false");
126 disabledMap.put("enabled", values);
127 enabledMap = disabledMap;
128 }
129 }
130 }
131
132 private Map<String, InternalSetting> availableSettings = new LinkedHashMap<>();
133
134 void setSettings(List<Map<String, String>> activeSettings) {
135 // store settings so they are available if a new event class is loaded
136 availableSettings = createSettingsMap(activeSettings);
137 List<EventControl> eventControls = MetadataRepository.getInstance().getEventControls();
138 if (!JVM.getJVM().isRecording()) {
139 for (EventControl ec : eventControls) {
140 ec.disable();
141 }
142 } else {
143 if (LogTag.JFR_SETTING.shouldLog(LogLevel.INFO.level)) {
144 Collections.sort(eventControls, (x,y) -> x.getEventType().getName().compareTo(y.getEventType().getName()));
145 }
146 for (EventControl ec : eventControls) {
147 setEventControl(ec);
148 }
149 }
150 if (JVM.getJVM().getAllowedToDoEventRetransforms()) {
151 updateRetransform(JVM.getJVM().getAllEventClasses());
152 }
153 }
154
155 public void updateRetransform(List<Class<? extends Event>> eventClasses) {
156 List<Class<?>> classes = new ArrayList<>();
157 for(Class<? extends Event> eventClass: eventClasses) {
158 EventHandler eh = Utils.getHandler(eventClass);
159 if (eh != null ) {
160 PlatformEventType eventType = eh.getPlatformEventType();
161 if (eventType.isMarkedForInstrumentation()) {
162 classes.add(eventClass);
163 eventType.markForInstrumentation(false);
164 // A bit premature to set it here, but hard to check
165 // after call to retransformClasses.
166 eventType.setInstrumented();
167 }
168 }
169 }
170 if (!classes.isEmpty()) {
171 JVM.getJVM().retransformClasses(classes.toArray(new Class<?>[0]));
172 }
173 }
174
175 private Map<String, InternalSetting> createSettingsMap(List<Map<String,String>> activeSettings) {
176 Map<String, InternalSetting> map = new LinkedHashMap<>(activeSettings.size());
177 for (Map<String, String> rec : activeSettings) {
178 for (InternalSetting internal : makeInternalSettings(rec)) {
179 InternalSetting is = map.get(internal.getSettingsId());
180 if (is == null) {
181 map.put(internal.getSettingsId(), internal);
182 } else {
183 is.add(internal);
184 }
185 }
186 }
187 return map;
188 }
189
190 private Collection<InternalSetting> makeInternalSettings(Map<String, String> rec) {
191 Map<String, InternalSetting> internals = new LinkedHashMap<>();
192 for (Map.Entry<String, String> entry : rec.entrySet()) {
193 String key = entry.getKey();
194 String value = entry.getValue();
195 int index = key.indexOf("#");
196 if (index > 1 && index < key.length() - 2) {
197 String eventName = key.substring(0, index);
198 eventName = Utils.upgradeLegacyJDKEvent(eventName);
199 InternalSetting s = internals.get(eventName);
200 String settingName = key.substring(index + 1).trim();
201 if (s == null) {
202 s = new InternalSetting(eventName);
203 internals.put(eventName, s);
204 }
205 s.add(settingName, value);
206 }
207 }
208 for (InternalSetting s : internals.values()) {
209 s.finish();
210 }
211
212 return internals.values();
213 }
214
215 void setEventControl(EventControl ec) {
216 InternalSetting is = getInternalSetting(ec);
217 Logger.log(LogTag.JFR_SETTING, LogLevel.INFO, "Applied settings for " + ec.getEventType().getLogName() + " {");
218 for (Entry<String, Control> entry : ec.getEntries()) {
219 Set<String> values = null;
220 String settingName = entry.getKey();
221 if (is != null) {
222 values = is.getValues(settingName);
223 }
224 Control control = entry.getValue();
225 if (values != null) {
226 control.apply(values);
227 String after = control.getLastValue();
228 if (LogTag.JFR_SETTING.shouldLog(LogLevel.INFO.level)) {
229 if (Utils.isSettingVisible(control, ec.getEventType().hasEventHook())) {
230 if (values.size() > 1) {
231 StringJoiner sj = new StringJoiner(", ", "{", "}");
232 for (String s : values) {
233 sj.add("\"" + s + "\"");
234 }
235 String message = " " + settingName + "= " + sj.toString() + " => \"" + after + "\"";
236 Logger.log(LogTag.JFR_SETTING, LogLevel.INFO, message);
237 } else {
238 String message = " " + settingName + "=\"" + control.getLastValue() + "\"";
239 Logger.log(LogTag.JFR_SETTING, LogLevel.INFO, message);
240 }
241 }
242 }
243 } else {
244 control.setDefault();
245 if (LogTag.JFR_SETTING.shouldLog(LogLevel.INFO.level)) {
246 String message = " " + settingName + "=\"" + control.getLastValue() + "\"";
247 Logger.log(LogTag.JFR_SETTING, LogLevel.INFO, message);
248 }
249 }
250 }
251 ec.writeActiveSettingEvent();
252 Logger.log(LogTag.JFR_SETTING, LogLevel.INFO, "}");
253 }
254
255 private InternalSetting getInternalSetting(EventControl ec) {
256 String name = ec.getEventType().getName();
257 InternalSetting nameBased = availableSettings.get(name);
258 InternalSetting idBased = availableSettings.get(ec.getSettingsId());
259
260 if (nameBased == null && idBased == null) {
261 return null;
262 }
263 if (idBased == null) {
264 return nameBased;
265 }
266 if (nameBased == null) {
267 return idBased;
268 }
269 InternalSetting mixed = new InternalSetting(nameBased.getSettingsId());
270 mixed.add(nameBased);
271 mixed.add(idBased);
272 return mixed;
273 }
274
275 @Override
276 public String toString() {
277 StringBuilder sb = new StringBuilder();
278 for (InternalSetting enabled : availableSettings.values()) {
279 sb.append(enabled.toString());
280 sb.append("\n");
281 }
282 return sb.toString();
283 }
284
285 boolean isEnabled(String eventName) {
286 InternalSetting is = availableSettings.get(eventName);
287 if (is == null) {
288 return false;
289 }
290 return is.isEnabled();
291 }
292 }