1 /* 2 * Copyright (c) 2003, 2024, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "classfile/classLoaderExt.hpp" 27 #include "classfile/javaClasses.inline.hpp" 28 #include "classfile/stringTable.hpp" 29 #include "classfile/modules.hpp" 30 #include "classfile/systemDictionary.hpp" 31 #include "classfile/vmClasses.hpp" 32 #include "classfile/vmSymbols.hpp" 33 #include "gc/shared/collectedHeap.hpp" 34 #include "interpreter/bytecodeStream.hpp" 35 #include "interpreter/interpreter.hpp" 36 #include "jfr/jfrEvents.hpp" 37 #include "jvmtifiles/jvmtiEnv.hpp" 38 #include "logging/log.hpp" 39 #include "logging/logConfiguration.hpp" 40 #include "memory/allocation.hpp" 41 #include "memory/resourceArea.hpp" 42 #include "memory/universe.hpp" 43 #include "oops/instanceKlass.hpp" 44 #include "oops/klass.inline.hpp" 45 #include "oops/objArrayOop.inline.hpp" 46 #include "oops/oop.inline.hpp" 47 #include "prims/jniCheck.hpp" 48 #include "prims/jvm_misc.hpp" 49 #include "prims/jvmtiAgentThread.hpp" 50 #include "prims/jvmtiClassFileReconstituter.hpp" 51 #include "prims/jvmtiCodeBlobEvents.hpp" 52 #include "prims/jvmtiExtensions.hpp" 53 #include "prims/jvmtiGetLoadedClasses.hpp" 54 #include "prims/jvmtiImpl.hpp" 55 #include "prims/jvmtiManageCapabilities.hpp" 56 #include "prims/jvmtiRawMonitor.hpp" 57 #include "prims/jvmtiRedefineClasses.hpp" 58 #include "prims/jvmtiTagMap.hpp" 59 #include "prims/jvmtiThreadState.inline.hpp" 60 #include "prims/jvmtiUtil.hpp" 61 #include "runtime/arguments.hpp" 62 #include "runtime/deoptimization.hpp" 63 #include "runtime/fieldDescriptor.inline.hpp" 64 #include "runtime/handles.inline.hpp" 65 #include "runtime/interfaceSupport.inline.hpp" 66 #include "runtime/javaCalls.hpp" 67 #include "runtime/javaThread.inline.hpp" 68 #include "runtime/jfieldIDWorkaround.hpp" 69 #include "runtime/jniHandles.inline.hpp" 70 #include "runtime/objectMonitor.inline.hpp" 71 #include "runtime/os.hpp" 72 #include "runtime/osThread.hpp" 73 #include "runtime/reflectionUtils.hpp" 74 #include "runtime/signature.hpp" 75 #include "runtime/threadHeapSampler.hpp" 76 #include "runtime/threads.hpp" 77 #include "runtime/threadSMR.hpp" 78 #include "runtime/timerTrace.hpp" 79 #include "runtime/vframe.inline.hpp" 80 #include "runtime/vmThread.hpp" 81 #include "services/threadService.hpp" 82 #include "utilities/exceptions.hpp" 83 #include "utilities/preserveException.hpp" 84 #include "utilities/utf8.hpp" 85 86 87 #define FIXLATER 0 // REMOVE this when completed. 88 89 // FIXLATER: hook into JvmtiTrace 90 #define TraceJVMTICalls false 91 92 JvmtiEnv::JvmtiEnv(jint version) : JvmtiEnvBase(version) { 93 } 94 95 JvmtiEnv::~JvmtiEnv() { 96 } 97 98 JvmtiEnv* 99 JvmtiEnv::create_a_jvmti(jint version) { 100 return new JvmtiEnv(version); 101 } 102 103 // VM operation class to copy jni function table at safepoint. 104 // More than one java threads or jvmti agents may be reading/ 105 // modifying jni function tables. To reduce the risk of bad 106 // interaction b/w these threads it is copied at safepoint. 107 class VM_JNIFunctionTableCopier : public VM_Operation { 108 private: 109 const struct JNINativeInterface_ *_function_table; 110 public: 111 VM_JNIFunctionTableCopier(const struct JNINativeInterface_ *func_tbl) { 112 _function_table = func_tbl; 113 }; 114 115 VMOp_Type type() const { return VMOp_JNIFunctionTableCopier; } 116 void doit() { 117 copy_jni_function_table(_function_table); 118 }; 119 }; 120 121 // 122 // Do not change the "prefix" marker below, everything above it is copied 123 // unchanged into the filled stub, everything below is controlled by the 124 // stub filler (only method bodies are carried forward, and then only for 125 // functionality still in the spec). 126 // 127 // end file prefix 128 129 // 130 // Memory Management functions 131 // 132 133 // mem_ptr - pre-checked for null 134 jvmtiError 135 JvmtiEnv::Allocate(jlong size, unsigned char** mem_ptr) { 136 return allocate(size, mem_ptr); 137 } /* end Allocate */ 138 139 140 // mem - null is a valid value, must be checked 141 jvmtiError 142 JvmtiEnv::Deallocate(unsigned char* mem) { 143 return deallocate(mem); 144 } /* end Deallocate */ 145 146 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 147 // data - null is a valid value, must be checked 148 jvmtiError 149 JvmtiEnv::SetThreadLocalStorage(jthread thread, const void* data) { 150 JavaThread* current = JavaThread::current(); 151 JvmtiThreadState* state = nullptr; 152 JvmtiVTMSTransitionDisabler disabler(thread); 153 ThreadsListHandle tlh(current); 154 155 JavaThread* java_thread = nullptr; 156 oop thread_obj = nullptr; 157 if (thread == nullptr) { 158 java_thread = current; 159 state = java_thread->jvmti_thread_state(); 160 } else { 161 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current, &java_thread, &thread_obj); 162 if (err != JVMTI_ERROR_NONE) { 163 return err; 164 } 165 state = java_lang_Thread::jvmti_thread_state(thread_obj); 166 } 167 if (state == nullptr) { 168 if (data == nullptr) { 169 // leaving state unset same as data set to null 170 return JVMTI_ERROR_NONE; 171 } 172 // otherwise, create the state 173 HandleMark hm(current); 174 Handle thread_handle(current, thread_obj); 175 state = JvmtiThreadState::state_for(java_thread, thread_handle); 176 if (state == nullptr) { 177 return JVMTI_ERROR_THREAD_NOT_ALIVE; 178 } 179 } 180 state->env_thread_state(this)->set_agent_thread_local_storage_data((void*)data); 181 return JVMTI_ERROR_NONE; 182 } /* end SetThreadLocalStorage */ 183 184 185 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 186 // data_ptr - pre-checked for null 187 jvmtiError 188 JvmtiEnv::GetThreadLocalStorage(jthread thread, void** data_ptr) { 189 JavaThread* current_thread = JavaThread::current(); 190 if (thread == nullptr) { 191 JvmtiThreadState* state = current_thread->jvmti_thread_state(); 192 *data_ptr = (state == nullptr) ? nullptr : 193 state->env_thread_state(this)->get_agent_thread_local_storage_data(); 194 } else { 195 // jvmti_GetThreadLocalStorage is "in native" and doesn't transition 196 // the thread to _thread_in_vm. However, when the TLS for a thread 197 // other than the current thread is required we need to transition 198 // from native so as to resolve the jthread. 199 200 MACOS_AARCH64_ONLY(ThreadWXEnable __wx(WXWrite, current_thread)); 201 ThreadInVMfromNative __tiv(current_thread); 202 VM_ENTRY_BASE(jvmtiError, JvmtiEnv::GetThreadLocalStorage , current_thread) 203 debug_only(VMNativeEntryWrapper __vew;) 204 205 JvmtiVTMSTransitionDisabler disabler(thread); 206 ThreadsListHandle tlh(current_thread); 207 208 JavaThread* java_thread = nullptr; 209 oop thread_obj = nullptr; 210 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current_thread, &java_thread, &thread_obj); 211 if (err != JVMTI_ERROR_NONE) { 212 return err; 213 } 214 215 HandleMark hm(current_thread); 216 Handle thread_handle(current_thread, thread_obj); 217 JvmtiThreadState* state = JvmtiThreadState::state_for(java_thread, thread_handle); 218 *data_ptr = (state == nullptr) ? nullptr : 219 state->env_thread_state(this)->get_agent_thread_local_storage_data(); 220 } 221 return JVMTI_ERROR_NONE; 222 } /* end GetThreadLocalStorage */ 223 224 // 225 // Module functions 226 // 227 228 // module_count_ptr - pre-checked for null 229 // modules_ptr - pre-checked for null 230 jvmtiError 231 JvmtiEnv::GetAllModules(jint* module_count_ptr, jobject** modules_ptr) { 232 JvmtiModuleClosure jmc; 233 234 return jmc.get_all_modules(this, module_count_ptr, modules_ptr); 235 } /* end GetAllModules */ 236 237 238 // class_loader - null is a valid value, must be pre-checked 239 // package_name - pre-checked for null 240 // module_ptr - pre-checked for null 241 jvmtiError 242 JvmtiEnv::GetNamedModule(jobject class_loader, const char* package_name, jobject* module_ptr) { 243 JavaThread* THREAD = JavaThread::current(); // For exception macros. 244 ResourceMark rm(THREAD); 245 246 Handle h_loader (THREAD, JNIHandles::resolve(class_loader)); 247 // Check that loader is a subclass of java.lang.ClassLoader. 248 if (h_loader.not_null() && !java_lang_ClassLoader::is_subclass(h_loader->klass())) { 249 return JVMTI_ERROR_ILLEGAL_ARGUMENT; 250 } 251 oop module = Modules::get_named_module(h_loader, package_name); 252 *module_ptr = module != nullptr ? JNIHandles::make_local(THREAD, module) : nullptr; 253 return JVMTI_ERROR_NONE; 254 } /* end GetNamedModule */ 255 256 257 // module - pre-checked for null 258 // to_module - pre-checked for null 259 jvmtiError 260 JvmtiEnv::AddModuleReads(jobject module, jobject to_module) { 261 JavaThread* THREAD = JavaThread::current(); // For exception macros. 262 263 // check module 264 Handle h_module(THREAD, JNIHandles::resolve(module)); 265 if (!java_lang_Module::is_instance(h_module())) { 266 return JVMTI_ERROR_INVALID_MODULE; 267 } 268 // check to_module 269 Handle h_to_module(THREAD, JNIHandles::resolve(to_module)); 270 if (!java_lang_Module::is_instance(h_to_module())) { 271 return JVMTI_ERROR_INVALID_MODULE; 272 } 273 return JvmtiExport::add_module_reads(h_module, h_to_module, THREAD); 274 } /* end AddModuleReads */ 275 276 277 // module - pre-checked for null 278 // pkg_name - pre-checked for null 279 // to_module - pre-checked for null 280 jvmtiError 281 JvmtiEnv::AddModuleExports(jobject module, const char* pkg_name, jobject to_module) { 282 JavaThread* THREAD = JavaThread::current(); // For exception macros. 283 Handle h_pkg = java_lang_String::create_from_str(pkg_name, THREAD); 284 285 // check module 286 Handle h_module(THREAD, JNIHandles::resolve(module)); 287 if (!java_lang_Module::is_instance(h_module())) { 288 return JVMTI_ERROR_INVALID_MODULE; 289 } 290 // check to_module 291 Handle h_to_module(THREAD, JNIHandles::resolve(to_module)); 292 if (!java_lang_Module::is_instance(h_to_module())) { 293 return JVMTI_ERROR_INVALID_MODULE; 294 } 295 return JvmtiExport::add_module_exports(h_module, h_pkg, h_to_module, THREAD); 296 } /* end AddModuleExports */ 297 298 299 // module - pre-checked for null 300 // pkg_name - pre-checked for null 301 // to_module - pre-checked for null 302 jvmtiError 303 JvmtiEnv::AddModuleOpens(jobject module, const char* pkg_name, jobject to_module) { 304 JavaThread* THREAD = JavaThread::current(); // For exception macros. 305 Handle h_pkg = java_lang_String::create_from_str(pkg_name, THREAD); 306 307 // check module 308 Handle h_module(THREAD, JNIHandles::resolve(module)); 309 if (!java_lang_Module::is_instance(h_module())) { 310 return JVMTI_ERROR_INVALID_MODULE; 311 } 312 // check to_module 313 Handle h_to_module(THREAD, JNIHandles::resolve(to_module)); 314 if (!java_lang_Module::is_instance(h_to_module())) { 315 return JVMTI_ERROR_INVALID_MODULE; 316 } 317 return JvmtiExport::add_module_opens(h_module, h_pkg, h_to_module, THREAD); 318 } /* end AddModuleOpens */ 319 320 321 // module - pre-checked for null 322 // service - pre-checked for null 323 jvmtiError 324 JvmtiEnv::AddModuleUses(jobject module, jclass service) { 325 JavaThread* THREAD = JavaThread::current(); // For exception macros. 326 327 // check module 328 Handle h_module(THREAD, JNIHandles::resolve(module)); 329 if (!java_lang_Module::is_instance(h_module())) { 330 return JVMTI_ERROR_INVALID_MODULE; 331 } 332 // check service 333 Handle h_service(THREAD, JNIHandles::resolve_external_guard(service)); 334 if (!java_lang_Class::is_instance(h_service()) || 335 java_lang_Class::is_primitive(h_service())) { 336 return JVMTI_ERROR_INVALID_CLASS; 337 } 338 return JvmtiExport::add_module_uses(h_module, h_service, THREAD); 339 } /* end AddModuleUses */ 340 341 342 // module - pre-checked for null 343 // service - pre-checked for null 344 // impl_class - pre-checked for null 345 jvmtiError 346 JvmtiEnv::AddModuleProvides(jobject module, jclass service, jclass impl_class) { 347 JavaThread* THREAD = JavaThread::current(); // For exception macros. 348 349 // check module 350 Handle h_module(THREAD, JNIHandles::resolve(module)); 351 if (!java_lang_Module::is_instance(h_module())) { 352 return JVMTI_ERROR_INVALID_MODULE; 353 } 354 // check service 355 Handle h_service(THREAD, JNIHandles::resolve_external_guard(service)); 356 if (!java_lang_Class::is_instance(h_service()) || 357 java_lang_Class::is_primitive(h_service())) { 358 return JVMTI_ERROR_INVALID_CLASS; 359 } 360 // check impl_class 361 Handle h_impl_class(THREAD, JNIHandles::resolve_external_guard(impl_class)); 362 if (!java_lang_Class::is_instance(h_impl_class()) || 363 java_lang_Class::is_primitive(h_impl_class())) { 364 return JVMTI_ERROR_INVALID_CLASS; 365 } 366 return JvmtiExport::add_module_provides(h_module, h_service, h_impl_class, THREAD); 367 } /* end AddModuleProvides */ 368 369 // module - pre-checked for null 370 // is_modifiable_class_ptr - pre-checked for null 371 jvmtiError 372 JvmtiEnv::IsModifiableModule(jobject module, jboolean* is_modifiable_module_ptr) { 373 JavaThread* current = JavaThread::current(); 374 375 // check module 376 Handle h_module(current, JNIHandles::resolve(module)); 377 if (!java_lang_Module::is_instance(h_module())) { 378 return JVMTI_ERROR_INVALID_MODULE; 379 } 380 381 *is_modifiable_module_ptr = JNI_TRUE; 382 return JVMTI_ERROR_NONE; 383 } /* end IsModifiableModule */ 384 385 386 // 387 // Class functions 388 // 389 390 // class_count_ptr - pre-checked for null 391 // classes_ptr - pre-checked for null 392 jvmtiError 393 JvmtiEnv::GetLoadedClasses(jint* class_count_ptr, jclass** classes_ptr) { 394 return JvmtiGetLoadedClasses::getLoadedClasses(this, class_count_ptr, classes_ptr); 395 } /* end GetLoadedClasses */ 396 397 398 // initiating_loader - null is a valid value, must be checked 399 // class_count_ptr - pre-checked for null 400 // classes_ptr - pre-checked for null 401 jvmtiError 402 JvmtiEnv::GetClassLoaderClasses(jobject initiating_loader, jint* class_count_ptr, jclass** classes_ptr) { 403 return JvmtiGetLoadedClasses::getClassLoaderClasses(this, initiating_loader, 404 class_count_ptr, classes_ptr); 405 } /* end GetClassLoaderClasses */ 406 407 // k_mirror - may be primitive, this must be checked 408 // is_modifiable_class_ptr - pre-checked for null 409 jvmtiError 410 JvmtiEnv::IsModifiableClass(oop k_mirror, jboolean* is_modifiable_class_ptr) { 411 *is_modifiable_class_ptr = VM_RedefineClasses::is_modifiable_class(k_mirror)? 412 JNI_TRUE : JNI_FALSE; 413 return JVMTI_ERROR_NONE; 414 } /* end IsModifiableClass */ 415 416 // class_count - pre-checked to be greater than or equal to 0 417 // classes - pre-checked for null 418 jvmtiError 419 JvmtiEnv::RetransformClasses(jint class_count, const jclass* classes) { 420 //TODO: add locking 421 422 int index; 423 JavaThread* current_thread = JavaThread::current(); 424 ResourceMark rm(current_thread); 425 426 jvmtiClassDefinition* class_definitions = 427 NEW_RESOURCE_ARRAY(jvmtiClassDefinition, class_count); 428 NULL_CHECK(class_definitions, JVMTI_ERROR_OUT_OF_MEMORY); 429 430 for (index = 0; index < class_count; index++) { 431 HandleMark hm(current_thread); 432 433 jclass jcls = classes[index]; 434 oop k_mirror = JNIHandles::resolve_external_guard(jcls); 435 if (k_mirror == nullptr) { 436 return JVMTI_ERROR_INVALID_CLASS; 437 } 438 if (!k_mirror->is_a(vmClasses::Class_klass())) { 439 return JVMTI_ERROR_INVALID_CLASS; 440 } 441 442 if (!VM_RedefineClasses::is_modifiable_class(k_mirror)) { 443 return JVMTI_ERROR_UNMODIFIABLE_CLASS; 444 } 445 446 Klass* klass = java_lang_Class::as_Klass(k_mirror); 447 448 jint status = klass->jvmti_class_status(); 449 if (status & (JVMTI_CLASS_STATUS_ERROR)) { 450 return JVMTI_ERROR_INVALID_CLASS; 451 } 452 453 InstanceKlass* ik = InstanceKlass::cast(klass); 454 if (ik->get_cached_class_file_bytes() == nullptr) { 455 // Not cached, we need to reconstitute the class file from the 456 // VM representation. We don't attach the reconstituted class 457 // bytes to the InstanceKlass here because they have not been 458 // validated and we're not at a safepoint. 459 JvmtiClassFileReconstituter reconstituter(ik); 460 if (reconstituter.get_error() != JVMTI_ERROR_NONE) { 461 return reconstituter.get_error(); 462 } 463 464 class_definitions[index].class_byte_count = (jint)reconstituter.class_file_size(); 465 class_definitions[index].class_bytes = (unsigned char*) 466 reconstituter.class_file_bytes(); 467 } else { 468 // it is cached, get it from the cache 469 class_definitions[index].class_byte_count = ik->get_cached_class_file_len(); 470 class_definitions[index].class_bytes = ik->get_cached_class_file_bytes(); 471 } 472 class_definitions[index].klass = jcls; 473 } 474 EventRetransformClasses event; 475 VM_RedefineClasses op(class_count, class_definitions, jvmti_class_load_kind_retransform); 476 VMThread::execute(&op); 477 jvmtiError error = op.check_error(); 478 if (error == JVMTI_ERROR_NONE) { 479 event.set_classCount(class_count); 480 event.set_redefinitionId(op.id()); 481 event.commit(); 482 } 483 return error; 484 } /* end RetransformClasses */ 485 486 487 // class_count - pre-checked to be greater than or equal to 0 488 // class_definitions - pre-checked for null 489 jvmtiError 490 JvmtiEnv::RedefineClasses(jint class_count, const jvmtiClassDefinition* class_definitions) { 491 //TODO: add locking 492 EventRedefineClasses event; 493 VM_RedefineClasses op(class_count, class_definitions, jvmti_class_load_kind_redefine); 494 VMThread::execute(&op); 495 jvmtiError error = op.check_error(); 496 if (error == JVMTI_ERROR_NONE) { 497 event.set_classCount(class_count); 498 event.set_redefinitionId(op.id()); 499 event.commit(); 500 } 501 return error; 502 } /* end RedefineClasses */ 503 504 505 // 506 // Object functions 507 // 508 509 // size_ptr - pre-checked for null 510 jvmtiError 511 JvmtiEnv::GetObjectSize(jobject object, jlong* size_ptr) { 512 oop mirror = JNIHandles::resolve_external_guard(object); 513 NULL_CHECK(mirror, JVMTI_ERROR_INVALID_OBJECT); 514 *size_ptr = (jlong)mirror->size() * wordSize; 515 return JVMTI_ERROR_NONE; 516 } /* end GetObjectSize */ 517 518 // 519 // Method functions 520 // 521 522 // prefix - null is a valid value, must be checked 523 jvmtiError 524 JvmtiEnv::SetNativeMethodPrefix(const char* prefix) { 525 return prefix == nullptr? 526 SetNativeMethodPrefixes(0, nullptr) : 527 SetNativeMethodPrefixes(1, (char**)&prefix); 528 } /* end SetNativeMethodPrefix */ 529 530 531 // prefix_count - pre-checked to be greater than or equal to 0 532 // prefixes - pre-checked for null 533 jvmtiError 534 JvmtiEnv::SetNativeMethodPrefixes(jint prefix_count, char** prefixes) { 535 // Have to grab JVMTI thread state lock to be sure that some thread 536 // isn't accessing the prefixes at the same time we are setting them. 537 // No locks during VM bring-up. 538 if (Threads::number_of_threads() == 0) { 539 return set_native_method_prefixes(prefix_count, prefixes); 540 } else { 541 MutexLocker mu(JvmtiThreadState_lock); 542 return set_native_method_prefixes(prefix_count, prefixes); 543 } 544 } /* end SetNativeMethodPrefixes */ 545 546 // 547 // Event Management functions 548 // 549 550 // callbacks - null is a valid value, must be checked 551 // size_of_callbacks - pre-checked to be greater than or equal to 0 552 jvmtiError 553 JvmtiEnv::SetEventCallbacks(const jvmtiEventCallbacks* callbacks, jint size_of_callbacks) { 554 JvmtiVTMSTransitionDisabler disabler; 555 JvmtiEventController::set_event_callbacks(this, callbacks, size_of_callbacks); 556 return JVMTI_ERROR_NONE; 557 } /* end SetEventCallbacks */ 558 559 560 // event_thread - null is a valid value, must be checked 561 jvmtiError 562 JvmtiEnv::SetEventNotificationMode(jvmtiEventMode mode, jvmtiEvent event_type, jthread event_thread, ...) { 563 bool enabled = (mode == JVMTI_ENABLE); 564 565 // event_type must be valid 566 if (!JvmtiEventController::is_valid_event_type(event_type)) { 567 return JVMTI_ERROR_INVALID_EVENT_TYPE; 568 } 569 570 // assure that needed capabilities are present 571 if (enabled && !JvmtiUtil::has_event_capability(event_type, get_capabilities())) { 572 return JVMTI_ERROR_MUST_POSSESS_CAPABILITY; 573 } 574 575 if (event_type == JVMTI_EVENT_CLASS_FILE_LOAD_HOOK && enabled) { 576 record_class_file_load_hook_enabled(); 577 } 578 JvmtiVTMSTransitionDisabler disabler; 579 580 if (event_thread == nullptr) { 581 // Can be called at Agent_OnLoad() time with event_thread == nullptr 582 // when Thread::current() does not work yet so we cannot create a 583 // ThreadsListHandle that is common to both thread-specific and 584 // global code paths. 585 586 JvmtiEventController::set_user_enabled(this, nullptr, (oop) nullptr, event_type, enabled); 587 } else { 588 // We have a specified event_thread. 589 JavaThread* current = JavaThread::current(); 590 ThreadsListHandle tlh(current); 591 592 JavaThread* java_thread = nullptr; 593 oop thread_obj = nullptr; 594 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), event_thread, current, &java_thread, &thread_obj); 595 if (err != JVMTI_ERROR_NONE) { 596 return err; 597 } 598 599 // global events cannot be controlled at thread level. 600 if (JvmtiEventController::is_global_event(event_type)) { 601 return JVMTI_ERROR_ILLEGAL_ARGUMENT; 602 } 603 604 JvmtiEventController::set_user_enabled(this, java_thread, thread_obj, event_type, enabled); 605 } 606 607 return JVMTI_ERROR_NONE; 608 } /* end SetEventNotificationMode */ 609 610 // 611 // Capability functions 612 // 613 614 // capabilities_ptr - pre-checked for null 615 jvmtiError 616 JvmtiEnv::GetPotentialCapabilities(jvmtiCapabilities* capabilities_ptr) { 617 JvmtiManageCapabilities::get_potential_capabilities(get_capabilities(), 618 get_prohibited_capabilities(), 619 capabilities_ptr); 620 return JVMTI_ERROR_NONE; 621 } /* end GetPotentialCapabilities */ 622 623 624 // capabilities_ptr - pre-checked for null 625 jvmtiError 626 JvmtiEnv::AddCapabilities(const jvmtiCapabilities* capabilities_ptr) { 627 return JvmtiManageCapabilities::add_capabilities(get_capabilities(), 628 get_prohibited_capabilities(), 629 capabilities_ptr, 630 get_capabilities()); 631 } /* end AddCapabilities */ 632 633 634 // capabilities_ptr - pre-checked for null 635 jvmtiError 636 JvmtiEnv::RelinquishCapabilities(const jvmtiCapabilities* capabilities_ptr) { 637 JvmtiManageCapabilities::relinquish_capabilities(get_capabilities(), capabilities_ptr, get_capabilities()); 638 return JVMTI_ERROR_NONE; 639 } /* end RelinquishCapabilities */ 640 641 642 // capabilities_ptr - pre-checked for null 643 jvmtiError 644 JvmtiEnv::GetCapabilities(jvmtiCapabilities* capabilities_ptr) { 645 JvmtiManageCapabilities::copy_capabilities(get_capabilities(), capabilities_ptr); 646 return JVMTI_ERROR_NONE; 647 } /* end GetCapabilities */ 648 649 // 650 // Class Loader Search functions 651 // 652 653 // segment - pre-checked for null 654 jvmtiError 655 JvmtiEnv::AddToBootstrapClassLoaderSearch(const char* segment) { 656 jvmtiPhase phase = get_phase(); 657 if (phase == JVMTI_PHASE_ONLOAD) { 658 Arguments::append_sysclasspath(segment); 659 return JVMTI_ERROR_NONE; 660 } else if (use_version_1_0_semantics()) { 661 // This JvmtiEnv requested version 1.0 semantics and this function 662 // is only allowed in the ONLOAD phase in version 1.0 so we need to 663 // return an error here. 664 return JVMTI_ERROR_WRONG_PHASE; 665 } else if (phase == JVMTI_PHASE_LIVE) { 666 // The phase is checked by the wrapper that called this function, 667 // but this thread could be racing with the thread that is 668 // terminating the VM so we check one more time. 669 670 // create the zip entry 671 ClassPathZipEntry* zip_entry = ClassLoader::create_class_path_zip_entry(segment, true); 672 if (zip_entry == nullptr) { 673 return JVMTI_ERROR_ILLEGAL_ARGUMENT; 674 } 675 676 // add the jar file to the bootclasspath 677 log_info(class, load)("opened: %s", zip_entry->name()); 678 #if INCLUDE_CDS 679 ClassLoaderExt::append_boot_classpath(zip_entry); 680 #else 681 ClassLoader::add_to_boot_append_entries(zip_entry); 682 #endif 683 return JVMTI_ERROR_NONE; 684 } else { 685 return JVMTI_ERROR_WRONG_PHASE; 686 } 687 688 } /* end AddToBootstrapClassLoaderSearch */ 689 690 691 // segment - pre-checked for null 692 jvmtiError 693 JvmtiEnv::AddToSystemClassLoaderSearch(const char* segment) { 694 jvmtiPhase phase = get_phase(); 695 696 if (phase == JVMTI_PHASE_ONLOAD) { 697 for (SystemProperty* p = Arguments::system_properties(); p != nullptr; p = p->next()) { 698 if (strcmp("java.class.path", p->key()) == 0) { 699 p->append_value(segment); 700 break; 701 } 702 } 703 return JVMTI_ERROR_NONE; 704 } else if (phase == JVMTI_PHASE_LIVE) { 705 // The phase is checked by the wrapper that called this function, 706 // but this thread could be racing with the thread that is 707 // terminating the VM so we check one more time. 708 JavaThread* THREAD = JavaThread::current(); // For exception macros. 709 HandleMark hm(THREAD); 710 711 // create the zip entry (which will open the zip file and hence 712 // check that the segment is indeed a zip file). 713 ClassPathZipEntry* zip_entry = ClassLoader::create_class_path_zip_entry(segment, false); 714 if (zip_entry == nullptr) { 715 return JVMTI_ERROR_ILLEGAL_ARGUMENT; 716 } 717 delete zip_entry; // no longer needed 718 719 Handle loader(THREAD, SystemDictionary::java_system_loader()); 720 721 // need the path as java.lang.String 722 Handle path = java_lang_String::create_from_platform_dependent_str(segment, THREAD); 723 if (HAS_PENDING_EXCEPTION) { 724 CLEAR_PENDING_EXCEPTION; 725 return JVMTI_ERROR_INTERNAL; 726 } 727 728 // Invoke the appendToClassPathForInstrumentation method - if the method 729 // is not found it means the loader doesn't support adding to the class path 730 // in the live phase. 731 { 732 JavaValue res(T_VOID); 733 JavaCalls::call_special(&res, 734 loader, 735 loader->klass(), 736 vmSymbols::appendToClassPathForInstrumentation_name(), 737 vmSymbols::appendToClassPathForInstrumentation_signature(), 738 path, 739 THREAD); 740 if (HAS_PENDING_EXCEPTION) { 741 Symbol* ex_name = PENDING_EXCEPTION->klass()->name(); 742 CLEAR_PENDING_EXCEPTION; 743 744 if (ex_name == vmSymbols::java_lang_NoSuchMethodError()) { 745 return JVMTI_ERROR_CLASS_LOADER_UNSUPPORTED; 746 } else { 747 return JVMTI_ERROR_INTERNAL; 748 } 749 } 750 } 751 752 return JVMTI_ERROR_NONE; 753 } else { 754 return JVMTI_ERROR_WRONG_PHASE; 755 } 756 } /* end AddToSystemClassLoaderSearch */ 757 758 // 759 // General functions 760 // 761 762 // phase_ptr - pre-checked for null 763 jvmtiError 764 JvmtiEnv::GetPhase(jvmtiPhase* phase_ptr) { 765 *phase_ptr = phase(); 766 return JVMTI_ERROR_NONE; 767 } /* end GetPhase */ 768 769 770 jvmtiError 771 JvmtiEnv::DisposeEnvironment() { 772 dispose(); 773 return JVMTI_ERROR_NONE; 774 } /* end DisposeEnvironment */ 775 776 777 // data - null is a valid value, must be checked 778 jvmtiError 779 JvmtiEnv::SetEnvironmentLocalStorage(const void* data) { 780 set_env_local_storage(data); 781 return JVMTI_ERROR_NONE; 782 } /* end SetEnvironmentLocalStorage */ 783 784 785 // data_ptr - pre-checked for null 786 jvmtiError 787 JvmtiEnv::GetEnvironmentLocalStorage(void** data_ptr) { 788 *data_ptr = (void*)get_env_local_storage(); 789 return JVMTI_ERROR_NONE; 790 } /* end GetEnvironmentLocalStorage */ 791 792 // version_ptr - pre-checked for null 793 jvmtiError 794 JvmtiEnv::GetVersionNumber(jint* version_ptr) { 795 *version_ptr = JVMTI_VERSION; 796 return JVMTI_ERROR_NONE; 797 } /* end GetVersionNumber */ 798 799 800 // name_ptr - pre-checked for null 801 jvmtiError 802 JvmtiEnv::GetErrorName(jvmtiError error, char** name_ptr) { 803 if (error < JVMTI_ERROR_NONE || error > JVMTI_ERROR_MAX) { 804 return JVMTI_ERROR_ILLEGAL_ARGUMENT; 805 } 806 const char *name = JvmtiUtil::error_name(error); 807 if (name == nullptr) { 808 return JVMTI_ERROR_ILLEGAL_ARGUMENT; 809 } 810 size_t len = strlen(name) + 1; 811 jvmtiError err = allocate(len, (unsigned char**)name_ptr); 812 if (err == JVMTI_ERROR_NONE) { 813 memcpy(*name_ptr, name, len); 814 } 815 return err; 816 } /* end GetErrorName */ 817 818 819 jvmtiError 820 JvmtiEnv::SetVerboseFlag(jvmtiVerboseFlag flag, jboolean value) { 821 LogLevelType level = value == 0 ? LogLevel::Off : LogLevel::Info; 822 switch (flag) { 823 case JVMTI_VERBOSE_OTHER: 824 // ignore 825 break; 826 case JVMTI_VERBOSE_CLASS: 827 LogConfiguration::configure_stdout(level, false, LOG_TAGS(class, unload)); 828 LogConfiguration::configure_stdout(level, false, LOG_TAGS(class, load)); 829 break; 830 case JVMTI_VERBOSE_GC: 831 LogConfiguration::configure_stdout(level, true, LOG_TAGS(gc)); 832 break; 833 case JVMTI_VERBOSE_JNI: 834 level = value == 0 ? LogLevel::Off : LogLevel::Debug; 835 LogConfiguration::configure_stdout(level, true, LOG_TAGS(jni, resolve)); 836 break; 837 default: 838 return JVMTI_ERROR_ILLEGAL_ARGUMENT; 839 }; 840 return JVMTI_ERROR_NONE; 841 } /* end SetVerboseFlag */ 842 843 844 // format_ptr - pre-checked for null 845 jvmtiError 846 JvmtiEnv::GetJLocationFormat(jvmtiJlocationFormat* format_ptr) { 847 *format_ptr = JVMTI_JLOCATION_JVMBCI; 848 return JVMTI_ERROR_NONE; 849 } /* end GetJLocationFormat */ 850 851 // 852 // Thread functions 853 // 854 855 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 856 // thread_state_ptr - pre-checked for null 857 jvmtiError 858 JvmtiEnv::GetThreadState(jthread thread, jint* thread_state_ptr) { 859 JavaThread* current_thread = JavaThread::current(); 860 JvmtiVTMSTransitionDisabler disabler(thread); 861 ThreadsListHandle tlh(current_thread); 862 863 JavaThread* java_thread = nullptr; 864 oop thread_oop = nullptr; 865 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current_thread, &java_thread, &thread_oop); 866 if (err != JVMTI_ERROR_NONE && err != JVMTI_ERROR_THREAD_NOT_ALIVE) { 867 // We got an error code so we don't have a JavaThread*, but only 868 // return an error from here if the error is not because the thread 869 // is a virtual thread. 870 return err; 871 } 872 *thread_state_ptr = JvmtiEnvBase::get_thread_or_vthread_state(thread_oop, java_thread); 873 return JVMTI_ERROR_NONE; 874 } /* end GetThreadState */ 875 876 877 // thread_ptr - pre-checked for null 878 jvmtiError 879 JvmtiEnv::GetCurrentThread(jthread* thread_ptr) { 880 JavaThread* cur_thread = JavaThread::current(); 881 oop thread_oop = get_vthread_or_thread_oop(cur_thread); 882 883 *thread_ptr = (jthread)JNIHandles::make_local(cur_thread, thread_oop); 884 return JVMTI_ERROR_NONE; 885 } /* end GetCurrentThread */ 886 887 888 // threads_count_ptr - pre-checked for null 889 // threads_ptr - pre-checked for null 890 jvmtiError 891 JvmtiEnv::GetAllThreads(jint* threads_count_ptr, jthread** threads_ptr) { 892 int nthreads = 0; 893 Handle *thread_objs = nullptr; 894 Thread* current_thread = Thread::current(); 895 ResourceMark rm(current_thread); 896 HandleMark hm(current_thread); 897 898 // enumerate threads (including agent threads) 899 ThreadsListEnumerator tle(current_thread, true); 900 nthreads = tle.num_threads(); 901 *threads_count_ptr = nthreads; 902 903 if (nthreads == 0) { 904 *threads_ptr = nullptr; 905 return JVMTI_ERROR_NONE; 906 } 907 908 thread_objs = NEW_RESOURCE_ARRAY(Handle, nthreads); 909 NULL_CHECK(thread_objs, JVMTI_ERROR_OUT_OF_MEMORY); 910 911 for (int i = 0; i < nthreads; i++) { 912 thread_objs[i] = Handle(tle.get_threadObj(i)); 913 } 914 915 jthread *jthreads = new_jthreadArray(nthreads, thread_objs); 916 NULL_CHECK(jthreads, JVMTI_ERROR_OUT_OF_MEMORY); 917 918 *threads_ptr = jthreads; 919 return JVMTI_ERROR_NONE; 920 } /* end GetAllThreads */ 921 922 923 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 924 jvmtiError 925 JvmtiEnv::SuspendThread(jthread thread) { 926 JavaThread* current = JavaThread::current(); 927 HandleMark hm(current); 928 Handle self_tobj; 929 930 jvmtiError err; 931 { 932 JvmtiVTMSTransitionDisabler disabler(true); 933 ThreadsListHandle tlh(current); 934 JavaThread* java_thread = nullptr; 935 oop thread_oop = nullptr; 936 937 err = get_threadOop_and_JavaThread(tlh.list(), thread, current, &java_thread, &thread_oop); 938 if (err != JVMTI_ERROR_NONE) { 939 return err; 940 } 941 942 // Do not use JvmtiVTMSTransitionDisabler in context of self suspend to avoid deadlocks. 943 if (java_thread != current) { 944 err = suspend_thread(thread_oop, java_thread, /* single_suspend */ true, nullptr); 945 return err; 946 } 947 // protect thread_oop as a safepoint can be reached in disabler destructor 948 self_tobj = Handle(current, thread_oop); 949 } 950 // Do self suspend for current JavaThread. 951 err = suspend_thread(self_tobj(), current, /* single_suspend */ true, nullptr); 952 return err; 953 } /* end SuspendThread */ 954 955 956 // request_count - pre-checked to be greater than or equal to 0 957 // request_list - pre-checked for null 958 // results - pre-checked for null 959 jvmtiError 960 JvmtiEnv::SuspendThreadList(jint request_count, const jthread* request_list, jvmtiError* results) { 961 JavaThread* current = JavaThread::current(); 962 HandleMark hm(current); 963 Handle self_tobj; 964 int self_idx = -1; 965 966 { 967 JvmtiVTMSTransitionDisabler disabler(true); 968 ThreadsListHandle tlh(current); 969 970 for (int i = 0; i < request_count; i++) { 971 JavaThread *java_thread = nullptr; 972 oop thread_oop = nullptr; 973 jthread thread = request_list[i]; 974 jvmtiError err = JvmtiExport::cv_external_thread_to_JavaThread(tlh.list(), thread, &java_thread, &thread_oop); 975 976 if (thread_oop != nullptr && 977 java_lang_VirtualThread::is_instance(thread_oop) && 978 !JvmtiEnvBase::is_vthread_alive(thread_oop)) { 979 err = JVMTI_ERROR_THREAD_NOT_ALIVE; 980 } 981 if (err != JVMTI_ERROR_NONE) { 982 if (thread_oop == nullptr || err != JVMTI_ERROR_INVALID_THREAD) { 983 results[i] = err; 984 continue; 985 } 986 } 987 if (java_thread == current) { 988 self_idx = i; 989 self_tobj = Handle(current, thread_oop); 990 continue; // self suspend after all other suspends 991 } 992 results[i] = suspend_thread(thread_oop, java_thread, /* single_suspend */ true, nullptr); 993 } 994 } 995 // Self suspend after all other suspends if necessary. 996 // Do not use JvmtiVTMSTransitionDisabler in context of self suspend to avoid deadlocks. 997 if (self_tobj() != nullptr) { 998 // there should not be any error for current java_thread 999 results[self_idx] = suspend_thread(self_tobj(), current, /* single_suspend */ true, nullptr); 1000 } 1001 // per-thread suspend results returned via results parameter 1002 return JVMTI_ERROR_NONE; 1003 } /* end SuspendThreadList */ 1004 1005 1006 jvmtiError 1007 JvmtiEnv::SuspendAllVirtualThreads(jint except_count, const jthread* except_list) { 1008 if (get_capabilities()->can_support_virtual_threads == 0) { 1009 return JVMTI_ERROR_MUST_POSSESS_CAPABILITY; 1010 } 1011 JavaThread* current = JavaThread::current(); 1012 HandleMark hm(current); 1013 Handle self_tobj; 1014 1015 { 1016 ResourceMark rm(current); 1017 JvmtiVTMSTransitionDisabler disabler(true); 1018 ThreadsListHandle tlh(current); 1019 GrowableArray<jthread>* elist = new GrowableArray<jthread>(except_count); 1020 1021 jvmtiError err = JvmtiEnvBase::check_thread_list(except_count, except_list); 1022 if (err != JVMTI_ERROR_NONE) { 1023 return err; 1024 } 1025 1026 // Collect threads from except_list for which resumed status must be restored (only for VirtualThread case) 1027 for (int idx = 0; idx < except_count; idx++) { 1028 jthread thread = except_list[idx]; 1029 oop thread_oop = JNIHandles::resolve_external_guard(thread); 1030 if (java_lang_VirtualThread::is_instance(thread_oop) && !JvmtiVTSuspender::is_vthread_suspended(thread_oop)) { 1031 // is not suspended, so its resumed status must be restored 1032 elist->append(except_list[idx]); 1033 } 1034 } 1035 1036 for (JavaThreadIteratorWithHandle jtiwh; JavaThread *java_thread = jtiwh.next(); ) { 1037 oop vt_oop = java_thread->jvmti_vthread(); 1038 if (!java_thread->is_exiting() && 1039 !java_thread->is_jvmti_agent_thread() && 1040 !java_thread->is_hidden_from_external_view() && 1041 vt_oop != nullptr && 1042 ((java_lang_VirtualThread::is_instance(vt_oop) && 1043 JvmtiEnvBase::is_vthread_alive(vt_oop) && 1044 !JvmtiVTSuspender::is_vthread_suspended(vt_oop)) || 1045 (vt_oop->is_a(vmClasses::BoundVirtualThread_klass()) && !java_thread->is_suspended())) && 1046 !is_in_thread_list(except_count, except_list, vt_oop) 1047 ) { 1048 if (java_thread == current) { 1049 self_tobj = Handle(current, vt_oop); 1050 continue; // self suspend after all other suspends 1051 } 1052 suspend_thread(vt_oop, java_thread, /* single_suspend */ false, nullptr); 1053 } 1054 } 1055 JvmtiVTSuspender::register_all_vthreads_suspend(); 1056 1057 // Restore resumed state for threads from except list that were not suspended before. 1058 for (int idx = 0; idx < elist->length(); idx++) { 1059 jthread thread = elist->at(idx); 1060 oop thread_oop = JNIHandles::resolve_external_guard(thread); 1061 if (JvmtiVTSuspender::is_vthread_suspended(thread_oop)) { 1062 JvmtiVTSuspender::register_vthread_resume(thread_oop); 1063 } 1064 } 1065 } 1066 // Self suspend after all other suspends if necessary. 1067 // Do not use JvmtiVTMSTransitionDisabler in context of self suspend to avoid deadlocks. 1068 if (self_tobj() != nullptr) { 1069 suspend_thread(self_tobj(), current, /* single_suspend */ false, nullptr); 1070 } 1071 return JVMTI_ERROR_NONE; 1072 } /* end SuspendAllVirtualThreads */ 1073 1074 1075 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 1076 jvmtiError 1077 JvmtiEnv::ResumeThread(jthread thread) { 1078 JvmtiVTMSTransitionDisabler disabler(true); 1079 JavaThread* current = JavaThread::current(); 1080 ThreadsListHandle tlh(current); 1081 1082 JavaThread* java_thread = nullptr; 1083 oop thread_oop = nullptr; 1084 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current, &java_thread, &thread_oop); 1085 if (err != JVMTI_ERROR_NONE) { 1086 return err; 1087 } 1088 err = resume_thread(thread_oop, java_thread, /* single_resume */ true); 1089 return err; 1090 } /* end ResumeThread */ 1091 1092 1093 // request_count - pre-checked to be greater than or equal to 0 1094 // request_list - pre-checked for null 1095 // results - pre-checked for null 1096 jvmtiError 1097 JvmtiEnv::ResumeThreadList(jint request_count, const jthread* request_list, jvmtiError* results) { 1098 oop thread_oop = nullptr; 1099 JavaThread* java_thread = nullptr; 1100 JvmtiVTMSTransitionDisabler disabler(true); 1101 ThreadsListHandle tlh; 1102 1103 for (int i = 0; i < request_count; i++) { 1104 jthread thread = request_list[i]; 1105 jvmtiError err = JvmtiExport::cv_external_thread_to_JavaThread(tlh.list(), thread, &java_thread, &thread_oop); 1106 1107 if (thread_oop != nullptr && 1108 java_lang_VirtualThread::is_instance(thread_oop) && 1109 !JvmtiEnvBase::is_vthread_alive(thread_oop)) { 1110 err = JVMTI_ERROR_THREAD_NOT_ALIVE; 1111 } 1112 if (err != JVMTI_ERROR_NONE) { 1113 if (thread_oop == nullptr || err != JVMTI_ERROR_INVALID_THREAD) { 1114 results[i] = err; 1115 continue; 1116 } 1117 } 1118 results[i] = resume_thread(thread_oop, java_thread, /* single_resume */ true); 1119 } 1120 // per-thread resume results returned via results parameter 1121 return JVMTI_ERROR_NONE; 1122 } /* end ResumeThreadList */ 1123 1124 1125 jvmtiError 1126 JvmtiEnv::ResumeAllVirtualThreads(jint except_count, const jthread* except_list) { 1127 if (get_capabilities()->can_support_virtual_threads == 0) { 1128 return JVMTI_ERROR_MUST_POSSESS_CAPABILITY; 1129 } 1130 jvmtiError err = JvmtiEnvBase::check_thread_list(except_count, except_list); 1131 if (err != JVMTI_ERROR_NONE) { 1132 return err; 1133 } 1134 ResourceMark rm; 1135 JvmtiVTMSTransitionDisabler disabler(true); 1136 GrowableArray<jthread>* elist = new GrowableArray<jthread>(except_count); 1137 1138 // Collect threads from except_list for which suspended status must be restored (only for VirtualThread case) 1139 for (int idx = 0; idx < except_count; idx++) { 1140 jthread thread = except_list[idx]; 1141 oop thread_oop = JNIHandles::resolve_external_guard(thread); 1142 if (java_lang_VirtualThread::is_instance(thread_oop) && JvmtiVTSuspender::is_vthread_suspended(thread_oop)) { 1143 // is suspended, so its suspended status must be restored 1144 elist->append(except_list[idx]); 1145 } 1146 } 1147 1148 for (JavaThreadIteratorWithHandle jtiwh; JavaThread *java_thread = jtiwh.next(); ) { 1149 oop vt_oop = java_thread->jvmti_vthread(); 1150 if (!java_thread->is_exiting() && 1151 !java_thread->is_jvmti_agent_thread() && 1152 !java_thread->is_hidden_from_external_view() && 1153 vt_oop != nullptr && 1154 ((java_lang_VirtualThread::is_instance(vt_oop) && 1155 JvmtiEnvBase::is_vthread_alive(vt_oop) && 1156 JvmtiVTSuspender::is_vthread_suspended(vt_oop)) || 1157 (vt_oop->is_a(vmClasses::BoundVirtualThread_klass()) && java_thread->is_suspended())) && 1158 !is_in_thread_list(except_count, except_list, vt_oop) 1159 ) { 1160 resume_thread(vt_oop, java_thread, /* single_resume */ false); 1161 } 1162 } 1163 JvmtiVTSuspender::register_all_vthreads_resume(); 1164 1165 // Restore suspended state for threads from except list that were suspended before. 1166 for (int idx = 0; idx < elist->length(); idx++) { 1167 jthread thread = elist->at(idx); 1168 oop thread_oop = JNIHandles::resolve_external_guard(thread); 1169 if (!JvmtiVTSuspender::is_vthread_suspended(thread_oop)) { 1170 JvmtiVTSuspender::register_vthread_suspend(thread_oop); 1171 } 1172 } 1173 return JVMTI_ERROR_NONE; 1174 } /* end ResumeAllVirtualThreads */ 1175 1176 1177 jvmtiError 1178 JvmtiEnv::StopThread(jthread thread, jobject exception) { 1179 JavaThread* current_thread = JavaThread::current(); 1180 1181 JvmtiVTMSTransitionDisabler disabler(thread); 1182 ThreadsListHandle tlh(current_thread); 1183 JavaThread* java_thread = nullptr; 1184 oop thread_oop = nullptr; 1185 1186 NULL_CHECK(thread, JVMTI_ERROR_INVALID_THREAD); 1187 1188 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current_thread, &java_thread, &thread_oop); 1189 1190 bool is_virtual = thread_oop != nullptr && thread_oop->is_a(vmClasses::BaseVirtualThread_klass()); 1191 1192 if (is_virtual && !is_JavaThread_current(java_thread, thread_oop)) { 1193 if (!is_vthread_suspended(thread_oop, java_thread)) { 1194 return JVMTI_ERROR_THREAD_NOT_SUSPENDED; 1195 } 1196 if (java_thread == nullptr) { // unmounted virtual thread 1197 return JVMTI_ERROR_OPAQUE_FRAME; 1198 } 1199 } 1200 if (err != JVMTI_ERROR_NONE) { 1201 return err; 1202 } 1203 oop e = JNIHandles::resolve_external_guard(exception); 1204 NULL_CHECK(e, JVMTI_ERROR_NULL_POINTER); 1205 1206 JavaThread::send_async_exception(java_thread, e); 1207 1208 return JVMTI_ERROR_NONE; 1209 1210 } /* end StopThread */ 1211 1212 1213 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 1214 jvmtiError 1215 JvmtiEnv::InterruptThread(jthread thread) { 1216 JavaThread* current_thread = JavaThread::current(); 1217 HandleMark hm(current_thread); 1218 1219 JvmtiVTMSTransitionDisabler disabler(thread); 1220 ThreadsListHandle tlh(current_thread); 1221 1222 JavaThread* java_thread = nullptr; 1223 oop thread_obj = nullptr; 1224 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current_thread, &java_thread, &thread_obj); 1225 if (err != JVMTI_ERROR_NONE) { 1226 return err; 1227 } 1228 1229 if (java_lang_VirtualThread::is_instance(thread_obj)) { 1230 // For virtual threads we have to call into Java to interrupt: 1231 Handle obj(current_thread, thread_obj); 1232 JavaValue result(T_VOID); 1233 JavaCalls::call_virtual(&result, 1234 obj, 1235 vmClasses::Thread_klass(), 1236 vmSymbols::interrupt_method_name(), 1237 vmSymbols::void_method_signature(), 1238 current_thread); 1239 1240 return JVMTI_ERROR_NONE; 1241 } 1242 1243 // Really this should be a Java call to Thread.interrupt to ensure the same 1244 // semantics, however historically this has not been done for some reason. 1245 // So we continue with that (which means we don't interact with any Java-level 1246 // Interruptible object) but we must set the Java-level interrupted state. 1247 java_lang_Thread::set_interrupted(thread_obj, true); 1248 java_thread->interrupt(); 1249 1250 return JVMTI_ERROR_NONE; 1251 } /* end InterruptThread */ 1252 1253 1254 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 1255 // info_ptr - pre-checked for null 1256 jvmtiError 1257 JvmtiEnv::GetThreadInfo(jthread thread, jvmtiThreadInfo* info_ptr) { 1258 JavaThread* current_thread = JavaThread::current(); 1259 ResourceMark rm(current_thread); 1260 HandleMark hm(current_thread); 1261 JavaThread* java_thread = nullptr; 1262 oop thread_oop = nullptr; 1263 1264 JvmtiVTMSTransitionDisabler disabler(thread); 1265 ThreadsListHandle tlh(current_thread); 1266 1267 // if thread is null the current thread is used 1268 if (thread == nullptr) { 1269 java_thread = JavaThread::current(); 1270 thread_oop = get_vthread_or_thread_oop(java_thread); 1271 if (thread_oop == nullptr || !thread_oop->is_a(vmClasses::Thread_klass())) { 1272 return JVMTI_ERROR_INVALID_THREAD; 1273 } 1274 } else { 1275 jvmtiError err = JvmtiExport::cv_external_thread_to_JavaThread(tlh.list(), thread, &java_thread, &thread_oop); 1276 if (err != JVMTI_ERROR_NONE) { 1277 // We got an error code so we don't have a JavaThread *, but 1278 // only return an error from here if we didn't get a valid 1279 // thread_oop. 1280 // In the virtual thread case the cv_external_thread_to_JavaThread is expected to correctly set 1281 // the thread_oop and return JVMTI_ERROR_INVALID_THREAD which we ignore here. 1282 if (thread_oop == nullptr) { 1283 return err; 1284 } 1285 } 1286 } 1287 // We have a valid thread_oop so we can return some thread info. 1288 1289 Handle thread_obj(current_thread, thread_oop); 1290 Handle name; 1291 ThreadPriority priority; 1292 Handle thread_group; 1293 Handle context_class_loader; 1294 bool is_daemon; 1295 1296 name = Handle(current_thread, java_lang_Thread::name(thread_obj())); 1297 1298 if (java_lang_VirtualThread::is_instance(thread_obj())) { 1299 priority = (ThreadPriority)JVMTI_THREAD_NORM_PRIORITY; 1300 is_daemon = true; 1301 if (java_lang_VirtualThread::state(thread_obj()) == java_lang_VirtualThread::TERMINATED) { 1302 thread_group = Handle(current_thread, nullptr); 1303 } else { 1304 thread_group = Handle(current_thread, java_lang_Thread_Constants::get_VTHREAD_GROUP()); 1305 } 1306 } else { 1307 priority = java_lang_Thread::priority(thread_obj()); 1308 is_daemon = java_lang_Thread::is_daemon(thread_obj()); 1309 if (java_lang_Thread::get_thread_status(thread_obj()) == JavaThreadStatus::TERMINATED) { 1310 thread_group = Handle(current_thread, nullptr); 1311 } else { 1312 thread_group = Handle(current_thread, java_lang_Thread::threadGroup(thread_obj())); 1313 } 1314 } 1315 1316 oop loader = java_lang_Thread::context_class_loader(thread_obj()); 1317 context_class_loader = Handle(current_thread, loader); 1318 1319 { const char *n; 1320 1321 if (name() != nullptr) { 1322 n = java_lang_String::as_utf8_string(name()); 1323 } else { 1324 int utf8_length = 0; 1325 n = UNICODE::as_utf8((jchar*) nullptr, utf8_length); 1326 } 1327 1328 info_ptr->name = (char *) jvmtiMalloc(strlen(n)+1); 1329 if (info_ptr->name == nullptr) 1330 return JVMTI_ERROR_OUT_OF_MEMORY; 1331 1332 strcpy(info_ptr->name, n); 1333 } 1334 info_ptr->is_daemon = is_daemon; 1335 info_ptr->priority = priority; 1336 1337 info_ptr->context_class_loader = (context_class_loader.is_null()) ? nullptr : 1338 jni_reference(context_class_loader); 1339 info_ptr->thread_group = jni_reference(thread_group); 1340 1341 return JVMTI_ERROR_NONE; 1342 } /* end GetThreadInfo */ 1343 1344 1345 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 1346 // owned_monitor_count_ptr - pre-checked for null 1347 // owned_monitors_ptr - pre-checked for null 1348 jvmtiError 1349 JvmtiEnv::GetOwnedMonitorInfo(jthread thread, jint* owned_monitor_count_ptr, jobject** owned_monitors_ptr) { 1350 JavaThread* calling_thread = JavaThread::current(); 1351 HandleMark hm(calling_thread); 1352 1353 // growable array of jvmti monitors info on the C-heap 1354 GrowableArray<jvmtiMonitorStackDepthInfo*> *owned_monitors_list = 1355 new (mtServiceability) GrowableArray<jvmtiMonitorStackDepthInfo*>(1, mtServiceability); 1356 1357 JvmtiVTMSTransitionDisabler disabler(thread); 1358 ThreadsListHandle tlh(calling_thread); 1359 1360 JavaThread* java_thread = nullptr; 1361 oop thread_oop = nullptr; 1362 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, calling_thread, &java_thread, &thread_oop); 1363 if (err != JVMTI_ERROR_NONE) { 1364 delete owned_monitors_list; 1365 return err; 1366 } 1367 1368 if (java_thread != nullptr) { 1369 Handle thread_handle(calling_thread, thread_oop); 1370 EscapeBarrier eb(true, calling_thread, java_thread); 1371 if (!eb.deoptimize_objects(MaxJavaStackTraceDepth)) { 1372 delete owned_monitors_list; 1373 return JVMTI_ERROR_OUT_OF_MEMORY; 1374 } 1375 // get owned monitors info with handshake 1376 GetOwnedMonitorInfoClosure op(this, calling_thread, owned_monitors_list); 1377 JvmtiHandshake::execute(&op, &tlh, java_thread, thread_handle); 1378 err = op.result(); 1379 } 1380 1381 jint owned_monitor_count = owned_monitors_list->length(); 1382 if (err == JVMTI_ERROR_NONE) { 1383 if ((err = allocate(owned_monitor_count * sizeof(jobject *), 1384 (unsigned char**)owned_monitors_ptr)) == JVMTI_ERROR_NONE) { 1385 // copy into the returned array 1386 for (int i = 0; i < owned_monitor_count; i++) { 1387 (*owned_monitors_ptr)[i] = 1388 ((jvmtiMonitorStackDepthInfo*)owned_monitors_list->at(i))->monitor; 1389 } 1390 *owned_monitor_count_ptr = owned_monitor_count; 1391 } 1392 } 1393 // clean up. 1394 for (int i = 0; i < owned_monitor_count; i++) { 1395 deallocate((unsigned char*)owned_monitors_list->at(i)); 1396 } 1397 delete owned_monitors_list; 1398 1399 return err; 1400 } /* end GetOwnedMonitorInfo */ 1401 1402 1403 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 1404 // monitor_info_count_ptr - pre-checked for null 1405 // monitor_info_ptr - pre-checked for null 1406 jvmtiError 1407 JvmtiEnv::GetOwnedMonitorStackDepthInfo(jthread thread, jint* monitor_info_count_ptr, jvmtiMonitorStackDepthInfo** monitor_info_ptr) { 1408 JavaThread* calling_thread = JavaThread::current(); 1409 HandleMark hm(calling_thread); 1410 1411 // growable array of jvmti monitors info on the C-heap 1412 GrowableArray<jvmtiMonitorStackDepthInfo*> *owned_monitors_list = 1413 new (mtServiceability) GrowableArray<jvmtiMonitorStackDepthInfo*>(1, mtServiceability); 1414 1415 JvmtiVTMSTransitionDisabler disabler(thread); 1416 ThreadsListHandle tlh(calling_thread); 1417 1418 JavaThread* java_thread = nullptr; 1419 oop thread_oop = nullptr; 1420 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, calling_thread, &java_thread, &thread_oop); 1421 if (err != JVMTI_ERROR_NONE) { 1422 delete owned_monitors_list; 1423 return err; 1424 } 1425 1426 if (java_thread != nullptr) { 1427 Handle thread_handle(calling_thread, thread_oop); 1428 EscapeBarrier eb(true, calling_thread, java_thread); 1429 if (!eb.deoptimize_objects(MaxJavaStackTraceDepth)) { 1430 delete owned_monitors_list; 1431 return JVMTI_ERROR_OUT_OF_MEMORY; 1432 } 1433 // get owned monitors info with handshake 1434 GetOwnedMonitorInfoClosure op(this, calling_thread, owned_monitors_list); 1435 JvmtiHandshake::execute(&op, &tlh, java_thread, thread_handle); 1436 err = op.result(); 1437 } 1438 1439 jint owned_monitor_count = owned_monitors_list->length(); 1440 if (err == JVMTI_ERROR_NONE) { 1441 if ((err = allocate(owned_monitor_count * sizeof(jvmtiMonitorStackDepthInfo), 1442 (unsigned char**)monitor_info_ptr)) == JVMTI_ERROR_NONE) { 1443 // copy to output array. 1444 for (int i = 0; i < owned_monitor_count; i++) { 1445 (*monitor_info_ptr)[i].monitor = 1446 ((jvmtiMonitorStackDepthInfo*)owned_monitors_list->at(i))->monitor; 1447 (*monitor_info_ptr)[i].stack_depth = 1448 ((jvmtiMonitorStackDepthInfo*)owned_monitors_list->at(i))->stack_depth; 1449 } 1450 } 1451 *monitor_info_count_ptr = owned_monitor_count; 1452 } 1453 1454 // clean up. 1455 for (int i = 0; i < owned_monitor_count; i++) { 1456 deallocate((unsigned char*)owned_monitors_list->at(i)); 1457 } 1458 delete owned_monitors_list; 1459 1460 return err; 1461 } /* end GetOwnedMonitorStackDepthInfo */ 1462 1463 1464 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 1465 // monitor_ptr - pre-checked for null 1466 jvmtiError 1467 JvmtiEnv::GetCurrentContendedMonitor(jthread thread, jobject* monitor_ptr) { 1468 JavaThread* current = JavaThread::current(); 1469 1470 *monitor_ptr = nullptr; 1471 1472 // get contended monitor information with handshake 1473 GetCurrentContendedMonitorClosure op(this, current, monitor_ptr); 1474 JvmtiHandshake::execute(&op, thread); 1475 return op.result(); 1476 } /* end GetCurrentContendedMonitor */ 1477 1478 1479 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 1480 // proc - pre-checked for null 1481 // arg - null is a valid value, must be checked 1482 jvmtiError 1483 JvmtiEnv::RunAgentThread(jthread thread, jvmtiStartFunction proc, const void* arg, jint priority) { 1484 JavaThread* current_thread = JavaThread::current(); 1485 1486 JavaThread* java_thread = nullptr; 1487 oop thread_oop = nullptr; 1488 ThreadsListHandle tlh(current_thread); 1489 jvmtiError err = JvmtiExport::cv_external_thread_to_JavaThread(tlh.list(), thread, &java_thread, &thread_oop); 1490 if (err != JVMTI_ERROR_NONE) { 1491 // We got an error code so we don't have a JavaThread *, but 1492 // only return an error from here if we didn't get a valid 1493 // thread_oop. 1494 if (thread_oop == nullptr) { 1495 return err; 1496 } 1497 // We have a valid thread_oop. 1498 } 1499 1500 if (thread_oop->is_a(vmClasses::BaseVirtualThread_klass())) { 1501 // No support for virtual threads. 1502 return JVMTI_ERROR_UNSUPPORTED_OPERATION; 1503 } 1504 if (java_thread != nullptr) { 1505 // 'thread' refers to an existing JavaThread. 1506 return JVMTI_ERROR_INVALID_THREAD; 1507 } 1508 1509 if (priority < JVMTI_THREAD_MIN_PRIORITY || priority > JVMTI_THREAD_MAX_PRIORITY) { 1510 return JVMTI_ERROR_INVALID_PRIORITY; 1511 } 1512 1513 Handle thread_hndl(current_thread, thread_oop); 1514 1515 JvmtiAgentThread* new_thread = new JvmtiAgentThread(this, proc, arg); 1516 1517 // At this point it may be possible that no osthread was created for the 1518 // JavaThread due to lack of resources. 1519 if (new_thread->osthread() == nullptr) { 1520 // The new thread is not known to Thread-SMR yet so we can just delete. 1521 delete new_thread; 1522 return JVMTI_ERROR_OUT_OF_MEMORY; 1523 } 1524 1525 JavaThread::start_internal_daemon(current_thread, new_thread, thread_hndl, 1526 (ThreadPriority)priority); 1527 1528 return JVMTI_ERROR_NONE; 1529 } /* end RunAgentThread */ 1530 1531 // 1532 // Thread Group functions 1533 // 1534 1535 // group_count_ptr - pre-checked for null 1536 // groups_ptr - pre-checked for null 1537 jvmtiError 1538 JvmtiEnv::GetTopThreadGroups(jint* group_count_ptr, jthreadGroup** groups_ptr) { 1539 JavaThread* current_thread = JavaThread::current(); 1540 1541 // Only one top level thread group now. 1542 *group_count_ptr = 1; 1543 1544 // Allocate memory to store global-refs to the thread groups. 1545 // Assume this area is freed by caller. 1546 *groups_ptr = (jthreadGroup *) jvmtiMalloc((sizeof(jthreadGroup)) * (*group_count_ptr)); 1547 1548 NULL_CHECK(*groups_ptr, JVMTI_ERROR_OUT_OF_MEMORY); 1549 1550 // Convert oop to Handle, then convert Handle to global-ref. 1551 { 1552 HandleMark hm(current_thread); 1553 Handle system_thread_group(current_thread, Universe::system_thread_group()); 1554 *groups_ptr[0] = jni_reference(system_thread_group); 1555 } 1556 1557 return JVMTI_ERROR_NONE; 1558 } /* end GetTopThreadGroups */ 1559 1560 1561 // info_ptr - pre-checked for null 1562 jvmtiError 1563 JvmtiEnv::GetThreadGroupInfo(jthreadGroup group, jvmtiThreadGroupInfo* info_ptr) { 1564 Thread* current_thread = Thread::current(); 1565 ResourceMark rm(current_thread); 1566 HandleMark hm(current_thread); 1567 1568 Handle group_obj (current_thread, JNIHandles::resolve_external_guard(group)); 1569 NULL_CHECK(group_obj(), JVMTI_ERROR_INVALID_THREAD_GROUP); 1570 1571 const char* name; 1572 Handle parent_group; 1573 bool is_daemon; 1574 ThreadPriority max_priority; 1575 1576 name = java_lang_ThreadGroup::name(group_obj()); 1577 parent_group = Handle(current_thread, java_lang_ThreadGroup::parent(group_obj())); 1578 is_daemon = java_lang_ThreadGroup::is_daemon(group_obj()); 1579 max_priority = java_lang_ThreadGroup::maxPriority(group_obj()); 1580 1581 info_ptr->is_daemon = is_daemon; 1582 info_ptr->max_priority = max_priority; 1583 info_ptr->parent = jni_reference(parent_group); 1584 1585 if (name != nullptr) { 1586 info_ptr->name = (char*)jvmtiMalloc(strlen(name)+1); 1587 NULL_CHECK(info_ptr->name, JVMTI_ERROR_OUT_OF_MEMORY); 1588 strcpy(info_ptr->name, name); 1589 } else { 1590 info_ptr->name = nullptr; 1591 } 1592 1593 return JVMTI_ERROR_NONE; 1594 } /* end GetThreadGroupInfo */ 1595 1596 // thread_count_ptr - pre-checked for null 1597 // threads_ptr - pre-checked for null 1598 // group_count_ptr - pre-checked for null 1599 // groups_ptr - pre-checked for null 1600 jvmtiError 1601 JvmtiEnv::GetThreadGroupChildren(jthreadGroup group, jint* thread_count_ptr, jthread** threads_ptr, jint* group_count_ptr, jthreadGroup** groups_ptr) { 1602 jvmtiError err; 1603 JavaThread* current_thread = JavaThread::current(); 1604 oop group_obj = JNIHandles::resolve_external_guard(group); 1605 NULL_CHECK(group_obj, JVMTI_ERROR_INVALID_THREAD_GROUP); 1606 1607 Handle *thread_objs = nullptr; 1608 objArrayHandle group_objs; 1609 jint nthreads = 0; 1610 jint ngroups = 0; 1611 int hidden_threads = 0; 1612 1613 ResourceMark rm(current_thread); 1614 HandleMark hm(current_thread); 1615 1616 Handle group_hdl(current_thread, group_obj); 1617 1618 err = get_live_threads(current_thread, group_hdl, &nthreads, &thread_objs); 1619 if (err != JVMTI_ERROR_NONE) { 1620 return err; 1621 } 1622 err = get_subgroups(current_thread, group_hdl, &ngroups, &group_objs); 1623 if (err != JVMTI_ERROR_NONE) { 1624 return err; 1625 } 1626 1627 *group_count_ptr = ngroups; 1628 *thread_count_ptr = nthreads; 1629 *threads_ptr = new_jthreadArray(nthreads, thread_objs); 1630 *groups_ptr = new_jthreadGroupArray(ngroups, group_objs); 1631 if (nthreads > 0 && *threads_ptr == nullptr) { 1632 return JVMTI_ERROR_OUT_OF_MEMORY; 1633 } 1634 if (ngroups > 0 && *groups_ptr == nullptr) { 1635 return JVMTI_ERROR_OUT_OF_MEMORY; 1636 } 1637 1638 return JVMTI_ERROR_NONE; 1639 } /* end GetThreadGroupChildren */ 1640 1641 1642 // 1643 // Stack Frame functions 1644 // 1645 1646 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 1647 // max_frame_count - pre-checked to be greater than or equal to 0 1648 // frame_buffer - pre-checked for null 1649 // count_ptr - pre-checked for null 1650 jvmtiError 1651 JvmtiEnv::GetStackTrace(jthread thread, jint start_depth, jint max_frame_count, jvmtiFrameInfo* frame_buffer, jint* count_ptr) { 1652 GetStackTraceClosure op(this, start_depth, max_frame_count, frame_buffer, count_ptr); 1653 JvmtiHandshake::execute(&op, thread); 1654 return op.result(); 1655 } /* end GetStackTrace */ 1656 1657 1658 // max_frame_count - pre-checked to be greater than or equal to 0 1659 // stack_info_ptr - pre-checked for null 1660 // thread_count_ptr - pre-checked for null 1661 jvmtiError 1662 JvmtiEnv::GetAllStackTraces(jint max_frame_count, jvmtiStackInfo** stack_info_ptr, jint* thread_count_ptr) { 1663 jvmtiError err = JVMTI_ERROR_NONE; 1664 JavaThread* calling_thread = JavaThread::current(); 1665 1666 // JVMTI get stack traces at safepoint. 1667 VM_GetAllStackTraces op(this, calling_thread, max_frame_count); 1668 VMThread::execute(&op); 1669 *thread_count_ptr = op.final_thread_count(); 1670 *stack_info_ptr = op.stack_info(); 1671 err = op.result(); 1672 return err; 1673 } /* end GetAllStackTraces */ 1674 1675 1676 // thread_count - pre-checked to be greater than or equal to 0 1677 // thread_list - pre-checked for null 1678 // max_frame_count - pre-checked to be greater than or equal to 0 1679 // stack_info_ptr - pre-checked for null 1680 jvmtiError 1681 JvmtiEnv::GetThreadListStackTraces(jint thread_count, const jthread* thread_list, jint max_frame_count, jvmtiStackInfo** stack_info_ptr) { 1682 jvmtiError err = JVMTI_ERROR_NONE; 1683 1684 if (thread_count == 1) { 1685 // Use direct handshake if we need to get only one stack trace. 1686 JavaThread *current_thread = JavaThread::current(); 1687 1688 jthread thread = thread_list[0]; 1689 1690 GetSingleStackTraceClosure op(this, current_thread, thread, max_frame_count); 1691 JvmtiHandshake::execute(&op, thread); 1692 err = op.result(); 1693 if (err == JVMTI_ERROR_NONE) { 1694 *stack_info_ptr = op.stack_info(); 1695 } 1696 } else { 1697 JvmtiVTMSTransitionDisabler disabler; 1698 1699 // JVMTI get stack traces at safepoint. 1700 VM_GetThreadListStackTraces op(this, thread_count, thread_list, max_frame_count); 1701 VMThread::execute(&op); 1702 err = op.result(); 1703 if (err == JVMTI_ERROR_NONE) { 1704 *stack_info_ptr = op.stack_info(); 1705 } 1706 } 1707 return err; 1708 } /* end GetThreadListStackTraces */ 1709 1710 1711 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 1712 // count_ptr - pre-checked for null 1713 jvmtiError 1714 JvmtiEnv::GetFrameCount(jthread thread, jint* count_ptr) { 1715 GetFrameCountClosure op(this, count_ptr); 1716 JvmtiHandshake::execute(&op, thread); 1717 return op.result(); 1718 } /* end GetFrameCount */ 1719 1720 1721 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 1722 jvmtiError 1723 JvmtiEnv::PopFrame(jthread thread) { 1724 JavaThread* current_thread = JavaThread::current(); 1725 HandleMark hm(current_thread); 1726 1727 if (thread == nullptr) { 1728 return JVMTI_ERROR_INVALID_THREAD; 1729 } 1730 JvmtiVTMSTransitionDisabler disabler(thread); 1731 ThreadsListHandle tlh(current_thread); 1732 1733 JavaThread* java_thread = nullptr; 1734 oop thread_obj = nullptr; 1735 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current_thread, &java_thread, &thread_obj); 1736 Handle thread_handle(current_thread, thread_obj); 1737 1738 if (err != JVMTI_ERROR_NONE) { 1739 return err; 1740 } 1741 bool self = java_thread == current_thread; 1742 1743 err = check_non_suspended_or_opaque_frame(java_thread, thread_obj, self); 1744 if (err != JVMTI_ERROR_NONE) { 1745 return err; 1746 } 1747 1748 // retrieve or create the state 1749 JvmtiThreadState* state = JvmtiThreadState::state_for(java_thread); 1750 if (state == nullptr) { 1751 return JVMTI_ERROR_THREAD_NOT_ALIVE; 1752 } 1753 1754 // Eagerly reallocate scalar replaced objects. 1755 EscapeBarrier eb(true, current_thread, java_thread); 1756 if (!eb.deoptimize_objects(1)) { 1757 // Reallocation of scalar replaced objects failed -> return with error 1758 return JVMTI_ERROR_OUT_OF_MEMORY; 1759 } 1760 1761 MutexLocker mu(JvmtiThreadState_lock); 1762 UpdateForPopTopFrameClosure op(state); 1763 JvmtiHandshake::execute(&op, &tlh, java_thread, thread_handle); 1764 return op.result(); 1765 } /* end PopFrame */ 1766 1767 1768 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 1769 // depth - pre-checked as non-negative 1770 // method_ptr - pre-checked for null 1771 // location_ptr - pre-checked for null 1772 jvmtiError 1773 JvmtiEnv::GetFrameLocation(jthread thread, jint depth, jmethodID* method_ptr, jlocation* location_ptr) { 1774 GetFrameLocationClosure op(this, depth, method_ptr, location_ptr); 1775 JvmtiHandshake::execute(&op, thread); 1776 return op.result(); 1777 } /* end GetFrameLocation */ 1778 1779 1780 // Threads_lock NOT held, java_thread not protected by lock 1781 // depth - pre-checked as non-negative 1782 jvmtiError 1783 JvmtiEnv::NotifyFramePop(jthread thread, jint depth) { 1784 ResourceMark rm; 1785 JvmtiVTMSTransitionDisabler disabler(thread); 1786 JavaThread* current = JavaThread::current(); 1787 ThreadsListHandle tlh(current); 1788 1789 JavaThread* java_thread = nullptr; 1790 oop thread_obj = nullptr; 1791 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current, &java_thread, &thread_obj); 1792 if (err != JVMTI_ERROR_NONE) { 1793 return err; 1794 } 1795 1796 HandleMark hm(current); 1797 Handle thread_handle(current, thread_obj); 1798 JvmtiThreadState *state = JvmtiThreadState::state_for(java_thread, thread_handle); 1799 if (state == nullptr) { 1800 return JVMTI_ERROR_THREAD_NOT_ALIVE; 1801 } 1802 1803 SetFramePopClosure op(this, state, depth); 1804 MutexLocker mu(current, JvmtiThreadState_lock); 1805 JvmtiHandshake::execute(&op, &tlh, java_thread, thread_handle); 1806 return op.result(); 1807 } /* end NotifyFramePop */ 1808 1809 1810 // 1811 // Force Early Return functions 1812 // 1813 1814 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 1815 jvmtiError 1816 JvmtiEnv::ForceEarlyReturnObject(jthread thread, jobject value) { 1817 jvalue val; 1818 val.l = value; 1819 return force_early_return(thread, val, atos); 1820 } /* end ForceEarlyReturnObject */ 1821 1822 1823 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 1824 jvmtiError 1825 JvmtiEnv::ForceEarlyReturnInt(jthread thread, jint value) { 1826 jvalue val; 1827 val.i = value; 1828 return force_early_return(thread, val, itos); 1829 } /* end ForceEarlyReturnInt */ 1830 1831 1832 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 1833 jvmtiError 1834 JvmtiEnv::ForceEarlyReturnLong(jthread thread, jlong value) { 1835 jvalue val; 1836 val.j = value; 1837 return force_early_return(thread, val, ltos); 1838 } /* end ForceEarlyReturnLong */ 1839 1840 1841 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 1842 jvmtiError 1843 JvmtiEnv::ForceEarlyReturnFloat(jthread thread, jfloat value) { 1844 jvalue val; 1845 val.f = value; 1846 return force_early_return(thread, val, ftos); 1847 } /* end ForceEarlyReturnFloat */ 1848 1849 1850 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 1851 jvmtiError 1852 JvmtiEnv::ForceEarlyReturnDouble(jthread thread, jdouble value) { 1853 jvalue val; 1854 val.d = value; 1855 return force_early_return(thread, val, dtos); 1856 } /* end ForceEarlyReturnDouble */ 1857 1858 1859 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 1860 jvmtiError 1861 JvmtiEnv::ForceEarlyReturnVoid(jthread thread) { 1862 jvalue val; 1863 val.j = 0L; 1864 return force_early_return(thread, val, vtos); 1865 } /* end ForceEarlyReturnVoid */ 1866 1867 1868 // 1869 // Heap functions 1870 // 1871 1872 // klass - null is a valid value, must be checked 1873 // initial_object - null is a valid value, must be checked 1874 // callbacks - pre-checked for null 1875 // user_data - null is a valid value, must be checked 1876 jvmtiError 1877 JvmtiEnv::FollowReferences(jint heap_filter, jclass klass, jobject initial_object, const jvmtiHeapCallbacks* callbacks, const void* user_data) { 1878 // check klass if provided 1879 Klass* k = nullptr; 1880 if (klass != nullptr) { 1881 oop k_mirror = JNIHandles::resolve_external_guard(klass); 1882 if (k_mirror == nullptr) { 1883 return JVMTI_ERROR_INVALID_CLASS; 1884 } 1885 if (java_lang_Class::is_primitive(k_mirror)) { 1886 return JVMTI_ERROR_NONE; 1887 } 1888 k = java_lang_Class::as_Klass(k_mirror); 1889 if (klass == nullptr) { 1890 return JVMTI_ERROR_INVALID_CLASS; 1891 } 1892 } 1893 1894 if (initial_object != nullptr) { 1895 oop init_obj = JNIHandles::resolve_external_guard(initial_object); 1896 if (init_obj == nullptr) { 1897 return JVMTI_ERROR_INVALID_OBJECT; 1898 } 1899 } 1900 1901 Thread *thread = Thread::current(); 1902 HandleMark hm(thread); 1903 1904 TraceTime t("FollowReferences", TRACETIME_LOG(Debug, jvmti, objecttagging)); 1905 JvmtiTagMap::tag_map_for(this)->follow_references(heap_filter, k, initial_object, callbacks, user_data); 1906 return JVMTI_ERROR_NONE; 1907 } /* end FollowReferences */ 1908 1909 1910 // klass - null is a valid value, must be checked 1911 // callbacks - pre-checked for null 1912 // user_data - null is a valid value, must be checked 1913 jvmtiError 1914 JvmtiEnv::IterateThroughHeap(jint heap_filter, jclass klass, const jvmtiHeapCallbacks* callbacks, const void* user_data) { 1915 // check klass if provided 1916 Klass* k = nullptr; 1917 if (klass != nullptr) { 1918 oop k_mirror = JNIHandles::resolve_external_guard(klass); 1919 if (k_mirror == nullptr) { 1920 return JVMTI_ERROR_INVALID_CLASS; 1921 } 1922 if (java_lang_Class::is_primitive(k_mirror)) { 1923 return JVMTI_ERROR_NONE; 1924 } 1925 k = java_lang_Class::as_Klass(k_mirror); 1926 if (k == nullptr) { 1927 return JVMTI_ERROR_INVALID_CLASS; 1928 } 1929 } 1930 1931 TraceTime t("IterateThroughHeap", TRACETIME_LOG(Debug, jvmti, objecttagging)); 1932 JvmtiTagMap::tag_map_for(this)->iterate_through_heap(heap_filter, k, callbacks, user_data); 1933 return JVMTI_ERROR_NONE; 1934 } /* end IterateThroughHeap */ 1935 1936 1937 // tag_ptr - pre-checked for null 1938 jvmtiError 1939 JvmtiEnv::GetTag(jobject object, jlong* tag_ptr) { 1940 oop o = JNIHandles::resolve_external_guard(object); 1941 NULL_CHECK(o, JVMTI_ERROR_INVALID_OBJECT); 1942 *tag_ptr = JvmtiTagMap::tag_map_for(this)->get_tag(object); 1943 return JVMTI_ERROR_NONE; 1944 } /* end GetTag */ 1945 1946 1947 jvmtiError 1948 JvmtiEnv::SetTag(jobject object, jlong tag) { 1949 oop o = JNIHandles::resolve_external_guard(object); 1950 NULL_CHECK(o, JVMTI_ERROR_INVALID_OBJECT); 1951 JvmtiTagMap::tag_map_for(this)->set_tag(object, tag); 1952 return JVMTI_ERROR_NONE; 1953 } /* end SetTag */ 1954 1955 1956 // tag_count - pre-checked to be greater than or equal to 0 1957 // tags - pre-checked for null 1958 // count_ptr - pre-checked for null 1959 // object_result_ptr - null is a valid value, must be checked 1960 // tag_result_ptr - null is a valid value, must be checked 1961 jvmtiError 1962 JvmtiEnv::GetObjectsWithTags(jint tag_count, const jlong* tags, jint* count_ptr, jobject** object_result_ptr, jlong** tag_result_ptr) { 1963 TraceTime t("GetObjectsWithTags", TRACETIME_LOG(Debug, jvmti, objecttagging)); 1964 return JvmtiTagMap::tag_map_for(this)->get_objects_with_tags((jlong*)tags, tag_count, count_ptr, object_result_ptr, tag_result_ptr); 1965 } /* end GetObjectsWithTags */ 1966 1967 1968 jvmtiError 1969 JvmtiEnv::ForceGarbageCollection() { 1970 Universe::heap()->collect(GCCause::_jvmti_force_gc); 1971 return JVMTI_ERROR_NONE; 1972 } /* end ForceGarbageCollection */ 1973 1974 1975 // 1976 // Heap (1.0) functions 1977 // 1978 1979 // object_reference_callback - pre-checked for null 1980 // user_data - null is a valid value, must be checked 1981 jvmtiError 1982 JvmtiEnv::IterateOverObjectsReachableFromObject(jobject object, jvmtiObjectReferenceCallback object_reference_callback, const void* user_data) { 1983 oop o = JNIHandles::resolve_external_guard(object); 1984 NULL_CHECK(o, JVMTI_ERROR_INVALID_OBJECT); 1985 JvmtiTagMap::tag_map_for(this)->iterate_over_objects_reachable_from_object(object, object_reference_callback, user_data); 1986 return JVMTI_ERROR_NONE; 1987 } /* end IterateOverObjectsReachableFromObject */ 1988 1989 1990 // heap_root_callback - null is a valid value, must be checked 1991 // stack_ref_callback - null is a valid value, must be checked 1992 // object_ref_callback - null is a valid value, must be checked 1993 // user_data - null is a valid value, must be checked 1994 jvmtiError 1995 JvmtiEnv::IterateOverReachableObjects(jvmtiHeapRootCallback heap_root_callback, jvmtiStackReferenceCallback stack_ref_callback, jvmtiObjectReferenceCallback object_ref_callback, const void* user_data) { 1996 TraceTime t("IterateOverReachableObjects", TRACETIME_LOG(Debug, jvmti, objecttagging)); 1997 JvmtiTagMap::tag_map_for(this)->iterate_over_reachable_objects(heap_root_callback, stack_ref_callback, object_ref_callback, user_data); 1998 return JVMTI_ERROR_NONE; 1999 } /* end IterateOverReachableObjects */ 2000 2001 2002 // heap_object_callback - pre-checked for null 2003 // user_data - null is a valid value, must be checked 2004 jvmtiError 2005 JvmtiEnv::IterateOverHeap(jvmtiHeapObjectFilter object_filter, jvmtiHeapObjectCallback heap_object_callback, const void* user_data) { 2006 TraceTime t("IterateOverHeap", TRACETIME_LOG(Debug, jvmti, objecttagging)); 2007 Thread *thread = Thread::current(); 2008 HandleMark hm(thread); 2009 JvmtiTagMap::tag_map_for(this)->iterate_over_heap(object_filter, nullptr, heap_object_callback, user_data); 2010 return JVMTI_ERROR_NONE; 2011 } /* end IterateOverHeap */ 2012 2013 2014 // k_mirror - may be primitive, this must be checked 2015 // heap_object_callback - pre-checked for null 2016 // user_data - null is a valid value, must be checked 2017 jvmtiError 2018 JvmtiEnv::IterateOverInstancesOfClass(oop k_mirror, jvmtiHeapObjectFilter object_filter, jvmtiHeapObjectCallback heap_object_callback, const void* user_data) { 2019 if (java_lang_Class::is_primitive(k_mirror)) { 2020 // DO PRIMITIVE CLASS PROCESSING 2021 return JVMTI_ERROR_NONE; 2022 } 2023 Klass* klass = java_lang_Class::as_Klass(k_mirror); 2024 if (klass == nullptr) { 2025 return JVMTI_ERROR_INVALID_CLASS; 2026 } 2027 TraceTime t("IterateOverInstancesOfClass", TRACETIME_LOG(Debug, jvmti, objecttagging)); 2028 JvmtiTagMap::tag_map_for(this)->iterate_over_heap(object_filter, klass, heap_object_callback, user_data); 2029 return JVMTI_ERROR_NONE; 2030 } /* end IterateOverInstancesOfClass */ 2031 2032 2033 // 2034 // Local Variable functions 2035 // 2036 2037 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 2038 // depth - pre-checked as non-negative 2039 // value_ptr - pre-checked for null 2040 jvmtiError 2041 JvmtiEnv::GetLocalObject(jthread thread, jint depth, jint slot, jobject* value_ptr) { 2042 JavaThread* current_thread = JavaThread::current(); 2043 // rm object is created to clean up the javaVFrame created in 2044 // doit_prologue(), but after doit() is finished with it. 2045 ResourceMark rm(current_thread); 2046 HandleMark hm(current_thread); 2047 JvmtiVTMSTransitionDisabler disabler(thread); 2048 ThreadsListHandle tlh(current_thread); 2049 2050 JavaThread* java_thread = nullptr; 2051 oop thread_obj = nullptr; 2052 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current_thread, &java_thread, &thread_obj); 2053 if (err != JVMTI_ERROR_NONE) { 2054 return err; 2055 } 2056 bool self = is_JavaThread_current(java_thread, thread_obj); 2057 2058 if (java_lang_VirtualThread::is_instance(thread_obj)) { 2059 VM_VirtualThreadGetOrSetLocal op(this, Handle(current_thread, thread_obj), 2060 current_thread, depth, slot, self); 2061 VMThread::execute(&op); 2062 err = op.result(); 2063 if (err == JVMTI_ERROR_NONE) { 2064 *value_ptr = op.value().l; 2065 } 2066 } else { 2067 // Support for ordinary threads 2068 VM_GetOrSetLocal op(java_thread, current_thread, depth, slot, self); 2069 VMThread::execute(&op); 2070 err = op.result(); 2071 if (err == JVMTI_ERROR_NONE) { 2072 *value_ptr = op.value().l; 2073 } 2074 } 2075 return err; 2076 } /* end GetLocalObject */ 2077 2078 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 2079 // depth - pre-checked as non-negative 2080 // value - pre-checked for null 2081 jvmtiError 2082 JvmtiEnv::GetLocalInstance(jthread thread, jint depth, jobject* value_ptr){ 2083 JavaThread* current_thread = JavaThread::current(); 2084 // rm object is created to clean up the javaVFrame created in 2085 // doit_prologue(), but after doit() is finished with it. 2086 ResourceMark rm(current_thread); 2087 HandleMark hm(current_thread); 2088 JvmtiVTMSTransitionDisabler disabler(thread); 2089 ThreadsListHandle tlh(current_thread); 2090 2091 JavaThread* java_thread = nullptr; 2092 oop thread_obj = nullptr; 2093 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current_thread, &java_thread, &thread_obj); 2094 if (err != JVMTI_ERROR_NONE) { 2095 return err; 2096 } 2097 bool self = is_JavaThread_current(java_thread, thread_obj); 2098 2099 if (java_lang_VirtualThread::is_instance(thread_obj)) { 2100 VM_VirtualThreadGetReceiver op(this, Handle(current_thread, thread_obj), 2101 current_thread, depth, self); 2102 VMThread::execute(&op); 2103 err = op.result(); 2104 if (err == JVMTI_ERROR_NONE) { 2105 *value_ptr = op.value().l; 2106 } 2107 } else { 2108 // Support for ordinary threads 2109 VM_GetReceiver op(java_thread, current_thread, depth, self); 2110 VMThread::execute(&op); 2111 err = op.result(); 2112 if (err == JVMTI_ERROR_NONE) { 2113 *value_ptr = op.value().l; 2114 } 2115 } 2116 return err; 2117 } /* end GetLocalInstance */ 2118 2119 2120 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 2121 // depth - pre-checked as non-negative 2122 // value_ptr - pre-checked for null 2123 jvmtiError 2124 JvmtiEnv::GetLocalInt(jthread thread, jint depth, jint slot, jint* value_ptr) { 2125 JavaThread* current_thread = JavaThread::current(); 2126 // rm object is created to clean up the javaVFrame created in 2127 // doit_prologue(), but after doit() is finished with it. 2128 ResourceMark rm(current_thread); 2129 HandleMark hm(current_thread); 2130 JvmtiVTMSTransitionDisabler disabler(thread); 2131 ThreadsListHandle tlh(current_thread); 2132 2133 JavaThread* java_thread = nullptr; 2134 oop thread_obj = nullptr; 2135 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current_thread, &java_thread, &thread_obj); 2136 if (err != JVMTI_ERROR_NONE) { 2137 return err; 2138 } 2139 bool self = is_JavaThread_current(java_thread, thread_obj); 2140 2141 if (java_lang_VirtualThread::is_instance(thread_obj)) { 2142 VM_VirtualThreadGetOrSetLocal op(this, Handle(current_thread, thread_obj), 2143 depth, slot, T_INT, self); 2144 VMThread::execute(&op); 2145 err = op.result(); 2146 if (err == JVMTI_ERROR_NONE) { 2147 *value_ptr = op.value().i; 2148 } 2149 } else { 2150 // Support for ordinary threads 2151 VM_GetOrSetLocal op(java_thread, depth, slot, T_INT, self); 2152 VMThread::execute(&op); 2153 err = op.result(); 2154 if (err == JVMTI_ERROR_NONE) { 2155 *value_ptr = op.value().i; 2156 } 2157 } 2158 return err; 2159 } /* end GetLocalInt */ 2160 2161 2162 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 2163 // depth - pre-checked as non-negative 2164 // value_ptr - pre-checked for null 2165 jvmtiError 2166 JvmtiEnv::GetLocalLong(jthread thread, jint depth, jint slot, jlong* value_ptr) { 2167 JavaThread* current_thread = JavaThread::current(); 2168 // rm object is created to clean up the javaVFrame created in 2169 // doit_prologue(), but after doit() is finished with it. 2170 ResourceMark rm(current_thread); 2171 HandleMark hm(current_thread); 2172 JvmtiVTMSTransitionDisabler disabler(thread); 2173 ThreadsListHandle tlh(current_thread); 2174 2175 JavaThread* java_thread = nullptr; 2176 oop thread_obj = nullptr; 2177 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current_thread, &java_thread, &thread_obj); 2178 if (err != JVMTI_ERROR_NONE) { 2179 return err; 2180 } 2181 bool self = is_JavaThread_current(java_thread, thread_obj); 2182 2183 if (java_lang_VirtualThread::is_instance(thread_obj)) { 2184 VM_VirtualThreadGetOrSetLocal op(this, Handle(current_thread, thread_obj), 2185 depth, slot, T_LONG, self); 2186 VMThread::execute(&op); 2187 err = op.result(); 2188 if (err == JVMTI_ERROR_NONE) { 2189 *value_ptr = op.value().j; 2190 } 2191 } else { 2192 // Support for ordinary threads 2193 VM_GetOrSetLocal op(java_thread, depth, slot, T_LONG, self); 2194 VMThread::execute(&op); 2195 err = op.result(); 2196 if (err == JVMTI_ERROR_NONE) { 2197 *value_ptr = op.value().j; 2198 } 2199 } 2200 return err; 2201 } /* end GetLocalLong */ 2202 2203 2204 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 2205 // depth - pre-checked as non-negative 2206 // value_ptr - pre-checked for null 2207 jvmtiError 2208 JvmtiEnv::GetLocalFloat(jthread thread, jint depth, jint slot, jfloat* value_ptr) { 2209 JavaThread* current_thread = JavaThread::current(); 2210 // rm object is created to clean up the javaVFrame created in 2211 // doit_prologue(), but after doit() is finished with it. 2212 ResourceMark rm(current_thread); 2213 HandleMark hm(current_thread); 2214 JvmtiVTMSTransitionDisabler disabler(thread); 2215 ThreadsListHandle tlh(current_thread); 2216 2217 JavaThread* java_thread = nullptr; 2218 oop thread_obj = nullptr; 2219 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current_thread, &java_thread, &thread_obj); 2220 if (err != JVMTI_ERROR_NONE) { 2221 return err; 2222 } 2223 bool self = is_JavaThread_current(java_thread, thread_obj); 2224 2225 if (java_lang_VirtualThread::is_instance(thread_obj)) { 2226 VM_VirtualThreadGetOrSetLocal op(this, Handle(current_thread, thread_obj), 2227 depth, slot, T_FLOAT, self); 2228 VMThread::execute(&op); 2229 err = op.result(); 2230 if (err == JVMTI_ERROR_NONE) { 2231 *value_ptr = op.value().f; 2232 } 2233 } else { 2234 // Support for ordinary threads 2235 VM_GetOrSetLocal op(java_thread, depth, slot, T_FLOAT, self); 2236 VMThread::execute(&op); 2237 err = op.result(); 2238 if (err == JVMTI_ERROR_NONE) { 2239 *value_ptr = op.value().f; 2240 } 2241 } 2242 return err; 2243 } /* end GetLocalFloat */ 2244 2245 2246 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 2247 // depth - pre-checked as non-negative 2248 // value_ptr - pre-checked for null 2249 jvmtiError 2250 JvmtiEnv::GetLocalDouble(jthread thread, jint depth, jint slot, jdouble* value_ptr) { 2251 JavaThread* current_thread = JavaThread::current(); 2252 // rm object is created to clean up the javaVFrame created in 2253 // doit_prologue(), but after doit() is finished with it. 2254 ResourceMark rm(current_thread); 2255 HandleMark hm(current_thread); 2256 JvmtiVTMSTransitionDisabler disabler(thread); 2257 ThreadsListHandle tlh(current_thread); 2258 2259 JavaThread* java_thread = nullptr; 2260 oop thread_obj = nullptr; 2261 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current_thread, &java_thread, &thread_obj); 2262 if (err != JVMTI_ERROR_NONE) { 2263 return err; 2264 } 2265 bool self = is_JavaThread_current(java_thread, thread_obj); 2266 2267 if (java_lang_VirtualThread::is_instance(thread_obj)) { 2268 VM_VirtualThreadGetOrSetLocal op(this, Handle(current_thread, thread_obj), 2269 depth, slot, T_DOUBLE, self); 2270 VMThread::execute(&op); 2271 err = op.result(); 2272 if (err == JVMTI_ERROR_NONE) { 2273 *value_ptr = op.value().d; 2274 } 2275 } else { 2276 // Support for ordinary threads 2277 VM_GetOrSetLocal op(java_thread, depth, slot, T_DOUBLE, self); 2278 VMThread::execute(&op); 2279 err = op.result(); 2280 if (err == JVMTI_ERROR_NONE) { 2281 *value_ptr = op.value().d; 2282 } 2283 } 2284 return err; 2285 } /* end GetLocalDouble */ 2286 2287 2288 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 2289 // depth - pre-checked as non-negative 2290 jvmtiError 2291 JvmtiEnv::SetLocalObject(jthread thread, jint depth, jint slot, jobject value) { 2292 JavaThread* current_thread = JavaThread::current(); 2293 // rm object is created to clean up the javaVFrame created in 2294 // doit_prologue(), but after doit() is finished with it. 2295 ResourceMark rm(current_thread); 2296 HandleMark hm(current_thread); 2297 JvmtiVTMSTransitionDisabler disabler(thread); 2298 ThreadsListHandle tlh(current_thread); 2299 2300 JavaThread* java_thread = nullptr; 2301 oop thread_obj = nullptr; 2302 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current_thread, &java_thread, &thread_obj); 2303 if (err != JVMTI_ERROR_NONE) { 2304 return err; 2305 } 2306 bool self = is_JavaThread_current(java_thread, thread_obj); 2307 jvalue val; 2308 val.l = value; 2309 2310 if (java_lang_VirtualThread::is_instance(thread_obj)) { 2311 VM_VirtualThreadGetOrSetLocal op(this, Handle(current_thread, thread_obj), 2312 depth, slot, T_OBJECT, val, self); 2313 VMThread::execute(&op); 2314 err = op.result(); 2315 } else { 2316 // Support for ordinary threads 2317 VM_GetOrSetLocal op(java_thread, depth, slot, T_OBJECT, val, self); 2318 VMThread::execute(&op); 2319 err = op.result(); 2320 } 2321 return err; 2322 } /* end SetLocalObject */ 2323 2324 2325 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 2326 // depth - pre-checked as non-negative 2327 jvmtiError 2328 JvmtiEnv::SetLocalInt(jthread thread, jint depth, jint slot, jint value) { 2329 JavaThread* current_thread = JavaThread::current(); 2330 // rm object is created to clean up the javaVFrame created in 2331 // doit_prologue(), but after doit() is finished with it. 2332 ResourceMark rm(current_thread); 2333 HandleMark hm(current_thread); 2334 JvmtiVTMSTransitionDisabler disabler(thread); 2335 ThreadsListHandle tlh(current_thread); 2336 2337 JavaThread* java_thread = nullptr; 2338 oop thread_obj = nullptr; 2339 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current_thread, &java_thread, &thread_obj); 2340 if (err != JVMTI_ERROR_NONE) { 2341 return err; 2342 } 2343 bool self = is_JavaThread_current(java_thread, thread_obj); 2344 jvalue val; 2345 val.i = value; 2346 2347 if (java_lang_VirtualThread::is_instance(thread_obj)) { 2348 VM_VirtualThreadGetOrSetLocal op(this, Handle(current_thread, thread_obj), 2349 depth, slot, T_INT, val, self); 2350 VMThread::execute(&op); 2351 err = op.result(); 2352 } else { 2353 // Support for ordinary threads 2354 VM_GetOrSetLocal op(java_thread, depth, slot, T_INT, val, self); 2355 VMThread::execute(&op); 2356 err = op.result(); 2357 } 2358 return err; 2359 } /* end SetLocalInt */ 2360 2361 2362 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 2363 // depth - pre-checked as non-negative 2364 jvmtiError 2365 JvmtiEnv::SetLocalLong(jthread thread, jint depth, jint slot, jlong value) { 2366 JavaThread* current_thread = JavaThread::current(); 2367 // rm object is created to clean up the javaVFrame created in 2368 // doit_prologue(), but after doit() is finished with it. 2369 ResourceMark rm(current_thread); 2370 HandleMark hm(current_thread); 2371 JvmtiVTMSTransitionDisabler disabler(thread); 2372 ThreadsListHandle tlh(current_thread); 2373 2374 JavaThread* java_thread = nullptr; 2375 oop thread_obj = nullptr; 2376 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current_thread, &java_thread, &thread_obj); 2377 if (err != JVMTI_ERROR_NONE) { 2378 return err; 2379 } 2380 bool self = is_JavaThread_current(java_thread, thread_obj); 2381 jvalue val; 2382 val.j = value; 2383 2384 if (java_lang_VirtualThread::is_instance(thread_obj)) { 2385 VM_VirtualThreadGetOrSetLocal op(this, Handle(current_thread, thread_obj), 2386 depth, slot, T_LONG, val, self); 2387 VMThread::execute(&op); 2388 err = op.result(); 2389 } else { 2390 // Support for ordinary threads 2391 VM_GetOrSetLocal op(java_thread, depth, slot, T_LONG, val, self); 2392 VMThread::execute(&op); 2393 err = op.result(); 2394 } 2395 return err; 2396 } /* end SetLocalLong */ 2397 2398 2399 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 2400 // depth - pre-checked as non-negative 2401 jvmtiError 2402 JvmtiEnv::SetLocalFloat(jthread thread, jint depth, jint slot, jfloat value) { 2403 JavaThread* current_thread = JavaThread::current(); 2404 // rm object is created to clean up the javaVFrame created in 2405 // doit_prologue(), but after doit() is finished with it. 2406 ResourceMark rm(current_thread); 2407 HandleMark hm(current_thread); 2408 JvmtiVTMSTransitionDisabler disabler(thread); 2409 ThreadsListHandle tlh(current_thread); 2410 2411 JavaThread* java_thread = nullptr; 2412 oop thread_obj = nullptr; 2413 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current_thread, &java_thread, &thread_obj); 2414 if (err != JVMTI_ERROR_NONE) { 2415 return err; 2416 } 2417 bool self = is_JavaThread_current(java_thread, thread_obj); 2418 jvalue val; 2419 val.f = value; 2420 2421 if (java_lang_VirtualThread::is_instance(thread_obj)) { 2422 VM_VirtualThreadGetOrSetLocal op(this, Handle(current_thread, thread_obj), 2423 depth, slot, T_FLOAT, val, self); 2424 VMThread::execute(&op); 2425 err = op.result(); 2426 } else { 2427 // Support for ordinary threads 2428 VM_GetOrSetLocal op(java_thread, depth, slot, T_FLOAT, val, self); 2429 VMThread::execute(&op); 2430 err = op.result(); 2431 } 2432 return err; 2433 } /* end SetLocalFloat */ 2434 2435 2436 // thread - NOT protected by ThreadsListHandle and NOT pre-checked 2437 // depth - pre-checked as non-negative 2438 jvmtiError 2439 JvmtiEnv::SetLocalDouble(jthread thread, jint depth, jint slot, jdouble value) { 2440 JavaThread* current_thread = JavaThread::current(); 2441 // rm object is created to clean up the javaVFrame created in 2442 // doit_prologue(), but after doit() is finished with it. 2443 ResourceMark rm(current_thread); 2444 HandleMark hm(current_thread); 2445 JvmtiVTMSTransitionDisabler disabler(thread); 2446 ThreadsListHandle tlh(current_thread); 2447 2448 JavaThread* java_thread = nullptr; 2449 oop thread_obj = nullptr; 2450 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current_thread, &java_thread, &thread_obj); 2451 if (err != JVMTI_ERROR_NONE) { 2452 return err; 2453 } 2454 bool self = is_JavaThread_current(java_thread, thread_obj); 2455 jvalue val; 2456 val.d = value; 2457 2458 if (java_lang_VirtualThread::is_instance(thread_obj)) { 2459 VM_VirtualThreadGetOrSetLocal op(this, Handle(current_thread, thread_obj), 2460 depth, slot, T_DOUBLE, val, self); 2461 VMThread::execute(&op); 2462 err = op.result(); 2463 } else { 2464 // Support for ordinary threads 2465 VM_GetOrSetLocal op(java_thread, depth, slot, T_DOUBLE, val, self); 2466 VMThread::execute(&op); 2467 err = op.result(); 2468 } 2469 return err; 2470 } /* end SetLocalDouble */ 2471 2472 2473 // 2474 // Breakpoint functions 2475 // 2476 2477 // method - pre-checked for validity, but may be null meaning obsolete method 2478 jvmtiError 2479 JvmtiEnv::SetBreakpoint(Method* method, jlocation location) { 2480 NULL_CHECK(method, JVMTI_ERROR_INVALID_METHODID); 2481 if (location < 0) { // simple invalid location check first 2482 return JVMTI_ERROR_INVALID_LOCATION; 2483 } 2484 // verify that the breakpoint is not past the end of the method 2485 if (location >= (jlocation) method->code_size()) { 2486 return JVMTI_ERROR_INVALID_LOCATION; 2487 } 2488 2489 ResourceMark rm; 2490 JvmtiBreakpoint bp(method, location); 2491 JvmtiBreakpoints& jvmti_breakpoints = JvmtiCurrentBreakpoints::get_jvmti_breakpoints(); 2492 if (jvmti_breakpoints.set(bp) == JVMTI_ERROR_DUPLICATE) 2493 return JVMTI_ERROR_DUPLICATE; 2494 2495 if (TraceJVMTICalls) { 2496 jvmti_breakpoints.print(); 2497 } 2498 2499 return JVMTI_ERROR_NONE; 2500 } /* end SetBreakpoint */ 2501 2502 2503 // method - pre-checked for validity, but may be null meaning obsolete method 2504 jvmtiError 2505 JvmtiEnv::ClearBreakpoint(Method* method, jlocation location) { 2506 NULL_CHECK(method, JVMTI_ERROR_INVALID_METHODID); 2507 2508 if (location < 0) { // simple invalid location check first 2509 return JVMTI_ERROR_INVALID_LOCATION; 2510 } 2511 2512 // verify that the breakpoint is not past the end of the method 2513 if (location >= (jlocation) method->code_size()) { 2514 return JVMTI_ERROR_INVALID_LOCATION; 2515 } 2516 2517 JvmtiBreakpoint bp(method, location); 2518 2519 JvmtiBreakpoints& jvmti_breakpoints = JvmtiCurrentBreakpoints::get_jvmti_breakpoints(); 2520 if (jvmti_breakpoints.clear(bp) == JVMTI_ERROR_NOT_FOUND) 2521 return JVMTI_ERROR_NOT_FOUND; 2522 2523 if (TraceJVMTICalls) { 2524 jvmti_breakpoints.print(); 2525 } 2526 2527 return JVMTI_ERROR_NONE; 2528 } /* end ClearBreakpoint */ 2529 2530 2531 // 2532 // Watched Field functions 2533 // 2534 2535 jvmtiError 2536 JvmtiEnv::SetFieldAccessWatch(fieldDescriptor* fdesc_ptr) { 2537 // make sure we haven't set this watch before 2538 if (fdesc_ptr->is_field_access_watched()) return JVMTI_ERROR_DUPLICATE; 2539 fdesc_ptr->set_is_field_access_watched(true); 2540 2541 JvmtiEventController::change_field_watch(JVMTI_EVENT_FIELD_ACCESS, true); 2542 2543 return JVMTI_ERROR_NONE; 2544 } /* end SetFieldAccessWatch */ 2545 2546 2547 jvmtiError 2548 JvmtiEnv::ClearFieldAccessWatch(fieldDescriptor* fdesc_ptr) { 2549 // make sure we have a watch to clear 2550 if (!fdesc_ptr->is_field_access_watched()) return JVMTI_ERROR_NOT_FOUND; 2551 fdesc_ptr->set_is_field_access_watched(false); 2552 2553 JvmtiEventController::change_field_watch(JVMTI_EVENT_FIELD_ACCESS, false); 2554 2555 return JVMTI_ERROR_NONE; 2556 } /* end ClearFieldAccessWatch */ 2557 2558 2559 jvmtiError 2560 JvmtiEnv::SetFieldModificationWatch(fieldDescriptor* fdesc_ptr) { 2561 // make sure we haven't set this watch before 2562 if (fdesc_ptr->is_field_modification_watched()) return JVMTI_ERROR_DUPLICATE; 2563 fdesc_ptr->set_is_field_modification_watched(true); 2564 2565 JvmtiEventController::change_field_watch(JVMTI_EVENT_FIELD_MODIFICATION, true); 2566 2567 return JVMTI_ERROR_NONE; 2568 } /* end SetFieldModificationWatch */ 2569 2570 2571 jvmtiError 2572 JvmtiEnv::ClearFieldModificationWatch(fieldDescriptor* fdesc_ptr) { 2573 // make sure we have a watch to clear 2574 if (!fdesc_ptr->is_field_modification_watched()) return JVMTI_ERROR_NOT_FOUND; 2575 fdesc_ptr->set_is_field_modification_watched(false); 2576 2577 JvmtiEventController::change_field_watch(JVMTI_EVENT_FIELD_MODIFICATION, false); 2578 2579 return JVMTI_ERROR_NONE; 2580 } /* end ClearFieldModificationWatch */ 2581 2582 // 2583 // Class functions 2584 // 2585 2586 2587 // k_mirror - may be primitive, this must be checked 2588 // signature_ptr - null is a valid value, must be checked 2589 // generic_ptr - null is a valid value, must be checked 2590 jvmtiError 2591 JvmtiEnv::GetClassSignature(oop k_mirror, char** signature_ptr, char** generic_ptr) { 2592 ResourceMark rm; 2593 bool isPrimitive = java_lang_Class::is_primitive(k_mirror); 2594 Klass* k = nullptr; 2595 if (!isPrimitive) { 2596 k = java_lang_Class::as_Klass(k_mirror); 2597 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); 2598 } 2599 if (signature_ptr != nullptr) { 2600 char* result = nullptr; 2601 if (isPrimitive) { 2602 char tchar = type2char(java_lang_Class::primitive_type(k_mirror)); 2603 result = (char*) jvmtiMalloc(2); 2604 result[0] = tchar; 2605 result[1] = '\0'; 2606 } else { 2607 const char* class_sig = k->signature_name(); 2608 result = (char *) jvmtiMalloc(strlen(class_sig)+1); 2609 strcpy(result, class_sig); 2610 } 2611 *signature_ptr = result; 2612 } 2613 if (generic_ptr != nullptr) { 2614 *generic_ptr = nullptr; 2615 if (!isPrimitive && k->is_instance_klass()) { 2616 Symbol* soo = InstanceKlass::cast(k)->generic_signature(); 2617 if (soo != nullptr) { 2618 const char *gen_sig = soo->as_C_string(); 2619 if (gen_sig != nullptr) { 2620 char* gen_result; 2621 jvmtiError err = allocate(strlen(gen_sig) + 1, 2622 (unsigned char **)&gen_result); 2623 if (err != JVMTI_ERROR_NONE) { 2624 return err; 2625 } 2626 strcpy(gen_result, gen_sig); 2627 *generic_ptr = gen_result; 2628 } 2629 } 2630 } 2631 } 2632 return JVMTI_ERROR_NONE; 2633 } /* end GetClassSignature */ 2634 2635 2636 // k_mirror - may be primitive, this must be checked 2637 // status_ptr - pre-checked for null 2638 jvmtiError 2639 JvmtiEnv::GetClassStatus(oop k_mirror, jint* status_ptr) { 2640 jint result = 0; 2641 if (java_lang_Class::is_primitive(k_mirror)) { 2642 result |= JVMTI_CLASS_STATUS_PRIMITIVE; 2643 } else { 2644 Klass* k = java_lang_Class::as_Klass(k_mirror); 2645 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); 2646 result = k->jvmti_class_status(); 2647 } 2648 *status_ptr = result; 2649 2650 return JVMTI_ERROR_NONE; 2651 } /* end GetClassStatus */ 2652 2653 2654 // k_mirror - may be primitive, this must be checked 2655 // source_name_ptr - pre-checked for null 2656 jvmtiError 2657 JvmtiEnv::GetSourceFileName(oop k_mirror, char** source_name_ptr) { 2658 if (java_lang_Class::is_primitive(k_mirror)) { 2659 return JVMTI_ERROR_ABSENT_INFORMATION; 2660 } 2661 Klass* k_klass = java_lang_Class::as_Klass(k_mirror); 2662 NULL_CHECK(k_klass, JVMTI_ERROR_INVALID_CLASS); 2663 2664 if (!k_klass->is_instance_klass()) { 2665 return JVMTI_ERROR_ABSENT_INFORMATION; 2666 } 2667 2668 Symbol* sfnOop = InstanceKlass::cast(k_klass)->source_file_name(); 2669 NULL_CHECK(sfnOop, JVMTI_ERROR_ABSENT_INFORMATION); 2670 { 2671 JavaThread* current_thread = JavaThread::current(); 2672 ResourceMark rm(current_thread); 2673 const char* sfncp = (const char*) sfnOop->as_C_string(); 2674 *source_name_ptr = (char *) jvmtiMalloc(strlen(sfncp)+1); 2675 strcpy(*source_name_ptr, sfncp); 2676 } 2677 2678 return JVMTI_ERROR_NONE; 2679 } /* end GetSourceFileName */ 2680 2681 2682 // k_mirror - may be primitive, this must be checked 2683 // modifiers_ptr - pre-checked for null 2684 jvmtiError 2685 JvmtiEnv::GetClassModifiers(oop k_mirror, jint* modifiers_ptr) { 2686 JavaThread* current_thread = JavaThread::current(); 2687 jint result = 0; 2688 if (!java_lang_Class::is_primitive(k_mirror)) { 2689 Klass* k = java_lang_Class::as_Klass(k_mirror); 2690 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); 2691 result = k->compute_modifier_flags(); 2692 2693 // Reset the deleted ACC_SUPER bit (deleted in compute_modifier_flags()). 2694 // if (k->is_super()) { 2695 // result |= JVM_ACC_SUPER; 2696 // } 2697 } else { 2698 result = (JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC); 2699 } 2700 *modifiers_ptr = result; 2701 2702 return JVMTI_ERROR_NONE; 2703 } /* end GetClassModifiers */ 2704 2705 2706 // k_mirror - may be primitive, this must be checked 2707 // method_count_ptr - pre-checked for null 2708 // methods_ptr - pre-checked for null 2709 jvmtiError 2710 JvmtiEnv::GetClassMethods(oop k_mirror, jint* method_count_ptr, jmethodID** methods_ptr) { 2711 JavaThread* current_thread = JavaThread::current(); 2712 HandleMark hm(current_thread); 2713 2714 if (java_lang_Class::is_primitive(k_mirror)) { 2715 *method_count_ptr = 0; 2716 *methods_ptr = (jmethodID*) jvmtiMalloc(0 * sizeof(jmethodID)); 2717 return JVMTI_ERROR_NONE; 2718 } 2719 Klass* k = java_lang_Class::as_Klass(k_mirror); 2720 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); 2721 2722 // Return CLASS_NOT_PREPARED error as per JVMTI spec. 2723 if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) { 2724 return JVMTI_ERROR_CLASS_NOT_PREPARED; 2725 } 2726 2727 if (!k->is_instance_klass()) { 2728 *method_count_ptr = 0; 2729 *methods_ptr = (jmethodID*) jvmtiMalloc(0 * sizeof(jmethodID)); 2730 return JVMTI_ERROR_NONE; 2731 } 2732 InstanceKlass* ik = InstanceKlass::cast(k); 2733 // Allocate the result and fill it in 2734 int result_length = ik->methods()->length(); 2735 jmethodID* result_list = (jmethodID*)jvmtiMalloc(result_length * sizeof(jmethodID)); 2736 int index; 2737 bool jmethodids_found = true; 2738 int skipped = 0; // skip overpass methods 2739 2740 for (index = 0; index < result_length; index++) { 2741 Method* m = ik->methods()->at(index); 2742 // Depending on can_maintain_original_method_order capability use the original 2743 // method ordering indices stored in the class, so we can emit jmethodIDs in 2744 // the order they appeared in the class file or just copy in current order. 2745 int result_index = JvmtiExport::can_maintain_original_method_order() ? ik->method_ordering()->at(index) : index; 2746 assert(result_index >= 0 && result_index < result_length, "invalid original method index"); 2747 if (m->is_overpass()) { 2748 result_list[result_index] = nullptr; 2749 skipped++; 2750 continue; 2751 } 2752 jmethodID id; 2753 if (jmethodids_found) { 2754 id = m->find_jmethod_id_or_null(); 2755 if (id == nullptr) { 2756 // If we find an uninitialized value, make sure there is 2757 // enough space for all the uninitialized values we might 2758 // find. 2759 ik->ensure_space_for_methodids(index); 2760 jmethodids_found = false; 2761 id = m->jmethod_id(); 2762 } 2763 } else { 2764 id = m->jmethod_id(); 2765 } 2766 result_list[result_index] = id; 2767 } 2768 2769 // Fill in return value. 2770 if (skipped > 0) { 2771 // copy results skipping null methodIDs 2772 *methods_ptr = (jmethodID*)jvmtiMalloc((result_length - skipped) * sizeof(jmethodID)); 2773 *method_count_ptr = result_length - skipped; 2774 for (index = 0, skipped = 0; index < result_length; index++) { 2775 if (result_list[index] == nullptr) { 2776 skipped++; 2777 } else { 2778 (*methods_ptr)[index - skipped] = result_list[index]; 2779 } 2780 } 2781 deallocate((unsigned char *)result_list); 2782 } else { 2783 *method_count_ptr = result_length; 2784 *methods_ptr = result_list; 2785 } 2786 2787 return JVMTI_ERROR_NONE; 2788 } /* end GetClassMethods */ 2789 2790 2791 // k_mirror - may be primitive, this must be checked 2792 // field_count_ptr - pre-checked for null 2793 // fields_ptr - pre-checked for null 2794 jvmtiError 2795 JvmtiEnv::GetClassFields(oop k_mirror, jint* field_count_ptr, jfieldID** fields_ptr) { 2796 if (java_lang_Class::is_primitive(k_mirror)) { 2797 *field_count_ptr = 0; 2798 *fields_ptr = (jfieldID*) jvmtiMalloc(0 * sizeof(jfieldID)); 2799 return JVMTI_ERROR_NONE; 2800 } 2801 JavaThread* current_thread = JavaThread::current(); 2802 HandleMark hm(current_thread); 2803 Klass* k = java_lang_Class::as_Klass(k_mirror); 2804 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); 2805 2806 // Return CLASS_NOT_PREPARED error as per JVMTI spec. 2807 if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) { 2808 return JVMTI_ERROR_CLASS_NOT_PREPARED; 2809 } 2810 2811 if (!k->is_instance_klass()) { 2812 *field_count_ptr = 0; 2813 *fields_ptr = (jfieldID*) jvmtiMalloc(0 * sizeof(jfieldID)); 2814 return JVMTI_ERROR_NONE; 2815 } 2816 2817 InstanceKlass* ik = InstanceKlass::cast(k); 2818 2819 FilteredJavaFieldStream flds(ik); 2820 2821 int result_count = flds.field_count(); 2822 2823 // Allocate the result and fill it in. 2824 jfieldID* result_list = (jfieldID*)jvmtiMalloc(result_count * sizeof(jfieldID)); 2825 for (int i = 0; i < result_count; i++, flds.next()) { 2826 result_list[i] = jfieldIDWorkaround::to_jfieldID(ik, flds.offset(), 2827 flds.access_flags().is_static(), 2828 flds.field_descriptor().is_flat()); 2829 } 2830 assert(flds.done(), "just checking"); 2831 2832 // Fill in the results 2833 *field_count_ptr = result_count; 2834 *fields_ptr = result_list; 2835 2836 return JVMTI_ERROR_NONE; 2837 } /* end GetClassFields */ 2838 2839 2840 // k_mirror - may be primitive, this must be checked 2841 // interface_count_ptr - pre-checked for null 2842 // interfaces_ptr - pre-checked for null 2843 jvmtiError 2844 JvmtiEnv::GetImplementedInterfaces(oop k_mirror, jint* interface_count_ptr, jclass** interfaces_ptr) { 2845 { 2846 if (java_lang_Class::is_primitive(k_mirror)) { 2847 *interface_count_ptr = 0; 2848 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass)); 2849 return JVMTI_ERROR_NONE; 2850 } 2851 JavaThread* current_thread = JavaThread::current(); 2852 HandleMark hm(current_thread); 2853 Klass* k = java_lang_Class::as_Klass(k_mirror); 2854 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); 2855 2856 // Return CLASS_NOT_PREPARED error as per JVMTI spec. 2857 if (!(k->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) 2858 return JVMTI_ERROR_CLASS_NOT_PREPARED; 2859 2860 if (!k->is_instance_klass()) { 2861 *interface_count_ptr = 0; 2862 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass)); 2863 return JVMTI_ERROR_NONE; 2864 } 2865 2866 InstanceKlass* ik = InstanceKlass::cast(k); 2867 Array<InstanceKlass*>* interface_list = ik->local_interfaces(); 2868 int result_length = (interface_list == nullptr ? 0 : interface_list->length()); 2869 jclass* result_list = (jclass*) jvmtiMalloc(result_length * sizeof(jclass)); 2870 for (int i_index = 0; i_index < result_length; i_index += 1) { 2871 InstanceKlass* klass_at = interface_list->at(i_index); 2872 assert(klass_at->is_klass(), "interfaces must be Klass*s"); 2873 assert(klass_at->is_interface(), "interfaces must be interfaces"); 2874 oop mirror_at = klass_at->java_mirror(); 2875 Handle handle_at = Handle(current_thread, mirror_at); 2876 result_list[i_index] = (jclass) jni_reference(handle_at); 2877 } 2878 *interface_count_ptr = result_length; 2879 *interfaces_ptr = result_list; 2880 } 2881 2882 return JVMTI_ERROR_NONE; 2883 } /* end GetImplementedInterfaces */ 2884 2885 2886 // k_mirror - may be primitive, this must be checked 2887 // minor_version_ptr - pre-checked for null 2888 // major_version_ptr - pre-checked for null 2889 jvmtiError 2890 JvmtiEnv::GetClassVersionNumbers(oop k_mirror, jint* minor_version_ptr, jint* major_version_ptr) { 2891 if (java_lang_Class::is_primitive(k_mirror)) { 2892 return JVMTI_ERROR_ABSENT_INFORMATION; 2893 } 2894 Klass* klass = java_lang_Class::as_Klass(k_mirror); 2895 2896 jint status = klass->jvmti_class_status(); 2897 if (status & (JVMTI_CLASS_STATUS_ERROR)) { 2898 return JVMTI_ERROR_INVALID_CLASS; 2899 } 2900 if (status & (JVMTI_CLASS_STATUS_ARRAY)) { 2901 return JVMTI_ERROR_ABSENT_INFORMATION; 2902 } 2903 2904 InstanceKlass* ik = InstanceKlass::cast(klass); 2905 *minor_version_ptr = ik->minor_version(); 2906 *major_version_ptr = ik->major_version(); 2907 2908 return JVMTI_ERROR_NONE; 2909 } /* end GetClassVersionNumbers */ 2910 2911 2912 // k_mirror - may be primitive, this must be checked 2913 // constant_pool_count_ptr - pre-checked for null 2914 // constant_pool_byte_count_ptr - pre-checked for null 2915 // constant_pool_bytes_ptr - pre-checked for null 2916 jvmtiError 2917 JvmtiEnv::GetConstantPool(oop k_mirror, jint* constant_pool_count_ptr, jint* constant_pool_byte_count_ptr, unsigned char** constant_pool_bytes_ptr) { 2918 if (java_lang_Class::is_primitive(k_mirror)) { 2919 return JVMTI_ERROR_ABSENT_INFORMATION; 2920 } 2921 2922 Klass* klass = java_lang_Class::as_Klass(k_mirror); 2923 Thread *thread = Thread::current(); 2924 ResourceMark rm(thread); 2925 2926 jint status = klass->jvmti_class_status(); 2927 if (status & (JVMTI_CLASS_STATUS_ERROR)) { 2928 return JVMTI_ERROR_INVALID_CLASS; 2929 } 2930 if (status & (JVMTI_CLASS_STATUS_ARRAY)) { 2931 return JVMTI_ERROR_ABSENT_INFORMATION; 2932 } 2933 2934 InstanceKlass* ik = InstanceKlass::cast(klass); 2935 JvmtiConstantPoolReconstituter reconstituter(ik); 2936 if (reconstituter.get_error() != JVMTI_ERROR_NONE) { 2937 return reconstituter.get_error(); 2938 } 2939 2940 unsigned char *cpool_bytes; 2941 int cpool_size = reconstituter.cpool_size(); 2942 if (reconstituter.get_error() != JVMTI_ERROR_NONE) { 2943 return reconstituter.get_error(); 2944 } 2945 jvmtiError res = allocate(cpool_size, &cpool_bytes); 2946 if (res != JVMTI_ERROR_NONE) { 2947 return res; 2948 } 2949 reconstituter.copy_cpool_bytes(cpool_bytes); 2950 if (reconstituter.get_error() != JVMTI_ERROR_NONE) { 2951 return reconstituter.get_error(); 2952 } 2953 2954 constantPoolHandle constants(thread, ik->constants()); 2955 *constant_pool_count_ptr = constants->length(); 2956 *constant_pool_byte_count_ptr = cpool_size; 2957 *constant_pool_bytes_ptr = cpool_bytes; 2958 2959 return JVMTI_ERROR_NONE; 2960 } /* end GetConstantPool */ 2961 2962 2963 // k_mirror - may be primitive, this must be checked 2964 // is_interface_ptr - pre-checked for null 2965 jvmtiError 2966 JvmtiEnv::IsInterface(oop k_mirror, jboolean* is_interface_ptr) { 2967 { 2968 bool result = false; 2969 if (!java_lang_Class::is_primitive(k_mirror)) { 2970 Klass* k = java_lang_Class::as_Klass(k_mirror); 2971 if (k != nullptr && k->is_interface()) { 2972 result = true; 2973 } 2974 } 2975 *is_interface_ptr = result; 2976 } 2977 2978 return JVMTI_ERROR_NONE; 2979 } /* end IsInterface */ 2980 2981 2982 // k_mirror - may be primitive, this must be checked 2983 // is_array_class_ptr - pre-checked for null 2984 jvmtiError 2985 JvmtiEnv::IsArrayClass(oop k_mirror, jboolean* is_array_class_ptr) { 2986 { 2987 bool result = false; 2988 if (!java_lang_Class::is_primitive(k_mirror)) { 2989 Klass* k = java_lang_Class::as_Klass(k_mirror); 2990 if (k != nullptr && k->is_array_klass()) { 2991 result = true; 2992 } 2993 } 2994 *is_array_class_ptr = result; 2995 } 2996 2997 return JVMTI_ERROR_NONE; 2998 } /* end IsArrayClass */ 2999 3000 3001 // k_mirror - may be primitive, this must be checked 3002 // classloader_ptr - pre-checked for null 3003 jvmtiError 3004 JvmtiEnv::GetClassLoader(oop k_mirror, jobject* classloader_ptr) { 3005 { 3006 if (java_lang_Class::is_primitive(k_mirror)) { 3007 *classloader_ptr = (jclass) jni_reference(Handle()); 3008 return JVMTI_ERROR_NONE; 3009 } 3010 JavaThread* current_thread = JavaThread::current(); 3011 HandleMark hm(current_thread); 3012 Klass* k = java_lang_Class::as_Klass(k_mirror); 3013 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); 3014 3015 oop result_oop = k->class_loader(); 3016 if (result_oop == nullptr) { 3017 *classloader_ptr = (jclass) jni_reference(Handle()); 3018 return JVMTI_ERROR_NONE; 3019 } 3020 Handle result_handle = Handle(current_thread, result_oop); 3021 jclass result_jnihandle = (jclass) jni_reference(result_handle); 3022 *classloader_ptr = result_jnihandle; 3023 } 3024 return JVMTI_ERROR_NONE; 3025 } /* end GetClassLoader */ 3026 3027 3028 // k_mirror - may be primitive, this must be checked 3029 // source_debug_extension_ptr - pre-checked for null 3030 jvmtiError 3031 JvmtiEnv::GetSourceDebugExtension(oop k_mirror, char** source_debug_extension_ptr) { 3032 { 3033 if (java_lang_Class::is_primitive(k_mirror)) { 3034 return JVMTI_ERROR_ABSENT_INFORMATION; 3035 } 3036 Klass* k = java_lang_Class::as_Klass(k_mirror); 3037 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); 3038 if (!k->is_instance_klass()) { 3039 return JVMTI_ERROR_ABSENT_INFORMATION; 3040 } 3041 const char* sde = InstanceKlass::cast(k)->source_debug_extension(); 3042 NULL_CHECK(sde, JVMTI_ERROR_ABSENT_INFORMATION); 3043 3044 { 3045 *source_debug_extension_ptr = (char *) jvmtiMalloc(strlen(sde)+1); 3046 strcpy(*source_debug_extension_ptr, sde); 3047 } 3048 } 3049 3050 return JVMTI_ERROR_NONE; 3051 } /* end GetSourceDebugExtension */ 3052 3053 // 3054 // Object functions 3055 // 3056 3057 // hash_code_ptr - pre-checked for null 3058 jvmtiError 3059 JvmtiEnv::GetObjectHashCode(jobject object, jint* hash_code_ptr) { 3060 oop mirror = JNIHandles::resolve_external_guard(object); 3061 NULL_CHECK(mirror, JVMTI_ERROR_INVALID_OBJECT); 3062 NULL_CHECK(hash_code_ptr, JVMTI_ERROR_NULL_POINTER); 3063 3064 { 3065 jint result = (jint) mirror->identity_hash(); 3066 *hash_code_ptr = result; 3067 } 3068 return JVMTI_ERROR_NONE; 3069 } /* end GetObjectHashCode */ 3070 3071 3072 // info_ptr - pre-checked for null 3073 jvmtiError 3074 JvmtiEnv::GetObjectMonitorUsage(jobject object, jvmtiMonitorUsage* info_ptr) { 3075 // This needs to be performed at a safepoint to gather stable data 3076 // because monitor owner / waiters might not be suspended. 3077 VM_GetObjectMonitorUsage op(this, JavaThread::current(), object, info_ptr); 3078 VMThread::execute(&op); 3079 return op.result(); 3080 } /* end GetObjectMonitorUsage */ 3081 3082 3083 // 3084 // Field functions 3085 // 3086 3087 // name_ptr - null is a valid value, must be checked 3088 // signature_ptr - null is a valid value, must be checked 3089 // generic_ptr - null is a valid value, must be checked 3090 jvmtiError 3091 JvmtiEnv::GetFieldName(fieldDescriptor* fdesc_ptr, char** name_ptr, char** signature_ptr, char** generic_ptr) { 3092 JavaThread* current_thread = JavaThread::current(); 3093 ResourceMark rm(current_thread); 3094 if (name_ptr == nullptr) { 3095 // just don't return the name 3096 } else { 3097 const char* fieldName = fdesc_ptr->name()->as_C_string(); 3098 *name_ptr = (char*) jvmtiMalloc(strlen(fieldName) + 1); 3099 if (*name_ptr == nullptr) 3100 return JVMTI_ERROR_OUT_OF_MEMORY; 3101 strcpy(*name_ptr, fieldName); 3102 } 3103 if (signature_ptr== nullptr) { 3104 // just don't return the signature 3105 } else { 3106 const char* fieldSignature = fdesc_ptr->signature()->as_C_string(); 3107 *signature_ptr = (char*) jvmtiMalloc(strlen(fieldSignature) + 1); 3108 if (*signature_ptr == nullptr) 3109 return JVMTI_ERROR_OUT_OF_MEMORY; 3110 strcpy(*signature_ptr, fieldSignature); 3111 } 3112 if (generic_ptr != nullptr) { 3113 *generic_ptr = nullptr; 3114 Symbol* soop = fdesc_ptr->generic_signature(); 3115 if (soop != nullptr) { 3116 const char* gen_sig = soop->as_C_string(); 3117 if (gen_sig != nullptr) { 3118 jvmtiError err = allocate(strlen(gen_sig) + 1, (unsigned char **)generic_ptr); 3119 if (err != JVMTI_ERROR_NONE) { 3120 return err; 3121 } 3122 strcpy(*generic_ptr, gen_sig); 3123 } 3124 } 3125 } 3126 return JVMTI_ERROR_NONE; 3127 } /* end GetFieldName */ 3128 3129 3130 // declaring_class_ptr - pre-checked for null 3131 jvmtiError 3132 JvmtiEnv::GetFieldDeclaringClass(fieldDescriptor* fdesc_ptr, jclass* declaring_class_ptr) { 3133 3134 *declaring_class_ptr = get_jni_class_non_null(fdesc_ptr->field_holder()); 3135 return JVMTI_ERROR_NONE; 3136 } /* end GetFieldDeclaringClass */ 3137 3138 3139 // modifiers_ptr - pre-checked for null 3140 jvmtiError 3141 JvmtiEnv::GetFieldModifiers(fieldDescriptor* fdesc_ptr, jint* modifiers_ptr) { 3142 3143 AccessFlags resultFlags = fdesc_ptr->access_flags(); 3144 jint result = resultFlags.as_int(); 3145 *modifiers_ptr = result; 3146 3147 return JVMTI_ERROR_NONE; 3148 } /* end GetFieldModifiers */ 3149 3150 3151 // is_synthetic_ptr - pre-checked for null 3152 jvmtiError 3153 JvmtiEnv::IsFieldSynthetic(fieldDescriptor* fdesc_ptr, jboolean* is_synthetic_ptr) { 3154 *is_synthetic_ptr = fdesc_ptr->is_synthetic(); 3155 return JVMTI_ERROR_NONE; 3156 } /* end IsFieldSynthetic */ 3157 3158 3159 // 3160 // Method functions 3161 // 3162 3163 // method - pre-checked for validity, but may be null meaning obsolete method 3164 // name_ptr - null is a valid value, must be checked 3165 // signature_ptr - null is a valid value, must be checked 3166 // generic_ptr - null is a valid value, must be checked 3167 jvmtiError 3168 JvmtiEnv::GetMethodName(Method* method, char** name_ptr, char** signature_ptr, char** generic_ptr) { 3169 NULL_CHECK(method, JVMTI_ERROR_INVALID_METHODID); 3170 JavaThread* current_thread = JavaThread::current(); 3171 3172 ResourceMark rm(current_thread); // get the utf8 name and signature 3173 if (name_ptr == nullptr) { 3174 // just don't return the name 3175 } else { 3176 const char* utf8_name = (const char *) method->name()->as_utf8(); 3177 *name_ptr = (char *) jvmtiMalloc(strlen(utf8_name)+1); 3178 strcpy(*name_ptr, utf8_name); 3179 } 3180 if (signature_ptr == nullptr) { 3181 // just don't return the signature 3182 } else { 3183 const char* utf8_signature = (const char *) method->signature()->as_utf8(); 3184 *signature_ptr = (char *) jvmtiMalloc(strlen(utf8_signature) + 1); 3185 strcpy(*signature_ptr, utf8_signature); 3186 } 3187 3188 if (generic_ptr != nullptr) { 3189 *generic_ptr = nullptr; 3190 Symbol* soop = method->generic_signature(); 3191 if (soop != nullptr) { 3192 const char* gen_sig = soop->as_C_string(); 3193 if (gen_sig != nullptr) { 3194 jvmtiError err = allocate(strlen(gen_sig) + 1, (unsigned char **)generic_ptr); 3195 if (err != JVMTI_ERROR_NONE) { 3196 return err; 3197 } 3198 strcpy(*generic_ptr, gen_sig); 3199 } 3200 } 3201 } 3202 return JVMTI_ERROR_NONE; 3203 } /* end GetMethodName */ 3204 3205 3206 // method - pre-checked for validity, but may be null meaning obsolete method 3207 // declaring_class_ptr - pre-checked for null 3208 jvmtiError 3209 JvmtiEnv::GetMethodDeclaringClass(Method* method, jclass* declaring_class_ptr) { 3210 NULL_CHECK(method, JVMTI_ERROR_INVALID_METHODID); 3211 (*declaring_class_ptr) = get_jni_class_non_null(method->method_holder()); 3212 return JVMTI_ERROR_NONE; 3213 } /* end GetMethodDeclaringClass */ 3214 3215 3216 // method - pre-checked for validity, but may be null meaning obsolete method 3217 // modifiers_ptr - pre-checked for null 3218 jvmtiError 3219 JvmtiEnv::GetMethodModifiers(Method* method, jint* modifiers_ptr) { 3220 NULL_CHECK(method, JVMTI_ERROR_INVALID_METHODID); 3221 (*modifiers_ptr) = method->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS; 3222 return JVMTI_ERROR_NONE; 3223 } /* end GetMethodModifiers */ 3224 3225 3226 // method - pre-checked for validity, but may be null meaning obsolete method 3227 // max_ptr - pre-checked for null 3228 jvmtiError 3229 JvmtiEnv::GetMaxLocals(Method* method, jint* max_ptr) { 3230 NULL_CHECK(method, JVMTI_ERROR_INVALID_METHODID); 3231 // get max stack 3232 (*max_ptr) = method->max_locals(); 3233 return JVMTI_ERROR_NONE; 3234 } /* end GetMaxLocals */ 3235 3236 3237 // method - pre-checked for validity, but may be null meaning obsolete method 3238 // size_ptr - pre-checked for null 3239 jvmtiError 3240 JvmtiEnv::GetArgumentsSize(Method* method, jint* size_ptr) { 3241 NULL_CHECK(method, JVMTI_ERROR_INVALID_METHODID); 3242 // get size of arguments 3243 3244 (*size_ptr) = method->size_of_parameters(); 3245 return JVMTI_ERROR_NONE; 3246 } /* end GetArgumentsSize */ 3247 3248 3249 // method - pre-checked for validity, but may be null meaning obsolete method 3250 // entry_count_ptr - pre-checked for null 3251 // table_ptr - pre-checked for null 3252 jvmtiError 3253 JvmtiEnv::GetLineNumberTable(Method* method, jint* entry_count_ptr, jvmtiLineNumberEntry** table_ptr) { 3254 NULL_CHECK(method, JVMTI_ERROR_INVALID_METHODID); 3255 if (!method->has_linenumber_table()) { 3256 return (JVMTI_ERROR_ABSENT_INFORMATION); 3257 } 3258 3259 // The line number table is compressed so we don't know how big it is until decompressed. 3260 // Decompression is really fast so we just do it twice. 3261 3262 // Compute size of table 3263 jint num_entries = 0; 3264 CompressedLineNumberReadStream stream(method->compressed_linenumber_table()); 3265 while (stream.read_pair()) { 3266 num_entries++; 3267 } 3268 jvmtiLineNumberEntry *jvmti_table = 3269 (jvmtiLineNumberEntry *)jvmtiMalloc(num_entries * (sizeof(jvmtiLineNumberEntry))); 3270 3271 // Fill jvmti table 3272 if (num_entries > 0) { 3273 int index = 0; 3274 CompressedLineNumberReadStream stream(method->compressed_linenumber_table()); 3275 while (stream.read_pair()) { 3276 jvmti_table[index].start_location = (jlocation) stream.bci(); 3277 jvmti_table[index].line_number = (jint) stream.line(); 3278 index++; 3279 } 3280 assert(index == num_entries, "sanity check"); 3281 } 3282 3283 // Set up results 3284 (*entry_count_ptr) = num_entries; 3285 (*table_ptr) = jvmti_table; 3286 3287 return JVMTI_ERROR_NONE; 3288 } /* end GetLineNumberTable */ 3289 3290 3291 // method - pre-checked for validity, but may be null meaning obsolete method 3292 // start_location_ptr - pre-checked for null 3293 // end_location_ptr - pre-checked for null 3294 jvmtiError 3295 JvmtiEnv::GetMethodLocation(Method* method, jlocation* start_location_ptr, jlocation* end_location_ptr) { 3296 3297 NULL_CHECK(method, JVMTI_ERROR_INVALID_METHODID); 3298 // get start and end location 3299 (*end_location_ptr) = (jlocation) (method->code_size() - 1); 3300 if (method->code_size() == 0) { 3301 // there is no code so there is no start location 3302 (*start_location_ptr) = (jlocation)(-1); 3303 } else { 3304 (*start_location_ptr) = (jlocation)(0); 3305 } 3306 3307 return JVMTI_ERROR_NONE; 3308 } /* end GetMethodLocation */ 3309 3310 3311 // method - pre-checked for validity, but may be null meaning obsolete method 3312 // entry_count_ptr - pre-checked for null 3313 // table_ptr - pre-checked for null 3314 jvmtiError 3315 JvmtiEnv::GetLocalVariableTable(Method* method, jint* entry_count_ptr, jvmtiLocalVariableEntry** table_ptr) { 3316 3317 NULL_CHECK(method, JVMTI_ERROR_INVALID_METHODID); 3318 JavaThread* current_thread = JavaThread::current(); 3319 3320 // does the klass have any local variable information? 3321 InstanceKlass* ik = method->method_holder(); 3322 if (!ik->has_localvariable_table()) { 3323 return (JVMTI_ERROR_ABSENT_INFORMATION); 3324 } 3325 3326 ConstantPool* constants = method->constants(); 3327 NULL_CHECK(constants, JVMTI_ERROR_ABSENT_INFORMATION); 3328 3329 // in the vm localvariable table representation, 6 consecutive elements in the table 3330 // represent a 6-tuple of shorts 3331 // [start_pc, length, name_index, descriptor_index, signature_index, index] 3332 jint num_entries = method->localvariable_table_length(); 3333 jvmtiLocalVariableEntry *jvmti_table = (jvmtiLocalVariableEntry *) 3334 jvmtiMalloc(num_entries * (sizeof(jvmtiLocalVariableEntry))); 3335 3336 if (num_entries > 0) { 3337 LocalVariableTableElement* table = method->localvariable_table_start(); 3338 for (int i = 0; i < num_entries; i++) { 3339 // get the 5 tuple information from the vm table 3340 jlocation start_location = (jlocation) table[i].start_bci; 3341 jint length = (jint) table[i].length; 3342 int name_index = (int) table[i].name_cp_index; 3343 int signature_index = (int) table[i].descriptor_cp_index; 3344 int generic_signature_index = (int) table[i].signature_cp_index; 3345 jint slot = (jint) table[i].slot; 3346 3347 // get utf8 name and signature 3348 char *name_buf = nullptr; 3349 char *sig_buf = nullptr; 3350 char *gen_sig_buf = nullptr; 3351 { 3352 ResourceMark rm(current_thread); 3353 3354 const char *utf8_name = (const char *) constants->symbol_at(name_index)->as_utf8(); 3355 name_buf = (char *) jvmtiMalloc(strlen(utf8_name)+1); 3356 strcpy(name_buf, utf8_name); 3357 3358 const char *utf8_signature = (const char *) constants->symbol_at(signature_index)->as_utf8(); 3359 sig_buf = (char *) jvmtiMalloc(strlen(utf8_signature)+1); 3360 strcpy(sig_buf, utf8_signature); 3361 3362 if (generic_signature_index > 0) { 3363 const char *utf8_gen_sign = (const char *) 3364 constants->symbol_at(generic_signature_index)->as_utf8(); 3365 gen_sig_buf = (char *) jvmtiMalloc(strlen(utf8_gen_sign)+1); 3366 strcpy(gen_sig_buf, utf8_gen_sign); 3367 } 3368 } 3369 3370 // fill in the jvmti local variable table 3371 jvmti_table[i].start_location = start_location; 3372 jvmti_table[i].length = length; 3373 jvmti_table[i].name = name_buf; 3374 jvmti_table[i].signature = sig_buf; 3375 jvmti_table[i].generic_signature = gen_sig_buf; 3376 jvmti_table[i].slot = slot; 3377 } 3378 } 3379 3380 // set results 3381 (*entry_count_ptr) = num_entries; 3382 (*table_ptr) = jvmti_table; 3383 3384 return JVMTI_ERROR_NONE; 3385 } /* end GetLocalVariableTable */ 3386 3387 3388 // method - pre-checked for validity, but may be null meaning obsolete method 3389 // bytecode_count_ptr - pre-checked for null 3390 // bytecodes_ptr - pre-checked for null 3391 jvmtiError 3392 JvmtiEnv::GetBytecodes(Method* method, jint* bytecode_count_ptr, unsigned char** bytecodes_ptr) { 3393 NULL_CHECK(method, JVMTI_ERROR_INVALID_METHODID); 3394 3395 methodHandle mh(Thread::current(), method); 3396 jint size = (jint)mh->code_size(); 3397 jvmtiError err = allocate(size, bytecodes_ptr); 3398 if (err != JVMTI_ERROR_NONE) { 3399 return err; 3400 } 3401 3402 (*bytecode_count_ptr) = size; 3403 // get byte codes 3404 JvmtiClassFileReconstituter::copy_bytecodes(mh, *bytecodes_ptr); 3405 3406 return JVMTI_ERROR_NONE; 3407 } /* end GetBytecodes */ 3408 3409 3410 // method - pre-checked for validity, but may be null meaning obsolete method 3411 // is_native_ptr - pre-checked for null 3412 jvmtiError 3413 JvmtiEnv::IsMethodNative(Method* method, jboolean* is_native_ptr) { 3414 NULL_CHECK(method, JVMTI_ERROR_INVALID_METHODID); 3415 (*is_native_ptr) = method->is_native(); 3416 return JVMTI_ERROR_NONE; 3417 } /* end IsMethodNative */ 3418 3419 3420 // method - pre-checked for validity, but may be null meaning obsolete method 3421 // is_synthetic_ptr - pre-checked for null 3422 jvmtiError 3423 JvmtiEnv::IsMethodSynthetic(Method* method, jboolean* is_synthetic_ptr) { 3424 NULL_CHECK(method, JVMTI_ERROR_INVALID_METHODID); 3425 (*is_synthetic_ptr) = method->is_synthetic(); 3426 return JVMTI_ERROR_NONE; 3427 } /* end IsMethodSynthetic */ 3428 3429 3430 // method - pre-checked for validity, but may be null meaning obsolete method 3431 // is_obsolete_ptr - pre-checked for null 3432 jvmtiError 3433 JvmtiEnv::IsMethodObsolete(Method* method, jboolean* is_obsolete_ptr) { 3434 if (use_version_1_0_semantics() && 3435 get_capabilities()->can_redefine_classes == 0) { 3436 // This JvmtiEnv requested version 1.0 semantics and this function 3437 // requires the can_redefine_classes capability in version 1.0 so 3438 // we need to return an error here. 3439 return JVMTI_ERROR_MUST_POSSESS_CAPABILITY; 3440 } 3441 3442 if (method == nullptr || method->is_obsolete()) { 3443 *is_obsolete_ptr = true; 3444 } else { 3445 *is_obsolete_ptr = false; 3446 } 3447 return JVMTI_ERROR_NONE; 3448 } /* end IsMethodObsolete */ 3449 3450 // 3451 // Raw Monitor functions 3452 // 3453 3454 // name - pre-checked for null 3455 // monitor_ptr - pre-checked for null 3456 jvmtiError 3457 JvmtiEnv::CreateRawMonitor(const char* name, jrawMonitorID* monitor_ptr) { 3458 JvmtiRawMonitor* rmonitor = new (std::nothrow) JvmtiRawMonitor(name); 3459 NULL_CHECK(rmonitor, JVMTI_ERROR_OUT_OF_MEMORY); 3460 3461 *monitor_ptr = (jrawMonitorID)rmonitor; 3462 3463 return JVMTI_ERROR_NONE; 3464 } /* end CreateRawMonitor */ 3465 3466 3467 // rmonitor - pre-checked for validity 3468 jvmtiError 3469 JvmtiEnv::DestroyRawMonitor(JvmtiRawMonitor * rmonitor) { 3470 if (Threads::number_of_threads() == 0) { 3471 // Remove this monitor from pending raw monitors list 3472 // if it has entered in onload or start phase. 3473 JvmtiPendingMonitors::destroy(rmonitor); 3474 } else { 3475 Thread* thread = Thread::current(); 3476 if (rmonitor->owner() == thread) { 3477 // The caller owns this monitor which we are about to destroy. 3478 // We exit the underlying synchronization object so that the 3479 // "delete monitor" call below can work without an assertion 3480 // failure on systems that don't like destroying synchronization 3481 // objects that are locked. 3482 int r; 3483 int recursion = rmonitor->recursions(); 3484 for (int i = 0; i <= recursion; i++) { 3485 r = rmonitor->raw_exit(thread); 3486 assert(r == JvmtiRawMonitor::M_OK, "raw_exit should have worked"); 3487 if (r != JvmtiRawMonitor::M_OK) { // robustness 3488 return JVMTI_ERROR_INTERNAL; 3489 } 3490 } 3491 } 3492 if (rmonitor->owner() != nullptr) { 3493 // The caller is trying to destroy a monitor that is locked by 3494 // someone else. While this is not forbidden by the JVMTI 3495 // spec, it will cause an assertion failure on systems that don't 3496 // like destroying synchronization objects that are locked. 3497 // We indicate a problem with the error return (and leak the 3498 // monitor's memory). 3499 return JVMTI_ERROR_NOT_MONITOR_OWNER; 3500 } 3501 } 3502 3503 delete rmonitor; 3504 3505 return JVMTI_ERROR_NONE; 3506 } /* end DestroyRawMonitor */ 3507 3508 3509 // rmonitor - pre-checked for validity 3510 jvmtiError 3511 JvmtiEnv::RawMonitorEnter(JvmtiRawMonitor * rmonitor) { 3512 if (Threads::number_of_threads() == 0) { 3513 // No JavaThreads exist so JvmtiRawMonitor enter cannot be 3514 // used, add this raw monitor to the pending list. 3515 // The pending monitors will be actually entered when 3516 // the VM is setup. 3517 // See transition_pending_raw_monitors in create_vm() 3518 // in thread.cpp. 3519 JvmtiPendingMonitors::enter(rmonitor); 3520 } else { 3521 Thread* thread = Thread::current(); 3522 // 8266889: raw_enter changes Java thread state, needs WXWrite 3523 MACOS_AARCH64_ONLY(ThreadWXEnable __wx(WXWrite, thread)); 3524 rmonitor->raw_enter(thread); 3525 } 3526 return JVMTI_ERROR_NONE; 3527 } /* end RawMonitorEnter */ 3528 3529 3530 // rmonitor - pre-checked for validity 3531 jvmtiError 3532 JvmtiEnv::RawMonitorExit(JvmtiRawMonitor * rmonitor) { 3533 jvmtiError err = JVMTI_ERROR_NONE; 3534 3535 if (Threads::number_of_threads() == 0) { 3536 // No JavaThreads exist so just remove this monitor from the pending list. 3537 // Bool value from exit is false if rmonitor is not in the list. 3538 if (!JvmtiPendingMonitors::exit(rmonitor)) { 3539 err = JVMTI_ERROR_NOT_MONITOR_OWNER; 3540 } 3541 } else { 3542 Thread* thread = Thread::current(); 3543 int r = rmonitor->raw_exit(thread); 3544 if (r == JvmtiRawMonitor::M_ILLEGAL_MONITOR_STATE) { 3545 err = JVMTI_ERROR_NOT_MONITOR_OWNER; 3546 } 3547 } 3548 return err; 3549 } /* end RawMonitorExit */ 3550 3551 3552 // rmonitor - pre-checked for validity 3553 jvmtiError 3554 JvmtiEnv::RawMonitorWait(JvmtiRawMonitor * rmonitor, jlong millis) { 3555 Thread* thread = Thread::current(); 3556 // 8266889: raw_wait changes Java thread state, needs WXWrite 3557 MACOS_AARCH64_ONLY(ThreadWXEnable __wx(WXWrite, thread)); 3558 int r = rmonitor->raw_wait(millis, thread); 3559 3560 switch (r) { 3561 case JvmtiRawMonitor::M_INTERRUPTED: 3562 return JVMTI_ERROR_INTERRUPT; 3563 case JvmtiRawMonitor::M_ILLEGAL_MONITOR_STATE: 3564 return JVMTI_ERROR_NOT_MONITOR_OWNER; 3565 default: 3566 return JVMTI_ERROR_NONE; 3567 } 3568 } /* end RawMonitorWait */ 3569 3570 3571 // rmonitor - pre-checked for validity 3572 jvmtiError 3573 JvmtiEnv::RawMonitorNotify(JvmtiRawMonitor * rmonitor) { 3574 Thread* thread = Thread::current(); 3575 int r = rmonitor->raw_notify(thread); 3576 3577 if (r == JvmtiRawMonitor::M_ILLEGAL_MONITOR_STATE) { 3578 return JVMTI_ERROR_NOT_MONITOR_OWNER; 3579 } 3580 return JVMTI_ERROR_NONE; 3581 } /* end RawMonitorNotify */ 3582 3583 3584 // rmonitor - pre-checked for validity 3585 jvmtiError 3586 JvmtiEnv::RawMonitorNotifyAll(JvmtiRawMonitor * rmonitor) { 3587 Thread* thread = Thread::current(); 3588 int r = rmonitor->raw_notifyAll(thread); 3589 3590 if (r == JvmtiRawMonitor::M_ILLEGAL_MONITOR_STATE) { 3591 return JVMTI_ERROR_NOT_MONITOR_OWNER; 3592 } 3593 return JVMTI_ERROR_NONE; 3594 } /* end RawMonitorNotifyAll */ 3595 3596 3597 // 3598 // JNI Function Interception functions 3599 // 3600 3601 3602 // function_table - pre-checked for null 3603 jvmtiError 3604 JvmtiEnv::SetJNIFunctionTable(const jniNativeInterface* function_table) { 3605 // Copy jni function table at safepoint. 3606 VM_JNIFunctionTableCopier copier(function_table); 3607 VMThread::execute(&copier); 3608 3609 return JVMTI_ERROR_NONE; 3610 } /* end SetJNIFunctionTable */ 3611 3612 3613 // function_table - pre-checked for null 3614 jvmtiError 3615 JvmtiEnv::GetJNIFunctionTable(jniNativeInterface** function_table) { 3616 *function_table=(jniNativeInterface*)jvmtiMalloc(sizeof(jniNativeInterface)); 3617 if (*function_table == nullptr) 3618 return JVMTI_ERROR_OUT_OF_MEMORY; 3619 memcpy(*function_table,(JavaThread::current())->get_jni_functions(),sizeof(jniNativeInterface)); 3620 return JVMTI_ERROR_NONE; 3621 } /* end GetJNIFunctionTable */ 3622 3623 3624 // 3625 // Event Management functions 3626 // 3627 3628 jvmtiError 3629 JvmtiEnv::GenerateEvents(jvmtiEvent event_type) { 3630 // can only generate two event types 3631 if (event_type != JVMTI_EVENT_COMPILED_METHOD_LOAD && 3632 event_type != JVMTI_EVENT_DYNAMIC_CODE_GENERATED) { 3633 return JVMTI_ERROR_ILLEGAL_ARGUMENT; 3634 } 3635 3636 // for compiled_method_load events we must check that the environment 3637 // has the can_generate_compiled_method_load_events capability. 3638 if (event_type == JVMTI_EVENT_COMPILED_METHOD_LOAD) { 3639 if (get_capabilities()->can_generate_compiled_method_load_events == 0) { 3640 return JVMTI_ERROR_MUST_POSSESS_CAPABILITY; 3641 } 3642 return JvmtiCodeBlobEvents::generate_compiled_method_load_events(this); 3643 } else { 3644 return JvmtiCodeBlobEvents::generate_dynamic_code_events(this); 3645 } 3646 3647 } /* end GenerateEvents */ 3648 3649 3650 // 3651 // Extension Mechanism functions 3652 // 3653 3654 // extension_count_ptr - pre-checked for null 3655 // extensions - pre-checked for null 3656 jvmtiError 3657 JvmtiEnv::GetExtensionFunctions(jint* extension_count_ptr, jvmtiExtensionFunctionInfo** extensions) { 3658 return JvmtiExtensions::get_functions(this, extension_count_ptr, extensions); 3659 } /* end GetExtensionFunctions */ 3660 3661 3662 // extension_count_ptr - pre-checked for null 3663 // extensions - pre-checked for null 3664 jvmtiError 3665 JvmtiEnv::GetExtensionEvents(jint* extension_count_ptr, jvmtiExtensionEventInfo** extensions) { 3666 return JvmtiExtensions::get_events(this, extension_count_ptr, extensions); 3667 } /* end GetExtensionEvents */ 3668 3669 3670 // callback - null is a valid value, must be checked 3671 jvmtiError 3672 JvmtiEnv::SetExtensionEventCallback(jint extension_event_index, jvmtiExtensionEvent callback) { 3673 return JvmtiExtensions::set_event_callback(this, extension_event_index, callback); 3674 } /* end SetExtensionEventCallback */ 3675 3676 // 3677 // Timers functions 3678 // 3679 3680 // info_ptr - pre-checked for null 3681 jvmtiError 3682 JvmtiEnv::GetCurrentThreadCpuTimerInfo(jvmtiTimerInfo* info_ptr) { 3683 os::current_thread_cpu_time_info(info_ptr); 3684 return JVMTI_ERROR_NONE; 3685 } /* end GetCurrentThreadCpuTimerInfo */ 3686 3687 3688 // nanos_ptr - pre-checked for null 3689 jvmtiError 3690 JvmtiEnv::GetCurrentThreadCpuTime(jlong* nanos_ptr) { 3691 Thread* thread = Thread::current(); 3692 3693 // Surprisingly the GetCurrentThreadCpuTime is used by non-JavaThread's. 3694 if (thread->is_Java_thread()) { 3695 if (JavaThread::cast(thread)->is_vthread_mounted()) { 3696 // No support for a VirtualThread (yet). 3697 return JVMTI_ERROR_UNSUPPORTED_OPERATION; 3698 } 3699 } 3700 *nanos_ptr = os::current_thread_cpu_time(); 3701 return JVMTI_ERROR_NONE; 3702 } /* end GetCurrentThreadCpuTime */ 3703 3704 3705 // info_ptr - pre-checked for null 3706 jvmtiError 3707 JvmtiEnv::GetThreadCpuTimerInfo(jvmtiTimerInfo* info_ptr) { 3708 os::thread_cpu_time_info(info_ptr); 3709 return JVMTI_ERROR_NONE; 3710 } /* end GetThreadCpuTimerInfo */ 3711 3712 3713 // nanos_ptr - pre-checked for null 3714 jvmtiError 3715 JvmtiEnv::GetThreadCpuTime(jthread thread, jlong* nanos_ptr) { 3716 JavaThread* current_thread = JavaThread::current(); 3717 ThreadsListHandle tlh(current_thread); 3718 JavaThread* java_thread = nullptr; 3719 oop thread_oop = nullptr; 3720 3721 jvmtiError err = get_threadOop_and_JavaThread(tlh.list(), thread, current_thread, &java_thread, &thread_oop); 3722 3723 if (thread_oop != nullptr && thread_oop->is_a(vmClasses::BaseVirtualThread_klass())) { 3724 // No support for virtual threads (yet). 3725 return JVMTI_ERROR_UNSUPPORTED_OPERATION; 3726 } 3727 if (err != JVMTI_ERROR_NONE) { 3728 return err; 3729 } 3730 NULL_CHECK(nanos_ptr, JVMTI_ERROR_NULL_POINTER); 3731 3732 *nanos_ptr = os::thread_cpu_time(java_thread); 3733 return JVMTI_ERROR_NONE; 3734 } /* end GetThreadCpuTime */ 3735 3736 3737 // info_ptr - pre-checked for null 3738 jvmtiError 3739 JvmtiEnv::GetTimerInfo(jvmtiTimerInfo* info_ptr) { 3740 os::javaTimeNanos_info(info_ptr); 3741 return JVMTI_ERROR_NONE; 3742 } /* end GetTimerInfo */ 3743 3744 3745 // nanos_ptr - pre-checked for null 3746 jvmtiError 3747 JvmtiEnv::GetTime(jlong* nanos_ptr) { 3748 *nanos_ptr = os::javaTimeNanos(); 3749 return JVMTI_ERROR_NONE; 3750 } /* end GetTime */ 3751 3752 3753 // processor_count_ptr - pre-checked for null 3754 jvmtiError 3755 JvmtiEnv::GetAvailableProcessors(jint* processor_count_ptr) { 3756 *processor_count_ptr = os::active_processor_count(); 3757 return JVMTI_ERROR_NONE; 3758 } /* end GetAvailableProcessors */ 3759 3760 jvmtiError 3761 JvmtiEnv::SetHeapSamplingInterval(jint sampling_interval) { 3762 if (sampling_interval < 0) { 3763 return JVMTI_ERROR_ILLEGAL_ARGUMENT; 3764 } 3765 ThreadHeapSampler::set_sampling_interval(sampling_interval); 3766 return JVMTI_ERROR_NONE; 3767 } /* end SetHeapSamplingInterval */ 3768 3769 // 3770 // System Properties functions 3771 // 3772 3773 // count_ptr - pre-checked for null 3774 // property_ptr - pre-checked for null 3775 jvmtiError 3776 JvmtiEnv::GetSystemProperties(jint* count_ptr, char*** property_ptr) { 3777 jvmtiError err = JVMTI_ERROR_NONE; 3778 3779 // Get the number of readable properties. 3780 *count_ptr = Arguments::PropertyList_readable_count(Arguments::system_properties()); 3781 3782 // Allocate memory to hold the exact number of readable properties. 3783 err = allocate(*count_ptr * sizeof(char *), (unsigned char **)property_ptr); 3784 if (err != JVMTI_ERROR_NONE) { 3785 return err; 3786 } 3787 int readable_count = 0; 3788 // Loop through the system properties until all the readable properties are found. 3789 for (SystemProperty* p = Arguments::system_properties(); p != nullptr && readable_count < *count_ptr; p = p->next()) { 3790 if (p->readable()) { 3791 const char *key = p->key(); 3792 char **tmp_value = *property_ptr+readable_count; 3793 readable_count++; 3794 err = allocate((strlen(key)+1) * sizeof(char), (unsigned char**)tmp_value); 3795 if (err == JVMTI_ERROR_NONE) { 3796 strcpy(*tmp_value, key); 3797 } else { 3798 // clean up previously allocated memory. 3799 for (int j = 0; j < readable_count; j++) { 3800 Deallocate((unsigned char*)*property_ptr+j); 3801 } 3802 Deallocate((unsigned char*)property_ptr); 3803 break; 3804 } 3805 } 3806 } 3807 assert(err != JVMTI_ERROR_NONE || readable_count == *count_ptr, "Bad readable property count"); 3808 return err; 3809 } /* end GetSystemProperties */ 3810 3811 3812 // property - pre-checked for null 3813 // value_ptr - pre-checked for null 3814 jvmtiError 3815 JvmtiEnv::GetSystemProperty(const char* property, char** value_ptr) { 3816 jvmtiError err = JVMTI_ERROR_NONE; 3817 const char *value; 3818 3819 // Return JVMTI_ERROR_NOT_AVAILABLE if property is not readable or doesn't exist. 3820 value = Arguments::PropertyList_get_readable_value(Arguments::system_properties(), property); 3821 if (value == nullptr) { 3822 err = JVMTI_ERROR_NOT_AVAILABLE; 3823 } else { 3824 err = allocate((strlen(value)+1) * sizeof(char), (unsigned char **)value_ptr); 3825 if (err == JVMTI_ERROR_NONE) { 3826 strcpy(*value_ptr, value); 3827 } 3828 } 3829 return err; 3830 } /* end GetSystemProperty */ 3831 3832 3833 // property - pre-checked for null 3834 // value - null is a valid value, must be checked 3835 jvmtiError 3836 JvmtiEnv::SetSystemProperty(const char* property, const char* value_ptr) { 3837 for (SystemProperty* p = Arguments::system_properties(); p != nullptr; p = p->next()) { 3838 if (strcmp(property, p->key()) == 0) { 3839 if (p->writeable()) { 3840 if (p->set_value(value_ptr, AllocFailStrategy::RETURN_NULL)) { 3841 return JVMTI_ERROR_NONE; 3842 } else { 3843 return JVMTI_ERROR_OUT_OF_MEMORY; 3844 } 3845 } else { 3846 // We found a property, but it's not writeable 3847 return JVMTI_ERROR_NOT_AVAILABLE; 3848 } 3849 } 3850 } 3851 3852 // We cannot find a property of the given name 3853 return JVMTI_ERROR_NOT_AVAILABLE; 3854 } /* end SetSystemProperty */