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