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 static jdk.jfr.internal.LogLevel.DEBUG;
29 import static jdk.jfr.internal.LogTag.JFR_SYSTEM;
30
31 import java.io.ByteArrayOutputStream;
32 import java.io.DataOutputStream;
33 import java.io.IOException;
34 import java.util.ArrayList;
35 import java.util.Collections;
36 import java.util.HashSet;
37 import java.util.List;
38 import java.util.Map;
39
40 import jdk.jfr.AnnotationElement;
41 import jdk.jfr.Event;
42 import jdk.jfr.EventType;
43 import jdk.jfr.Period;
44 import jdk.jfr.StackTrace;
45 import jdk.jfr.Threshold;
46 import jdk.jfr.ValueDescriptor;
47 import jdk.jfr.internal.RequestEngine.RequestHook;
48 import jdk.jfr.internal.handlers.EventHandler;
49
50 public final class MetadataRepository {
51
52 private static final JVM jvm = JVM.getJVM();
53 private static final MetadataRepository instace = new MetadataRepository();
54
55 private final List<EventType> nativeEventTypes = new ArrayList<>(100);
56 private final List<EventControl> nativeControls = new ArrayList<EventControl>(100);
57 private final TypeLibrary typeLibrary = TypeLibrary.getInstance();
58 private final SettingsManager settingsManager = new SettingsManager();
59 private boolean staleMetadata = true;
60 private boolean unregistered;
61 private long lastUnloaded = -1;
62
63 public MetadataRepository() {
64 initializeJVMEventTypes();
65 }
66
67 private void initializeJVMEventTypes() {
68 List<RequestHook> requestHooks = new ArrayList<>();
69 for (Type type : typeLibrary.getTypes()) {
70 if (type instanceof PlatformEventType) {
71 PlatformEventType pEventType = (PlatformEventType) type;
72 EventType eventType = PrivateAccess.getInstance().newEventType(pEventType);
73 pEventType.setHasDuration(eventType.getAnnotation(Threshold.class) != null);
74 pEventType.setHasStackTrace(eventType.getAnnotation(StackTrace.class) != null);
75 pEventType.setHasCutoff(eventType.getAnnotation(Cutoff.class) != null);
76 pEventType.setHasPeriod(eventType.getAnnotation(Period.class) != null);
77 // Must add hook before EventControl is created as it removes
78 // annotations, such as Period and Threshold.
79 if (pEventType.hasPeriod()) {
80 pEventType.setEventHook(true);
81 if (!(Type.EVENT_NAME_PREFIX + "ExecutionSample").equals(type.getName())) {
82 requestHooks.add(new RequestHook(pEventType));
83 }
84 }
85 nativeControls.add(new EventControl(pEventType));
86 nativeEventTypes.add(eventType);
87 }
88 }
89 RequestEngine.addHooks(requestHooks);
90 }
91
92 public static MetadataRepository getInstance() {
93 return instace;
94 }
95
96 public synchronized List<EventType> getRegisteredEventTypes() {
97 List<EventHandler> handlers = getEventHandlers();
98 List<EventType> eventTypes = new ArrayList<>(handlers.size() + nativeEventTypes.size());
99 for (EventHandler h : handlers) {
100 if (h.isRegistered()) {
101 eventTypes.add(h.getEventType());
102 }
103 }
104 eventTypes.addAll(nativeEventTypes);
105 return eventTypes;
106 }
107
108 public synchronized EventType getEventType(Class<? extends Event> eventClass) {
109 EventHandler h = getHandler(eventClass);
110 if (h != null && h.isRegistered()) {
111 return h.getEventType();
112 }
113 throw new IllegalStateException("Event class " + eventClass.getName() + " is not registered");
114 }
115
116 public synchronized void unregister(Class<? extends Event> eventClass) {
117 Utils.checkRegisterPermission();
118 EventHandler handler = getHandler(eventClass);
119 if (handler != null) {
120 handler.setRegistered(false);
121 }
122 // never registered, ignore call
123 }
124 public synchronized EventType register(Class<? extends Event> eventClass) {
125 return register(eventClass, Collections.emptyList(), Collections.emptyList());
126 }
127
128 public synchronized EventType register(Class<? extends Event> eventClass, List<AnnotationElement> dynamicAnnotations, List<ValueDescriptor> dynamicFields) {
129 Utils.checkRegisterPermission();
130 EventHandler handler = getHandler(eventClass);
131 if (handler == null) {
132 handler = makeHandler(eventClass, dynamicAnnotations, dynamicFields);
133 }
134 handler.setRegistered(true);
135 typeLibrary.addType(handler.getPlatformEventType());
136 if (jvm.isRecording()) {
137 storeDescriptorInJVM(); // needed for emergency dump
138 settingsManager.setEventControl(handler.getEventControl());
139 settingsManager.updateRetransform(Collections.singletonList((eventClass)));
140 } else {
141 setStaleMetadata();
142 }
143 return handler.getEventType();
144 }
145
146 private EventHandler getHandler(Class<? extends Event> eventClass) {
147 Utils.ensureValidEventSubclass(eventClass);
148 SecuritySupport.makeVisibleToJFR(eventClass);
149 Utils.ensureInitialized(eventClass);
150 return Utils.getHandler(eventClass);
151 }
152
153 private EventHandler makeHandler(Class<? extends Event> eventClass, List<AnnotationElement> dynamicAnnotations, List<ValueDescriptor> dynamicFields) throws InternalError {
154 SecuritySupport.addHandlerExport(eventClass);
155 PlatformEventType pEventType = (PlatformEventType) TypeLibrary.createType(eventClass, dynamicAnnotations, dynamicFields);
156 EventType eventType = PrivateAccess.getInstance().newEventType(pEventType);
157 EventControl ec = new EventControl(pEventType, eventClass);
158 Class<? extends EventHandler> handlerClass = null;
159 try {
160 String eventHandlerName = EventHandlerCreator.makeEventHandlerName(eventType.getId());
161 handlerClass = Class.forName(eventHandlerName, false, Event.class.getClassLoader()).asSubclass(EventHandler.class);
162 // Created eagerly on class load, tag as instrumented
163 pEventType.setInstrumented();
164 Logger.log(JFR_SYSTEM, DEBUG, "Found existing event handler for " + eventType.getName());
165 } catch (ClassNotFoundException cne) {
166 EventHandlerCreator ehc = new EventHandlerCreator(eventType.getId(), ec.getSettingInfos(), eventType, eventClass);
167 handlerClass = ehc.makeEventHandlerClass();
168 Logger.log(LogTag.JFR_SYSTEM, DEBUG, "Created event handler for " + eventType.getName());
169 }
170 EventHandler handler = EventHandlerCreator.instantiateEventHandler(handlerClass, true, eventType, ec);
171 Utils.setHandler(eventClass, handler);
172 return handler;
173 }
174
175
176 public synchronized void setSettings(List<Map<String, String>> list) {
177 settingsManager.setSettings(list);
178 }
179
180 synchronized void disableEvents() {
181 for (EventControl c : getEventControls()) {
182 c.disable();
183 }
184 }
185
186 public synchronized List<EventControl> getEventControls() {
187 List<EventControl> controls = new ArrayList<>();
188 controls.addAll(nativeControls);
189 for (EventHandler eh : getEventHandlers()) {
190 controls.add(eh.getEventControl());
191 }
192 return controls;
193 }
194
195 private void storeDescriptorInJVM() throws InternalError {
196 jvm.storeMetadataDescriptor(getBinaryRepresentation());
197 staleMetadata = false;
198 }
199
200 private static List<EventHandler> getEventHandlers() {
201 List<Class<? extends Event>> allEventClasses = jvm.getAllEventClasses();
202 List<EventHandler> eventHandlers = new ArrayList<>(allEventClasses.size());
203 for (Class<? extends Event> clazz : allEventClasses) {
204 EventHandler eh = Utils.getHandler(clazz);
205 if (eh != null) {
206 eventHandlers.add(eh);
207 }
208 }
209 return eventHandlers;
210 }
211
212 private byte[] getBinaryRepresentation() {
213 ByteArrayOutputStream baos = new ByteArrayOutputStream(40000);
214 DataOutputStream daos = new DataOutputStream(baos);
215 try {
216 List<Type> types = typeLibrary.getTypes();
217 Collections.sort(types);
218 MetadataDescriptor.write(types, daos);
219 daos.flush();
220 return baos.toByteArray();
221 } catch (IOException e) {
222 // should not happen
223 throw new InternalError(e);
224 }
225 }
226
227 synchronized boolean isEnabled(String eventName) {
228 return settingsManager.isEnabled(eventName);
229 }
230
231 synchronized void setStaleMetadata() {
232 staleMetadata = true;
233 }
234
235 // Lock around setOutput ensures that other threads dosn't
236 // emit event after setOutput and unregister the event class, before a call
237 // to storeDescriptorInJVM
238 synchronized void setOutput(String filename) {
239 jvm.setOutput(filename);
240
241 unregisterUnloaded();
242 if (unregistered) {
243 staleMetadata = typeLibrary.clearUnregistered();
244 unregistered = false;
245 }
246 if (staleMetadata) {
247 storeDescriptorInJVM();
248 }
249 }
250
251 private void unregisterUnloaded() {
252 long unloaded = jvm.getUnloadedEventClassCount();
253 if (this.lastUnloaded != unloaded) {
254 this.lastUnloaded = unloaded;
255 List<Class<? extends Event>> eventClasses = jvm.getAllEventClasses();
256 HashSet<Long> knownIds = new HashSet<>(eventClasses.size());
257 for (Class<? extends Event> ec: eventClasses) {
258 knownIds.add(Type.getTypeId(ec));
259 }
260 for (Type type : typeLibrary.getTypes()) {
261 if (type instanceof PlatformEventType) {
262 if (!knownIds.contains(type.getId())) {
263 PlatformEventType pe = (PlatformEventType) type;
264 if (!pe.isJVM()) {
265 pe.setRegistered(false);
266 }
267 }
268 }
269 }
270 }
271 }
272
273 synchronized public void setUnregistered() {
274 unregistered = true;
275 }
276
277 }