1 /* Copyright (C) 2016 The Android Open Source Project
2 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
3 *
4 * This file implements interfaces from the file jvmti.h. This implementation
5 * is licensed under the same terms as the file jvmti.h. The
6 * copyright and license information for the file jvmti.h follows.
7 *
8 * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
9 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
10 *
11 * This code is free software; you can redistribute it and/or modify it
12 * under the terms of the GNU General Public License version 2 only, as
13 * published by the Free Software Foundation. Oracle designates this
14 * particular file as subject to the "Classpath" exception as provided
15 * by Oracle in the LICENSE file that accompanied this code.
16 *
17 * This code is distributed in the hope that it will be useful, but WITHOUT
18 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
19 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
20 * version 2 for more details (a copy is included in the LICENSE file that
21 * accompanied this code).
22 *
23 * You should have received a copy of the GNU General Public License version
24 * 2 along with this work; if not, write to the Free Software Foundation,
25 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
26 *
27 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
28 * or visit www.oracle.com if you need additional information or have any
29 * questions.
30 */
31
32 #include <memory>
33 #include <string>
34 #include <type_traits>
35 #include <vector>
36
37 #include <android-base/logging.h>
38
39 #include <jni.h>
40
41 #include "jvmti.h"
42
43 #include "alloc_manager.h"
44 #include "art_jvmti.h"
45 #include "base/logging.h" // For gLogVerbosity.
46 #include "base/mutex.h"
47 #include "events-inl.h"
48 #include "jni/jni_env_ext-inl.h"
49 #include "obj_ptr-inl.h"
50 #include "object_tagging.h"
51 #include "runtime.h"
52 #include "scoped_thread_state_change-inl.h"
53 #include "thread-current-inl.h"
54 #include "thread_list.h"
55 #include "ti_allocator.h"
56 #include "ti_breakpoint.h"
57 #include "ti_class.h"
58 #include "ti_dump.h"
59 #include "ti_extension.h"
60 #include "ti_field.h"
61 #include "ti_heap.h"
62 #include "ti_jni.h"
63 #include "ti_logging.h"
64 #include "ti_method.h"
65 #include "ti_monitor.h"
66 #include "ti_object.h"
67 #include "ti_phase.h"
68 #include "ti_properties.h"
69 #include "ti_redefine.h"
70 #include "ti_search.h"
71 #include "ti_stack.h"
72 #include "ti_thread.h"
73 #include "ti_threadgroup.h"
74 #include "ti_timers.h"
75 #include "transform.h"
76
77 namespace openjdkjvmti {
78
79 // NB These are heap allocated to avoid the static destructors being run if an agent calls exit(3).
80 // These should never be null.
81 EventHandler* gEventHandler;
82 DeoptManager* gDeoptManager;
83 AllocationManager* gAllocManager;
84
85 #define ENSURE_NON_NULL(n) \
86 do { \
87 if ((n) == nullptr) { \
88 return ERR(NULL_POINTER); \
89 } \
90 } while (false)
91
92 // Returns whether we are able to use all jvmti features.
IsFullJvmtiAvailable()93 static bool IsFullJvmtiAvailable() {
94 art::Runtime* runtime = art::Runtime::Current();
95 return runtime->GetInstrumentation()->IsForcedInterpretOnly() || runtime->IsJavaDebuggable();
96 }
97
98 class JvmtiFunctions {
99 private:
getEnvironmentError(jvmtiEnv * env)100 static jvmtiError getEnvironmentError(jvmtiEnv* env) {
101 if (env == nullptr) {
102 return ERR(INVALID_ENVIRONMENT);
103 } else if (art::Thread::Current() == nullptr) {
104 return ERR(UNATTACHED_THREAD);
105 } else {
106 return OK;
107 }
108 }
109
110 #define ENSURE_VALID_ENV(env) \
111 do { \
112 jvmtiError ensure_valid_env_ ## __LINE__ = getEnvironmentError(env); \
113 if (ensure_valid_env_ ## __LINE__ != OK) { \
114 return ensure_valid_env_ ## __LINE__ ; \
115 } \
116 } while (false)
117
118 #define ENSURE_HAS_CAP(env, cap) \
119 do { \
120 if (ArtJvmTiEnv::AsArtJvmTiEnv(env)->capabilities.cap != 1) { \
121 return ERR(MUST_POSSESS_CAPABILITY); \
122 } \
123 } while (false)
124
125 public:
Allocate(jvmtiEnv * env,jlong size,unsigned char ** mem_ptr)126 static jvmtiError Allocate(jvmtiEnv* env, jlong size, unsigned char** mem_ptr) {
127 jvmtiError err = getEnvironmentError(env);
128 // Allow UNATTACHED_THREAD since we don't really care about that for this function.
129 if (err != OK && err != ERR(UNATTACHED_THREAD)) {
130 return err;
131 }
132 ENSURE_NON_NULL(mem_ptr);
133 return AllocUtil::Allocate(env, size, mem_ptr);
134 }
135
Deallocate(jvmtiEnv * env,unsigned char * mem)136 static jvmtiError Deallocate(jvmtiEnv* env, unsigned char* mem) {
137 jvmtiError err = getEnvironmentError(env);
138 // Allow UNATTACHED_THREAD since we don't really care about that for this function.
139 if (err != OK && err != ERR(UNATTACHED_THREAD)) {
140 return err;
141 }
142 return AllocUtil::Deallocate(env, mem);
143 }
144
GetThreadState(jvmtiEnv * env,jthread thread,jint * thread_state_ptr)145 static jvmtiError GetThreadState(jvmtiEnv* env, jthread thread, jint* thread_state_ptr) {
146 ENSURE_VALID_ENV(env);
147 return ThreadUtil::GetThreadState(env, thread, thread_state_ptr);
148 }
149
GetCurrentThread(jvmtiEnv * env,jthread * thread_ptr)150 static jvmtiError GetCurrentThread(jvmtiEnv* env, jthread* thread_ptr) {
151 ENSURE_VALID_ENV(env);
152 return ThreadUtil::GetCurrentThread(env, thread_ptr);
153 }
154
GetAllThreads(jvmtiEnv * env,jint * threads_count_ptr,jthread ** threads_ptr)155 static jvmtiError GetAllThreads(jvmtiEnv* env, jint* threads_count_ptr, jthread** threads_ptr) {
156 ENSURE_VALID_ENV(env);
157 return ThreadUtil::GetAllThreads(env, threads_count_ptr, threads_ptr);
158 }
159
SuspendThread(jvmtiEnv * env,jthread thread)160 static jvmtiError SuspendThread(jvmtiEnv* env, jthread thread) {
161 ENSURE_VALID_ENV(env);
162 ENSURE_HAS_CAP(env, can_suspend);
163 return ThreadUtil::SuspendThread(env, thread);
164 }
165
SuspendThreadList(jvmtiEnv * env,jint request_count,const jthread * request_list,jvmtiError * results)166 static jvmtiError SuspendThreadList(jvmtiEnv* env,
167 jint request_count,
168 const jthread* request_list,
169 jvmtiError* results) {
170 ENSURE_VALID_ENV(env);
171 ENSURE_HAS_CAP(env, can_suspend);
172 return ThreadUtil::SuspendThreadList(env, request_count, request_list, results);
173 }
174
ResumeThread(jvmtiEnv * env,jthread thread)175 static jvmtiError ResumeThread(jvmtiEnv* env, jthread thread) {
176 ENSURE_VALID_ENV(env);
177 ENSURE_HAS_CAP(env, can_suspend);
178 return ThreadUtil::ResumeThread(env, thread);
179 }
180
ResumeThreadList(jvmtiEnv * env,jint request_count,const jthread * request_list,jvmtiError * results)181 static jvmtiError ResumeThreadList(jvmtiEnv* env,
182 jint request_count,
183 const jthread* request_list,
184 jvmtiError* results) {
185 ENSURE_VALID_ENV(env);
186 ENSURE_HAS_CAP(env, can_suspend);
187 return ThreadUtil::ResumeThreadList(env, request_count, request_list, results);
188 }
189
StopThread(jvmtiEnv * env,jthread thread,jobject exception)190 static jvmtiError StopThread(jvmtiEnv* env, jthread thread, jobject exception) {
191 ENSURE_VALID_ENV(env);
192 ENSURE_HAS_CAP(env, can_signal_thread);
193 return ThreadUtil::StopThread(env, thread, exception);
194 }
195
InterruptThread(jvmtiEnv * env,jthread thread)196 static jvmtiError InterruptThread(jvmtiEnv* env, jthread thread) {
197 ENSURE_VALID_ENV(env);
198 ENSURE_HAS_CAP(env, can_signal_thread);
199 return ThreadUtil::InterruptThread(env, thread);
200 }
201
GetThreadInfo(jvmtiEnv * env,jthread thread,jvmtiThreadInfo * info_ptr)202 static jvmtiError GetThreadInfo(jvmtiEnv* env, jthread thread, jvmtiThreadInfo* info_ptr) {
203 ENSURE_VALID_ENV(env);
204 return ThreadUtil::GetThreadInfo(env, thread, info_ptr);
205 }
206
GetOwnedMonitorInfo(jvmtiEnv * env,jthread thread,jint * owned_monitor_count_ptr,jobject ** owned_monitors_ptr)207 static jvmtiError GetOwnedMonitorInfo(jvmtiEnv* env,
208 jthread thread,
209 jint* owned_monitor_count_ptr,
210 jobject** owned_monitors_ptr) {
211 ENSURE_VALID_ENV(env);
212 ENSURE_HAS_CAP(env, can_get_owned_monitor_info);
213 return StackUtil::GetOwnedMonitorInfo(env,
214 thread,
215 owned_monitor_count_ptr,
216 owned_monitors_ptr);
217 }
218
GetOwnedMonitorStackDepthInfo(jvmtiEnv * env,jthread thread,jint * monitor_info_count_ptr,jvmtiMonitorStackDepthInfo ** monitor_info_ptr)219 static jvmtiError GetOwnedMonitorStackDepthInfo(jvmtiEnv* env,
220 jthread thread,
221 jint* monitor_info_count_ptr,
222 jvmtiMonitorStackDepthInfo** monitor_info_ptr) {
223 ENSURE_VALID_ENV(env);
224 ENSURE_HAS_CAP(env, can_get_owned_monitor_stack_depth_info);
225 return StackUtil::GetOwnedMonitorStackDepthInfo(env,
226 thread,
227 monitor_info_count_ptr,
228 monitor_info_ptr);
229 }
230
GetCurrentContendedMonitor(jvmtiEnv * env,jthread thread,jobject * monitor_ptr)231 static jvmtiError GetCurrentContendedMonitor(jvmtiEnv* env,
232 jthread thread,
233 jobject* monitor_ptr) {
234 ENSURE_VALID_ENV(env);
235 ENSURE_HAS_CAP(env, can_get_current_contended_monitor);
236 return MonitorUtil::GetCurrentContendedMonitor(env, thread, monitor_ptr);
237 }
238
RunAgentThread(jvmtiEnv * env,jthread thread,jvmtiStartFunction proc,const void * arg,jint priority)239 static jvmtiError RunAgentThread(jvmtiEnv* env,
240 jthread thread,
241 jvmtiStartFunction proc,
242 const void* arg,
243 jint priority) {
244 ENSURE_VALID_ENV(env);
245 return ThreadUtil::RunAgentThread(env, thread, proc, arg, priority);
246 }
247
SetThreadLocalStorage(jvmtiEnv * env,jthread thread,const void * data)248 static jvmtiError SetThreadLocalStorage(jvmtiEnv* env, jthread thread, const void* data) {
249 ENSURE_VALID_ENV(env);
250 return ThreadUtil::SetThreadLocalStorage(env, thread, data);
251 }
252
GetThreadLocalStorage(jvmtiEnv * env,jthread thread,void ** data_ptr)253 static jvmtiError GetThreadLocalStorage(jvmtiEnv* env, jthread thread, void** data_ptr) {
254 ENSURE_VALID_ENV(env);
255 return ThreadUtil::GetThreadLocalStorage(env, thread, data_ptr);
256 }
257
GetTopThreadGroups(jvmtiEnv * env,jint * group_count_ptr,jthreadGroup ** groups_ptr)258 static jvmtiError GetTopThreadGroups(jvmtiEnv* env,
259 jint* group_count_ptr,
260 jthreadGroup** groups_ptr) {
261 ENSURE_VALID_ENV(env);
262 return ThreadGroupUtil::GetTopThreadGroups(env, group_count_ptr, groups_ptr);
263 }
264
GetThreadGroupInfo(jvmtiEnv * env,jthreadGroup group,jvmtiThreadGroupInfo * info_ptr)265 static jvmtiError GetThreadGroupInfo(jvmtiEnv* env,
266 jthreadGroup group,
267 jvmtiThreadGroupInfo* info_ptr) {
268 ENSURE_VALID_ENV(env);
269 return ThreadGroupUtil::GetThreadGroupInfo(env, group, info_ptr);
270 }
271
GetThreadGroupChildren(jvmtiEnv * env,jthreadGroup group,jint * thread_count_ptr,jthread ** threads_ptr,jint * group_count_ptr,jthreadGroup ** groups_ptr)272 static jvmtiError GetThreadGroupChildren(jvmtiEnv* env,
273 jthreadGroup group,
274 jint* thread_count_ptr,
275 jthread** threads_ptr,
276 jint* group_count_ptr,
277 jthreadGroup** groups_ptr) {
278 ENSURE_VALID_ENV(env);
279 return ThreadGroupUtil::GetThreadGroupChildren(env,
280 group,
281 thread_count_ptr,
282 threads_ptr,
283 group_count_ptr,
284 groups_ptr);
285 }
286
GetStackTrace(jvmtiEnv * env,jthread thread,jint start_depth,jint max_frame_count,jvmtiFrameInfo * frame_buffer,jint * count_ptr)287 static jvmtiError GetStackTrace(jvmtiEnv* env,
288 jthread thread,
289 jint start_depth,
290 jint max_frame_count,
291 jvmtiFrameInfo* frame_buffer,
292 jint* count_ptr) {
293 ENSURE_VALID_ENV(env);
294 return StackUtil::GetStackTrace(env,
295 thread,
296 start_depth,
297 max_frame_count,
298 frame_buffer,
299 count_ptr);
300 }
301
GetAllStackTraces(jvmtiEnv * env,jint max_frame_count,jvmtiStackInfo ** stack_info_ptr,jint * thread_count_ptr)302 static jvmtiError GetAllStackTraces(jvmtiEnv* env,
303 jint max_frame_count,
304 jvmtiStackInfo** stack_info_ptr,
305 jint* thread_count_ptr) {
306 ENSURE_VALID_ENV(env);
307 return StackUtil::GetAllStackTraces(env, max_frame_count, stack_info_ptr, thread_count_ptr);
308 }
309
GetThreadListStackTraces(jvmtiEnv * env,jint thread_count,const jthread * thread_list,jint max_frame_count,jvmtiStackInfo ** stack_info_ptr)310 static jvmtiError GetThreadListStackTraces(jvmtiEnv* env,
311 jint thread_count,
312 const jthread* thread_list,
313 jint max_frame_count,
314 jvmtiStackInfo** stack_info_ptr) {
315 ENSURE_VALID_ENV(env);
316 return StackUtil::GetThreadListStackTraces(env,
317 thread_count,
318 thread_list,
319 max_frame_count,
320 stack_info_ptr);
321 }
322
GetFrameCount(jvmtiEnv * env,jthread thread,jint * count_ptr)323 static jvmtiError GetFrameCount(jvmtiEnv* env, jthread thread, jint* count_ptr) {
324 ENSURE_VALID_ENV(env);
325 return StackUtil::GetFrameCount(env, thread, count_ptr);
326 }
327
PopFrame(jvmtiEnv * env,jthread thread)328 static jvmtiError PopFrame(jvmtiEnv* env, jthread thread) {
329 ENSURE_VALID_ENV(env);
330 ENSURE_HAS_CAP(env, can_pop_frame);
331 return StackUtil::PopFrame(env, thread);
332 }
333
GetFrameLocation(jvmtiEnv * env,jthread thread,jint depth,jmethodID * method_ptr,jlocation * location_ptr)334 static jvmtiError GetFrameLocation(jvmtiEnv* env,
335 jthread thread,
336 jint depth,
337 jmethodID* method_ptr,
338 jlocation* location_ptr) {
339 ENSURE_VALID_ENV(env);
340 return StackUtil::GetFrameLocation(env, thread, depth, method_ptr, location_ptr);
341 }
342
NotifyFramePop(jvmtiEnv * env,jthread thread,jint depth)343 static jvmtiError NotifyFramePop(jvmtiEnv* env, jthread thread, jint depth) {
344 ENSURE_VALID_ENV(env);
345 ENSURE_HAS_CAP(env, can_generate_frame_pop_events);
346 return StackUtil::NotifyFramePop(env, thread, depth);
347 }
348
ForceEarlyReturnObject(jvmtiEnv * env,jthread thread,jobject value)349 static jvmtiError ForceEarlyReturnObject(jvmtiEnv* env, jthread thread, jobject value) {
350 ENSURE_VALID_ENV(env);
351 ENSURE_HAS_CAP(env, can_force_early_return);
352 return StackUtil::ForceEarlyReturn(env, gEventHandler, thread, value);
353 }
354
ForceEarlyReturnInt(jvmtiEnv * env,jthread thread,jint value)355 static jvmtiError ForceEarlyReturnInt(jvmtiEnv* env, jthread thread, jint value) {
356 ENSURE_VALID_ENV(env);
357 ENSURE_HAS_CAP(env, can_force_early_return);
358 return StackUtil::ForceEarlyReturn(env, gEventHandler, thread, value);
359 }
360
ForceEarlyReturnLong(jvmtiEnv * env,jthread thread,jlong value)361 static jvmtiError ForceEarlyReturnLong(jvmtiEnv* env, jthread thread, jlong value) {
362 ENSURE_VALID_ENV(env);
363 ENSURE_HAS_CAP(env, can_force_early_return);
364 return StackUtil::ForceEarlyReturn(env, gEventHandler, thread, value);
365 }
366
ForceEarlyReturnFloat(jvmtiEnv * env,jthread thread,jfloat value)367 static jvmtiError ForceEarlyReturnFloat(jvmtiEnv* env, jthread thread, jfloat value) {
368 ENSURE_VALID_ENV(env);
369 ENSURE_HAS_CAP(env, can_force_early_return);
370 return StackUtil::ForceEarlyReturn(env, gEventHandler, thread, value);
371 }
372
ForceEarlyReturnDouble(jvmtiEnv * env,jthread thread,jdouble value)373 static jvmtiError ForceEarlyReturnDouble(jvmtiEnv* env, jthread thread, jdouble value) {
374 ENSURE_VALID_ENV(env);
375 ENSURE_HAS_CAP(env, can_force_early_return);
376 return StackUtil::ForceEarlyReturn(env, gEventHandler, thread, value);
377 }
378
ForceEarlyReturnVoid(jvmtiEnv * env,jthread thread)379 static jvmtiError ForceEarlyReturnVoid(jvmtiEnv* env, jthread thread) {
380 ENSURE_VALID_ENV(env);
381 ENSURE_HAS_CAP(env, can_force_early_return);
382 return StackUtil::ForceEarlyReturn<nullptr_t>(env, gEventHandler, thread, nullptr);
383 }
384
FollowReferences(jvmtiEnv * env,jint heap_filter,jclass klass,jobject initial_object,const jvmtiHeapCallbacks * callbacks,const void * user_data)385 static jvmtiError FollowReferences(jvmtiEnv* env,
386 jint heap_filter,
387 jclass klass,
388 jobject initial_object,
389 const jvmtiHeapCallbacks* callbacks,
390 const void* user_data) {
391 ENSURE_VALID_ENV(env);
392 ENSURE_HAS_CAP(env, can_tag_objects);
393 HeapUtil heap_util(ArtJvmTiEnv::AsArtJvmTiEnv(env)->object_tag_table.get());
394 return heap_util.FollowReferences(env,
395 heap_filter,
396 klass,
397 initial_object,
398 callbacks,
399 user_data);
400 }
401
IterateThroughHeap(jvmtiEnv * env,jint heap_filter,jclass klass,const jvmtiHeapCallbacks * callbacks,const void * user_data)402 static jvmtiError IterateThroughHeap(jvmtiEnv* env,
403 jint heap_filter,
404 jclass klass,
405 const jvmtiHeapCallbacks* callbacks,
406 const void* user_data) {
407 ENSURE_VALID_ENV(env);
408 ENSURE_HAS_CAP(env, can_tag_objects);
409 HeapUtil heap_util(ArtJvmTiEnv::AsArtJvmTiEnv(env)->object_tag_table.get());
410 return heap_util.IterateThroughHeap(env, heap_filter, klass, callbacks, user_data);
411 }
412
GetTag(jvmtiEnv * env,jobject object,jlong * tag_ptr)413 static jvmtiError GetTag(jvmtiEnv* env, jobject object, jlong* tag_ptr) {
414 ENSURE_VALID_ENV(env);
415 ENSURE_HAS_CAP(env, can_tag_objects);
416
417 JNIEnv* jni_env = GetJniEnv(env);
418 if (jni_env == nullptr) {
419 return ERR(INTERNAL);
420 }
421
422 art::ScopedObjectAccess soa(jni_env);
423 art::ObjPtr<art::mirror::Object> obj = soa.Decode<art::mirror::Object>(object);
424 if (!ArtJvmTiEnv::AsArtJvmTiEnv(env)->object_tag_table->GetTag(obj.Ptr(), tag_ptr)) {
425 *tag_ptr = 0;
426 }
427
428 return ERR(NONE);
429 }
430
SetTag(jvmtiEnv * env,jobject object,jlong tag)431 static jvmtiError SetTag(jvmtiEnv* env, jobject object, jlong tag) {
432 ENSURE_VALID_ENV(env);
433 ENSURE_HAS_CAP(env, can_tag_objects);
434
435 if (object == nullptr) {
436 return ERR(NULL_POINTER);
437 }
438
439 JNIEnv* jni_env = GetJniEnv(env);
440 if (jni_env == nullptr) {
441 return ERR(INTERNAL);
442 }
443
444 art::ScopedObjectAccess soa(jni_env);
445 art::ObjPtr<art::mirror::Object> obj = soa.Decode<art::mirror::Object>(object);
446 ArtJvmTiEnv::AsArtJvmTiEnv(env)->object_tag_table->Set(obj.Ptr(), tag);
447
448 return ERR(NONE);
449 }
450
GetObjectsWithTags(jvmtiEnv * env,jint tag_count,const jlong * tags,jint * count_ptr,jobject ** object_result_ptr,jlong ** tag_result_ptr)451 static jvmtiError GetObjectsWithTags(jvmtiEnv* env,
452 jint tag_count,
453 const jlong* tags,
454 jint* count_ptr,
455 jobject** object_result_ptr,
456 jlong** tag_result_ptr) {
457 ENSURE_VALID_ENV(env);
458 ENSURE_HAS_CAP(env, can_tag_objects);
459
460 JNIEnv* jni_env = GetJniEnv(env);
461 if (jni_env == nullptr) {
462 return ERR(INTERNAL);
463 }
464
465 art::ScopedObjectAccess soa(jni_env);
466 return ArtJvmTiEnv::AsArtJvmTiEnv(env)->object_tag_table->GetTaggedObjects(env,
467 tag_count,
468 tags,
469 count_ptr,
470 object_result_ptr,
471 tag_result_ptr);
472 }
473
ForceGarbageCollection(jvmtiEnv * env)474 static jvmtiError ForceGarbageCollection(jvmtiEnv* env) {
475 ENSURE_VALID_ENV(env);
476 return HeapUtil::ForceGarbageCollection(env);
477 }
478
IterateOverObjectsReachableFromObject(jvmtiEnv * env,jobject object ATTRIBUTE_UNUSED,jvmtiObjectReferenceCallback object_reference_callback ATTRIBUTE_UNUSED,const void * user_data ATTRIBUTE_UNUSED)479 static jvmtiError IterateOverObjectsReachableFromObject(
480 jvmtiEnv* env,
481 jobject object ATTRIBUTE_UNUSED,
482 jvmtiObjectReferenceCallback object_reference_callback ATTRIBUTE_UNUSED,
483 const void* user_data ATTRIBUTE_UNUSED) {
484 ENSURE_VALID_ENV(env);
485 ENSURE_HAS_CAP(env, can_tag_objects);
486 return ERR(NOT_IMPLEMENTED);
487 }
488
IterateOverReachableObjects(jvmtiEnv * env,jvmtiHeapRootCallback heap_root_callback ATTRIBUTE_UNUSED,jvmtiStackReferenceCallback stack_ref_callback ATTRIBUTE_UNUSED,jvmtiObjectReferenceCallback object_ref_callback ATTRIBUTE_UNUSED,const void * user_data ATTRIBUTE_UNUSED)489 static jvmtiError IterateOverReachableObjects(
490 jvmtiEnv* env,
491 jvmtiHeapRootCallback heap_root_callback ATTRIBUTE_UNUSED,
492 jvmtiStackReferenceCallback stack_ref_callback ATTRIBUTE_UNUSED,
493 jvmtiObjectReferenceCallback object_ref_callback ATTRIBUTE_UNUSED,
494 const void* user_data ATTRIBUTE_UNUSED) {
495 ENSURE_VALID_ENV(env);
496 ENSURE_HAS_CAP(env, can_tag_objects);
497 return ERR(NOT_IMPLEMENTED);
498 }
499
IterateOverHeap(jvmtiEnv * env,jvmtiHeapObjectFilter object_filter ATTRIBUTE_UNUSED,jvmtiHeapObjectCallback heap_object_callback ATTRIBUTE_UNUSED,const void * user_data ATTRIBUTE_UNUSED)500 static jvmtiError IterateOverHeap(jvmtiEnv* env,
501 jvmtiHeapObjectFilter object_filter ATTRIBUTE_UNUSED,
502 jvmtiHeapObjectCallback heap_object_callback ATTRIBUTE_UNUSED,
503 const void* user_data ATTRIBUTE_UNUSED) {
504 ENSURE_VALID_ENV(env);
505 ENSURE_HAS_CAP(env, can_tag_objects);
506 return ERR(NOT_IMPLEMENTED);
507 }
508
IterateOverInstancesOfClass(jvmtiEnv * env,jclass klass,jvmtiHeapObjectFilter object_filter,jvmtiHeapObjectCallback heap_object_callback,const void * user_data)509 static jvmtiError IterateOverInstancesOfClass(
510 jvmtiEnv* env,
511 jclass klass,
512 jvmtiHeapObjectFilter object_filter,
513 jvmtiHeapObjectCallback heap_object_callback,
514 const void* user_data) {
515 ENSURE_VALID_ENV(env);
516 ENSURE_HAS_CAP(env, can_tag_objects);
517 HeapUtil heap_util(ArtJvmTiEnv::AsArtJvmTiEnv(env)->object_tag_table.get());
518 return heap_util.IterateOverInstancesOfClass(
519 env, klass, object_filter, heap_object_callback, user_data);
520 }
521
GetLocalObject(jvmtiEnv * env,jthread thread,jint depth,jint slot,jobject * value_ptr)522 static jvmtiError GetLocalObject(jvmtiEnv* env,
523 jthread thread,
524 jint depth,
525 jint slot,
526 jobject* value_ptr) {
527 ENSURE_VALID_ENV(env);
528 ENSURE_HAS_CAP(env, can_access_local_variables);
529 return MethodUtil::GetLocalVariable(env, thread, depth, slot, value_ptr);
530 }
531
GetLocalInstance(jvmtiEnv * env,jthread thread,jint depth,jobject * value_ptr)532 static jvmtiError GetLocalInstance(jvmtiEnv* env,
533 jthread thread,
534 jint depth,
535 jobject* value_ptr) {
536 ENSURE_VALID_ENV(env);
537 ENSURE_HAS_CAP(env, can_access_local_variables);
538 return MethodUtil::GetLocalInstance(env, thread, depth, value_ptr);
539 }
540
GetLocalInt(jvmtiEnv * env,jthread thread,jint depth,jint slot,jint * value_ptr)541 static jvmtiError GetLocalInt(jvmtiEnv* env,
542 jthread thread,
543 jint depth,
544 jint slot,
545 jint* value_ptr) {
546 ENSURE_VALID_ENV(env);
547 ENSURE_HAS_CAP(env, can_access_local_variables);
548 return MethodUtil::GetLocalVariable(env, thread, depth, slot, value_ptr);
549 }
550
GetLocalLong(jvmtiEnv * env,jthread thread,jint depth,jint slot,jlong * value_ptr)551 static jvmtiError GetLocalLong(jvmtiEnv* env,
552 jthread thread,
553 jint depth,
554 jint slot,
555 jlong* value_ptr) {
556 ENSURE_VALID_ENV(env);
557 ENSURE_HAS_CAP(env, can_access_local_variables);
558 return MethodUtil::GetLocalVariable(env, thread, depth, slot, value_ptr);
559 }
560
GetLocalFloat(jvmtiEnv * env,jthread thread,jint depth,jint slot,jfloat * value_ptr)561 static jvmtiError GetLocalFloat(jvmtiEnv* env,
562 jthread thread,
563 jint depth,
564 jint slot,
565 jfloat* value_ptr) {
566 ENSURE_VALID_ENV(env);
567 ENSURE_HAS_CAP(env, can_access_local_variables);
568 return MethodUtil::GetLocalVariable(env, thread, depth, slot, value_ptr);
569 }
570
GetLocalDouble(jvmtiEnv * env,jthread thread,jint depth,jint slot,jdouble * value_ptr)571 static jvmtiError GetLocalDouble(jvmtiEnv* env,
572 jthread thread,
573 jint depth,
574 jint slot,
575 jdouble* value_ptr) {
576 ENSURE_VALID_ENV(env);
577 ENSURE_HAS_CAP(env, can_access_local_variables);
578 return MethodUtil::GetLocalVariable(env, thread, depth, slot, value_ptr);
579 }
580
SetLocalObject(jvmtiEnv * env,jthread thread,jint depth,jint slot,jobject value)581 static jvmtiError SetLocalObject(jvmtiEnv* env,
582 jthread thread,
583 jint depth,
584 jint slot,
585 jobject value) {
586 ENSURE_VALID_ENV(env);
587 ENSURE_HAS_CAP(env, can_access_local_variables);
588 return MethodUtil::SetLocalVariable(env, thread, depth, slot, value);
589 }
590
SetLocalInt(jvmtiEnv * env,jthread thread,jint depth,jint slot,jint value)591 static jvmtiError SetLocalInt(jvmtiEnv* env,
592 jthread thread,
593 jint depth,
594 jint slot,
595 jint value) {
596 ENSURE_VALID_ENV(env);
597 ENSURE_HAS_CAP(env, can_access_local_variables);
598 return MethodUtil::SetLocalVariable(env, thread, depth, slot, value);
599 }
600
SetLocalLong(jvmtiEnv * env,jthread thread,jint depth,jint slot,jlong value)601 static jvmtiError SetLocalLong(jvmtiEnv* env,
602 jthread thread,
603 jint depth,
604 jint slot,
605 jlong value) {
606 ENSURE_VALID_ENV(env);
607 ENSURE_HAS_CAP(env, can_access_local_variables);
608 return MethodUtil::SetLocalVariable(env, thread, depth, slot, value);
609 }
610
SetLocalFloat(jvmtiEnv * env,jthread thread,jint depth,jint slot,jfloat value)611 static jvmtiError SetLocalFloat(jvmtiEnv* env,
612 jthread thread,
613 jint depth,
614 jint slot,
615 jfloat value) {
616 ENSURE_VALID_ENV(env);
617 ENSURE_HAS_CAP(env, can_access_local_variables);
618 return MethodUtil::SetLocalVariable(env, thread, depth, slot, value);
619 }
620
SetLocalDouble(jvmtiEnv * env,jthread thread,jint depth,jint slot,jdouble value)621 static jvmtiError SetLocalDouble(jvmtiEnv* env,
622 jthread thread,
623 jint depth,
624 jint slot,
625 jdouble value) {
626 ENSURE_VALID_ENV(env);
627 ENSURE_HAS_CAP(env, can_access_local_variables);
628 return MethodUtil::SetLocalVariable(env, thread, depth, slot, value);
629 }
630
631
SetBreakpoint(jvmtiEnv * env,jmethodID method,jlocation location)632 static jvmtiError SetBreakpoint(jvmtiEnv* env, jmethodID method, jlocation location) {
633 ENSURE_VALID_ENV(env);
634 ENSURE_HAS_CAP(env, can_generate_breakpoint_events);
635 return BreakpointUtil::SetBreakpoint(env, method, location);
636 }
637
ClearBreakpoint(jvmtiEnv * env,jmethodID method,jlocation location)638 static jvmtiError ClearBreakpoint(jvmtiEnv* env, jmethodID method, jlocation location) {
639 ENSURE_VALID_ENV(env);
640 ENSURE_HAS_CAP(env, can_generate_breakpoint_events);
641 return BreakpointUtil::ClearBreakpoint(env, method, location);
642 }
643
SetFieldAccessWatch(jvmtiEnv * env,jclass klass,jfieldID field)644 static jvmtiError SetFieldAccessWatch(jvmtiEnv* env, jclass klass, jfieldID field) {
645 ENSURE_VALID_ENV(env);
646 ENSURE_HAS_CAP(env, can_generate_field_access_events);
647 return FieldUtil::SetFieldAccessWatch(env, klass, field);
648 }
649
ClearFieldAccessWatch(jvmtiEnv * env,jclass klass,jfieldID field)650 static jvmtiError ClearFieldAccessWatch(jvmtiEnv* env, jclass klass, jfieldID field) {
651 ENSURE_VALID_ENV(env);
652 ENSURE_HAS_CAP(env, can_generate_field_access_events);
653 return FieldUtil::ClearFieldAccessWatch(env, klass, field);
654 }
655
SetFieldModificationWatch(jvmtiEnv * env,jclass klass,jfieldID field)656 static jvmtiError SetFieldModificationWatch(jvmtiEnv* env, jclass klass, jfieldID field) {
657 ENSURE_VALID_ENV(env);
658 ENSURE_HAS_CAP(env, can_generate_field_modification_events);
659 return FieldUtil::SetFieldModificationWatch(env, klass, field);
660 }
661
ClearFieldModificationWatch(jvmtiEnv * env,jclass klass,jfieldID field)662 static jvmtiError ClearFieldModificationWatch(jvmtiEnv* env, jclass klass, jfieldID field) {
663 ENSURE_VALID_ENV(env);
664 ENSURE_HAS_CAP(env, can_generate_field_modification_events);
665 return FieldUtil::ClearFieldModificationWatch(env, klass, field);
666 }
667
GetLoadedClasses(jvmtiEnv * env,jint * class_count_ptr,jclass ** classes_ptr)668 static jvmtiError GetLoadedClasses(jvmtiEnv* env, jint* class_count_ptr, jclass** classes_ptr) {
669 ENSURE_VALID_ENV(env);
670 HeapUtil heap_util(ArtJvmTiEnv::AsArtJvmTiEnv(env)->object_tag_table.get());
671 return heap_util.GetLoadedClasses(env, class_count_ptr, classes_ptr);
672 }
673
GetClassLoaderClasses(jvmtiEnv * env,jobject initiating_loader,jint * class_count_ptr,jclass ** classes_ptr)674 static jvmtiError GetClassLoaderClasses(jvmtiEnv* env,
675 jobject initiating_loader,
676 jint* class_count_ptr,
677 jclass** classes_ptr) {
678 ENSURE_VALID_ENV(env);
679 return ClassUtil::GetClassLoaderClasses(env, initiating_loader, class_count_ptr, classes_ptr);
680 }
681
GetClassSignature(jvmtiEnv * env,jclass klass,char ** signature_ptr,char ** generic_ptr)682 static jvmtiError GetClassSignature(jvmtiEnv* env,
683 jclass klass,
684 char** signature_ptr,
685 char** generic_ptr) {
686 ENSURE_VALID_ENV(env);
687 return ClassUtil::GetClassSignature(env, klass, signature_ptr, generic_ptr);
688 }
689
GetClassStatus(jvmtiEnv * env,jclass klass,jint * status_ptr)690 static jvmtiError GetClassStatus(jvmtiEnv* env, jclass klass, jint* status_ptr) {
691 ENSURE_VALID_ENV(env);
692 return ClassUtil::GetClassStatus(env, klass, status_ptr);
693 }
694
GetSourceFileName(jvmtiEnv * env,jclass klass,char ** source_name_ptr)695 static jvmtiError GetSourceFileName(jvmtiEnv* env, jclass klass, char** source_name_ptr) {
696 ENSURE_VALID_ENV(env);
697 ENSURE_HAS_CAP(env, can_get_source_file_name);
698 return ClassUtil::GetSourceFileName(env, klass, source_name_ptr);
699 }
700
GetClassModifiers(jvmtiEnv * env,jclass klass,jint * modifiers_ptr)701 static jvmtiError GetClassModifiers(jvmtiEnv* env, jclass klass, jint* modifiers_ptr) {
702 ENSURE_VALID_ENV(env);
703 return ClassUtil::GetClassModifiers(env, klass, modifiers_ptr);
704 }
705
GetClassMethods(jvmtiEnv * env,jclass klass,jint * method_count_ptr,jmethodID ** methods_ptr)706 static jvmtiError GetClassMethods(jvmtiEnv* env,
707 jclass klass,
708 jint* method_count_ptr,
709 jmethodID** methods_ptr) {
710 ENSURE_VALID_ENV(env);
711 return ClassUtil::GetClassMethods(env, klass, method_count_ptr, methods_ptr);
712 }
713
GetClassFields(jvmtiEnv * env,jclass klass,jint * field_count_ptr,jfieldID ** fields_ptr)714 static jvmtiError GetClassFields(jvmtiEnv* env,
715 jclass klass,
716 jint* field_count_ptr,
717 jfieldID** fields_ptr) {
718 ENSURE_VALID_ENV(env);
719 return ClassUtil::GetClassFields(env, klass, field_count_ptr, fields_ptr);
720 }
721
GetImplementedInterfaces(jvmtiEnv * env,jclass klass,jint * interface_count_ptr,jclass ** interfaces_ptr)722 static jvmtiError GetImplementedInterfaces(jvmtiEnv* env,
723 jclass klass,
724 jint* interface_count_ptr,
725 jclass** interfaces_ptr) {
726 ENSURE_VALID_ENV(env);
727 return ClassUtil::GetImplementedInterfaces(env, klass, interface_count_ptr, interfaces_ptr);
728 }
729
GetClassVersionNumbers(jvmtiEnv * env,jclass klass,jint * minor_version_ptr,jint * major_version_ptr)730 static jvmtiError GetClassVersionNumbers(jvmtiEnv* env,
731 jclass klass,
732 jint* minor_version_ptr,
733 jint* major_version_ptr) {
734 ENSURE_VALID_ENV(env);
735 return ClassUtil::GetClassVersionNumbers(env, klass, minor_version_ptr, major_version_ptr);
736 }
737
GetConstantPool(jvmtiEnv * env,jclass klass ATTRIBUTE_UNUSED,jint * constant_pool_count_ptr ATTRIBUTE_UNUSED,jint * constant_pool_byte_count_ptr ATTRIBUTE_UNUSED,unsigned char ** constant_pool_bytes_ptr ATTRIBUTE_UNUSED)738 static jvmtiError GetConstantPool(jvmtiEnv* env,
739 jclass klass ATTRIBUTE_UNUSED,
740 jint* constant_pool_count_ptr ATTRIBUTE_UNUSED,
741 jint* constant_pool_byte_count_ptr ATTRIBUTE_UNUSED,
742 unsigned char** constant_pool_bytes_ptr ATTRIBUTE_UNUSED) {
743 ENSURE_VALID_ENV(env);
744 ENSURE_HAS_CAP(env, can_get_constant_pool);
745 return ERR(NOT_IMPLEMENTED);
746 }
747
IsInterface(jvmtiEnv * env,jclass klass,jboolean * is_interface_ptr)748 static jvmtiError IsInterface(jvmtiEnv* env, jclass klass, jboolean* is_interface_ptr) {
749 ENSURE_VALID_ENV(env);
750 return ClassUtil::IsInterface(env, klass, is_interface_ptr);
751 }
752
IsArrayClass(jvmtiEnv * env,jclass klass,jboolean * is_array_class_ptr)753 static jvmtiError IsArrayClass(jvmtiEnv* env,
754 jclass klass,
755 jboolean* is_array_class_ptr) {
756 ENSURE_VALID_ENV(env);
757 return ClassUtil::IsArrayClass(env, klass, is_array_class_ptr);
758 }
759
IsModifiableClass(jvmtiEnv * env,jclass klass,jboolean * is_modifiable_class_ptr)760 static jvmtiError IsModifiableClass(jvmtiEnv* env,
761 jclass klass,
762 jboolean* is_modifiable_class_ptr) {
763 ENSURE_VALID_ENV(env);
764 return Redefiner::IsModifiableClass(env, klass, is_modifiable_class_ptr);
765 }
766
GetClassLoader(jvmtiEnv * env,jclass klass,jobject * classloader_ptr)767 static jvmtiError GetClassLoader(jvmtiEnv* env, jclass klass, jobject* classloader_ptr) {
768 ENSURE_VALID_ENV(env);
769 return ClassUtil::GetClassLoader(env, klass, classloader_ptr);
770 }
771
GetSourceDebugExtension(jvmtiEnv * env,jclass klass,char ** source_debug_extension_ptr)772 static jvmtiError GetSourceDebugExtension(jvmtiEnv* env,
773 jclass klass,
774 char** source_debug_extension_ptr) {
775 ENSURE_VALID_ENV(env);
776 ENSURE_HAS_CAP(env, can_get_source_debug_extension);
777 return ClassUtil::GetSourceDebugExtension(env, klass, source_debug_extension_ptr);
778 }
779
RetransformClasses(jvmtiEnv * env,jint class_count,const jclass * classes)780 static jvmtiError RetransformClasses(jvmtiEnv* env, jint class_count, const jclass* classes) {
781 ENSURE_VALID_ENV(env);
782 ENSURE_HAS_CAP(env, can_retransform_classes);
783 return Transformer::RetransformClasses(env, class_count, classes);
784 }
785
RedefineClasses(jvmtiEnv * env,jint class_count,const jvmtiClassDefinition * class_definitions)786 static jvmtiError RedefineClasses(jvmtiEnv* env,
787 jint class_count,
788 const jvmtiClassDefinition* class_definitions) {
789 ENSURE_VALID_ENV(env);
790 ENSURE_HAS_CAP(env, can_redefine_classes);
791 return Redefiner::RedefineClasses(env, class_count, class_definitions);
792 }
793
GetObjectSize(jvmtiEnv * env,jobject object,jlong * size_ptr)794 static jvmtiError GetObjectSize(jvmtiEnv* env, jobject object, jlong* size_ptr) {
795 ENSURE_VALID_ENV(env);
796 return ObjectUtil::GetObjectSize(env, object, size_ptr);
797 }
798
GetObjectHashCode(jvmtiEnv * env,jobject object,jint * hash_code_ptr)799 static jvmtiError GetObjectHashCode(jvmtiEnv* env, jobject object, jint* hash_code_ptr) {
800 ENSURE_VALID_ENV(env);
801 return ObjectUtil::GetObjectHashCode(env, object, hash_code_ptr);
802 }
803
GetObjectMonitorUsage(jvmtiEnv * env,jobject object,jvmtiMonitorUsage * info_ptr)804 static jvmtiError GetObjectMonitorUsage(jvmtiEnv* env,
805 jobject object,
806 jvmtiMonitorUsage* info_ptr) {
807 ENSURE_VALID_ENV(env);
808 ENSURE_HAS_CAP(env, can_get_monitor_info);
809 return ObjectUtil::GetObjectMonitorUsage(env, object, info_ptr);
810 }
811
GetFieldName(jvmtiEnv * env,jclass klass,jfieldID field,char ** name_ptr,char ** signature_ptr,char ** generic_ptr)812 static jvmtiError GetFieldName(jvmtiEnv* env,
813 jclass klass,
814 jfieldID field,
815 char** name_ptr,
816 char** signature_ptr,
817 char** generic_ptr) {
818 ENSURE_VALID_ENV(env);
819 return FieldUtil::GetFieldName(env, klass, field, name_ptr, signature_ptr, generic_ptr);
820 }
821
GetFieldDeclaringClass(jvmtiEnv * env,jclass klass,jfieldID field,jclass * declaring_class_ptr)822 static jvmtiError GetFieldDeclaringClass(jvmtiEnv* env,
823 jclass klass,
824 jfieldID field,
825 jclass* declaring_class_ptr) {
826 ENSURE_VALID_ENV(env);
827 return FieldUtil::GetFieldDeclaringClass(env, klass, field, declaring_class_ptr);
828 }
829
GetFieldModifiers(jvmtiEnv * env,jclass klass,jfieldID field,jint * modifiers_ptr)830 static jvmtiError GetFieldModifiers(jvmtiEnv* env,
831 jclass klass,
832 jfieldID field,
833 jint* modifiers_ptr) {
834 ENSURE_VALID_ENV(env);
835 return FieldUtil::GetFieldModifiers(env, klass, field, modifiers_ptr);
836 }
837
IsFieldSynthetic(jvmtiEnv * env,jclass klass,jfieldID field,jboolean * is_synthetic_ptr)838 static jvmtiError IsFieldSynthetic(jvmtiEnv* env,
839 jclass klass,
840 jfieldID field,
841 jboolean* is_synthetic_ptr) {
842 ENSURE_VALID_ENV(env);
843 ENSURE_HAS_CAP(env, can_get_synthetic_attribute);
844 return FieldUtil::IsFieldSynthetic(env, klass, field, is_synthetic_ptr);
845 }
846
GetMethodName(jvmtiEnv * env,jmethodID method,char ** name_ptr,char ** signature_ptr,char ** generic_ptr)847 static jvmtiError GetMethodName(jvmtiEnv* env,
848 jmethodID method,
849 char** name_ptr,
850 char** signature_ptr,
851 char** generic_ptr) {
852 ENSURE_VALID_ENV(env);
853 return MethodUtil::GetMethodName(env, method, name_ptr, signature_ptr, generic_ptr);
854 }
855
GetMethodDeclaringClass(jvmtiEnv * env,jmethodID method,jclass * declaring_class_ptr)856 static jvmtiError GetMethodDeclaringClass(jvmtiEnv* env,
857 jmethodID method,
858 jclass* declaring_class_ptr) {
859 ENSURE_VALID_ENV(env);
860 return MethodUtil::GetMethodDeclaringClass(env, method, declaring_class_ptr);
861 }
862
GetMethodModifiers(jvmtiEnv * env,jmethodID method,jint * modifiers_ptr)863 static jvmtiError GetMethodModifiers(jvmtiEnv* env,
864 jmethodID method,
865 jint* modifiers_ptr) {
866 ENSURE_VALID_ENV(env);
867 return MethodUtil::GetMethodModifiers(env, method, modifiers_ptr);
868 }
869
GetMaxLocals(jvmtiEnv * env,jmethodID method,jint * max_ptr)870 static jvmtiError GetMaxLocals(jvmtiEnv* env,
871 jmethodID method,
872 jint* max_ptr) {
873 ENSURE_VALID_ENV(env);
874 return MethodUtil::GetMaxLocals(env, method, max_ptr);
875 }
876
GetArgumentsSize(jvmtiEnv * env,jmethodID method,jint * size_ptr)877 static jvmtiError GetArgumentsSize(jvmtiEnv* env,
878 jmethodID method,
879 jint* size_ptr) {
880 ENSURE_VALID_ENV(env);
881 return MethodUtil::GetArgumentsSize(env, method, size_ptr);
882 }
883
GetLineNumberTable(jvmtiEnv * env,jmethodID method,jint * entry_count_ptr,jvmtiLineNumberEntry ** table_ptr)884 static jvmtiError GetLineNumberTable(jvmtiEnv* env,
885 jmethodID method,
886 jint* entry_count_ptr,
887 jvmtiLineNumberEntry** table_ptr) {
888 ENSURE_VALID_ENV(env);
889 ENSURE_HAS_CAP(env, can_get_line_numbers);
890 return MethodUtil::GetLineNumberTable(env, method, entry_count_ptr, table_ptr);
891 }
892
GetMethodLocation(jvmtiEnv * env,jmethodID method,jlocation * start_location_ptr,jlocation * end_location_ptr)893 static jvmtiError GetMethodLocation(jvmtiEnv* env,
894 jmethodID method,
895 jlocation* start_location_ptr,
896 jlocation* end_location_ptr) {
897 ENSURE_VALID_ENV(env);
898 return MethodUtil::GetMethodLocation(env, method, start_location_ptr, end_location_ptr);
899 }
900
GetLocalVariableTable(jvmtiEnv * env,jmethodID method,jint * entry_count_ptr,jvmtiLocalVariableEntry ** table_ptr)901 static jvmtiError GetLocalVariableTable(jvmtiEnv* env,
902 jmethodID method,
903 jint* entry_count_ptr,
904 jvmtiLocalVariableEntry** table_ptr) {
905 ENSURE_VALID_ENV(env);
906 ENSURE_HAS_CAP(env, can_access_local_variables);
907 return MethodUtil::GetLocalVariableTable(env, method, entry_count_ptr, table_ptr);
908 }
909
GetBytecodes(jvmtiEnv * env,jmethodID method,jint * bytecode_count_ptr,unsigned char ** bytecodes_ptr)910 static jvmtiError GetBytecodes(jvmtiEnv* env,
911 jmethodID method,
912 jint* bytecode_count_ptr,
913 unsigned char** bytecodes_ptr) {
914 ENSURE_VALID_ENV(env);
915 ENSURE_HAS_CAP(env, can_get_bytecodes);
916 return MethodUtil::GetBytecodes(env, method, bytecode_count_ptr, bytecodes_ptr);
917 }
918
IsMethodNative(jvmtiEnv * env,jmethodID method,jboolean * is_native_ptr)919 static jvmtiError IsMethodNative(jvmtiEnv* env, jmethodID method, jboolean* is_native_ptr) {
920 ENSURE_VALID_ENV(env);
921 return MethodUtil::IsMethodNative(env, method, is_native_ptr);
922 }
923
IsMethodSynthetic(jvmtiEnv * env,jmethodID method,jboolean * is_synthetic_ptr)924 static jvmtiError IsMethodSynthetic(jvmtiEnv* env, jmethodID method, jboolean* is_synthetic_ptr) {
925 ENSURE_VALID_ENV(env);
926 ENSURE_HAS_CAP(env, can_get_synthetic_attribute);
927 return MethodUtil::IsMethodSynthetic(env, method, is_synthetic_ptr);
928 }
929
IsMethodObsolete(jvmtiEnv * env,jmethodID method,jboolean * is_obsolete_ptr)930 static jvmtiError IsMethodObsolete(jvmtiEnv* env, jmethodID method, jboolean* is_obsolete_ptr) {
931 ENSURE_VALID_ENV(env);
932 return MethodUtil::IsMethodObsolete(env, method, is_obsolete_ptr);
933 }
934
SetNativeMethodPrefix(jvmtiEnv * env,const char * prefix ATTRIBUTE_UNUSED)935 static jvmtiError SetNativeMethodPrefix(jvmtiEnv* env, const char* prefix ATTRIBUTE_UNUSED) {
936 ENSURE_VALID_ENV(env);
937 ENSURE_HAS_CAP(env, can_set_native_method_prefix);
938 return ERR(NOT_IMPLEMENTED);
939 }
940
SetNativeMethodPrefixes(jvmtiEnv * env,jint prefix_count ATTRIBUTE_UNUSED,char ** prefixes ATTRIBUTE_UNUSED)941 static jvmtiError SetNativeMethodPrefixes(jvmtiEnv* env,
942 jint prefix_count ATTRIBUTE_UNUSED,
943 char** prefixes ATTRIBUTE_UNUSED) {
944 ENSURE_VALID_ENV(env);
945 ENSURE_HAS_CAP(env, can_set_native_method_prefix);
946 return ERR(NOT_IMPLEMENTED);
947 }
948
CreateRawMonitor(jvmtiEnv * env,const char * name,jrawMonitorID * monitor_ptr)949 static jvmtiError CreateRawMonitor(jvmtiEnv* env, const char* name, jrawMonitorID* monitor_ptr) {
950 ENSURE_VALID_ENV(env);
951 return MonitorUtil::CreateRawMonitor(env, name, monitor_ptr);
952 }
953
DestroyRawMonitor(jvmtiEnv * env,jrawMonitorID monitor)954 static jvmtiError DestroyRawMonitor(jvmtiEnv* env, jrawMonitorID monitor) {
955 ENSURE_VALID_ENV(env);
956 return MonitorUtil::DestroyRawMonitor(env, monitor);
957 }
958
RawMonitorEnter(jvmtiEnv * env,jrawMonitorID monitor)959 static jvmtiError RawMonitorEnter(jvmtiEnv* env, jrawMonitorID monitor) {
960 ENSURE_VALID_ENV(env);
961 return MonitorUtil::RawMonitorEnter(env, monitor);
962 }
963
RawMonitorExit(jvmtiEnv * env,jrawMonitorID monitor)964 static jvmtiError RawMonitorExit(jvmtiEnv* env, jrawMonitorID monitor) {
965 ENSURE_VALID_ENV(env);
966 return MonitorUtil::RawMonitorExit(env, monitor);
967 }
968
RawMonitorWait(jvmtiEnv * env,jrawMonitorID monitor,jlong millis)969 static jvmtiError RawMonitorWait(jvmtiEnv* env, jrawMonitorID monitor, jlong millis) {
970 ENSURE_VALID_ENV(env);
971 return MonitorUtil::RawMonitorWait(env, monitor, millis);
972 }
973
RawMonitorNotify(jvmtiEnv * env,jrawMonitorID monitor)974 static jvmtiError RawMonitorNotify(jvmtiEnv* env, jrawMonitorID monitor) {
975 ENSURE_VALID_ENV(env);
976 return MonitorUtil::RawMonitorNotify(env, monitor);
977 }
978
RawMonitorNotifyAll(jvmtiEnv * env,jrawMonitorID monitor)979 static jvmtiError RawMonitorNotifyAll(jvmtiEnv* env, jrawMonitorID monitor) {
980 ENSURE_VALID_ENV(env);
981 return MonitorUtil::RawMonitorNotifyAll(env, monitor);
982 }
983
SetJNIFunctionTable(jvmtiEnv * env,const jniNativeInterface * function_table)984 static jvmtiError SetJNIFunctionTable(jvmtiEnv* env, const jniNativeInterface* function_table) {
985 ENSURE_VALID_ENV(env);
986 return JNIUtil::SetJNIFunctionTable(env, function_table);
987 }
988
GetJNIFunctionTable(jvmtiEnv * env,jniNativeInterface ** function_table)989 static jvmtiError GetJNIFunctionTable(jvmtiEnv* env, jniNativeInterface** function_table) {
990 ENSURE_VALID_ENV(env);
991 return JNIUtil::GetJNIFunctionTable(env, function_table);
992 }
993
994 // TODO: This will require locking, so that an agent can't remove callbacks when we're dispatching
995 // an event.
SetEventCallbacks(jvmtiEnv * env,const jvmtiEventCallbacks * callbacks,jint size_of_callbacks)996 static jvmtiError SetEventCallbacks(jvmtiEnv* env,
997 const jvmtiEventCallbacks* callbacks,
998 jint size_of_callbacks) {
999 ENSURE_VALID_ENV(env);
1000 if (size_of_callbacks < 0) {
1001 return ERR(ILLEGAL_ARGUMENT);
1002 }
1003
1004 if (callbacks == nullptr) {
1005 ArtJvmTiEnv::AsArtJvmTiEnv(env)->event_callbacks.reset();
1006 return ERR(NONE);
1007 }
1008
1009 // Lock the event_info_mutex_ while we replace the callbacks.
1010 ArtJvmTiEnv* art_env = ArtJvmTiEnv::AsArtJvmTiEnv(env);
1011 art::WriterMutexLock lk(art::Thread::Current(), art_env->event_info_mutex_);
1012 std::unique_ptr<ArtJvmtiEventCallbacks> tmp(new ArtJvmtiEventCallbacks());
1013 // Copy over the extension events.
1014 tmp->CopyExtensionsFrom(art_env->event_callbacks.get());
1015 // Never overwrite the extension events.
1016 size_t copy_size = std::min(sizeof(jvmtiEventCallbacks),
1017 static_cast<size_t>(size_of_callbacks));
1018 copy_size = art::RoundDown(copy_size, sizeof(void*));
1019 // Copy non-extension events.
1020 memcpy(tmp.get(), callbacks, copy_size);
1021
1022 // replace the event table.
1023 art_env->event_callbacks = std::move(tmp);
1024
1025 return ERR(NONE);
1026 }
1027
SetEventNotificationMode(jvmtiEnv * env,jvmtiEventMode mode,jvmtiEvent event_type,jthread event_thread,...)1028 static jvmtiError SetEventNotificationMode(jvmtiEnv* env,
1029 jvmtiEventMode mode,
1030 jvmtiEvent event_type,
1031 jthread event_thread,
1032 ...) {
1033 ENSURE_VALID_ENV(env);
1034 ArtJvmTiEnv* art_env = ArtJvmTiEnv::AsArtJvmTiEnv(env);
1035 return gEventHandler->SetEvent(art_env,
1036 event_thread,
1037 GetArtJvmtiEvent(art_env, event_type),
1038 mode);
1039 }
1040
GenerateEvents(jvmtiEnv * env,jvmtiEvent event_type ATTRIBUTE_UNUSED)1041 static jvmtiError GenerateEvents(jvmtiEnv* env,
1042 jvmtiEvent event_type ATTRIBUTE_UNUSED) {
1043 ENSURE_VALID_ENV(env);
1044 return OK;
1045 }
1046
GetExtensionFunctions(jvmtiEnv * env,jint * extension_count_ptr,jvmtiExtensionFunctionInfo ** extensions)1047 static jvmtiError GetExtensionFunctions(jvmtiEnv* env,
1048 jint* extension_count_ptr,
1049 jvmtiExtensionFunctionInfo** extensions) {
1050 ENSURE_VALID_ENV(env);
1051 ENSURE_NON_NULL(extension_count_ptr);
1052 ENSURE_NON_NULL(extensions);
1053 return ExtensionUtil::GetExtensionFunctions(env, extension_count_ptr, extensions);
1054 }
1055
GetExtensionEvents(jvmtiEnv * env,jint * extension_count_ptr,jvmtiExtensionEventInfo ** extensions)1056 static jvmtiError GetExtensionEvents(jvmtiEnv* env,
1057 jint* extension_count_ptr,
1058 jvmtiExtensionEventInfo** extensions) {
1059 ENSURE_VALID_ENV(env);
1060 ENSURE_NON_NULL(extension_count_ptr);
1061 ENSURE_NON_NULL(extensions);
1062 return ExtensionUtil::GetExtensionEvents(env, extension_count_ptr, extensions);
1063 }
1064
SetExtensionEventCallback(jvmtiEnv * env,jint extension_event_index,jvmtiExtensionEvent callback)1065 static jvmtiError SetExtensionEventCallback(jvmtiEnv* env,
1066 jint extension_event_index,
1067 jvmtiExtensionEvent callback) {
1068 ENSURE_VALID_ENV(env);
1069 return ExtensionUtil::SetExtensionEventCallback(env,
1070 extension_event_index,
1071 callback,
1072 gEventHandler);
1073 }
1074
1075 #define FOR_ALL_CAPABILITIES(FUN) \
1076 FUN(can_tag_objects) \
1077 FUN(can_generate_field_modification_events) \
1078 FUN(can_generate_field_access_events) \
1079 FUN(can_get_bytecodes) \
1080 FUN(can_get_synthetic_attribute) \
1081 FUN(can_get_owned_monitor_info) \
1082 FUN(can_get_current_contended_monitor) \
1083 FUN(can_get_monitor_info) \
1084 FUN(can_pop_frame) \
1085 FUN(can_redefine_classes) \
1086 FUN(can_signal_thread) \
1087 FUN(can_get_source_file_name) \
1088 FUN(can_get_line_numbers) \
1089 FUN(can_get_source_debug_extension) \
1090 FUN(can_access_local_variables) \
1091 FUN(can_maintain_original_method_order) \
1092 FUN(can_generate_single_step_events) \
1093 FUN(can_generate_exception_events) \
1094 FUN(can_generate_frame_pop_events) \
1095 FUN(can_generate_breakpoint_events) \
1096 FUN(can_suspend) \
1097 FUN(can_redefine_any_class) \
1098 FUN(can_get_current_thread_cpu_time) \
1099 FUN(can_get_thread_cpu_time) \
1100 FUN(can_generate_method_entry_events) \
1101 FUN(can_generate_method_exit_events) \
1102 FUN(can_generate_all_class_hook_events) \
1103 FUN(can_generate_compiled_method_load_events) \
1104 FUN(can_generate_monitor_events) \
1105 FUN(can_generate_vm_object_alloc_events) \
1106 FUN(can_generate_native_method_bind_events) \
1107 FUN(can_generate_garbage_collection_events) \
1108 FUN(can_generate_object_free_events) \
1109 FUN(can_force_early_return) \
1110 FUN(can_get_owned_monitor_stack_depth_info) \
1111 FUN(can_get_constant_pool) \
1112 FUN(can_set_native_method_prefix) \
1113 FUN(can_retransform_classes) \
1114 FUN(can_retransform_any_class) \
1115 FUN(can_generate_resource_exhaustion_heap_events) \
1116 FUN(can_generate_resource_exhaustion_threads_events)
1117
GetPotentialCapabilities(jvmtiEnv * env,jvmtiCapabilities * capabilities_ptr)1118 static jvmtiError GetPotentialCapabilities(jvmtiEnv* env, jvmtiCapabilities* capabilities_ptr) {
1119 ENSURE_VALID_ENV(env);
1120 ENSURE_NON_NULL(capabilities_ptr);
1121 *capabilities_ptr = kPotentialCapabilities;
1122 if (UNLIKELY(!IsFullJvmtiAvailable())) {
1123 #define REMOVE_NONDEBUGGABLE_UNSUPPORTED(e) \
1124 do { \
1125 if (kNonDebuggableUnsupportedCapabilities.e == 1) { \
1126 capabilities_ptr->e = 0; \
1127 } \
1128 } while (false);
1129
1130 FOR_ALL_CAPABILITIES(REMOVE_NONDEBUGGABLE_UNSUPPORTED);
1131 #undef REMOVE_NONDEBUGGABLE_UNSUPPORTED
1132 }
1133 return OK;
1134 }
1135
AddCapabilities(jvmtiEnv * env,const jvmtiCapabilities * capabilities_ptr)1136 static jvmtiError AddCapabilities(jvmtiEnv* env, const jvmtiCapabilities* capabilities_ptr) {
1137 ENSURE_VALID_ENV(env);
1138 ENSURE_NON_NULL(capabilities_ptr);
1139 ArtJvmTiEnv* art_env = static_cast<ArtJvmTiEnv*>(env);
1140 jvmtiError ret = OK;
1141 jvmtiCapabilities changed = {};
1142 jvmtiCapabilities potential_capabilities = {};
1143 ret = env->GetPotentialCapabilities(&potential_capabilities);
1144 if (ret != OK) {
1145 return ret;
1146 }
1147 #define ADD_CAPABILITY(e) \
1148 do { \
1149 if (capabilities_ptr->e == 1) { \
1150 if (potential_capabilities.e == 1) { \
1151 if (art_env->capabilities.e != 1) { \
1152 art_env->capabilities.e = 1; \
1153 changed.e = 1; \
1154 }\
1155 } else { \
1156 ret = ERR(NOT_AVAILABLE); \
1157 } \
1158 } \
1159 } while (false);
1160
1161 FOR_ALL_CAPABILITIES(ADD_CAPABILITY);
1162 #undef ADD_CAPABILITY
1163 gEventHandler->HandleChangedCapabilities(ArtJvmTiEnv::AsArtJvmTiEnv(env),
1164 changed,
1165 /*added=*/true);
1166 return ret;
1167 }
1168
RelinquishCapabilities(jvmtiEnv * env,const jvmtiCapabilities * capabilities_ptr)1169 static jvmtiError RelinquishCapabilities(jvmtiEnv* env,
1170 const jvmtiCapabilities* capabilities_ptr) {
1171 ENSURE_VALID_ENV(env);
1172 ENSURE_NON_NULL(capabilities_ptr);
1173 ArtJvmTiEnv* art_env = reinterpret_cast<ArtJvmTiEnv*>(env);
1174 jvmtiCapabilities changed = {};
1175 #define DEL_CAPABILITY(e) \
1176 do { \
1177 if (capabilities_ptr->e == 1) { \
1178 if (art_env->capabilities.e == 1) { \
1179 art_env->capabilities.e = 0;\
1180 changed.e = 1; \
1181 } \
1182 } \
1183 } while (false);
1184
1185 FOR_ALL_CAPABILITIES(DEL_CAPABILITY);
1186 #undef DEL_CAPABILITY
1187 gEventHandler->HandleChangedCapabilities(ArtJvmTiEnv::AsArtJvmTiEnv(env),
1188 changed,
1189 /*added=*/false);
1190 return OK;
1191 }
1192
1193 #undef FOR_ALL_CAPABILITIES
1194
GetCapabilities(jvmtiEnv * env,jvmtiCapabilities * capabilities_ptr)1195 static jvmtiError GetCapabilities(jvmtiEnv* env, jvmtiCapabilities* capabilities_ptr) {
1196 ENSURE_VALID_ENV(env);
1197 ENSURE_NON_NULL(capabilities_ptr);
1198 ArtJvmTiEnv* artenv = reinterpret_cast<ArtJvmTiEnv*>(env);
1199 *capabilities_ptr = artenv->capabilities;
1200 return OK;
1201 }
1202
GetCurrentThreadCpuTimerInfo(jvmtiEnv * env,jvmtiTimerInfo * info_ptr ATTRIBUTE_UNUSED)1203 static jvmtiError GetCurrentThreadCpuTimerInfo(jvmtiEnv* env,
1204 jvmtiTimerInfo* info_ptr ATTRIBUTE_UNUSED) {
1205 ENSURE_VALID_ENV(env);
1206 ENSURE_HAS_CAP(env, can_get_current_thread_cpu_time);
1207 return ERR(NOT_IMPLEMENTED);
1208 }
1209
GetCurrentThreadCpuTime(jvmtiEnv * env,jlong * nanos_ptr ATTRIBUTE_UNUSED)1210 static jvmtiError GetCurrentThreadCpuTime(jvmtiEnv* env, jlong* nanos_ptr ATTRIBUTE_UNUSED) {
1211 ENSURE_VALID_ENV(env);
1212 ENSURE_HAS_CAP(env, can_get_current_thread_cpu_time);
1213 return ERR(NOT_IMPLEMENTED);
1214 }
1215
GetThreadCpuTimerInfo(jvmtiEnv * env,jvmtiTimerInfo * info_ptr ATTRIBUTE_UNUSED)1216 static jvmtiError GetThreadCpuTimerInfo(jvmtiEnv* env,
1217 jvmtiTimerInfo* info_ptr ATTRIBUTE_UNUSED) {
1218 ENSURE_VALID_ENV(env);
1219 ENSURE_HAS_CAP(env, can_get_thread_cpu_time);
1220 return ERR(NOT_IMPLEMENTED);
1221 }
1222
GetThreadCpuTime(jvmtiEnv * env,jthread thread ATTRIBUTE_UNUSED,jlong * nanos_ptr ATTRIBUTE_UNUSED)1223 static jvmtiError GetThreadCpuTime(jvmtiEnv* env,
1224 jthread thread ATTRIBUTE_UNUSED,
1225 jlong* nanos_ptr ATTRIBUTE_UNUSED) {
1226 ENSURE_VALID_ENV(env);
1227 ENSURE_HAS_CAP(env, can_get_thread_cpu_time);
1228 return ERR(NOT_IMPLEMENTED);
1229 }
1230
GetTimerInfo(jvmtiEnv * env,jvmtiTimerInfo * info_ptr)1231 static jvmtiError GetTimerInfo(jvmtiEnv* env, jvmtiTimerInfo* info_ptr) {
1232 ENSURE_VALID_ENV(env);
1233 return TimerUtil::GetTimerInfo(env, info_ptr);
1234 }
1235
GetTime(jvmtiEnv * env,jlong * nanos_ptr)1236 static jvmtiError GetTime(jvmtiEnv* env, jlong* nanos_ptr) {
1237 ENSURE_VALID_ENV(env);
1238 return TimerUtil::GetTime(env, nanos_ptr);
1239 }
1240
GetAvailableProcessors(jvmtiEnv * env,jint * processor_count_ptr)1241 static jvmtiError GetAvailableProcessors(jvmtiEnv* env, jint* processor_count_ptr) {
1242 ENSURE_VALID_ENV(env);
1243 return TimerUtil::GetAvailableProcessors(env, processor_count_ptr);
1244 }
1245
AddToBootstrapClassLoaderSearch(jvmtiEnv * env,const char * segment)1246 static jvmtiError AddToBootstrapClassLoaderSearch(jvmtiEnv* env, const char* segment) {
1247 ENSURE_VALID_ENV(env);
1248 return SearchUtil::AddToBootstrapClassLoaderSearch(env, segment);
1249 }
1250
AddToSystemClassLoaderSearch(jvmtiEnv * env,const char * segment)1251 static jvmtiError AddToSystemClassLoaderSearch(jvmtiEnv* env, const char* segment) {
1252 ENSURE_VALID_ENV(env);
1253 return SearchUtil::AddToSystemClassLoaderSearch(env, segment);
1254 }
1255
GetSystemProperties(jvmtiEnv * env,jint * count_ptr,char *** property_ptr)1256 static jvmtiError GetSystemProperties(jvmtiEnv* env, jint* count_ptr, char*** property_ptr) {
1257 ENSURE_VALID_ENV(env);
1258 return PropertiesUtil::GetSystemProperties(env, count_ptr, property_ptr);
1259 }
1260
GetSystemProperty(jvmtiEnv * env,const char * property,char ** value_ptr)1261 static jvmtiError GetSystemProperty(jvmtiEnv* env, const char* property, char** value_ptr) {
1262 ENSURE_VALID_ENV(env);
1263 return PropertiesUtil::GetSystemProperty(env, property, value_ptr);
1264 }
1265
SetSystemProperty(jvmtiEnv * env,const char * property,const char * value)1266 static jvmtiError SetSystemProperty(jvmtiEnv* env, const char* property, const char* value) {
1267 ENSURE_VALID_ENV(env);
1268 return PropertiesUtil::SetSystemProperty(env, property, value);
1269 }
1270
GetPhase(jvmtiEnv * env,jvmtiPhase * phase_ptr)1271 static jvmtiError GetPhase(jvmtiEnv* env, jvmtiPhase* phase_ptr) {
1272 ENSURE_VALID_ENV(env);
1273 return PhaseUtil::GetPhase(env, phase_ptr);
1274 }
1275
DisposeEnvironment(jvmtiEnv * env)1276 static jvmtiError DisposeEnvironment(jvmtiEnv* env) {
1277 ENSURE_VALID_ENV(env);
1278 ArtJvmTiEnv* tienv = ArtJvmTiEnv::AsArtJvmTiEnv(env);
1279 gEventHandler->RemoveArtJvmTiEnv(tienv);
1280 art::Runtime::Current()->RemoveSystemWeakHolder(tienv->object_tag_table.get());
1281 ThreadUtil::RemoveEnvironment(tienv);
1282 delete tienv;
1283 return OK;
1284 }
1285
SetEnvironmentLocalStorage(jvmtiEnv * env,const void * data)1286 static jvmtiError SetEnvironmentLocalStorage(jvmtiEnv* env, const void* data) {
1287 ENSURE_VALID_ENV(env);
1288 reinterpret_cast<ArtJvmTiEnv*>(env)->local_data = const_cast<void*>(data);
1289 return OK;
1290 }
1291
GetEnvironmentLocalStorage(jvmtiEnv * env,void ** data_ptr)1292 static jvmtiError GetEnvironmentLocalStorage(jvmtiEnv* env, void** data_ptr) {
1293 ENSURE_VALID_ENV(env);
1294 *data_ptr = reinterpret_cast<ArtJvmTiEnv*>(env)->local_data;
1295 return OK;
1296 }
1297
GetVersionNumber(jvmtiEnv * env,jint * version_ptr)1298 static jvmtiError GetVersionNumber(jvmtiEnv* env, jint* version_ptr) {
1299 ENSURE_VALID_ENV(env);
1300 *version_ptr = ArtJvmTiEnv::AsArtJvmTiEnv(env)->ti_version;
1301 return OK;
1302 }
1303
GetErrorName(jvmtiEnv * env,jvmtiError error,char ** name_ptr)1304 static jvmtiError GetErrorName(jvmtiEnv* env, jvmtiError error, char** name_ptr) {
1305 ENSURE_NON_NULL(name_ptr);
1306 auto copy_fn = [&](const char* name_cstr) {
1307 jvmtiError res;
1308 JvmtiUniquePtr<char[]> copy = CopyString(env, name_cstr, &res);
1309 if (copy == nullptr) {
1310 *name_ptr = nullptr;
1311 return res;
1312 } else {
1313 *name_ptr = copy.release();
1314 return OK;
1315 }
1316 };
1317 switch (error) {
1318 #define ERROR_CASE(e) case (JVMTI_ERROR_ ## e) : \
1319 return copy_fn("JVMTI_ERROR_"#e);
1320 ERROR_CASE(NONE);
1321 ERROR_CASE(INVALID_THREAD);
1322 ERROR_CASE(INVALID_THREAD_GROUP);
1323 ERROR_CASE(INVALID_PRIORITY);
1324 ERROR_CASE(THREAD_NOT_SUSPENDED);
1325 ERROR_CASE(THREAD_SUSPENDED);
1326 ERROR_CASE(THREAD_NOT_ALIVE);
1327 ERROR_CASE(INVALID_OBJECT);
1328 ERROR_CASE(INVALID_CLASS);
1329 ERROR_CASE(CLASS_NOT_PREPARED);
1330 ERROR_CASE(INVALID_METHODID);
1331 ERROR_CASE(INVALID_LOCATION);
1332 ERROR_CASE(INVALID_FIELDID);
1333 ERROR_CASE(NO_MORE_FRAMES);
1334 ERROR_CASE(OPAQUE_FRAME);
1335 ERROR_CASE(TYPE_MISMATCH);
1336 ERROR_CASE(INVALID_SLOT);
1337 ERROR_CASE(DUPLICATE);
1338 ERROR_CASE(NOT_FOUND);
1339 ERROR_CASE(INVALID_MONITOR);
1340 ERROR_CASE(NOT_MONITOR_OWNER);
1341 ERROR_CASE(INTERRUPT);
1342 ERROR_CASE(INVALID_CLASS_FORMAT);
1343 ERROR_CASE(CIRCULAR_CLASS_DEFINITION);
1344 ERROR_CASE(FAILS_VERIFICATION);
1345 ERROR_CASE(UNSUPPORTED_REDEFINITION_METHOD_ADDED);
1346 ERROR_CASE(UNSUPPORTED_REDEFINITION_SCHEMA_CHANGED);
1347 ERROR_CASE(INVALID_TYPESTATE);
1348 ERROR_CASE(UNSUPPORTED_REDEFINITION_HIERARCHY_CHANGED);
1349 ERROR_CASE(UNSUPPORTED_REDEFINITION_METHOD_DELETED);
1350 ERROR_CASE(UNSUPPORTED_VERSION);
1351 ERROR_CASE(NAMES_DONT_MATCH);
1352 ERROR_CASE(UNSUPPORTED_REDEFINITION_CLASS_MODIFIERS_CHANGED);
1353 ERROR_CASE(UNSUPPORTED_REDEFINITION_METHOD_MODIFIERS_CHANGED);
1354 ERROR_CASE(UNMODIFIABLE_CLASS);
1355 ERROR_CASE(NOT_AVAILABLE);
1356 ERROR_CASE(MUST_POSSESS_CAPABILITY);
1357 ERROR_CASE(NULL_POINTER);
1358 ERROR_CASE(ABSENT_INFORMATION);
1359 ERROR_CASE(INVALID_EVENT_TYPE);
1360 ERROR_CASE(ILLEGAL_ARGUMENT);
1361 ERROR_CASE(NATIVE_METHOD);
1362 ERROR_CASE(CLASS_LOADER_UNSUPPORTED);
1363 ERROR_CASE(OUT_OF_MEMORY);
1364 ERROR_CASE(ACCESS_DENIED);
1365 ERROR_CASE(WRONG_PHASE);
1366 ERROR_CASE(INTERNAL);
1367 ERROR_CASE(UNATTACHED_THREAD);
1368 ERROR_CASE(INVALID_ENVIRONMENT);
1369 #undef ERROR_CASE
1370 }
1371
1372 return ERR(ILLEGAL_ARGUMENT);
1373 }
1374
SetVerboseFlag(jvmtiEnv * env,jvmtiVerboseFlag flag,jboolean value)1375 static jvmtiError SetVerboseFlag(jvmtiEnv* env,
1376 jvmtiVerboseFlag flag,
1377 jboolean value) {
1378 ENSURE_VALID_ENV(env);
1379 if (flag == jvmtiVerboseFlag::JVMTI_VERBOSE_OTHER) {
1380 // OTHER is special, as it's 0, so can't do a bit check.
1381 bool val = (value == JNI_TRUE) ? true : false;
1382
1383 art::gLogVerbosity.collector = val;
1384 art::gLogVerbosity.compiler = val;
1385 art::gLogVerbosity.deopt = val;
1386 art::gLogVerbosity.heap = val;
1387 art::gLogVerbosity.interpreter = val;
1388 art::gLogVerbosity.jdwp = val;
1389 art::gLogVerbosity.jit = val;
1390 art::gLogVerbosity.monitor = val;
1391 art::gLogVerbosity.oat = val;
1392 art::gLogVerbosity.profiler = val;
1393 art::gLogVerbosity.signals = val;
1394 art::gLogVerbosity.simulator = val;
1395 art::gLogVerbosity.startup = val;
1396 art::gLogVerbosity.third_party_jni = val;
1397 art::gLogVerbosity.threads = val;
1398 art::gLogVerbosity.verifier = val;
1399 // Do not set verifier-debug.
1400 art::gLogVerbosity.image = val;
1401 art::gLogVerbosity.plugin = val;
1402
1403 // Note: can't switch systrace_lock_logging. That requires changing entrypoints.
1404
1405 art::gLogVerbosity.agents = val;
1406 } else {
1407 // Spec isn't clear whether "flag" is a mask or supposed to be single. We implement the mask
1408 // semantics.
1409 constexpr std::underlying_type<jvmtiVerboseFlag>::type kMask =
1410 jvmtiVerboseFlag::JVMTI_VERBOSE_GC |
1411 jvmtiVerboseFlag::JVMTI_VERBOSE_CLASS |
1412 jvmtiVerboseFlag::JVMTI_VERBOSE_JNI;
1413 if ((flag & ~kMask) != 0) {
1414 return ERR(ILLEGAL_ARGUMENT);
1415 }
1416
1417 bool val = (value == JNI_TRUE) ? true : false;
1418
1419 if ((flag & jvmtiVerboseFlag::JVMTI_VERBOSE_GC) != 0) {
1420 art::gLogVerbosity.gc = val;
1421 }
1422
1423 if ((flag & jvmtiVerboseFlag::JVMTI_VERBOSE_CLASS) != 0) {
1424 art::gLogVerbosity.class_linker = val;
1425 }
1426
1427 if ((flag & jvmtiVerboseFlag::JVMTI_VERBOSE_JNI) != 0) {
1428 art::gLogVerbosity.jni = val;
1429 }
1430 }
1431
1432 return ERR(NONE);
1433 }
1434
GetJLocationFormat(jvmtiEnv * env,jvmtiJlocationFormat * format_ptr)1435 static jvmtiError GetJLocationFormat(jvmtiEnv* env, jvmtiJlocationFormat* format_ptr) {
1436 ENSURE_VALID_ENV(env);
1437 // Report BCI as jlocation format. We report dex bytecode indices.
1438 if (format_ptr == nullptr) {
1439 return ERR(NULL_POINTER);
1440 }
1441 *format_ptr = jvmtiJlocationFormat::JVMTI_JLOCATION_JVMBCI;
1442 return ERR(NONE);
1443 }
1444 };
1445
IsJvmtiVersion(jint version)1446 static bool IsJvmtiVersion(jint version) {
1447 return version == JVMTI_VERSION_1 ||
1448 version == JVMTI_VERSION_1_0 ||
1449 version == JVMTI_VERSION_1_1 ||
1450 version == JVMTI_VERSION_1_2 ||
1451 version == JVMTI_VERSION;
1452 }
1453
1454 extern const jvmtiInterface_1 gJvmtiInterface;
1455
ArtJvmTiEnv(art::JavaVMExt * runtime,EventHandler * event_handler,jint version)1456 ArtJvmTiEnv::ArtJvmTiEnv(art::JavaVMExt* runtime, EventHandler* event_handler, jint version)
1457 : art_vm(runtime),
1458 local_data(nullptr),
1459 ti_version(version),
1460 capabilities(),
1461 event_info_mutex_("jvmtiEnv_EventInfoMutex"),
1462 last_error_mutex_("jvmtiEnv_LastErrorMutex", art::LockLevel::kGenericBottomLock) {
1463 object_tag_table = std::make_unique<ObjectTagTable>(event_handler, this);
1464 functions = &gJvmtiInterface;
1465 }
1466
1467 // Creates a jvmtiEnv and returns it with the art::ti::Env that is associated with it. new_art_ti
1468 // is a pointer to the uninitialized memory for an art::ti::Env.
CreateArtJvmTiEnv(art::JavaVMExt * vm,jint version,void ** new_jvmtiEnv)1469 static void CreateArtJvmTiEnv(art::JavaVMExt* vm, jint version, /*out*/void** new_jvmtiEnv) {
1470 struct ArtJvmTiEnv* env = new ArtJvmTiEnv(vm, gEventHandler, version);
1471 *new_jvmtiEnv = env;
1472
1473 gEventHandler->RegisterArtJvmTiEnv(env);
1474
1475 art::Runtime::Current()->AddSystemWeakHolder(
1476 ArtJvmTiEnv::AsArtJvmTiEnv(env)->object_tag_table.get());
1477 }
1478
1479 // A hook that the runtime uses to allow plugins to handle GetEnv calls. It returns true and
1480 // places the return value in 'env' if this library can handle the GetEnv request. Otherwise
1481 // returns false and does not modify the 'env' pointer.
GetEnvHandler(art::JavaVMExt * vm,void ** env,jint version)1482 static jint GetEnvHandler(art::JavaVMExt* vm, /*out*/void** env, jint version) {
1483 // JavaDebuggable will either be set by the runtime as it is starting up or the plugin if it's
1484 // loaded early enough. If this is false we cannot guarantee conformance to all JVMTI behaviors
1485 // due to optimizations. We will only allow agents to get ArtTiEnvs using the kArtTiVersion.
1486 if (IsFullJvmtiAvailable() && IsJvmtiVersion(version)) {
1487 CreateArtJvmTiEnv(vm, JVMTI_VERSION, env);
1488 return JNI_OK;
1489 } else if (version == kArtTiVersion) {
1490 CreateArtJvmTiEnv(vm, kArtTiVersion, env);
1491 return JNI_OK;
1492 } else {
1493 printf("version 0x%x is not valid!", version);
1494 return JNI_EVERSION;
1495 }
1496 }
1497
1498 // The plugin initialization function. This adds the jvmti environment.
ArtPlugin_Initialize()1499 extern "C" bool ArtPlugin_Initialize() {
1500 art::Runtime* runtime = art::Runtime::Current();
1501
1502 gAllocManager = new AllocationManager;
1503 gDeoptManager = new DeoptManager;
1504 gEventHandler = new EventHandler;
1505
1506 gDeoptManager->Setup();
1507 if (runtime->IsStarted()) {
1508 PhaseUtil::SetToLive();
1509 } else {
1510 PhaseUtil::SetToOnLoad();
1511 }
1512 PhaseUtil::Register(gEventHandler);
1513 ThreadUtil::Register(gEventHandler);
1514 ClassUtil::Register(gEventHandler);
1515 DumpUtil::Register(gEventHandler);
1516 MethodUtil::Register(gEventHandler);
1517 HeapExtensions::Register(gEventHandler);
1518 SearchUtil::Register();
1519 HeapUtil::Register();
1520 FieldUtil::Register(gEventHandler);
1521 BreakpointUtil::Register(gEventHandler);
1522 Transformer::Register(gEventHandler);
1523
1524 {
1525 // Make sure we can deopt anything we need to.
1526 art::ScopedSuspendAll ssa(__FUNCTION__);
1527 gDeoptManager->FinishSetup();
1528 }
1529
1530 runtime->GetJavaVM()->AddEnvironmentHook(GetEnvHandler);
1531
1532 return true;
1533 }
1534
ArtPlugin_Deinitialize()1535 extern "C" bool ArtPlugin_Deinitialize() {
1536 gEventHandler->Shutdown();
1537 gDeoptManager->Shutdown();
1538 PhaseUtil::Unregister();
1539 ThreadUtil::Unregister();
1540 ClassUtil::Unregister();
1541 DumpUtil::Unregister();
1542 MethodUtil::Unregister();
1543 SearchUtil::Unregister();
1544 HeapUtil::Unregister();
1545 FieldUtil::Unregister();
1546 BreakpointUtil::Unregister();
1547
1548 // TODO It would be good to delete the gEventHandler and gDeoptManager here but we cannot since
1549 // daemon threads might be suspended and we want to make sure that even if they wake up briefly
1550 // they won't hit deallocated memory. By this point none of the functions will do anything since
1551 // they have already shutdown.
1552
1553 return true;
1554 }
1555
1556 // The actual struct holding all of the entrypoints into the jvmti interface.
1557 const jvmtiInterface_1 gJvmtiInterface = {
1558 nullptr, // reserved1
1559 JvmtiFunctions::SetEventNotificationMode,
1560 nullptr, // reserved3
1561 JvmtiFunctions::GetAllThreads,
1562 JvmtiFunctions::SuspendThread,
1563 JvmtiFunctions::ResumeThread,
1564 JvmtiFunctions::StopThread,
1565 JvmtiFunctions::InterruptThread,
1566 JvmtiFunctions::GetThreadInfo,
1567 JvmtiFunctions::GetOwnedMonitorInfo, // 10
1568 JvmtiFunctions::GetCurrentContendedMonitor,
1569 JvmtiFunctions::RunAgentThread,
1570 JvmtiFunctions::GetTopThreadGroups,
1571 JvmtiFunctions::GetThreadGroupInfo,
1572 JvmtiFunctions::GetThreadGroupChildren,
1573 JvmtiFunctions::GetFrameCount,
1574 JvmtiFunctions::GetThreadState,
1575 JvmtiFunctions::GetCurrentThread,
1576 JvmtiFunctions::GetFrameLocation,
1577 JvmtiFunctions::NotifyFramePop, // 20
1578 JvmtiFunctions::GetLocalObject,
1579 JvmtiFunctions::GetLocalInt,
1580 JvmtiFunctions::GetLocalLong,
1581 JvmtiFunctions::GetLocalFloat,
1582 JvmtiFunctions::GetLocalDouble,
1583 JvmtiFunctions::SetLocalObject,
1584 JvmtiFunctions::SetLocalInt,
1585 JvmtiFunctions::SetLocalLong,
1586 JvmtiFunctions::SetLocalFloat,
1587 JvmtiFunctions::SetLocalDouble, // 30
1588 JvmtiFunctions::CreateRawMonitor,
1589 JvmtiFunctions::DestroyRawMonitor,
1590 JvmtiFunctions::RawMonitorEnter,
1591 JvmtiFunctions::RawMonitorExit,
1592 JvmtiFunctions::RawMonitorWait,
1593 JvmtiFunctions::RawMonitorNotify,
1594 JvmtiFunctions::RawMonitorNotifyAll,
1595 JvmtiFunctions::SetBreakpoint,
1596 JvmtiFunctions::ClearBreakpoint,
1597 nullptr, // reserved40
1598 JvmtiFunctions::SetFieldAccessWatch,
1599 JvmtiFunctions::ClearFieldAccessWatch,
1600 JvmtiFunctions::SetFieldModificationWatch,
1601 JvmtiFunctions::ClearFieldModificationWatch,
1602 JvmtiFunctions::IsModifiableClass,
1603 JvmtiFunctions::Allocate,
1604 JvmtiFunctions::Deallocate,
1605 JvmtiFunctions::GetClassSignature,
1606 JvmtiFunctions::GetClassStatus,
1607 JvmtiFunctions::GetSourceFileName, // 50
1608 JvmtiFunctions::GetClassModifiers,
1609 JvmtiFunctions::GetClassMethods,
1610 JvmtiFunctions::GetClassFields,
1611 JvmtiFunctions::GetImplementedInterfaces,
1612 JvmtiFunctions::IsInterface,
1613 JvmtiFunctions::IsArrayClass,
1614 JvmtiFunctions::GetClassLoader,
1615 JvmtiFunctions::GetObjectHashCode,
1616 JvmtiFunctions::GetObjectMonitorUsage,
1617 JvmtiFunctions::GetFieldName, // 60
1618 JvmtiFunctions::GetFieldDeclaringClass,
1619 JvmtiFunctions::GetFieldModifiers,
1620 JvmtiFunctions::IsFieldSynthetic,
1621 JvmtiFunctions::GetMethodName,
1622 JvmtiFunctions::GetMethodDeclaringClass,
1623 JvmtiFunctions::GetMethodModifiers,
1624 nullptr, // reserved67
1625 JvmtiFunctions::GetMaxLocals,
1626 JvmtiFunctions::GetArgumentsSize,
1627 JvmtiFunctions::GetLineNumberTable, // 70
1628 JvmtiFunctions::GetMethodLocation,
1629 JvmtiFunctions::GetLocalVariableTable,
1630 JvmtiFunctions::SetNativeMethodPrefix,
1631 JvmtiFunctions::SetNativeMethodPrefixes,
1632 JvmtiFunctions::GetBytecodes,
1633 JvmtiFunctions::IsMethodNative,
1634 JvmtiFunctions::IsMethodSynthetic,
1635 JvmtiFunctions::GetLoadedClasses,
1636 JvmtiFunctions::GetClassLoaderClasses,
1637 JvmtiFunctions::PopFrame, // 80
1638 JvmtiFunctions::ForceEarlyReturnObject,
1639 JvmtiFunctions::ForceEarlyReturnInt,
1640 JvmtiFunctions::ForceEarlyReturnLong,
1641 JvmtiFunctions::ForceEarlyReturnFloat,
1642 JvmtiFunctions::ForceEarlyReturnDouble,
1643 JvmtiFunctions::ForceEarlyReturnVoid,
1644 JvmtiFunctions::RedefineClasses,
1645 JvmtiFunctions::GetVersionNumber,
1646 JvmtiFunctions::GetCapabilities,
1647 JvmtiFunctions::GetSourceDebugExtension, // 90
1648 JvmtiFunctions::IsMethodObsolete,
1649 JvmtiFunctions::SuspendThreadList,
1650 JvmtiFunctions::ResumeThreadList,
1651 nullptr, // reserved94
1652 nullptr, // reserved95
1653 nullptr, // reserved96
1654 nullptr, // reserved97
1655 nullptr, // reserved98
1656 nullptr, // reserved99
1657 JvmtiFunctions::GetAllStackTraces, // 100
1658 JvmtiFunctions::GetThreadListStackTraces,
1659 JvmtiFunctions::GetThreadLocalStorage,
1660 JvmtiFunctions::SetThreadLocalStorage,
1661 JvmtiFunctions::GetStackTrace,
1662 nullptr, // reserved105
1663 JvmtiFunctions::GetTag,
1664 JvmtiFunctions::SetTag,
1665 JvmtiFunctions::ForceGarbageCollection,
1666 JvmtiFunctions::IterateOverObjectsReachableFromObject,
1667 JvmtiFunctions::IterateOverReachableObjects, // 110
1668 JvmtiFunctions::IterateOverHeap,
1669 JvmtiFunctions::IterateOverInstancesOfClass,
1670 nullptr, // reserved113
1671 JvmtiFunctions::GetObjectsWithTags,
1672 JvmtiFunctions::FollowReferences,
1673 JvmtiFunctions::IterateThroughHeap,
1674 nullptr, // reserved117
1675 nullptr, // reserved118
1676 nullptr, // reserved119
1677 JvmtiFunctions::SetJNIFunctionTable, // 120
1678 JvmtiFunctions::GetJNIFunctionTable,
1679 JvmtiFunctions::SetEventCallbacks,
1680 JvmtiFunctions::GenerateEvents,
1681 JvmtiFunctions::GetExtensionFunctions,
1682 JvmtiFunctions::GetExtensionEvents,
1683 JvmtiFunctions::SetExtensionEventCallback,
1684 JvmtiFunctions::DisposeEnvironment,
1685 JvmtiFunctions::GetErrorName,
1686 JvmtiFunctions::GetJLocationFormat,
1687 JvmtiFunctions::GetSystemProperties, // 130
1688 JvmtiFunctions::GetSystemProperty,
1689 JvmtiFunctions::SetSystemProperty,
1690 JvmtiFunctions::GetPhase,
1691 JvmtiFunctions::GetCurrentThreadCpuTimerInfo,
1692 JvmtiFunctions::GetCurrentThreadCpuTime,
1693 JvmtiFunctions::GetThreadCpuTimerInfo,
1694 JvmtiFunctions::GetThreadCpuTime,
1695 JvmtiFunctions::GetTimerInfo,
1696 JvmtiFunctions::GetTime,
1697 JvmtiFunctions::GetPotentialCapabilities, // 140
1698 nullptr, // reserved141
1699 JvmtiFunctions::AddCapabilities,
1700 JvmtiFunctions::RelinquishCapabilities,
1701 JvmtiFunctions::GetAvailableProcessors,
1702 JvmtiFunctions::GetClassVersionNumbers,
1703 JvmtiFunctions::GetConstantPool,
1704 JvmtiFunctions::GetEnvironmentLocalStorage,
1705 JvmtiFunctions::SetEnvironmentLocalStorage,
1706 JvmtiFunctions::AddToBootstrapClassLoaderSearch,
1707 JvmtiFunctions::SetVerboseFlag, // 150
1708 JvmtiFunctions::AddToSystemClassLoaderSearch,
1709 JvmtiFunctions::RetransformClasses,
1710 JvmtiFunctions::GetOwnedMonitorStackDepthInfo,
1711 JvmtiFunctions::GetObjectSize,
1712 JvmtiFunctions::GetLocalInstance,
1713 };
1714
1715 }; // namespace openjdkjvmti
1716