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 <unordered_map>
22 #include <vector>
23
24 #include <android-base/logging.h>
25 #include <android-base/thread_annotations.h>
26
27 #include "android-base/thread_annotations.h"
28 #include "base/macros.h"
29 #include "base/mutex.h"
30 #include "jvmti.h"
31 #include "managed_stack.h"
32 #include "thread.h"
33
34 namespace openjdkjvmti {
35
36 struct ArtJvmTiEnv;
37 class JvmtiEventAllocationListener;
38 class JvmtiDdmChunkListener;
39 class JvmtiGcPauseListener;
40 class JvmtiMethodTraceListener;
41 class JvmtiMonitorListener;
42 class JvmtiParkListener;
43
44 // an enum for ArtEvents. This differs from the JVMTI events only in that we distinguish between
45 // retransformation capable and incapable loading
46 enum class ArtJvmtiEvent : jint {
47 kMinEventTypeVal = JVMTI_MIN_EVENT_TYPE_VAL,
48 kVmInit = JVMTI_EVENT_VM_INIT,
49 kVmDeath = JVMTI_EVENT_VM_DEATH,
50 kThreadStart = JVMTI_EVENT_THREAD_START,
51 kThreadEnd = JVMTI_EVENT_THREAD_END,
52 kClassFileLoadHookNonRetransformable = JVMTI_EVENT_CLASS_FILE_LOAD_HOOK,
53 kClassLoad = JVMTI_EVENT_CLASS_LOAD,
54 kClassPrepare = JVMTI_EVENT_CLASS_PREPARE,
55 kVmStart = JVMTI_EVENT_VM_START,
56 kException = JVMTI_EVENT_EXCEPTION,
57 kExceptionCatch = JVMTI_EVENT_EXCEPTION_CATCH,
58 kSingleStep = JVMTI_EVENT_SINGLE_STEP,
59 kFramePop = JVMTI_EVENT_FRAME_POP,
60 kBreakpoint = JVMTI_EVENT_BREAKPOINT,
61 kFieldAccess = JVMTI_EVENT_FIELD_ACCESS,
62 kFieldModification = JVMTI_EVENT_FIELD_MODIFICATION,
63 kMethodEntry = JVMTI_EVENT_METHOD_ENTRY,
64 kMethodExit = JVMTI_EVENT_METHOD_EXIT,
65 kNativeMethodBind = JVMTI_EVENT_NATIVE_METHOD_BIND,
66 kCompiledMethodLoad = JVMTI_EVENT_COMPILED_METHOD_LOAD,
67 kCompiledMethodUnload = JVMTI_EVENT_COMPILED_METHOD_UNLOAD,
68 kDynamicCodeGenerated = JVMTI_EVENT_DYNAMIC_CODE_GENERATED,
69 kDataDumpRequest = JVMTI_EVENT_DATA_DUMP_REQUEST,
70 kMonitorWait = JVMTI_EVENT_MONITOR_WAIT,
71 kMonitorWaited = JVMTI_EVENT_MONITOR_WAITED,
72 kMonitorContendedEnter = JVMTI_EVENT_MONITOR_CONTENDED_ENTER,
73 kMonitorContendedEntered = JVMTI_EVENT_MONITOR_CONTENDED_ENTERED,
74 kResourceExhausted = JVMTI_EVENT_RESOURCE_EXHAUSTED,
75 kGarbageCollectionStart = JVMTI_EVENT_GARBAGE_COLLECTION_START,
76 kGarbageCollectionFinish = JVMTI_EVENT_GARBAGE_COLLECTION_FINISH,
77 kObjectFree = JVMTI_EVENT_OBJECT_FREE,
78 kVmObjectAlloc = JVMTI_EVENT_VM_OBJECT_ALLOC,
79 // Internal event to mark a ClassFileLoadHook as one created with the can_retransform_classes
80 // capability.
81 kClassFileLoadHookRetransformable = JVMTI_MAX_EVENT_TYPE_VAL + 1,
82 kDdmPublishChunk = JVMTI_MAX_EVENT_TYPE_VAL + 2,
83 kObsoleteObjectCreated = JVMTI_MAX_EVENT_TYPE_VAL + 3,
84 kStructuralDexFileLoadHook = JVMTI_MAX_EVENT_TYPE_VAL + 4,
85 kMaxNormalEventTypeVal = kStructuralDexFileLoadHook,
86
87 // All that follow are events used to implement internal JVMTI functions. They are not settable
88 // directly by agents.
89 kMinInternalEventTypeVal = kMaxNormalEventTypeVal + 1,
90
91 // Internal event we use to implement the ForceEarlyReturn functions.
92 kForceEarlyReturnUpdateReturnValue = kMinInternalEventTypeVal,
93 kMaxInternalEventTypeVal = kForceEarlyReturnUpdateReturnValue,
94
95 kMaxEventTypeVal = kMaxInternalEventTypeVal,
96 };
97
98 constexpr jint kInternalEventCount = static_cast<jint>(ArtJvmtiEvent::kMaxInternalEventTypeVal) -
99 static_cast<jint>(ArtJvmtiEvent::kMinInternalEventTypeVal) + 1;
100
101 using ArtJvmtiEventDdmPublishChunk = void (*)(jvmtiEnv *jvmti_env,
102 jint data_type,
103 jint data_len,
104 const jbyte* data);
105
106 using ArtJvmtiEventObsoleteObjectCreated = void (*)(jvmtiEnv *jvmti_env,
107 jlong* obsolete_tag,
108 jlong* new_tag);
109
110 using ArtJvmtiEventStructuralDexFileLoadHook = void (*)(jvmtiEnv *jvmti_env,
111 JNIEnv* jni_env,
112 jclass class_being_redefined,
113 jobject loader,
114 const char* name,
115 jobject protection_domain,
116 jint dex_data_len,
117 const unsigned char* dex_data,
118 jint* new_dex_data_len,
119 unsigned char** new_dex_data);
120
121 // It is not enough to store a Thread pointer, as these may be reused. Use the pointer and the
122 // thread id.
123 // Note: We could just use the tid like tracing does.
124 using UniqueThread = std::pair<art::Thread*, uint32_t>;
125
126 struct UniqueThreadHasher {
operatorUniqueThreadHasher127 std::size_t operator()(const UniqueThread& k) const {
128 return std::hash<uint32_t>{}(k.second) ^ (std::hash<void*>{}(k.first) << 1);
129 }
130 };
131
132 struct ArtJvmtiEventCallbacks : jvmtiEventCallbacks {
ArtJvmtiEventCallbacksArtJvmtiEventCallbacks133 ArtJvmtiEventCallbacks()
134 : DdmPublishChunk(nullptr),
135 ObsoleteObjectCreated(nullptr),
136 StructuralDexFileLoadHook(nullptr) {
137 memset(this, 0, sizeof(jvmtiEventCallbacks));
138 }
139
140 // Copies extension functions from other callback struct if it exists. There must not have been
141 // any modifications to this struct when it is called.
142 void CopyExtensionsFrom(const ArtJvmtiEventCallbacks* cb);
143
144 jvmtiError Set(jint index, jvmtiExtensionEvent cb);
145
146 ArtJvmtiEventDdmPublishChunk DdmPublishChunk;
147 ArtJvmtiEventObsoleteObjectCreated ObsoleteObjectCreated;
148 ArtJvmtiEventStructuralDexFileLoadHook StructuralDexFileLoadHook;
149 };
150
151 bool IsExtensionEvent(jint e);
152 bool IsExtensionEvent(ArtJvmtiEvent e);
153
154 // Convert a jvmtiEvent into a ArtJvmtiEvent
155 ALWAYS_INLINE static inline ArtJvmtiEvent GetArtJvmtiEvent(ArtJvmTiEnv* env, jvmtiEvent e);
156
GetJvmtiEvent(ArtJvmtiEvent e)157 static inline jvmtiEvent GetJvmtiEvent(ArtJvmtiEvent e) {
158 if (UNLIKELY(e == ArtJvmtiEvent::kClassFileLoadHookRetransformable)) {
159 return JVMTI_EVENT_CLASS_FILE_LOAD_HOOK;
160 } else {
161 return static_cast<jvmtiEvent>(e);
162 }
163 }
164
165 struct EventMask {
166 static constexpr size_t kEventsSize =
167 static_cast<size_t>(ArtJvmtiEvent::kMaxEventTypeVal) -
168 static_cast<size_t>(ArtJvmtiEvent::kMinEventTypeVal) + 1;
169 std::bitset<kEventsSize> bit_set;
170
EventIsInRangeEventMask171 static bool EventIsInRange(ArtJvmtiEvent event) {
172 return event >= ArtJvmtiEvent::kMinEventTypeVal && event <= ArtJvmtiEvent::kMaxEventTypeVal;
173 }
174
175 void Set(ArtJvmtiEvent event, bool value = true) {
176 DCHECK(EventIsInRange(event));
177 bit_set.set(static_cast<size_t>(event) - static_cast<size_t>(ArtJvmtiEvent::kMinEventTypeVal),
178 value);
179 }
180
TestEventMask181 bool Test(ArtJvmtiEvent event) const {
182 DCHECK(EventIsInRange(event));
183 return bit_set.test(
184 static_cast<size_t>(event) - static_cast<size_t>(ArtJvmtiEvent::kMinEventTypeVal));
185 }
186 };
187
188 struct EventMasks {
189 // The globally enabled events.
190 EventMask global_event_mask;
191
192 // The per-thread enabled events.
193
194 // TODO: Native thread objects are immovable, so we can use them as keys in an (unordered) map,
195 // if necessary.
196 std::vector<std::pair<UniqueThread, EventMask>> thread_event_masks;
197
198 // A union of the per-thread events, for fast-pathing.
199 EventMask unioned_thread_event_mask;
200
201 EventMask& GetEventMask(art::Thread* thread);
202 EventMask* GetEventMaskOrNull(art::Thread* thread);
203 // Circular dependencies mean we cannot see the definition of ArtJvmTiEnv so the mutex is simply
204 // asserted in the function.
205 // Note that the 'env' passed in must be the same env this EventMasks is associated with.
206 void EnableEvent(ArtJvmTiEnv* env, art::Thread* thread, ArtJvmtiEvent event);
207 // REQUIRES(env->event_info_mutex_);
208 // Circular dependencies mean we cannot see the definition of ArtJvmTiEnv so the mutex is simply
209 // asserted in the function.
210 // Note that the 'env' passed in must be the same env this EventMasks is associated with.
211 void DisableEvent(ArtJvmTiEnv* env, art::Thread* thread, ArtJvmtiEvent event);
212 // REQUIRES(env->event_info_mutex_);
213 bool IsEnabledAnywhere(ArtJvmtiEvent event);
214 // Make any changes to event masks needed for the given capability changes. If caps_added is true
215 // then caps is all the newly set capabilities of the jvmtiEnv. If it is false then caps is the
216 // set of all capabilities that were removed from the jvmtiEnv.
217 void HandleChangedCapabilities(const jvmtiCapabilities& caps, bool caps_added);
218 };
219
220 namespace impl {
221 template <ArtJvmtiEvent kEvent> struct EventHandlerFunc { };
222 } // namespace impl
223
224 // Helper class for event handling.
225 class EventHandler {
226 public:
227 EventHandler();
228 ~EventHandler();
229
230 // do cleanup for the event handler.
231 void Shutdown();
232
233 // Register an env. It is assumed that this happens on env creation, that is, no events are
234 // enabled, yet.
235 void RegisterArtJvmTiEnv(ArtJvmTiEnv* env) REQUIRES(!envs_lock_);
236
237 // Remove an env.
238 void RemoveArtJvmTiEnv(ArtJvmTiEnv* env) REQUIRES(!envs_lock_);
239
IsEventEnabledAnywhere(ArtJvmtiEvent event)240 bool IsEventEnabledAnywhere(ArtJvmtiEvent event) const {
241 if (!EventMask::EventIsInRange(event)) {
242 return false;
243 }
244 return global_mask.Test(event);
245 }
246
247 // Sets an internal event. Unlike normal JVMTI events internal events are not associated with any
248 // particular jvmtiEnv and are refcounted. This refcounting is done to allow us to easily enable
249 // events during functions and disable them during the requested event callback. Since these are
250 // used to implement various JVMTI functions these events always have a single target thread. If
251 // target is null the current thread is used.
252 jvmtiError SetInternalEvent(jthread target,
253 ArtJvmtiEvent event,
254 jvmtiEventMode mode)
255 REQUIRES(!envs_lock_, !art::Locks::mutator_lock_);
256
257 jvmtiError SetEvent(ArtJvmTiEnv* env,
258 jthread thread,
259 ArtJvmtiEvent event,
260 jvmtiEventMode mode)
261 REQUIRES(!envs_lock_);
262
263 // Dispatch event to all registered environments. Since this one doesn't have a JNIEnv* it doesn't
264 // matter if it has the mutator_lock.
265 template <ArtJvmtiEvent kEvent, typename ...Args>
266 ALWAYS_INLINE
267 inline void DispatchEvent(art::Thread* thread, Args... args) const
268 REQUIRES(!envs_lock_);
269
270 // Dispatch event to all registered environments stashing exceptions as needed. This works since
271 // JNIEnv* is always the second argument if it is passed to an event. Needed since C++ does not
272 // allow partial template function specialization.
273 //
274 // We need both of these since we want to make sure to push a stack frame when it is possible for
275 // the event to allocate local references.
276 template <ArtJvmtiEvent kEvent, typename ...Args>
277 ALWAYS_INLINE
278 inline void DispatchEvent(art::Thread* thread, JNIEnv* jnienv, Args... args) const
279 REQUIRES(!envs_lock_);
280
281 // Tell the event handler capabilities were added/lost so it can adjust the sent events.If
282 // caps_added is true then caps is all the newly set capabilities of the jvmtiEnv. If it is false
283 // then caps is the set of all capabilities that were removed from the jvmtiEnv.
284 ALWAYS_INLINE
285 inline void HandleChangedCapabilities(ArtJvmTiEnv* env,
286 const jvmtiCapabilities& caps,
287 bool added)
288 REQUIRES(!envs_lock_);
289
290 // Dispatch event to the given environment, only.
291 template <ArtJvmtiEvent kEvent, typename ...Args>
292 ALWAYS_INLINE
293 inline void DispatchEventOnEnv(ArtJvmTiEnv* env,
294 art::Thread* thread,
295 JNIEnv* jnienv,
296 Args... args) const
297 REQUIRES(!envs_lock_);
298
299 // Dispatch event to the given environment, only.
300 template <ArtJvmtiEvent kEvent, typename ...Args>
301 ALWAYS_INLINE
302 inline void DispatchEventOnEnv(ArtJvmTiEnv* env, art::Thread* thread, Args... args) const
303 REQUIRES(!envs_lock_);
304
305 void AddDelayedNonStandardExitEvent(const art::ShadowFrame* frame, bool is_object, jvalue val)
306 REQUIRES_SHARED(art::Locks::mutator_lock_)
307 REQUIRES(art::Locks::user_code_suspension_lock_, art::Locks::thread_list_lock_);
308
309 template<typename Visitor>
ForEachEnv(art::Thread * self,Visitor v)310 void ForEachEnv(art::Thread* self, Visitor v) REQUIRES(!envs_lock_) {
311 art::ReaderMutexLock mu(self, envs_lock_);
312 for (ArtJvmTiEnv* e : envs) {
313 if (e != nullptr) {
314 v(e);
315 }
316 }
317 }
318
319 private:
320 void SetupTraceListener(JvmtiMethodTraceListener* listener, ArtJvmtiEvent event, bool enable);
321
322 uint32_t GetInstrumentationEventsFor(ArtJvmtiEvent event);
323
324 // Specifically handle the FramePop event which it might not always be possible to turn off.
325 void SetupFramePopTraceListener(bool enable);
326
327 template <ArtJvmtiEvent kEvent, typename ...Args>
328 ALWAYS_INLINE
329 inline std::vector<impl::EventHandlerFunc<kEvent>> CollectEvents(art::Thread* thread,
330 Args... args) const
331 REQUIRES(!envs_lock_);
332
333 template <ArtJvmtiEvent kEvent>
334 ALWAYS_INLINE
335 inline bool ShouldDispatchOnThread(ArtJvmTiEnv* env, art::Thread* thread) const;
336
337 template <ArtJvmtiEvent kEvent, typename ...Args>
338 ALWAYS_INLINE
339 static inline void ExecuteCallback(impl::EventHandlerFunc<kEvent> handler,
340 JNIEnv* env,
341 Args... args)
342 REQUIRES(!envs_lock_);
343
344 template <ArtJvmtiEvent kEvent, typename ...Args>
345 ALWAYS_INLINE
346 static inline void ExecuteCallback(impl::EventHandlerFunc<kEvent> handler, Args... args)
347 REQUIRES(!envs_lock_);
348
349 // Public for use to collect dispatches
350 template <ArtJvmtiEvent kEvent, typename ...Args>
351 ALWAYS_INLINE
352 inline bool ShouldDispatch(ArtJvmTiEnv* env, art::Thread* thread, Args... args) const;
353
354 ALWAYS_INLINE
355 inline bool NeedsEventUpdate(ArtJvmTiEnv* env,
356 const jvmtiCapabilities& caps,
357 bool added);
358
359 // Recalculates the event mask for the given event.
360 ALWAYS_INLINE
361 inline void RecalculateGlobalEventMask(ArtJvmtiEvent event) REQUIRES(!envs_lock_);
362 ALWAYS_INLINE
363 inline void RecalculateGlobalEventMaskLocked(ArtJvmtiEvent event) REQUIRES_SHARED(envs_lock_);
364
365 // Returns whether there are any active requests for the given event on the given thread. This
366 // should only be used while modifying the events for a thread.
367 bool GetThreadEventState(ArtJvmtiEvent event, art::Thread* thread)
368 REQUIRES(envs_lock_, art::Locks::thread_list_lock_);
369
370 template <ArtJvmtiEvent kEvent>
371 ALWAYS_INLINE inline void DispatchClassFileLoadHookEvent(art::Thread* thread,
372 JNIEnv* jnienv,
373 jclass class_being_redefined,
374 jobject loader,
375 const char* name,
376 jobject protection_domain,
377 jint class_data_len,
378 const unsigned char* class_data,
379 jint* new_class_data_len,
380 unsigned char** new_class_data) const
381 REQUIRES(!envs_lock_);
382
383 template <ArtJvmtiEvent kEvent>
384 ALWAYS_INLINE inline void DispatchClassLoadOrPrepareEvent(art::Thread* thread,
385 JNIEnv* jnienv,
386 jthread jni_thread,
387 jclass klass) const
388 REQUIRES(!envs_lock_);
389
390 // Sets up the global state needed for the first/last enable of an event across all threads
391 void HandleEventType(ArtJvmtiEvent event, bool enable);
392 // Perform deopts required for enabling the event on the given thread. Null thread indicates
393 // global event enabled.
394 jvmtiError HandleEventDeopt(ArtJvmtiEvent event, jthread thread, bool enable);
395 void HandleLocalAccessCapabilityAdded();
396 void HandleBreakpointEventsChanged(bool enable);
397
398 bool OtherMonitorEventsEnabledAnywhere(ArtJvmtiEvent event);
399
400 int32_t GetInternalEventRefcount(ArtJvmtiEvent event) const REQUIRES(envs_lock_);
401 // Increment internal event refcount for the given event and return the new count.
402 int32_t IncrInternalEventRefcount(ArtJvmtiEvent event) REQUIRES(envs_lock_);
403 // Decrement internal event refcount for the given event and return the new count.
404 int32_t DecrInternalEventRefcount(ArtJvmtiEvent event) REQUIRES(envs_lock_);
405
406 int32_t& GetInternalEventThreadRefcount(ArtJvmtiEvent event, art::Thread* target)
407 REQUIRES(envs_lock_, art::Locks::thread_list_lock_);
408 // Increment internal event refcount for the given event and return the new count.
409 int32_t IncrInternalEventThreadRefcount(ArtJvmtiEvent event, art::Thread* target)
410 REQUIRES(envs_lock_, art::Locks::thread_list_lock_);
411 // Decrement internal event refcount for the given event and return the new count.
412 int32_t DecrInternalEventThreadRefcount(ArtJvmtiEvent event, art::Thread* target)
413 REQUIRES(envs_lock_, art::Locks::thread_list_lock_);
414
415 // List of all JvmTiEnv objects that have been created, in their creation order. It is a std::list
416 // since we mostly access it by iterating over the entire thing, only ever append to the end, and
417 // need to be able to remove arbitrary elements from it.
418 std::list<ArtJvmTiEnv*> envs GUARDED_BY(envs_lock_);
419
420 // Close to top level lock. Nothing should be held when we lock this (except for mutator_lock_
421 // which is needed when setting new events).
422 mutable art::ReaderWriterMutex envs_lock_ ACQUIRED_AFTER(art::Locks::mutator_lock_);
423
424 // A union of all enabled events, anywhere.
425 EventMask global_mask;
426
427 std::unique_ptr<JvmtiEventAllocationListener> alloc_listener_;
428 std::unique_ptr<JvmtiDdmChunkListener> ddm_listener_;
429 std::unique_ptr<JvmtiGcPauseListener> gc_pause_listener_;
430 std::unique_ptr<JvmtiMethodTraceListener> method_trace_listener_;
431 std::unique_ptr<JvmtiMonitorListener> monitor_listener_;
432 std::unique_ptr<JvmtiParkListener> park_listener_;
433
434 // True if frame pop has ever been enabled. Since we store pointers to stack frames we need to
435 // continue to listen to this event even if it has been disabled.
436 // TODO We could remove the listeners once all jvmtiEnvs have drained their shadow-frame vectors.
437 bool frame_pop_enabled;
438
439 // The overall refcount for each internal event across all threads.
440 std::array<int32_t, kInternalEventCount> internal_event_refcount_ GUARDED_BY(envs_lock_);
441 // The refcount for each thread for each internal event.
442 // TODO We should clean both this and the normal EventMask lists up when threads end.
443 std::array<std::unordered_map<UniqueThread, int32_t, UniqueThreadHasher>, kInternalEventCount>
444 internal_event_thread_refcount_
445 GUARDED_BY(envs_lock_) GUARDED_BY(art::Locks::thread_list_lock_);
446
447 friend class JvmtiMethodTraceListener;
448 };
449
450 } // namespace openjdkjvmti
451
452 #endif // ART_OPENJDKJVMTI_EVENTS_H_
453