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