1 /*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #ifndef ART_OPENJDKJVMTI_EVENTS_H_
18 #define ART_OPENJDKJVMTI_EVENTS_H_
19
20 #include <bitset>
21 #include <vector>
22
23 #include <android-base/logging.h>
24 #include <android-base/thread_annotations.h>
25
26 #include "base/macros.h"
27 #include "base/mutex.h"
28 #include "jvmti.h"
29 #include "thread.h"
30
31 namespace openjdkjvmti {
32
33 struct ArtJvmTiEnv;
34 class JvmtiAllocationListener;
35 class JvmtiDdmChunkListener;
36 class JvmtiGcPauseListener;
37 class JvmtiMethodTraceListener;
38 class JvmtiMonitorListener;
39 class JvmtiParkListener;
40
41 // an enum for ArtEvents. This differs from the JVMTI events only in that we distinguish between
42 // retransformation capable and incapable loading
43 enum class ArtJvmtiEvent : jint {
44 kMinEventTypeVal = JVMTI_MIN_EVENT_TYPE_VAL,
45 kVmInit = JVMTI_EVENT_VM_INIT,
46 kVmDeath = JVMTI_EVENT_VM_DEATH,
47 kThreadStart = JVMTI_EVENT_THREAD_START,
48 kThreadEnd = JVMTI_EVENT_THREAD_END,
49 kClassFileLoadHookNonRetransformable = JVMTI_EVENT_CLASS_FILE_LOAD_HOOK,
50 kClassLoad = JVMTI_EVENT_CLASS_LOAD,
51 kClassPrepare = JVMTI_EVENT_CLASS_PREPARE,
52 kVmStart = JVMTI_EVENT_VM_START,
53 kException = JVMTI_EVENT_EXCEPTION,
54 kExceptionCatch = JVMTI_EVENT_EXCEPTION_CATCH,
55 kSingleStep = JVMTI_EVENT_SINGLE_STEP,
56 kFramePop = JVMTI_EVENT_FRAME_POP,
57 kBreakpoint = JVMTI_EVENT_BREAKPOINT,
58 kFieldAccess = JVMTI_EVENT_FIELD_ACCESS,
59 kFieldModification = JVMTI_EVENT_FIELD_MODIFICATION,
60 kMethodEntry = JVMTI_EVENT_METHOD_ENTRY,
61 kMethodExit = JVMTI_EVENT_METHOD_EXIT,
62 kNativeMethodBind = JVMTI_EVENT_NATIVE_METHOD_BIND,
63 kCompiledMethodLoad = JVMTI_EVENT_COMPILED_METHOD_LOAD,
64 kCompiledMethodUnload = JVMTI_EVENT_COMPILED_METHOD_UNLOAD,
65 kDynamicCodeGenerated = JVMTI_EVENT_DYNAMIC_CODE_GENERATED,
66 kDataDumpRequest = JVMTI_EVENT_DATA_DUMP_REQUEST,
67 kMonitorWait = JVMTI_EVENT_MONITOR_WAIT,
68 kMonitorWaited = JVMTI_EVENT_MONITOR_WAITED,
69 kMonitorContendedEnter = JVMTI_EVENT_MONITOR_CONTENDED_ENTER,
70 kMonitorContendedEntered = JVMTI_EVENT_MONITOR_CONTENDED_ENTERED,
71 kResourceExhausted = JVMTI_EVENT_RESOURCE_EXHAUSTED,
72 kGarbageCollectionStart = JVMTI_EVENT_GARBAGE_COLLECTION_START,
73 kGarbageCollectionFinish = JVMTI_EVENT_GARBAGE_COLLECTION_FINISH,
74 kObjectFree = JVMTI_EVENT_OBJECT_FREE,
75 kVmObjectAlloc = JVMTI_EVENT_VM_OBJECT_ALLOC,
76 kClassFileLoadHookRetransformable = JVMTI_MAX_EVENT_TYPE_VAL + 1,
77 kDdmPublishChunk = JVMTI_MAX_EVENT_TYPE_VAL + 2,
78 kMaxEventTypeVal = kDdmPublishChunk,
79 };
80
81 using ArtJvmtiEventDdmPublishChunk = void (*)(jvmtiEnv *jvmti_env,
82 JNIEnv* jni_env,
83 jint data_type,
84 jint data_len,
85 const jbyte* data);
86
87 struct ArtJvmtiEventCallbacks : jvmtiEventCallbacks {
ArtJvmtiEventCallbacksArtJvmtiEventCallbacks88 ArtJvmtiEventCallbacks() : DdmPublishChunk(nullptr) {
89 memset(this, 0, sizeof(jvmtiEventCallbacks));
90 }
91
92 // Copies extension functions from other callback struct if it exists. There must not have been
93 // any modifications to this struct when it is called.
94 void CopyExtensionsFrom(const ArtJvmtiEventCallbacks* cb);
95
96 jvmtiError Set(jint index, jvmtiExtensionEvent cb);
97
98 ArtJvmtiEventDdmPublishChunk DdmPublishChunk;
99 };
100
101 bool IsExtensionEvent(jint e);
102 bool IsExtensionEvent(ArtJvmtiEvent e);
103
104 // Convert a jvmtiEvent into a ArtJvmtiEvent
105 ALWAYS_INLINE static inline ArtJvmtiEvent GetArtJvmtiEvent(ArtJvmTiEnv* env, jvmtiEvent e);
106
GetJvmtiEvent(ArtJvmtiEvent e)107 static inline jvmtiEvent GetJvmtiEvent(ArtJvmtiEvent e) {
108 if (UNLIKELY(e == ArtJvmtiEvent::kClassFileLoadHookRetransformable)) {
109 return JVMTI_EVENT_CLASS_FILE_LOAD_HOOK;
110 } else {
111 return static_cast<jvmtiEvent>(e);
112 }
113 }
114
115 struct EventMask {
116 static constexpr size_t kEventsSize =
117 static_cast<size_t>(ArtJvmtiEvent::kMaxEventTypeVal) -
118 static_cast<size_t>(ArtJvmtiEvent::kMinEventTypeVal) + 1;
119 std::bitset<kEventsSize> bit_set;
120
EventIsInRangeEventMask121 static bool EventIsInRange(ArtJvmtiEvent event) {
122 return event >= ArtJvmtiEvent::kMinEventTypeVal && event <= ArtJvmtiEvent::kMaxEventTypeVal;
123 }
124
125 void Set(ArtJvmtiEvent event, bool value = true) {
126 DCHECK(EventIsInRange(event));
127 bit_set.set(static_cast<size_t>(event) - static_cast<size_t>(ArtJvmtiEvent::kMinEventTypeVal),
128 value);
129 }
130
TestEventMask131 bool Test(ArtJvmtiEvent event) const {
132 DCHECK(EventIsInRange(event));
133 return bit_set.test(
134 static_cast<size_t>(event) - static_cast<size_t>(ArtJvmtiEvent::kMinEventTypeVal));
135 }
136 };
137
138 struct EventMasks {
139 // The globally enabled events.
140 EventMask global_event_mask;
141
142 // The per-thread enabled events.
143
144 // It is not enough to store a Thread pointer, as these may be reused. Use the pointer and the
145 // thread id.
146 // Note: We could just use the tid like tracing does.
147 using UniqueThread = std::pair<art::Thread*, uint32_t>;
148 // TODO: Native thread objects are immovable, so we can use them as keys in an (unordered) map,
149 // if necessary.
150 std::vector<std::pair<UniqueThread, EventMask>> thread_event_masks;
151
152 // A union of the per-thread events, for fast-pathing.
153 EventMask unioned_thread_event_mask;
154
155 EventMask& GetEventMask(art::Thread* thread);
156 EventMask* GetEventMaskOrNull(art::Thread* thread);
157 // Circular dependencies mean we cannot see the definition of ArtJvmTiEnv so the mutex is simply
158 // asserted in the function.
159 // Note that the 'env' passed in must be the same env this EventMasks is associated with.
160 void EnableEvent(ArtJvmTiEnv* env, art::Thread* thread, ArtJvmtiEvent event);
161 // REQUIRES(env->event_info_mutex_);
162 // Circular dependencies mean we cannot see the definition of ArtJvmTiEnv so the mutex is simply
163 // asserted in the function.
164 // Note that the 'env' passed in must be the same env this EventMasks is associated with.
165 void DisableEvent(ArtJvmTiEnv* env, art::Thread* thread, ArtJvmtiEvent event);
166 // REQUIRES(env->event_info_mutex_);
167 bool IsEnabledAnywhere(ArtJvmtiEvent event);
168 // Make any changes to event masks needed for the given capability changes. If caps_added is true
169 // then caps is all the newly set capabilities of the jvmtiEnv. If it is false then caps is the
170 // set of all capabilities that were removed from the jvmtiEnv.
171 void HandleChangedCapabilities(const jvmtiCapabilities& caps, bool caps_added);
172 };
173
174 namespace impl {
175 template <ArtJvmtiEvent kEvent> struct EventHandlerFunc { };
176 } // namespace impl
177
178 // Helper class for event handling.
179 class EventHandler {
180 public:
181 EventHandler();
182 ~EventHandler();
183
184 // do cleanup for the event handler.
185 void Shutdown();
186
187 // Register an env. It is assumed that this happens on env creation, that is, no events are
188 // enabled, yet.
189 void RegisterArtJvmTiEnv(ArtJvmTiEnv* env) REQUIRES(!envs_lock_);
190
191 // Remove an env.
192 void RemoveArtJvmTiEnv(ArtJvmTiEnv* env) REQUIRES(!envs_lock_);
193
IsEventEnabledAnywhere(ArtJvmtiEvent event)194 bool IsEventEnabledAnywhere(ArtJvmtiEvent event) const {
195 if (!EventMask::EventIsInRange(event)) {
196 return false;
197 }
198 return global_mask.Test(event);
199 }
200
201 jvmtiError SetEvent(ArtJvmTiEnv* env,
202 jthread thread,
203 ArtJvmtiEvent event,
204 jvmtiEventMode mode)
205 REQUIRES(!envs_lock_);
206
207 // Dispatch event to all registered environments. Since this one doesn't have a JNIEnv* it doesn't
208 // matter if it has the mutator_lock.
209 template <ArtJvmtiEvent kEvent, typename ...Args>
210 ALWAYS_INLINE
211 inline void DispatchEvent(art::Thread* thread, Args... args) const
212 REQUIRES(!envs_lock_);
213
214 // Dispatch event to all registered environments stashing exceptions as needed. This works since
215 // JNIEnv* is always the second argument if it is passed to an event. Needed since C++ does not
216 // allow partial template function specialization.
217 //
218 // We need both of these since we want to make sure to push a stack frame when it is possible for
219 // the event to allocate local references.
220 template <ArtJvmtiEvent kEvent, typename ...Args>
221 ALWAYS_INLINE
222 inline void DispatchEvent(art::Thread* thread, JNIEnv* jnienv, Args... args) const
223 REQUIRES(!envs_lock_);
224
225 // Tell the event handler capabilities were added/lost so it can adjust the sent events.If
226 // caps_added is true then caps is all the newly set capabilities of the jvmtiEnv. If it is false
227 // then caps is the set of all capabilities that were removed from the jvmtiEnv.
228 ALWAYS_INLINE
229 inline void HandleChangedCapabilities(ArtJvmTiEnv* env,
230 const jvmtiCapabilities& caps,
231 bool added)
232 REQUIRES(!envs_lock_);
233
234 // Dispatch event to the given environment, only.
235 template <ArtJvmtiEvent kEvent, typename ...Args>
236 ALWAYS_INLINE
237 inline void DispatchEventOnEnv(ArtJvmTiEnv* env,
238 art::Thread* thread,
239 JNIEnv* jnienv,
240 Args... args) const
241 REQUIRES(!envs_lock_);
242
243 // Dispatch event to the given environment, only.
244 template <ArtJvmtiEvent kEvent, typename ...Args>
245 ALWAYS_INLINE
246 inline void DispatchEventOnEnv(ArtJvmTiEnv* env, art::Thread* thread, Args... args) const
247 REQUIRES(!envs_lock_);
248
249 private:
250 void SetupTraceListener(JvmtiMethodTraceListener* listener, ArtJvmtiEvent event, bool enable);
251
252 // Specifically handle the FramePop event which it might not always be possible to turn off.
253 void SetupFramePopTraceListener(bool enable);
254
255 template <ArtJvmtiEvent kEvent, typename ...Args>
256 ALWAYS_INLINE
257 inline std::vector<impl::EventHandlerFunc<kEvent>> CollectEvents(art::Thread* thread,
258 Args... args) const
259 REQUIRES(!envs_lock_);
260
261 template <ArtJvmtiEvent kEvent>
262 ALWAYS_INLINE
263 inline bool ShouldDispatchOnThread(ArtJvmTiEnv* env, art::Thread* thread) const;
264
265 template <ArtJvmtiEvent kEvent, typename ...Args>
266 ALWAYS_INLINE
267 static inline void ExecuteCallback(impl::EventHandlerFunc<kEvent> handler,
268 JNIEnv* env,
269 Args... args)
270 REQUIRES(!envs_lock_);
271
272 template <ArtJvmtiEvent kEvent, typename ...Args>
273 ALWAYS_INLINE
274 static inline void ExecuteCallback(impl::EventHandlerFunc<kEvent> handler, Args... args)
275 REQUIRES(!envs_lock_);
276
277 // Public for use to collect dispatches
278 template <ArtJvmtiEvent kEvent, typename ...Args>
279 ALWAYS_INLINE
280 inline bool ShouldDispatch(ArtJvmTiEnv* env, art::Thread* thread, Args... args) const;
281
282 ALWAYS_INLINE
283 inline bool NeedsEventUpdate(ArtJvmTiEnv* env,
284 const jvmtiCapabilities& caps,
285 bool added);
286
287 // Recalculates the event mask for the given event.
288 ALWAYS_INLINE
289 inline void RecalculateGlobalEventMask(ArtJvmtiEvent event) REQUIRES(!envs_lock_);
290 ALWAYS_INLINE
291 inline void RecalculateGlobalEventMaskLocked(ArtJvmtiEvent event) REQUIRES_SHARED(envs_lock_);
292
293 // Returns whether there are any active requests for the given event on the given thread. This
294 // should only be used while modifying the events for a thread.
295 bool GetThreadEventState(ArtJvmtiEvent event, art::Thread* thread)
296 REQUIRES(envs_lock_, art::Locks::thread_list_lock_);
297
298 template <ArtJvmtiEvent kEvent>
299 ALWAYS_INLINE inline void DispatchClassFileLoadHookEvent(art::Thread* thread,
300 JNIEnv* jnienv,
301 jclass class_being_redefined,
302 jobject loader,
303 const char* name,
304 jobject protection_domain,
305 jint class_data_len,
306 const unsigned char* class_data,
307 jint* new_class_data_len,
308 unsigned char** new_class_data) const
309 REQUIRES(!envs_lock_);
310
311 template <ArtJvmtiEvent kEvent>
312 ALWAYS_INLINE inline void DispatchClassLoadOrPrepareEvent(art::Thread* thread,
313 JNIEnv* jnienv,
314 jthread jni_thread,
315 jclass klass) const
316 REQUIRES(!envs_lock_);
317
318 // Sets up the global state needed for the first/last enable of an event across all threads
319 void HandleEventType(ArtJvmtiEvent event, bool enable);
320 // Perform deopts required for enabling the event on the given thread. Null thread indicates
321 // global event enabled.
322 jvmtiError HandleEventDeopt(ArtJvmtiEvent event, jthread thread, bool enable);
323 void HandleLocalAccessCapabilityAdded();
324 void HandleBreakpointEventsChanged(bool enable);
325
326 bool OtherMonitorEventsEnabledAnywhere(ArtJvmtiEvent event);
327
328 // List of all JvmTiEnv objects that have been created, in their creation order. It is a std::list
329 // since we mostly access it by iterating over the entire thing, only ever append to the end, and
330 // need to be able to remove arbitrary elements from it.
331 std::list<ArtJvmTiEnv*> envs GUARDED_BY(envs_lock_);
332
333 // Close to top level lock. Nothing should be held when we lock this (except for mutator_lock_
334 // which is needed when setting new events).
335 mutable art::ReaderWriterMutex envs_lock_ ACQUIRED_AFTER(art::Locks::mutator_lock_);
336
337 // A union of all enabled events, anywhere.
338 EventMask global_mask;
339
340 std::unique_ptr<JvmtiAllocationListener> alloc_listener_;
341 std::unique_ptr<JvmtiDdmChunkListener> ddm_listener_;
342 std::unique_ptr<JvmtiGcPauseListener> gc_pause_listener_;
343 std::unique_ptr<JvmtiMethodTraceListener> method_trace_listener_;
344 std::unique_ptr<JvmtiMonitorListener> monitor_listener_;
345 std::unique_ptr<JvmtiParkListener> park_listener_;
346
347 // True if frame pop has ever been enabled. Since we store pointers to stack frames we need to
348 // continue to listen to this event even if it has been disabled.
349 // TODO We could remove the listeners once all jvmtiEnvs have drained their shadow-frame vectors.
350 bool frame_pop_enabled;
351 };
352
353 } // namespace openjdkjvmti
354
355 #endif // ART_OPENJDKJVMTI_EVENTS_H_
356