jvmtiEnv.cpp revision 2721:f08d439fab8c
1130803Smarcel/* 2130803Smarcel * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved. 3130803Smarcel * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4130803Smarcel * 5130803Smarcel * This code is free software; you can redistribute it and/or modify it 6130803Smarcel * under the terms of the GNU General Public License version 2 only, as 7130803Smarcel * published by the Free Software Foundation. 8130803Smarcel * 9130803Smarcel * This code is distributed in the hope that it will be useful, but WITHOUT 10130803Smarcel * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11130803Smarcel * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12130803Smarcel * version 2 for more details (a copy is included in the LICENSE file that 13130803Smarcel * accompanied this code). 14130803Smarcel * 15130803Smarcel * You should have received a copy of the GNU General Public License version 16130803Smarcel * 2 along with this work; if not, write to the Free Software Foundation, 17130803Smarcel * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18130803Smarcel * 19130803Smarcel * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20130803Smarcel * or visit www.oracle.com if you need additional information or have any 21130803Smarcel * questions. 22130803Smarcel * 23130803Smarcel */ 24130803Smarcel 25130803Smarcel#include "precompiled.hpp" 26130803Smarcel#include "classfile/systemDictionary.hpp" 27130803Smarcel#include "classfile/vmSymbols.hpp" 28130803Smarcel#include "interpreter/bytecodeStream.hpp" 29130803Smarcel#include "interpreter/interpreter.hpp" 30130803Smarcel#include "jvmtifiles/jvmtiEnv.hpp" 31130803Smarcel#include "memory/resourceArea.hpp" 32130803Smarcel#include "memory/universe.inline.hpp" 33130803Smarcel#include "oops/cpCacheOop.hpp" 34130803Smarcel#include "oops/instanceKlass.hpp" 35130803Smarcel#include "prims/jniCheck.hpp" 36130803Smarcel#include "prims/jvm_misc.hpp" 37130803Smarcel#include "prims/jvmtiAgentThread.hpp" 38130803Smarcel#include "prims/jvmtiClassFileReconstituter.hpp" 39130803Smarcel#include "prims/jvmtiCodeBlobEvents.hpp" 40130803Smarcel#include "prims/jvmtiExtensions.hpp" 41130803Smarcel#include "prims/jvmtiGetLoadedClasses.hpp" 42130803Smarcel#include "prims/jvmtiImpl.hpp" 43130803Smarcel#include "prims/jvmtiManageCapabilities.hpp" 44130803Smarcel#include "prims/jvmtiRawMonitor.hpp" 45130803Smarcel#include "prims/jvmtiRedefineClasses.hpp" 46130803Smarcel#include "prims/jvmtiTagMap.hpp" 47130803Smarcel#include "prims/jvmtiThreadState.inline.hpp" 48130803Smarcel#include "prims/jvmtiUtil.hpp" 49130803Smarcel#include "runtime/arguments.hpp" 50130803Smarcel#include "runtime/deoptimization.hpp" 51130803Smarcel#include "runtime/interfaceSupport.hpp" 52130803Smarcel#include "runtime/javaCalls.hpp" 53130803Smarcel#include "runtime/jfieldIDWorkaround.hpp" 54130803Smarcel#include "runtime/osThread.hpp" 55130803Smarcel#include "runtime/reflectionUtils.hpp" 56130803Smarcel#include "runtime/signature.hpp" 57130803Smarcel#include "runtime/vframe.hpp" 58130803Smarcel#include "runtime/vmThread.hpp" 59130803Smarcel#include "services/threadService.hpp" 60130803Smarcel#include "utilities/exceptions.hpp" 61130803Smarcel#include "utilities/preserveException.hpp" 62130803Smarcel#ifdef TARGET_OS_FAMILY_linux 63130803Smarcel# include "thread_linux.inline.hpp" 64130803Smarcel#endif 65130803Smarcel#ifdef TARGET_OS_FAMILY_solaris 66130803Smarcel# include "thread_solaris.inline.hpp" 67130803Smarcel#endif 68130803Smarcel#ifdef TARGET_OS_FAMILY_windows 69130803Smarcel# include "thread_windows.inline.hpp" 70130803Smarcel#endif 71130803Smarcel#ifdef TARGET_OS_FAMILY_bsd 72130803Smarcel# include "thread_bsd.inline.hpp" 73130803Smarcel#endif 74130803Smarcel 75130803Smarcel 76130803Smarcel 77130803Smarcel#define FIXLATER 0 // REMOVE this when completed. 78130803Smarcel 79130803Smarcel // FIXLATER: hook into JvmtiTrace 80130803Smarcel#define TraceJVMTICalls false 81130803Smarcel 82130803SmarcelJvmtiEnv::JvmtiEnv(jint version) : JvmtiEnvBase(version) { 83130803Smarcel} 84130803Smarcel 85130803SmarcelJvmtiEnv::~JvmtiEnv() { 86130803Smarcel} 87130803Smarcel 88130803SmarcelJvmtiEnv* 89130803SmarcelJvmtiEnv::create_a_jvmti(jint version) { 90130803Smarcel return new JvmtiEnv(version); 91130803Smarcel} 92130803Smarcel 93130803Smarcel// VM operation class to copy jni function table at safepoint. 94130803Smarcel// More than one java threads or jvmti agents may be reading/ 95130803Smarcel// modifying jni function tables. To reduce the risk of bad 96130803Smarcel// interaction b/w these threads it is copied at safepoint. 97130803Smarcelclass VM_JNIFunctionTableCopier : public VM_Operation { 98130803Smarcel private: 99130803Smarcel const struct JNINativeInterface_ *_function_table; 100130803Smarcel public: 101130803Smarcel VM_JNIFunctionTableCopier(const struct JNINativeInterface_ *func_tbl) { 102130803Smarcel _function_table = func_tbl; 103130803Smarcel }; 104130803Smarcel 105130803Smarcel VMOp_Type type() const { return VMOp_JNIFunctionTableCopier; } 106130803Smarcel void doit() { 107130803Smarcel copy_jni_function_table(_function_table); 108130803Smarcel }; 109130803Smarcel}; 110130803Smarcel 111130803Smarcel// 112130803Smarcel// Do not change the "prefix" marker below, everything above it is copied 113130803Smarcel// unchanged into the filled stub, everything below is controlled by the 114130803Smarcel// stub filler (only method bodies are carried forward, and then only for 115130803Smarcel// functionality still in the spec). 116130803Smarcel// 117130803Smarcel// end file prefix 118130803Smarcel 119130803Smarcel // 120130803Smarcel // Memory Management functions 121130803Smarcel // 122130803Smarcel 123130803Smarcel// mem_ptr - pre-checked for NULL 124130803SmarceljvmtiError 125130803SmarcelJvmtiEnv::Allocate(jlong size, unsigned char** mem_ptr) { 126130803Smarcel return allocate(size, mem_ptr); 127130803Smarcel} /* end Allocate */ 128130803Smarcel 129130803Smarcel 130130803Smarcel// mem - NULL is a valid value, must be checked 131130803SmarceljvmtiError 132130803SmarcelJvmtiEnv::Deallocate(unsigned char* mem) { 133130803Smarcel return deallocate(mem); 134130803Smarcel} /* end Deallocate */ 135130803Smarcel 136130803Smarcel// Threads_lock NOT held, java_thread not protected by lock 137130803Smarcel// java_thread - pre-checked 138130803Smarcel// data - NULL is a valid value, must be checked 139130803SmarceljvmtiError 140130803SmarcelJvmtiEnv::SetThreadLocalStorage(JavaThread* java_thread, const void* data) { 141130803Smarcel JvmtiThreadState* state = java_thread->jvmti_thread_state(); 142130803Smarcel if (state == NULL) { 143130803Smarcel if (data == NULL) { 144130803Smarcel // leaving state unset same as data set to NULL 145130803Smarcel return JVMTI_ERROR_NONE; 146130803Smarcel } 147130803Smarcel // otherwise, create the state 148130803Smarcel state = JvmtiThreadState::state_for(java_thread); 149130803Smarcel if (state == NULL) { 150130803Smarcel return JVMTI_ERROR_THREAD_NOT_ALIVE; 151130803Smarcel } 152130803Smarcel } 153130803Smarcel state->env_thread_state(this)->set_agent_thread_local_storage_data((void*)data); 154130803Smarcel return JVMTI_ERROR_NONE; 155130803Smarcel} /* end SetThreadLocalStorage */ 156130803Smarcel 157130803Smarcel 158130803Smarcel// Threads_lock NOT held 159130803Smarcel// thread - NOT pre-checked 160130803Smarcel// data_ptr - pre-checked for NULL 161130803SmarceljvmtiError 162130803SmarcelJvmtiEnv::GetThreadLocalStorage(jthread thread, void** data_ptr) { 163130803Smarcel JavaThread* current_thread = JavaThread::current(); 164130803Smarcel if (thread == NULL) { 165130803Smarcel JvmtiThreadState* state = current_thread->jvmti_thread_state(); 166130803Smarcel *data_ptr = (state == NULL) ? NULL : 167130803Smarcel state->env_thread_state(this)->get_agent_thread_local_storage_data(); 168130803Smarcel } else { 169130803Smarcel 170130803Smarcel // jvmti_GetThreadLocalStorage is "in native" and doesn't transition 171130803Smarcel // the thread to _thread_in_vm. However, when the TLS for a thread 172130803Smarcel // other than the current thread is required we need to transition 173130803Smarcel // from native so as to resolve the jthread. 174130803Smarcel 175130803Smarcel ThreadInVMfromNative __tiv(current_thread); 176130803Smarcel __ENTRY(jvmtiError, JvmtiEnv::GetThreadLocalStorage , current_thread) 177130803Smarcel debug_only(VMNativeEntryWrapper __vew;) 178130803Smarcel 179130803Smarcel oop thread_oop = JNIHandles::resolve_external_guard(thread); 180130803Smarcel if (thread_oop == NULL) { 181130803Smarcel return JVMTI_ERROR_INVALID_THREAD; 182130803Smarcel } 183130803Smarcel if (!thread_oop->is_a(SystemDictionary::Thread_klass())) { 184130803Smarcel return JVMTI_ERROR_INVALID_THREAD; 185130803Smarcel } 186130803Smarcel JavaThread* java_thread = java_lang_Thread::thread(thread_oop); 187130803Smarcel if (java_thread == NULL) { 188130803Smarcel return JVMTI_ERROR_THREAD_NOT_ALIVE; 189130803Smarcel } 190130803Smarcel JvmtiThreadState* state = java_thread->jvmti_thread_state(); 191130803Smarcel *data_ptr = (state == NULL) ? NULL : 192130803Smarcel state->env_thread_state(this)->get_agent_thread_local_storage_data(); 193130803Smarcel } 194130803Smarcel return JVMTI_ERROR_NONE; 195130803Smarcel} /* end GetThreadLocalStorage */ 196130803Smarcel 197130803Smarcel // 198130803Smarcel // Class functions 199130803Smarcel // 200130803Smarcel 201130803Smarcel// class_count_ptr - pre-checked for NULL 202130803Smarcel// classes_ptr - pre-checked for NULL 203130803SmarceljvmtiError 204130803SmarcelJvmtiEnv::GetLoadedClasses(jint* class_count_ptr, jclass** classes_ptr) { 205130803Smarcel return JvmtiGetLoadedClasses::getLoadedClasses(this, class_count_ptr, classes_ptr); 206130803Smarcel} /* end GetLoadedClasses */ 207130803Smarcel 208130803Smarcel 209130803Smarcel// initiating_loader - NULL is a valid value, must be checked 210130803Smarcel// class_count_ptr - pre-checked for NULL 211130803Smarcel// classes_ptr - pre-checked for NULL 212130803SmarceljvmtiError 213130803SmarcelJvmtiEnv::GetClassLoaderClasses(jobject initiating_loader, jint* class_count_ptr, jclass** classes_ptr) { 214130803Smarcel return JvmtiGetLoadedClasses::getClassLoaderClasses(this, initiating_loader, 215130803Smarcel class_count_ptr, classes_ptr); 216130803Smarcel} /* end GetClassLoaderClasses */ 217130803Smarcel 218130803Smarcel// k_mirror - may be primitive, this must be checked 219130803Smarcel// is_modifiable_class_ptr - pre-checked for NULL 220130803SmarceljvmtiError 221130803SmarcelJvmtiEnv::IsModifiableClass(oop k_mirror, jboolean* is_modifiable_class_ptr) { 222130803Smarcel *is_modifiable_class_ptr = VM_RedefineClasses::is_modifiable_class(k_mirror)? 223130803Smarcel JNI_TRUE : JNI_FALSE; 224130803Smarcel return JVMTI_ERROR_NONE; 225130803Smarcel} /* end IsModifiableClass */ 226130803Smarcel 227130803Smarcel// class_count - pre-checked to be greater than or equal to 0 228130803Smarcel// classes - pre-checked for NULL 229130803SmarceljvmtiError 230130803SmarcelJvmtiEnv::RetransformClasses(jint class_count, const jclass* classes) { 231130803Smarcel//TODO: add locking 232130803Smarcel 233130803Smarcel int index; 234130803Smarcel JavaThread* current_thread = JavaThread::current(); 235130803Smarcel ResourceMark rm(current_thread); 236130803Smarcel 237130803Smarcel jvmtiClassDefinition* class_definitions = 238130803Smarcel NEW_RESOURCE_ARRAY(jvmtiClassDefinition, class_count); 239130803Smarcel NULL_CHECK(class_definitions, JVMTI_ERROR_OUT_OF_MEMORY); 240130803Smarcel 241130803Smarcel for (index = 0; index < class_count; index++) { 242130803Smarcel HandleMark hm(current_thread); 243130803Smarcel 244130803Smarcel jclass jcls = classes[index]; 245130803Smarcel oop k_mirror = JNIHandles::resolve_external_guard(jcls); 246130803Smarcel if (k_mirror == NULL) { 247130803Smarcel return JVMTI_ERROR_INVALID_CLASS; 248130803Smarcel } 249130803Smarcel if (!k_mirror->is_a(SystemDictionary::Class_klass())) { 250130803Smarcel return JVMTI_ERROR_INVALID_CLASS; 251130803Smarcel } 252130803Smarcel 253130803Smarcel if (java_lang_Class::is_primitive(k_mirror)) { 254130803Smarcel return JVMTI_ERROR_UNMODIFIABLE_CLASS; 255130803Smarcel } 256130803Smarcel 257130803Smarcel klassOop k_oop = java_lang_Class::as_klassOop(k_mirror); 258130803Smarcel KlassHandle klass(current_thread, k_oop); 259130803Smarcel 260130803Smarcel jint status = klass->jvmti_class_status(); 261130803Smarcel if (status & (JVMTI_CLASS_STATUS_ERROR)) { 262130803Smarcel return JVMTI_ERROR_INVALID_CLASS; 263130803Smarcel } 264130803Smarcel if (status & (JVMTI_CLASS_STATUS_ARRAY)) { 265130803Smarcel return JVMTI_ERROR_UNMODIFIABLE_CLASS; 266130803Smarcel } 267130803Smarcel 268130803Smarcel instanceKlassHandle ikh(current_thread, k_oop); 269130803Smarcel if (ikh->get_cached_class_file_bytes() == NULL) { 270130803Smarcel // not cached, we need to reconstitute the class file from VM representation 271130803Smarcel constantPoolHandle constants(current_thread, ikh->constants()); 272130803Smarcel ObjectLocker ol(constants, current_thread); // lock constant pool while we query it 273130803Smarcel 274130803Smarcel JvmtiClassFileReconstituter reconstituter(ikh); 275130803Smarcel if (reconstituter.get_error() != JVMTI_ERROR_NONE) { 276130803Smarcel return reconstituter.get_error(); 277130803Smarcel } 278130803Smarcel 279130803Smarcel class_definitions[index].class_byte_count = (jint)reconstituter.class_file_size(); 280130803Smarcel class_definitions[index].class_bytes = (unsigned char*) 281130803Smarcel reconstituter.class_file_bytes(); 282130803Smarcel } else { 283130803Smarcel // it is cached, get it from the cache 284130803Smarcel class_definitions[index].class_byte_count = ikh->get_cached_class_file_len(); 285130803Smarcel class_definitions[index].class_bytes = ikh->get_cached_class_file_bytes(); 286130803Smarcel } 287130803Smarcel class_definitions[index].klass = jcls; 288130803Smarcel } 289130803Smarcel VM_RedefineClasses op(class_count, class_definitions, jvmti_class_load_kind_retransform); 290130803Smarcel VMThread::execute(&op); 291130803Smarcel return (op.check_error()); 292130803Smarcel} /* end RetransformClasses */ 293130803Smarcel 294130803Smarcel 295130803Smarcel// class_count - pre-checked to be greater than or equal to 0 296130803Smarcel// class_definitions - pre-checked for NULL 297130803SmarceljvmtiError 298130803SmarcelJvmtiEnv::RedefineClasses(jint class_count, const jvmtiClassDefinition* class_definitions) { 299130803Smarcel//TODO: add locking 300130803Smarcel VM_RedefineClasses op(class_count, class_definitions, jvmti_class_load_kind_redefine); 301130803Smarcel VMThread::execute(&op); 302130803Smarcel return (op.check_error()); 303130803Smarcel} /* end RedefineClasses */ 304130803Smarcel 305130803Smarcel 306130803Smarcel // 307130803Smarcel // Object functions 308130803Smarcel // 309130803Smarcel 310130803Smarcel// size_ptr - pre-checked for NULL 311130803SmarceljvmtiError 312130803SmarcelJvmtiEnv::GetObjectSize(jobject object, jlong* size_ptr) { 313130803Smarcel oop mirror = JNIHandles::resolve_external_guard(object); 314130803Smarcel NULL_CHECK(mirror, JVMTI_ERROR_INVALID_OBJECT); 315130803Smarcel 316130803Smarcel if (mirror->klass() == SystemDictionary::Class_klass()) { 317130803Smarcel if (!java_lang_Class::is_primitive(mirror)) { 318130803Smarcel mirror = java_lang_Class::as_klassOop(mirror); 319130803Smarcel assert(mirror != NULL, "class for non-primitive mirror must exist"); 320130803Smarcel } 321130803Smarcel } 322130803Smarcel 323130803Smarcel *size_ptr = mirror->size() * wordSize; 324130803Smarcel return JVMTI_ERROR_NONE; 325130803Smarcel} /* end GetObjectSize */ 326130803Smarcel 327130803Smarcel // 328130803Smarcel // Method functions 329130803Smarcel // 330130803Smarcel 331130803Smarcel// prefix - NULL is a valid value, must be checked 332130803SmarceljvmtiError 333130803SmarcelJvmtiEnv::SetNativeMethodPrefix(const char* prefix) { 334130803Smarcel return prefix == NULL? 335130803Smarcel SetNativeMethodPrefixes(0, NULL) : 336130803Smarcel SetNativeMethodPrefixes(1, (char**)&prefix); 337130803Smarcel} /* end SetNativeMethodPrefix */ 338130803Smarcel 339130803Smarcel 340130803Smarcel// prefix_count - pre-checked to be greater than or equal to 0 341130803Smarcel// prefixes - pre-checked for NULL 342130803SmarceljvmtiError 343130803SmarcelJvmtiEnv::SetNativeMethodPrefixes(jint prefix_count, char** prefixes) { 344130803Smarcel // Have to grab JVMTI thread state lock to be sure that some thread 345130803Smarcel // isn't accessing the prefixes at the same time we are setting them. 346130803Smarcel // No locks during VM bring-up. 347130803Smarcel if (Threads::number_of_threads() == 0) { 348130803Smarcel return set_native_method_prefixes(prefix_count, prefixes); 349130803Smarcel } else { 350130803Smarcel MutexLocker mu(JvmtiThreadState_lock); 351130803Smarcel return set_native_method_prefixes(prefix_count, prefixes); 352130803Smarcel } 353130803Smarcel} /* end SetNativeMethodPrefixes */ 354130803Smarcel 355130803Smarcel // 356130803Smarcel // Event Management functions 357130803Smarcel // 358130803Smarcel 359130803Smarcel// callbacks - NULL is a valid value, must be checked 360130803Smarcel// size_of_callbacks - pre-checked to be greater than or equal to 0 361130803SmarceljvmtiError 362130803SmarcelJvmtiEnv::SetEventCallbacks(const jvmtiEventCallbacks* callbacks, jint size_of_callbacks) { 363130803Smarcel JvmtiEventController::set_event_callbacks(this, callbacks, size_of_callbacks); 364130803Smarcel return JVMTI_ERROR_NONE; 365130803Smarcel} /* end SetEventCallbacks */ 366130803Smarcel 367130803Smarcel 368130803Smarcel// event_thread - NULL is a valid value, must be checked 369130803SmarceljvmtiError 370130803SmarcelJvmtiEnv::SetEventNotificationMode(jvmtiEventMode mode, jvmtiEvent event_type, jthread event_thread, ...) { 371130803Smarcel JavaThread* java_thread = NULL; 372130803Smarcel if (event_thread != NULL) { 373130803Smarcel oop thread_oop = JNIHandles::resolve_external_guard(event_thread); 374130803Smarcel if (thread_oop == NULL) { 375130803Smarcel return JVMTI_ERROR_INVALID_THREAD; 376130803Smarcel } 377130803Smarcel if (!thread_oop->is_a(SystemDictionary::Thread_klass())) { 378130803Smarcel return JVMTI_ERROR_INVALID_THREAD; 379130803Smarcel } 380130803Smarcel java_thread = java_lang_Thread::thread(thread_oop); 381130803Smarcel if (java_thread == NULL) { 382130803Smarcel return JVMTI_ERROR_THREAD_NOT_ALIVE; 383130803Smarcel } 384130803Smarcel } 385130803Smarcel 386130803Smarcel // event_type must be valid 387130803Smarcel if (!JvmtiEventController::is_valid_event_type(event_type)) { 388130803Smarcel return JVMTI_ERROR_INVALID_EVENT_TYPE; 389130803Smarcel } 390130803Smarcel 391130803Smarcel // global events cannot be controlled at thread level. 392130803Smarcel if (java_thread != NULL && JvmtiEventController::is_global_event(event_type)) { 393130803Smarcel return JVMTI_ERROR_ILLEGAL_ARGUMENT; 394130803Smarcel } 395130803Smarcel 396130803Smarcel bool enabled = (mode == JVMTI_ENABLE); 397130803Smarcel 398130803Smarcel // assure that needed capabilities are present 399130803Smarcel if (enabled && !JvmtiUtil::has_event_capability(event_type, get_capabilities())) { 400130803Smarcel return JVMTI_ERROR_MUST_POSSESS_CAPABILITY; 401130803Smarcel } 402130803Smarcel 403130803Smarcel if (event_type == JVMTI_EVENT_CLASS_FILE_LOAD_HOOK && enabled) { 404130803Smarcel record_class_file_load_hook_enabled(); 405130803Smarcel } 406130803Smarcel JvmtiEventController::set_user_enabled(this, java_thread, event_type, enabled); 407130803Smarcel 408130803Smarcel return JVMTI_ERROR_NONE; 409130803Smarcel} /* end SetEventNotificationMode */ 410130803Smarcel 411130803Smarcel // 412130803Smarcel // Capability functions 413130803Smarcel // 414130803Smarcel 415130803Smarcel// capabilities_ptr - pre-checked for NULL 416130803SmarceljvmtiError 417130803SmarcelJvmtiEnv::GetPotentialCapabilities(jvmtiCapabilities* capabilities_ptr) { 418130803Smarcel JvmtiManageCapabilities::get_potential_capabilities(get_capabilities(), 419130803Smarcel get_prohibited_capabilities(), 420130803Smarcel capabilities_ptr); 421130803Smarcel return JVMTI_ERROR_NONE; 422130803Smarcel} /* end GetPotentialCapabilities */ 423130803Smarcel 424130803Smarcel 425130803Smarcel// capabilities_ptr - pre-checked for NULL 426130803SmarceljvmtiError 427130803SmarcelJvmtiEnv::AddCapabilities(const jvmtiCapabilities* capabilities_ptr) { 428130803Smarcel return JvmtiManageCapabilities::add_capabilities(get_capabilities(), 429130803Smarcel get_prohibited_capabilities(), 430130803Smarcel capabilities_ptr, 431130803Smarcel get_capabilities()); 432130803Smarcel} /* end AddCapabilities */ 433130803Smarcel 434130803Smarcel 435130803Smarcel// capabilities_ptr - pre-checked for NULL 436130803SmarceljvmtiError 437130803SmarcelJvmtiEnv::RelinquishCapabilities(const jvmtiCapabilities* capabilities_ptr) { 438130803Smarcel JvmtiManageCapabilities::relinquish_capabilities(get_capabilities(), capabilities_ptr, get_capabilities()); 439130803Smarcel return JVMTI_ERROR_NONE; 440130803Smarcel} /* end RelinquishCapabilities */ 441130803Smarcel 442130803Smarcel 443130803Smarcel// capabilities_ptr - pre-checked for NULL 444130803SmarceljvmtiError 445130803SmarcelJvmtiEnv::GetCapabilities(jvmtiCapabilities* capabilities_ptr) { 446130803Smarcel JvmtiManageCapabilities::copy_capabilities(get_capabilities(), capabilities_ptr); 447130803Smarcel return JVMTI_ERROR_NONE; 448130803Smarcel} /* end GetCapabilities */ 449130803Smarcel 450130803Smarcel // 451130803Smarcel // Class Loader Search functions 452130803Smarcel // 453130803Smarcel 454130803Smarcel// segment - pre-checked for NULL 455130803SmarceljvmtiError 456130803SmarcelJvmtiEnv::AddToBootstrapClassLoaderSearch(const char* segment) { 457130803Smarcel jvmtiPhase phase = get_phase(); 458130803Smarcel if (phase == JVMTI_PHASE_ONLOAD) { 459130803Smarcel Arguments::append_sysclasspath(segment); 460130803Smarcel return JVMTI_ERROR_NONE; 461130803Smarcel } else if (use_version_1_0_semantics()) { 462130803Smarcel // This JvmtiEnv requested version 1.0 semantics and this function 463130803Smarcel // is only allowed in the ONLOAD phase in version 1.0 so we need to 464130803Smarcel // return an error here. 465130803Smarcel return JVMTI_ERROR_WRONG_PHASE; 466130803Smarcel } else if (phase == JVMTI_PHASE_LIVE) { 467130803Smarcel // The phase is checked by the wrapper that called this function, 468130803Smarcel // but this thread could be racing with the thread that is 469130803Smarcel // terminating the VM so we check one more time. 470130803Smarcel 471130803Smarcel // create the zip entry 472130803Smarcel ClassPathZipEntry* zip_entry = ClassLoader::create_class_path_zip_entry(segment); 473130803Smarcel if (zip_entry == NULL) { 474130803Smarcel return JVMTI_ERROR_ILLEGAL_ARGUMENT; 475130803Smarcel } 476130803Smarcel 477130803Smarcel // lock the loader 478130803Smarcel Thread* thread = Thread::current(); 479130803Smarcel HandleMark hm; 480130803Smarcel Handle loader_lock = Handle(thread, SystemDictionary::system_loader_lock()); 481130803Smarcel 482130803Smarcel ObjectLocker ol(loader_lock, thread); 483130803Smarcel 484130803Smarcel // add the jar file to the bootclasspath 485130803Smarcel if (TraceClassLoading) { 486130803Smarcel tty->print_cr("[Opened %s]", zip_entry->name()); 487130803Smarcel } 488130803Smarcel ClassLoader::add_to_list(zip_entry); 489130803Smarcel return JVMTI_ERROR_NONE; 490130803Smarcel } else { 491130803Smarcel return JVMTI_ERROR_WRONG_PHASE; 492130803Smarcel } 493130803Smarcel 494130803Smarcel} /* end AddToBootstrapClassLoaderSearch */ 495130803Smarcel 496130803Smarcel 497130803Smarcel// segment - pre-checked for NULL 498130803SmarceljvmtiError 499130803SmarcelJvmtiEnv::AddToSystemClassLoaderSearch(const char* segment) { 500130803Smarcel jvmtiPhase phase = get_phase(); 501130803Smarcel 502130803Smarcel if (phase == JVMTI_PHASE_ONLOAD) { 503130803Smarcel for (SystemProperty* p = Arguments::system_properties(); p != NULL; p = p->next()) { 504130803Smarcel if (strcmp("java.class.path", p->key()) == 0) { 505130803Smarcel p->append_value(segment); 506130803Smarcel break; 507130803Smarcel } 508130803Smarcel } 509130803Smarcel return JVMTI_ERROR_NONE; 510130803Smarcel } else if (phase == JVMTI_PHASE_LIVE) { 511130803Smarcel // The phase is checked by the wrapper that called this function, 512130803Smarcel // but this thread could be racing with the thread that is 513130803Smarcel // terminating the VM so we check one more time. 514130803Smarcel HandleMark hm; 515130803Smarcel 516130803Smarcel // create the zip entry (which will open the zip file and hence 517130803Smarcel // check that the segment is indeed a zip file). 518130803Smarcel ClassPathZipEntry* zip_entry = ClassLoader::create_class_path_zip_entry(segment); 519130803Smarcel if (zip_entry == NULL) { 520130803Smarcel return JVMTI_ERROR_ILLEGAL_ARGUMENT; 521130803Smarcel } 522130803Smarcel delete zip_entry; // no longer needed 523130803Smarcel 524130803Smarcel // lock the loader 525130803Smarcel Thread* THREAD = Thread::current(); 526130803Smarcel Handle loader = Handle(THREAD, SystemDictionary::java_system_loader()); 527130803Smarcel 528130803Smarcel ObjectLocker ol(loader, THREAD); 529130803Smarcel 530130803Smarcel // need the path as java.lang.String 531130803Smarcel Handle path = java_lang_String::create_from_platform_dependent_str(segment, THREAD); 532130803Smarcel if (HAS_PENDING_EXCEPTION) { 533130803Smarcel CLEAR_PENDING_EXCEPTION; 534130803Smarcel return JVMTI_ERROR_INTERNAL; 535130803Smarcel } 536130803Smarcel 537130803Smarcel instanceKlassHandle loader_ik(THREAD, loader->klass()); 538130803Smarcel 539130803Smarcel // Invoke the appendToClassPathForInstrumentation method - if the method 540130803Smarcel // is not found it means the loader doesn't support adding to the class path 541130803Smarcel // in the live phase. 542130803Smarcel { 543130803Smarcel JavaValue res(T_VOID); 544130803Smarcel JavaCalls::call_special(&res, 545130803Smarcel loader, 546130803Smarcel loader_ik, 547130803Smarcel vmSymbols::appendToClassPathForInstrumentation_name(), 548130803Smarcel vmSymbols::appendToClassPathForInstrumentation_signature(), 549130803Smarcel path, 550130803Smarcel THREAD); 551130803Smarcel if (HAS_PENDING_EXCEPTION) { 552130803Smarcel Symbol* ex_name = PENDING_EXCEPTION->klass()->klass_part()->name(); 553130803Smarcel CLEAR_PENDING_EXCEPTION; 554130803Smarcel 555130803Smarcel if (ex_name == vmSymbols::java_lang_NoSuchMethodError()) { 556130803Smarcel return JVMTI_ERROR_CLASS_LOADER_UNSUPPORTED; 557130803Smarcel } else { 558130803Smarcel return JVMTI_ERROR_INTERNAL; 559130803Smarcel } 560130803Smarcel } 561130803Smarcel } 562130803Smarcel 563130803Smarcel return JVMTI_ERROR_NONE; 564130803Smarcel } else { 565130803Smarcel return JVMTI_ERROR_WRONG_PHASE; 566130803Smarcel } 567130803Smarcel} /* end AddToSystemClassLoaderSearch */ 568130803Smarcel 569130803Smarcel // 570130803Smarcel // General functions 571130803Smarcel // 572130803Smarcel 573130803Smarcel// phase_ptr - pre-checked for NULL 574130803SmarceljvmtiError 575130803SmarcelJvmtiEnv::GetPhase(jvmtiPhase* phase_ptr) { 576130803Smarcel *phase_ptr = get_phase(); 577130803Smarcel return JVMTI_ERROR_NONE; 578130803Smarcel} /* end GetPhase */ 579130803Smarcel 580130803Smarcel 581130803SmarceljvmtiError 582130803SmarcelJvmtiEnv::DisposeEnvironment() { 583130803Smarcel dispose(); 584130803Smarcel return JVMTI_ERROR_NONE; 585130803Smarcel} /* end DisposeEnvironment */ 586130803Smarcel 587130803Smarcel 588130803Smarcel// data - NULL is a valid value, must be checked 589130803SmarceljvmtiError 590130803SmarcelJvmtiEnv::SetEnvironmentLocalStorage(const void* data) { 591130803Smarcel set_env_local_storage(data); 592130803Smarcel return JVMTI_ERROR_NONE; 593130803Smarcel} /* end SetEnvironmentLocalStorage */ 594130803Smarcel 595130803Smarcel 596130803Smarcel// data_ptr - pre-checked for NULL 597130803SmarceljvmtiError 598130803SmarcelJvmtiEnv::GetEnvironmentLocalStorage(void** data_ptr) { 599130803Smarcel *data_ptr = (void*)get_env_local_storage(); 600130803Smarcel return JVMTI_ERROR_NONE; 601130803Smarcel} /* end GetEnvironmentLocalStorage */ 602130803Smarcel 603130803Smarcel// version_ptr - pre-checked for NULL 604130803SmarceljvmtiError 605130803SmarcelJvmtiEnv::GetVersionNumber(jint* version_ptr) { 606130803Smarcel *version_ptr = JVMTI_VERSION; 607130803Smarcel return JVMTI_ERROR_NONE; 608130803Smarcel} /* end GetVersionNumber */ 609130803Smarcel 610130803Smarcel 611130803Smarcel// name_ptr - pre-checked for NULL 612130803SmarceljvmtiError 613130803SmarcelJvmtiEnv::GetErrorName(jvmtiError error, char** name_ptr) { 614130803Smarcel if (error < JVMTI_ERROR_NONE || error > JVMTI_ERROR_MAX) { 615130803Smarcel return JVMTI_ERROR_ILLEGAL_ARGUMENT; 616130803Smarcel } 617130803Smarcel const char *name = JvmtiUtil::error_name(error); 618130803Smarcel if (name == NULL) { 619130803Smarcel return JVMTI_ERROR_ILLEGAL_ARGUMENT; 620130803Smarcel } 621130803Smarcel size_t len = strlen(name) + 1; 622130803Smarcel jvmtiError err = allocate(len, (unsigned char**)name_ptr); 623130803Smarcel if (err == JVMTI_ERROR_NONE) { 624130803Smarcel memcpy(*name_ptr, name, len); 625130803Smarcel } 626130803Smarcel return err; 627130803Smarcel} /* end GetErrorName */ 628130803Smarcel 629130803Smarcel 630130803SmarceljvmtiError 631130803SmarcelJvmtiEnv::SetVerboseFlag(jvmtiVerboseFlag flag, jboolean value) { 632130803Smarcel switch (flag) { 633130803Smarcel case JVMTI_VERBOSE_OTHER: 634130803Smarcel // ignore 635130803Smarcel break; 636130803Smarcel case JVMTI_VERBOSE_CLASS: 637130803Smarcel TraceClassLoading = value != 0; 638130803Smarcel TraceClassUnloading = value != 0; 639130803Smarcel break; 640130803Smarcel case JVMTI_VERBOSE_GC: 641130803Smarcel PrintGC = value != 0; 642130803Smarcel break; 643130803Smarcel case JVMTI_VERBOSE_JNI: 644130803Smarcel PrintJNIResolving = value != 0; 645130803Smarcel break; 646130803Smarcel default: 647130803Smarcel return JVMTI_ERROR_ILLEGAL_ARGUMENT; 648130803Smarcel }; 649130803Smarcel return JVMTI_ERROR_NONE; 650130803Smarcel} /* end SetVerboseFlag */ 651130803Smarcel 652130803Smarcel 653130803Smarcel// format_ptr - pre-checked for NULL 654130803SmarceljvmtiError 655130803SmarcelJvmtiEnv::GetJLocationFormat(jvmtiJlocationFormat* format_ptr) { 656130803Smarcel *format_ptr = JVMTI_JLOCATION_JVMBCI; 657130803Smarcel return JVMTI_ERROR_NONE; 658130803Smarcel} /* end GetJLocationFormat */ 659130803Smarcel 660130803Smarcel#ifndef JVMTI_KERNEL 661130803Smarcel 662130803Smarcel // 663130803Smarcel // Thread functions 664130803Smarcel // 665130803Smarcel 666130803Smarcel// Threads_lock NOT held 667130803Smarcel// thread - NOT pre-checked 668130803Smarcel// thread_state_ptr - pre-checked for NULL 669130803SmarceljvmtiError 670130803SmarcelJvmtiEnv::GetThreadState(jthread thread, jint* thread_state_ptr) { 671130803Smarcel jint state; 672130803Smarcel oop thread_oop; 673130803Smarcel JavaThread* thr; 674130803Smarcel 675130803Smarcel if (thread == NULL) { 676130803Smarcel thread_oop = JavaThread::current()->threadObj(); 677130803Smarcel } else { 678130803Smarcel thread_oop = JNIHandles::resolve_external_guard(thread); 679130803Smarcel } 680130803Smarcel 681130803Smarcel if (thread_oop == NULL || !thread_oop->is_a(SystemDictionary::Thread_klass())) { 682130803Smarcel return JVMTI_ERROR_INVALID_THREAD; 683130803Smarcel } 684130803Smarcel 685130803Smarcel // get most state bits 686130803Smarcel state = (jint)java_lang_Thread::get_thread_status(thread_oop); 687130803Smarcel 688130803Smarcel // add more state bits 689130803Smarcel thr = java_lang_Thread::thread(thread_oop); 690130803Smarcel if (thr != NULL) { 691130803Smarcel JavaThreadState jts = thr->thread_state(); 692130803Smarcel 693130803Smarcel if (thr->is_being_ext_suspended()) { 694130803Smarcel state |= JVMTI_THREAD_STATE_SUSPENDED; 695130803Smarcel } 696130803Smarcel if (jts == _thread_in_native) { 697130803Smarcel state |= JVMTI_THREAD_STATE_IN_NATIVE; 698130803Smarcel } 699130803Smarcel OSThread* osThread = thr->osthread(); 700130803Smarcel if (osThread != NULL && osThread->interrupted()) { 701130803Smarcel state |= JVMTI_THREAD_STATE_INTERRUPTED; 702130803Smarcel } 703130803Smarcel } 704130803Smarcel 705130803Smarcel *thread_state_ptr = state; 706130803Smarcel return JVMTI_ERROR_NONE; 707130803Smarcel} /* end GetThreadState */ 708130803Smarcel 709130803Smarcel 710130803Smarcel// thread_ptr - pre-checked for NULL 711130803SmarceljvmtiError 712130803SmarcelJvmtiEnv::GetCurrentThread(jthread* thread_ptr) { 713130803Smarcel JavaThread* current_thread = JavaThread::current(); 714130803Smarcel *thread_ptr = (jthread)JNIHandles::make_local(current_thread, current_thread->threadObj()); 715130803Smarcel return JVMTI_ERROR_NONE; 716130803Smarcel} /* end GetCurrentThread */ 717130803Smarcel 718130803Smarcel 719130803Smarcel// threads_count_ptr - pre-checked for NULL 720130803Smarcel// threads_ptr - pre-checked for NULL 721130803SmarceljvmtiError 722130803SmarcelJvmtiEnv::GetAllThreads(jint* threads_count_ptr, jthread** threads_ptr) { 723130803Smarcel int nthreads = 0; 724130803Smarcel Handle *thread_objs = NULL; 725130803Smarcel ResourceMark rm; 726130803Smarcel HandleMark hm; 727130803Smarcel 728130803Smarcel // enumerate threads (including agent threads) 729130803Smarcel ThreadsListEnumerator tle(Thread::current(), true); 730130803Smarcel nthreads = tle.num_threads(); 731130803Smarcel *threads_count_ptr = nthreads; 732130803Smarcel 733130803Smarcel if (nthreads == 0) { 734130803Smarcel *threads_ptr = NULL; 735130803Smarcel return JVMTI_ERROR_NONE; 736130803Smarcel } 737130803Smarcel 738130803Smarcel thread_objs = NEW_RESOURCE_ARRAY(Handle, nthreads); 739130803Smarcel NULL_CHECK(thread_objs, JVMTI_ERROR_OUT_OF_MEMORY); 740130803Smarcel 741130803Smarcel for (int i=0; i < nthreads; i++) { 742130803Smarcel thread_objs[i] = Handle(tle.get_threadObj(i)); 743130803Smarcel } 744130803Smarcel 745130803Smarcel // have to make global handles outside of Threads_lock 746130803Smarcel jthread *jthreads = new_jthreadArray(nthreads, thread_objs); 747130803Smarcel NULL_CHECK(jthreads, JVMTI_ERROR_OUT_OF_MEMORY); 748130803Smarcel 749130803Smarcel *threads_ptr = jthreads; 750130803Smarcel return JVMTI_ERROR_NONE; 751130803Smarcel} /* end GetAllThreads */ 752130803Smarcel 753130803Smarcel 754130803Smarcel// Threads_lock NOT held, java_thread not protected by lock 755130803Smarcel// java_thread - pre-checked 756130803SmarceljvmtiError 757130803SmarcelJvmtiEnv::SuspendThread(JavaThread* java_thread) { 758130803Smarcel // don't allow hidden thread suspend request. 759130803Smarcel if (java_thread->is_hidden_from_external_view()) { 760130803Smarcel return (JVMTI_ERROR_NONE); 761130803Smarcel } 762130803Smarcel 763130803Smarcel { 764130803Smarcel MutexLockerEx ml(java_thread->SR_lock(), Mutex::_no_safepoint_check_flag); 765130803Smarcel if (java_thread->is_external_suspend()) { 766130803Smarcel // don't allow nested external suspend requests. 767130803Smarcel return (JVMTI_ERROR_THREAD_SUSPENDED); 768130803Smarcel } 769130803Smarcel if (java_thread->is_exiting()) { // thread is in the process of exiting 770130803Smarcel return (JVMTI_ERROR_THREAD_NOT_ALIVE); 771130803Smarcel } 772130803Smarcel java_thread->set_external_suspend(); 773130803Smarcel } 774130803Smarcel 775130803Smarcel if (!JvmtiSuspendControl::suspend(java_thread)) { 776130803Smarcel // the thread was in the process of exiting 777130803Smarcel return (JVMTI_ERROR_THREAD_NOT_ALIVE); 778130803Smarcel } 779130803Smarcel return JVMTI_ERROR_NONE; 780130803Smarcel} /* end SuspendThread */ 781130803Smarcel 782130803Smarcel 783130803Smarcel// request_count - pre-checked to be greater than or equal to 0 784130803Smarcel// request_list - pre-checked for NULL 785130803Smarcel// results - pre-checked for NULL 786130803SmarceljvmtiError 787130803SmarcelJvmtiEnv::SuspendThreadList(jint request_count, const jthread* request_list, jvmtiError* results) { 788130803Smarcel int needSafepoint = 0; // > 0 if we need a safepoint 789130803Smarcel for (int i = 0; i < request_count; i++) { 790130803Smarcel JavaThread *java_thread = get_JavaThread(request_list[i]); 791130803Smarcel if (java_thread == NULL) { 792130803Smarcel results[i] = JVMTI_ERROR_INVALID_THREAD; 793130803Smarcel continue; 794130803Smarcel } 795130803Smarcel // the thread has not yet run or has exited (not on threads list) 796130803Smarcel if (java_thread->threadObj() == NULL) { 797130803Smarcel results[i] = JVMTI_ERROR_THREAD_NOT_ALIVE; 798130803Smarcel continue; 799130803Smarcel } 800130803Smarcel if (java_lang_Thread::thread(java_thread->threadObj()) == NULL) { 801130803Smarcel results[i] = JVMTI_ERROR_THREAD_NOT_ALIVE; 802130803Smarcel continue; 803130803Smarcel } 804130803Smarcel // don't allow hidden thread suspend request. 805130803Smarcel if (java_thread->is_hidden_from_external_view()) { 806130803Smarcel results[i] = JVMTI_ERROR_NONE; // indicate successful suspend 807130803Smarcel continue; 808130803Smarcel } 809130803Smarcel 810130803Smarcel { 811130803Smarcel MutexLockerEx ml(java_thread->SR_lock(), Mutex::_no_safepoint_check_flag); 812130803Smarcel if (java_thread->is_external_suspend()) { 813130803Smarcel // don't allow nested external suspend requests. 814130803Smarcel results[i] = JVMTI_ERROR_THREAD_SUSPENDED; 815130803Smarcel continue; 816130803Smarcel } 817130803Smarcel if (java_thread->is_exiting()) { // thread is in the process of exiting 818130803Smarcel results[i] = JVMTI_ERROR_THREAD_NOT_ALIVE; 819130803Smarcel continue; 820130803Smarcel } 821130803Smarcel java_thread->set_external_suspend(); 822130803Smarcel } 823130803Smarcel if (java_thread->thread_state() == _thread_in_native) { 824130803Smarcel // We need to try and suspend native threads here. Threads in 825130803Smarcel // other states will self-suspend on their next transition. 826130803Smarcel if (!JvmtiSuspendControl::suspend(java_thread)) { 827130803Smarcel // The thread was in the process of exiting. Force another 828130803Smarcel // safepoint to make sure that this thread transitions. 829130803Smarcel needSafepoint++; 830130803Smarcel results[i] = JVMTI_ERROR_THREAD_NOT_ALIVE; 831130803Smarcel continue; 832130803Smarcel } 833130803Smarcel } else { 834130803Smarcel needSafepoint++; 835130803Smarcel } 836130803Smarcel results[i] = JVMTI_ERROR_NONE; // indicate successful suspend 837130803Smarcel } 838130803Smarcel if (needSafepoint > 0) { 839130803Smarcel VM_ForceSafepoint vfs; 840130803Smarcel VMThread::execute(&vfs); 841130803Smarcel } 842130803Smarcel // per-thread suspend results returned via results parameter 843130803Smarcel return JVMTI_ERROR_NONE; 844130803Smarcel} /* end SuspendThreadList */ 845130803Smarcel 846130803Smarcel 847130803Smarcel// Threads_lock NOT held, java_thread not protected by lock 848130803Smarcel// java_thread - pre-checked 849130803SmarceljvmtiError 850130803SmarcelJvmtiEnv::ResumeThread(JavaThread* java_thread) { 851130803Smarcel // don't allow hidden thread resume request. 852130803Smarcel if (java_thread->is_hidden_from_external_view()) { 853130803Smarcel return JVMTI_ERROR_NONE; 854130803Smarcel } 855130803Smarcel 856130803Smarcel if (!java_thread->is_being_ext_suspended()) { 857130803Smarcel return JVMTI_ERROR_THREAD_NOT_SUSPENDED; 858130803Smarcel } 859130803Smarcel 860130803Smarcel if (!JvmtiSuspendControl::resume(java_thread)) { 861130803Smarcel return JVMTI_ERROR_INTERNAL; 862130803Smarcel } 863130803Smarcel return JVMTI_ERROR_NONE; 864130803Smarcel} /* end ResumeThread */ 865130803Smarcel 866130803Smarcel 867130803Smarcel// request_count - pre-checked to be greater than or equal to 0 868130803Smarcel// request_list - pre-checked for NULL 869130803Smarcel// results - pre-checked for NULL 870130803SmarceljvmtiError 871130803SmarcelJvmtiEnv::ResumeThreadList(jint request_count, const jthread* request_list, jvmtiError* results) { 872130803Smarcel for (int i = 0; i < request_count; i++) { 873130803Smarcel JavaThread *java_thread = get_JavaThread(request_list[i]); 874130803Smarcel if (java_thread == NULL) { 875130803Smarcel results[i] = JVMTI_ERROR_INVALID_THREAD; 876130803Smarcel continue; 877130803Smarcel } 878130803Smarcel // don't allow hidden thread resume request. 879130803Smarcel if (java_thread->is_hidden_from_external_view()) { 880130803Smarcel results[i] = JVMTI_ERROR_NONE; // indicate successful resume 881130803Smarcel continue; 882130803Smarcel } 883130803Smarcel if (!java_thread->is_being_ext_suspended()) { 884130803Smarcel results[i] = JVMTI_ERROR_THREAD_NOT_SUSPENDED; 885130803Smarcel continue; 886130803Smarcel } 887130803Smarcel 888130803Smarcel if (!JvmtiSuspendControl::resume(java_thread)) { 889130803Smarcel results[i] = JVMTI_ERROR_INTERNAL; 890130803Smarcel continue; 891130803Smarcel } 892130803Smarcel 893130803Smarcel results[i] = JVMTI_ERROR_NONE; // indicate successful suspend 894130803Smarcel } 895130803Smarcel // per-thread resume results returned via results parameter 896130803Smarcel return JVMTI_ERROR_NONE; 897130803Smarcel} /* end ResumeThreadList */ 898130803Smarcel 899130803Smarcel 900130803Smarcel// Threads_lock NOT held, java_thread not protected by lock 901130803Smarcel// java_thread - pre-checked 902130803SmarceljvmtiError 903130803SmarcelJvmtiEnv::StopThread(JavaThread* java_thread, jobject exception) { 904130803Smarcel oop e = JNIHandles::resolve_external_guard(exception); 905130803Smarcel NULL_CHECK(e, JVMTI_ERROR_NULL_POINTER); 906130803Smarcel 907130803Smarcel JavaThread::send_async_exception(java_thread->threadObj(), e); 908130803Smarcel 909130803Smarcel return JVMTI_ERROR_NONE; 910130803Smarcel 911130803Smarcel} /* end StopThread */ 912130803Smarcel 913130803Smarcel 914130803Smarcel// Threads_lock NOT held 915130803Smarcel// thread - NOT pre-checked 916130803SmarceljvmtiError 917130803SmarcelJvmtiEnv::InterruptThread(jthread thread) { 918130803Smarcel oop thread_oop = JNIHandles::resolve_external_guard(thread); 919130803Smarcel if (thread_oop == NULL || !thread_oop->is_a(SystemDictionary::Thread_klass())) 920130803Smarcel return JVMTI_ERROR_INVALID_THREAD; 921130803Smarcel 922130803Smarcel JavaThread* current_thread = JavaThread::current(); 923130803Smarcel 924130803Smarcel // Todo: this is a duplicate of JVM_Interrupt; share code in future 925 // Ensure that the C++ Thread and OSThread structures aren't freed before we operate 926 MutexLockerEx ml(current_thread->threadObj() == thread_oop ? NULL : Threads_lock); 927 // We need to re-resolve the java_thread, since a GC might have happened during the 928 // acquire of the lock 929 930 JavaThread* java_thread = java_lang_Thread::thread(JNIHandles::resolve_external_guard(thread)); 931 NULL_CHECK(java_thread, JVMTI_ERROR_THREAD_NOT_ALIVE); 932 933 Thread::interrupt(java_thread); 934 935 return JVMTI_ERROR_NONE; 936} /* end InterruptThread */ 937 938 939// Threads_lock NOT held 940// thread - NOT pre-checked 941// info_ptr - pre-checked for NULL 942jvmtiError 943JvmtiEnv::GetThreadInfo(jthread thread, jvmtiThreadInfo* info_ptr) { 944 ResourceMark rm; 945 HandleMark hm; 946 947 JavaThread* current_thread = JavaThread::current(); 948 949 // if thread is NULL the current thread is used 950 oop thread_oop; 951 if (thread == NULL) { 952 thread_oop = current_thread->threadObj(); 953 } else { 954 thread_oop = JNIHandles::resolve_external_guard(thread); 955 } 956 if (thread_oop == NULL || !thread_oop->is_a(SystemDictionary::Thread_klass())) 957 return JVMTI_ERROR_INVALID_THREAD; 958 959 Handle thread_obj(current_thread, thread_oop); 960 typeArrayHandle name; 961 ThreadPriority priority; 962 Handle thread_group; 963 Handle context_class_loader; 964 bool is_daemon; 965 966 { MutexLocker mu(Threads_lock); 967 968 name = typeArrayHandle(current_thread, java_lang_Thread::name(thread_obj())); 969 priority = java_lang_Thread::priority(thread_obj()); 970 thread_group = Handle(current_thread, java_lang_Thread::threadGroup(thread_obj())); 971 is_daemon = java_lang_Thread::is_daemon(thread_obj()); 972 973 oop loader = java_lang_Thread::context_class_loader(thread_obj()); 974 context_class_loader = Handle(current_thread, loader); 975 } 976 { const char *n; 977 978 if (name() != NULL) { 979 n = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length()); 980 } else { 981 n = UNICODE::as_utf8(NULL, 0); 982 } 983 984 info_ptr->name = (char *) jvmtiMalloc(strlen(n)+1); 985 if (info_ptr->name == NULL) 986 return JVMTI_ERROR_OUT_OF_MEMORY; 987 988 strcpy(info_ptr->name, n); 989 } 990 info_ptr->is_daemon = is_daemon; 991 info_ptr->priority = priority; 992 993 info_ptr->context_class_loader = (context_class_loader.is_null()) ? NULL : 994 jni_reference(context_class_loader); 995 info_ptr->thread_group = jni_reference(thread_group); 996 997 return JVMTI_ERROR_NONE; 998} /* end GetThreadInfo */ 999 1000 1001// Threads_lock NOT held, java_thread not protected by lock 1002// java_thread - pre-checked 1003// owned_monitor_count_ptr - pre-checked for NULL 1004// owned_monitors_ptr - pre-checked for NULL 1005jvmtiError 1006JvmtiEnv::GetOwnedMonitorInfo(JavaThread* java_thread, jint* owned_monitor_count_ptr, jobject** owned_monitors_ptr) { 1007 jvmtiError err = JVMTI_ERROR_NONE; 1008 JavaThread* calling_thread = JavaThread::current(); 1009 1010 // growable array of jvmti monitors info on the C-heap 1011 GrowableArray<jvmtiMonitorStackDepthInfo*> *owned_monitors_list = 1012 new (ResourceObj::C_HEAP) GrowableArray<jvmtiMonitorStackDepthInfo*>(1, true); 1013 1014 uint32_t debug_bits = 0; 1015 if (is_thread_fully_suspended(java_thread, true, &debug_bits)) { 1016 err = get_owned_monitors(calling_thread, java_thread, owned_monitors_list); 1017 } else { 1018 // JVMTI get monitors info at safepoint. Do not require target thread to 1019 // be suspended. 1020 VM_GetOwnedMonitorInfo op(this, calling_thread, java_thread, owned_monitors_list); 1021 VMThread::execute(&op); 1022 err = op.result(); 1023 } 1024 jint owned_monitor_count = owned_monitors_list->length(); 1025 if (err == JVMTI_ERROR_NONE) { 1026 if ((err = allocate(owned_monitor_count * sizeof(jobject *), 1027 (unsigned char**)owned_monitors_ptr)) == JVMTI_ERROR_NONE) { 1028 // copy into the returned array 1029 for (int i = 0; i < owned_monitor_count; i++) { 1030 (*owned_monitors_ptr)[i] = 1031 ((jvmtiMonitorStackDepthInfo*)owned_monitors_list->at(i))->monitor; 1032 } 1033 *owned_monitor_count_ptr = owned_monitor_count; 1034 } 1035 } 1036 // clean up. 1037 for (int i = 0; i < owned_monitor_count; i++) { 1038 deallocate((unsigned char*)owned_monitors_list->at(i)); 1039 } 1040 delete owned_monitors_list; 1041 1042 return err; 1043} /* end GetOwnedMonitorInfo */ 1044 1045 1046// Threads_lock NOT held, java_thread not protected by lock 1047// java_thread - pre-checked 1048// monitor_info_count_ptr - pre-checked for NULL 1049// monitor_info_ptr - pre-checked for NULL 1050jvmtiError 1051JvmtiEnv::GetOwnedMonitorStackDepthInfo(JavaThread* java_thread, jint* monitor_info_count_ptr, jvmtiMonitorStackDepthInfo** monitor_info_ptr) { 1052 jvmtiError err = JVMTI_ERROR_NONE; 1053 JavaThread* calling_thread = JavaThread::current(); 1054 1055 // growable array of jvmti monitors info on the C-heap 1056 GrowableArray<jvmtiMonitorStackDepthInfo*> *owned_monitors_list = 1057 new (ResourceObj::C_HEAP) GrowableArray<jvmtiMonitorStackDepthInfo*>(1, true); 1058 1059 uint32_t debug_bits = 0; 1060 if (is_thread_fully_suspended(java_thread, true, &debug_bits)) { 1061 err = get_owned_monitors(calling_thread, java_thread, owned_monitors_list); 1062 } else { 1063 // JVMTI get owned monitors info at safepoint. Do not require target thread to 1064 // be suspended. 1065 VM_GetOwnedMonitorInfo op(this, calling_thread, java_thread, owned_monitors_list); 1066 VMThread::execute(&op); 1067 err = op.result(); 1068 } 1069 1070 jint owned_monitor_count = owned_monitors_list->length(); 1071 if (err == JVMTI_ERROR_NONE) { 1072 if ((err = allocate(owned_monitor_count * sizeof(jvmtiMonitorStackDepthInfo), 1073 (unsigned char**)monitor_info_ptr)) == JVMTI_ERROR_NONE) { 1074 // copy to output array. 1075 for (int i = 0; i < owned_monitor_count; i++) { 1076 (*monitor_info_ptr)[i].monitor = 1077 ((jvmtiMonitorStackDepthInfo*)owned_monitors_list->at(i))->monitor; 1078 (*monitor_info_ptr)[i].stack_depth = 1079 ((jvmtiMonitorStackDepthInfo*)owned_monitors_list->at(i))->stack_depth; 1080 } 1081 } 1082 *monitor_info_count_ptr = owned_monitor_count; 1083 } 1084 1085 // clean up. 1086 for (int i = 0; i < owned_monitor_count; i++) { 1087 deallocate((unsigned char*)owned_monitors_list->at(i)); 1088 } 1089 delete owned_monitors_list; 1090 1091 return err; 1092} /* end GetOwnedMonitorStackDepthInfo */ 1093 1094 1095// Threads_lock NOT held, java_thread not protected by lock 1096// java_thread - pre-checked 1097// monitor_ptr - pre-checked for NULL 1098jvmtiError 1099JvmtiEnv::GetCurrentContendedMonitor(JavaThread* java_thread, jobject* monitor_ptr) { 1100 jvmtiError err = JVMTI_ERROR_NONE; 1101 uint32_t debug_bits = 0; 1102 JavaThread* calling_thread = JavaThread::current(); 1103 if (is_thread_fully_suspended(java_thread, true, &debug_bits)) { 1104 err = get_current_contended_monitor(calling_thread, java_thread, monitor_ptr); 1105 } else { 1106 // get contended monitor information at safepoint. 1107 VM_GetCurrentContendedMonitor op(this, calling_thread, java_thread, monitor_ptr); 1108 VMThread::execute(&op); 1109 err = op.result(); 1110 } 1111 return err; 1112} /* end GetCurrentContendedMonitor */ 1113 1114 1115// Threads_lock NOT held 1116// thread - NOT pre-checked 1117// proc - pre-checked for NULL 1118// arg - NULL is a valid value, must be checked 1119jvmtiError 1120JvmtiEnv::RunAgentThread(jthread thread, jvmtiStartFunction proc, const void* arg, jint priority) { 1121 oop thread_oop = JNIHandles::resolve_external_guard(thread); 1122 if (thread_oop == NULL || !thread_oop->is_a(SystemDictionary::Thread_klass())) { 1123 return JVMTI_ERROR_INVALID_THREAD; 1124 } 1125 if (priority < JVMTI_THREAD_MIN_PRIORITY || priority > JVMTI_THREAD_MAX_PRIORITY) { 1126 return JVMTI_ERROR_INVALID_PRIORITY; 1127 } 1128 1129 //Thread-self 1130 JavaThread* current_thread = JavaThread::current(); 1131 1132 Handle thread_hndl(current_thread, thread_oop); 1133 { 1134 MutexLocker mu(Threads_lock); // grab Threads_lock 1135 1136 JvmtiAgentThread *new_thread = new JvmtiAgentThread(this, proc, arg); 1137 1138 // At this point it may be possible that no osthread was created for the 1139 // JavaThread due to lack of memory. 1140 if (new_thread == NULL || new_thread->osthread() == NULL) { 1141 if (new_thread) delete new_thread; 1142 return JVMTI_ERROR_OUT_OF_MEMORY; 1143 } 1144 1145 java_lang_Thread::set_thread(thread_hndl(), new_thread); 1146 java_lang_Thread::set_priority(thread_hndl(), (ThreadPriority)priority); 1147 java_lang_Thread::set_daemon(thread_hndl()); 1148 1149 new_thread->set_threadObj(thread_hndl()); 1150 Threads::add(new_thread); 1151 Thread::start(new_thread); 1152 } // unlock Threads_lock 1153 1154 return JVMTI_ERROR_NONE; 1155} /* end RunAgentThread */ 1156 1157 // 1158 // Thread Group functions 1159 // 1160 1161// group_count_ptr - pre-checked for NULL 1162// groups_ptr - pre-checked for NULL 1163jvmtiError 1164JvmtiEnv::GetTopThreadGroups(jint* group_count_ptr, jthreadGroup** groups_ptr) { 1165 JavaThread* current_thread = JavaThread::current(); 1166 1167 // Only one top level thread group now. 1168 *group_count_ptr = 1; 1169 1170 // Allocate memory to store global-refs to the thread groups. 1171 // Assume this area is freed by caller. 1172 *groups_ptr = (jthreadGroup *) jvmtiMalloc((sizeof(jthreadGroup)) * (*group_count_ptr)); 1173 1174 NULL_CHECK(*groups_ptr, JVMTI_ERROR_OUT_OF_MEMORY); 1175 1176 // Convert oop to Handle, then convert Handle to global-ref. 1177 { 1178 HandleMark hm(current_thread); 1179 Handle system_thread_group(current_thread, Universe::system_thread_group()); 1180 *groups_ptr[0] = jni_reference(system_thread_group); 1181 } 1182 1183 return JVMTI_ERROR_NONE; 1184} /* end GetTopThreadGroups */ 1185 1186 1187// info_ptr - pre-checked for NULL 1188jvmtiError 1189JvmtiEnv::GetThreadGroupInfo(jthreadGroup group, jvmtiThreadGroupInfo* info_ptr) { 1190 ResourceMark rm; 1191 HandleMark hm; 1192 1193 JavaThread* current_thread = JavaThread::current(); 1194 1195 Handle group_obj (current_thread, JNIHandles::resolve_external_guard(group)); 1196 NULL_CHECK(group_obj(), JVMTI_ERROR_INVALID_THREAD_GROUP); 1197 1198 typeArrayHandle name; 1199 Handle parent_group; 1200 bool is_daemon; 1201 ThreadPriority max_priority; 1202 1203 { MutexLocker mu(Threads_lock); 1204 1205 name = typeArrayHandle(current_thread, 1206 java_lang_ThreadGroup::name(group_obj())); 1207 parent_group = Handle(current_thread, java_lang_ThreadGroup::parent(group_obj())); 1208 is_daemon = java_lang_ThreadGroup::is_daemon(group_obj()); 1209 max_priority = java_lang_ThreadGroup::maxPriority(group_obj()); 1210 } 1211 1212 info_ptr->is_daemon = is_daemon; 1213 info_ptr->max_priority = max_priority; 1214 info_ptr->parent = jni_reference(parent_group); 1215 1216 if (name() != NULL) { 1217 const char* n = UNICODE::as_utf8((jchar*) name->base(T_CHAR), name->length()); 1218 info_ptr->name = (char *)jvmtiMalloc(strlen(n)+1); 1219 NULL_CHECK(info_ptr->name, JVMTI_ERROR_OUT_OF_MEMORY); 1220 strcpy(info_ptr->name, n); 1221 } else { 1222 info_ptr->name = NULL; 1223 } 1224 1225 return JVMTI_ERROR_NONE; 1226} /* end GetThreadGroupInfo */ 1227 1228 1229// thread_count_ptr - pre-checked for NULL 1230// threads_ptr - pre-checked for NULL 1231// group_count_ptr - pre-checked for NULL 1232// groups_ptr - pre-checked for NULL 1233jvmtiError 1234JvmtiEnv::GetThreadGroupChildren(jthreadGroup group, jint* thread_count_ptr, jthread** threads_ptr, jint* group_count_ptr, jthreadGroup** groups_ptr) { 1235 JavaThread* current_thread = JavaThread::current(); 1236 oop group_obj = (oop) JNIHandles::resolve_external_guard(group); 1237 NULL_CHECK(group_obj, JVMTI_ERROR_INVALID_THREAD_GROUP); 1238 1239 Handle *thread_objs = NULL; 1240 Handle *group_objs = NULL; 1241 int nthreads = 0; 1242 int ngroups = 0; 1243 int hidden_threads = 0; 1244 1245 ResourceMark rm; 1246 HandleMark hm; 1247 1248 Handle group_hdl(current_thread, group_obj); 1249 1250 { MutexLocker mu(Threads_lock); 1251 1252 nthreads = java_lang_ThreadGroup::nthreads(group_hdl()); 1253 ngroups = java_lang_ThreadGroup::ngroups(group_hdl()); 1254 1255 if (nthreads > 0) { 1256 objArrayOop threads = java_lang_ThreadGroup::threads(group_hdl()); 1257 assert(nthreads <= threads->length(), "too many threads"); 1258 thread_objs = NEW_RESOURCE_ARRAY(Handle,nthreads); 1259 for (int i=0, j=0; i<nthreads; i++) { 1260 oop thread_obj = threads->obj_at(i); 1261 assert(thread_obj != NULL, "thread_obj is NULL"); 1262 JavaThread *javathread = java_lang_Thread::thread(thread_obj); 1263 // Filter out hidden java threads. 1264 if (javathread != NULL && javathread->is_hidden_from_external_view()) { 1265 hidden_threads++; 1266 continue; 1267 } 1268 thread_objs[j++] = Handle(current_thread, thread_obj); 1269 } 1270 nthreads -= hidden_threads; 1271 } 1272 if (ngroups > 0) { 1273 objArrayOop groups = java_lang_ThreadGroup::groups(group_hdl()); 1274 assert(ngroups <= groups->length(), "too many threads"); 1275 group_objs = NEW_RESOURCE_ARRAY(Handle,ngroups); 1276 for (int i=0; i<ngroups; i++) { 1277 oop group_obj = groups->obj_at(i); 1278 assert(group_obj != NULL, "group_obj != NULL"); 1279 group_objs[i] = Handle(current_thread, group_obj); 1280 } 1281 } 1282 } 1283 1284 // have to make global handles outside of Threads_lock 1285 *group_count_ptr = ngroups; 1286 *thread_count_ptr = nthreads; 1287 *threads_ptr = new_jthreadArray(nthreads, thread_objs); 1288 *groups_ptr = new_jthreadGroupArray(ngroups, group_objs); 1289 if ((nthreads > 0) && (*threads_ptr == NULL)) { 1290 return JVMTI_ERROR_OUT_OF_MEMORY; 1291 } 1292 if ((ngroups > 0) && (*groups_ptr == NULL)) { 1293 return JVMTI_ERROR_OUT_OF_MEMORY; 1294 } 1295 1296 return JVMTI_ERROR_NONE; 1297} /* end GetThreadGroupChildren */ 1298 1299 1300 // 1301 // Stack Frame functions 1302 // 1303 1304// Threads_lock NOT held, java_thread not protected by lock 1305// java_thread - pre-checked 1306// max_frame_count - pre-checked to be greater than or equal to 0 1307// frame_buffer - pre-checked for NULL 1308// count_ptr - pre-checked for NULL 1309jvmtiError 1310JvmtiEnv::GetStackTrace(JavaThread* java_thread, jint start_depth, jint max_frame_count, jvmtiFrameInfo* frame_buffer, jint* count_ptr) { 1311 jvmtiError err = JVMTI_ERROR_NONE; 1312 uint32_t debug_bits = 0; 1313 if (is_thread_fully_suspended(java_thread, true, &debug_bits)) { 1314 err = get_stack_trace(java_thread, start_depth, max_frame_count, frame_buffer, count_ptr); 1315 } else { 1316 // JVMTI get stack trace at safepoint. Do not require target thread to 1317 // be suspended. 1318 VM_GetStackTrace op(this, java_thread, start_depth, max_frame_count, frame_buffer, count_ptr); 1319 VMThread::execute(&op); 1320 err = op.result(); 1321 } 1322 1323 return err; 1324} /* end GetStackTrace */ 1325 1326 1327// max_frame_count - pre-checked to be greater than or equal to 0 1328// stack_info_ptr - pre-checked for NULL 1329// thread_count_ptr - pre-checked for NULL 1330jvmtiError 1331JvmtiEnv::GetAllStackTraces(jint max_frame_count, jvmtiStackInfo** stack_info_ptr, jint* thread_count_ptr) { 1332 jvmtiError err = JVMTI_ERROR_NONE; 1333 JavaThread* calling_thread = JavaThread::current(); 1334 1335 // JVMTI get stack traces at safepoint. 1336 VM_GetAllStackTraces op(this, calling_thread, max_frame_count); 1337 VMThread::execute(&op); 1338 *thread_count_ptr = op.final_thread_count(); 1339 *stack_info_ptr = op.stack_info(); 1340 err = op.result(); 1341 return err; 1342} /* end GetAllStackTraces */ 1343 1344 1345// thread_count - pre-checked to be greater than or equal to 0 1346// thread_list - pre-checked for NULL 1347// max_frame_count - pre-checked to be greater than or equal to 0 1348// stack_info_ptr - pre-checked for NULL 1349jvmtiError 1350JvmtiEnv::GetThreadListStackTraces(jint thread_count, const jthread* thread_list, jint max_frame_count, jvmtiStackInfo** stack_info_ptr) { 1351 jvmtiError err = JVMTI_ERROR_NONE; 1352 // JVMTI get stack traces at safepoint. 1353 VM_GetThreadListStackTraces op(this, thread_count, thread_list, max_frame_count); 1354 VMThread::execute(&op); 1355 err = op.result(); 1356 if (err == JVMTI_ERROR_NONE) { 1357 *stack_info_ptr = op.stack_info(); 1358 } 1359 return err; 1360} /* end GetThreadListStackTraces */ 1361 1362 1363// Threads_lock NOT held, java_thread not protected by lock 1364// java_thread - pre-checked 1365// count_ptr - pre-checked for NULL 1366jvmtiError 1367JvmtiEnv::GetFrameCount(JavaThread* java_thread, jint* count_ptr) { 1368 jvmtiError err = JVMTI_ERROR_NONE; 1369 1370 // retrieve or create JvmtiThreadState. 1371 JvmtiThreadState* state = JvmtiThreadState::state_for(java_thread); 1372 if (state == NULL) { 1373 return JVMTI_ERROR_THREAD_NOT_ALIVE; 1374 } 1375 uint32_t debug_bits = 0; 1376 if (is_thread_fully_suspended(java_thread, true, &debug_bits)) { 1377 err = get_frame_count(state, count_ptr); 1378 } else { 1379 // get java stack frame count at safepoint. 1380 VM_GetFrameCount op(this, state, count_ptr); 1381 VMThread::execute(&op); 1382 err = op.result(); 1383 } 1384 return err; 1385} /* end GetFrameCount */ 1386 1387 1388// Threads_lock NOT held, java_thread not protected by lock 1389// java_thread - pre-checked 1390jvmtiError 1391JvmtiEnv::PopFrame(JavaThread* java_thread) { 1392 JavaThread* current_thread = JavaThread::current(); 1393 HandleMark hm(current_thread); 1394 uint32_t debug_bits = 0; 1395 1396 // retrieve or create the state 1397 JvmtiThreadState* state = JvmtiThreadState::state_for(java_thread); 1398 if (state == NULL) { 1399 return JVMTI_ERROR_THREAD_NOT_ALIVE; 1400 } 1401 1402 // Check if java_thread is fully suspended 1403 if (!is_thread_fully_suspended(java_thread, true /* wait for suspend completion */, &debug_bits)) { 1404 return JVMTI_ERROR_THREAD_NOT_SUSPENDED; 1405 } 1406 // Check to see if a PopFrame was already in progress 1407 if (java_thread->popframe_condition() != JavaThread::popframe_inactive) { 1408 // Probably possible for JVMTI clients to trigger this, but the 1409 // JPDA backend shouldn't allow this to happen 1410 return JVMTI_ERROR_INTERNAL; 1411 } 1412 1413 { 1414 // Was workaround bug 1415 // 4812902: popFrame hangs if the method is waiting at a synchronize 1416 // Catch this condition and return an error to avoid hanging. 1417 // Now JVMTI spec allows an implementation to bail out with an opaque frame error. 1418 OSThread* osThread = java_thread->osthread(); 1419 if (osThread->get_state() == MONITOR_WAIT) { 1420 return JVMTI_ERROR_OPAQUE_FRAME; 1421 } 1422 } 1423 1424 { 1425 ResourceMark rm(current_thread); 1426 // Check if there are more than one Java frame in this thread, that the top two frames 1427 // are Java (not native) frames, and that there is no intervening VM frame 1428 int frame_count = 0; 1429 bool is_interpreted[2]; 1430 intptr_t *frame_sp[2]; 1431 // The 2-nd arg of constructor is needed to stop iterating at java entry frame. 1432 for (vframeStream vfs(java_thread, true); !vfs.at_end(); vfs.next()) { 1433 methodHandle mh(current_thread, vfs.method()); 1434 if (mh->is_native()) return(JVMTI_ERROR_OPAQUE_FRAME); 1435 is_interpreted[frame_count] = vfs.is_interpreted_frame(); 1436 frame_sp[frame_count] = vfs.frame_id(); 1437 if (++frame_count > 1) break; 1438 } 1439 if (frame_count < 2) { 1440 // We haven't found two adjacent non-native Java frames on the top. 1441 // There can be two situations here: 1442 // 1. There are no more java frames 1443 // 2. Two top java frames are separated by non-java native frames 1444 if(vframeFor(java_thread, 1) == NULL) { 1445 return JVMTI_ERROR_NO_MORE_FRAMES; 1446 } else { 1447 // Intervening non-java native or VM frames separate java frames. 1448 // Current implementation does not support this. See bug #5031735. 1449 // In theory it is possible to pop frames in such cases. 1450 return JVMTI_ERROR_OPAQUE_FRAME; 1451 } 1452 } 1453 1454 // If any of the top 2 frames is a compiled one, need to deoptimize it 1455 for (int i = 0; i < 2; i++) { 1456 if (!is_interpreted[i]) { 1457 Deoptimization::deoptimize_frame(java_thread, frame_sp[i]); 1458 } 1459 } 1460 1461 // Update the thread state to reflect that the top frame is popped 1462 // so that cur_stack_depth is maintained properly and all frameIDs 1463 // are invalidated. 1464 // The current frame will be popped later when the suspended thread 1465 // is resumed and right before returning from VM to Java. 1466 // (see call_VM_base() in assembler_<cpu>.cpp). 1467 1468 // It's fine to update the thread state here because no JVMTI events 1469 // shall be posted for this PopFrame. 1470 1471 state->update_for_pop_top_frame(); 1472 java_thread->set_popframe_condition(JavaThread::popframe_pending_bit); 1473 // Set pending step flag for this popframe and it is cleared when next 1474 // step event is posted. 1475 state->set_pending_step_for_popframe(); 1476 } 1477 1478 return JVMTI_ERROR_NONE; 1479} /* end PopFrame */ 1480 1481 1482// Threads_lock NOT held, java_thread not protected by lock 1483// java_thread - pre-checked 1484// java_thread - unchecked 1485// depth - pre-checked as non-negative 1486// method_ptr - pre-checked for NULL 1487// location_ptr - pre-checked for NULL 1488jvmtiError 1489JvmtiEnv::GetFrameLocation(JavaThread* java_thread, jint depth, jmethodID* method_ptr, jlocation* location_ptr) { 1490 jvmtiError err = JVMTI_ERROR_NONE; 1491 uint32_t debug_bits = 0; 1492 1493 if (is_thread_fully_suspended(java_thread, true, &debug_bits)) { 1494 err = get_frame_location(java_thread, depth, method_ptr, location_ptr); 1495 } else { 1496 // JVMTI get java stack frame location at safepoint. 1497 VM_GetFrameLocation op(this, java_thread, depth, method_ptr, location_ptr); 1498 VMThread::execute(&op); 1499 err = op.result(); 1500 } 1501 return err; 1502} /* end GetFrameLocation */ 1503 1504 1505// Threads_lock NOT held, java_thread not protected by lock 1506// java_thread - pre-checked 1507// java_thread - unchecked 1508// depth - pre-checked as non-negative 1509jvmtiError 1510JvmtiEnv::NotifyFramePop(JavaThread* java_thread, jint depth) { 1511 ResourceMark rm; 1512 uint32_t debug_bits = 0; 1513 1514 JvmtiThreadState *state = JvmtiThreadState::state_for(java_thread); 1515 if (state == NULL) { 1516 return JVMTI_ERROR_THREAD_NOT_ALIVE; 1517 } 1518 1519 if (!JvmtiEnv::is_thread_fully_suspended(java_thread, true, &debug_bits)) { 1520 return JVMTI_ERROR_THREAD_NOT_SUSPENDED; 1521 } 1522 1523 if (TraceJVMTICalls) { 1524 JvmtiSuspendControl::print(); 1525 } 1526 1527 vframe *vf = vframeFor(java_thread, depth); 1528 if (vf == NULL) { 1529 return JVMTI_ERROR_NO_MORE_FRAMES; 1530 } 1531 1532 if (!vf->is_java_frame() || ((javaVFrame*) vf)->method()->is_native()) { 1533 return JVMTI_ERROR_OPAQUE_FRAME; 1534 } 1535 1536 assert(vf->frame_pointer() != NULL, "frame pointer mustn't be NULL"); 1537 1538 int frame_number = state->count_frames() - depth; 1539 state->env_thread_state(this)->set_frame_pop(frame_number); 1540 1541 return JVMTI_ERROR_NONE; 1542} /* end NotifyFramePop */ 1543 1544 1545 // 1546 // Force Early Return functions 1547 // 1548 1549// Threads_lock NOT held, java_thread not protected by lock 1550// java_thread - pre-checked 1551jvmtiError 1552JvmtiEnv::ForceEarlyReturnObject(JavaThread* java_thread, jobject value) { 1553 jvalue val; 1554 val.l = value; 1555 return force_early_return(java_thread, val, atos); 1556} /* end ForceEarlyReturnObject */ 1557 1558 1559// Threads_lock NOT held, java_thread not protected by lock 1560// java_thread - pre-checked 1561jvmtiError 1562JvmtiEnv::ForceEarlyReturnInt(JavaThread* java_thread, jint value) { 1563 jvalue val; 1564 val.i = value; 1565 return force_early_return(java_thread, val, itos); 1566} /* end ForceEarlyReturnInt */ 1567 1568 1569// Threads_lock NOT held, java_thread not protected by lock 1570// java_thread - pre-checked 1571jvmtiError 1572JvmtiEnv::ForceEarlyReturnLong(JavaThread* java_thread, jlong value) { 1573 jvalue val; 1574 val.j = value; 1575 return force_early_return(java_thread, val, ltos); 1576} /* end ForceEarlyReturnLong */ 1577 1578 1579// Threads_lock NOT held, java_thread not protected by lock 1580// java_thread - pre-checked 1581jvmtiError 1582JvmtiEnv::ForceEarlyReturnFloat(JavaThread* java_thread, jfloat value) { 1583 jvalue val; 1584 val.f = value; 1585 return force_early_return(java_thread, val, ftos); 1586} /* end ForceEarlyReturnFloat */ 1587 1588 1589// Threads_lock NOT held, java_thread not protected by lock 1590// java_thread - pre-checked 1591jvmtiError 1592JvmtiEnv::ForceEarlyReturnDouble(JavaThread* java_thread, jdouble value) { 1593 jvalue val; 1594 val.d = value; 1595 return force_early_return(java_thread, val, dtos); 1596} /* end ForceEarlyReturnDouble */ 1597 1598 1599// Threads_lock NOT held, java_thread not protected by lock 1600// java_thread - pre-checked 1601jvmtiError 1602JvmtiEnv::ForceEarlyReturnVoid(JavaThread* java_thread) { 1603 jvalue val; 1604 val.j = 0L; 1605 return force_early_return(java_thread, val, vtos); 1606} /* end ForceEarlyReturnVoid */ 1607 1608 1609 // 1610 // Heap functions 1611 // 1612 1613// klass - NULL is a valid value, must be checked 1614// initial_object - NULL is a valid value, must be checked 1615// callbacks - pre-checked for NULL 1616// user_data - NULL is a valid value, must be checked 1617jvmtiError 1618JvmtiEnv::FollowReferences(jint heap_filter, jclass klass, jobject initial_object, const jvmtiHeapCallbacks* callbacks, const void* user_data) { 1619 // check klass if provided 1620 klassOop k_oop = NULL; 1621 if (klass != NULL) { 1622 oop k_mirror = JNIHandles::resolve_external_guard(klass); 1623 if (k_mirror == NULL) { 1624 return JVMTI_ERROR_INVALID_CLASS; 1625 } 1626 if (java_lang_Class::is_primitive(k_mirror)) { 1627 return JVMTI_ERROR_NONE; 1628 } 1629 k_oop = java_lang_Class::as_klassOop(k_mirror); 1630 if (k_oop == NULL) { 1631 return JVMTI_ERROR_INVALID_CLASS; 1632 } 1633 } 1634 1635 Thread *thread = Thread::current(); 1636 HandleMark hm(thread); 1637 KlassHandle kh (thread, k_oop); 1638 1639 TraceTime t("FollowReferences", TraceJVMTIObjectTagging); 1640 JvmtiTagMap::tag_map_for(this)->follow_references(heap_filter, kh, initial_object, callbacks, user_data); 1641 return JVMTI_ERROR_NONE; 1642} /* end FollowReferences */ 1643 1644 1645// klass - NULL is a valid value, must be checked 1646// callbacks - pre-checked for NULL 1647// user_data - NULL is a valid value, must be checked 1648jvmtiError 1649JvmtiEnv::IterateThroughHeap(jint heap_filter, jclass klass, const jvmtiHeapCallbacks* callbacks, const void* user_data) { 1650 // check klass if provided 1651 klassOop k_oop = NULL; 1652 if (klass != NULL) { 1653 oop k_mirror = JNIHandles::resolve_external_guard(klass); 1654 if (k_mirror == NULL) { 1655 return JVMTI_ERROR_INVALID_CLASS; 1656 } 1657 if (java_lang_Class::is_primitive(k_mirror)) { 1658 return JVMTI_ERROR_NONE; 1659 } 1660 k_oop = java_lang_Class::as_klassOop(k_mirror); 1661 if (k_oop == NULL) { 1662 return JVMTI_ERROR_INVALID_CLASS; 1663 } 1664 } 1665 1666 Thread *thread = Thread::current(); 1667 HandleMark hm(thread); 1668 KlassHandle kh (thread, k_oop); 1669 1670 TraceTime t("IterateThroughHeap", TraceJVMTIObjectTagging); 1671 JvmtiTagMap::tag_map_for(this)->iterate_through_heap(heap_filter, kh, callbacks, user_data); 1672 return JVMTI_ERROR_NONE; 1673} /* end IterateThroughHeap */ 1674 1675 1676// tag_ptr - pre-checked for NULL 1677jvmtiError 1678JvmtiEnv::GetTag(jobject object, jlong* tag_ptr) { 1679 oop o = JNIHandles::resolve_external_guard(object); 1680 NULL_CHECK(o, JVMTI_ERROR_INVALID_OBJECT); 1681 *tag_ptr = JvmtiTagMap::tag_map_for(this)->get_tag(object); 1682 return JVMTI_ERROR_NONE; 1683} /* end GetTag */ 1684 1685 1686jvmtiError 1687JvmtiEnv::SetTag(jobject object, jlong tag) { 1688 oop o = JNIHandles::resolve_external_guard(object); 1689 NULL_CHECK(o, JVMTI_ERROR_INVALID_OBJECT); 1690 JvmtiTagMap::tag_map_for(this)->set_tag(object, tag); 1691 return JVMTI_ERROR_NONE; 1692} /* end SetTag */ 1693 1694 1695// tag_count - pre-checked to be greater than or equal to 0 1696// tags - pre-checked for NULL 1697// count_ptr - pre-checked for NULL 1698// object_result_ptr - NULL is a valid value, must be checked 1699// tag_result_ptr - NULL is a valid value, must be checked 1700jvmtiError 1701JvmtiEnv::GetObjectsWithTags(jint tag_count, const jlong* tags, jint* count_ptr, jobject** object_result_ptr, jlong** tag_result_ptr) { 1702 TraceTime t("GetObjectsWithTags", TraceJVMTIObjectTagging); 1703 return JvmtiTagMap::tag_map_for(this)->get_objects_with_tags((jlong*)tags, tag_count, count_ptr, object_result_ptr, tag_result_ptr); 1704} /* end GetObjectsWithTags */ 1705 1706 1707jvmtiError 1708JvmtiEnv::ForceGarbageCollection() { 1709 Universe::heap()->collect(GCCause::_jvmti_force_gc); 1710 return JVMTI_ERROR_NONE; 1711} /* end ForceGarbageCollection */ 1712 1713 1714 // 1715 // Heap (1.0) functions 1716 // 1717 1718// object_reference_callback - pre-checked for NULL 1719// user_data - NULL is a valid value, must be checked 1720jvmtiError 1721JvmtiEnv::IterateOverObjectsReachableFromObject(jobject object, jvmtiObjectReferenceCallback object_reference_callback, const void* user_data) { 1722 oop o = JNIHandles::resolve_external_guard(object); 1723 NULL_CHECK(o, JVMTI_ERROR_INVALID_OBJECT); 1724 JvmtiTagMap::tag_map_for(this)->iterate_over_objects_reachable_from_object(object, object_reference_callback, user_data); 1725 return JVMTI_ERROR_NONE; 1726} /* end IterateOverObjectsReachableFromObject */ 1727 1728 1729// heap_root_callback - NULL is a valid value, must be checked 1730// stack_ref_callback - NULL is a valid value, must be checked 1731// object_ref_callback - NULL is a valid value, must be checked 1732// user_data - NULL is a valid value, must be checked 1733jvmtiError 1734JvmtiEnv::IterateOverReachableObjects(jvmtiHeapRootCallback heap_root_callback, jvmtiStackReferenceCallback stack_ref_callback, jvmtiObjectReferenceCallback object_ref_callback, const void* user_data) { 1735 TraceTime t("IterateOverReachableObjects", TraceJVMTIObjectTagging); 1736 JvmtiTagMap::tag_map_for(this)->iterate_over_reachable_objects(heap_root_callback, stack_ref_callback, object_ref_callback, user_data); 1737 return JVMTI_ERROR_NONE; 1738} /* end IterateOverReachableObjects */ 1739 1740 1741// heap_object_callback - pre-checked for NULL 1742// user_data - NULL is a valid value, must be checked 1743jvmtiError 1744JvmtiEnv::IterateOverHeap(jvmtiHeapObjectFilter object_filter, jvmtiHeapObjectCallback heap_object_callback, const void* user_data) { 1745 TraceTime t("IterateOverHeap", TraceJVMTIObjectTagging); 1746 Thread *thread = Thread::current(); 1747 HandleMark hm(thread); 1748 JvmtiTagMap::tag_map_for(this)->iterate_over_heap(object_filter, KlassHandle(), heap_object_callback, user_data); 1749 return JVMTI_ERROR_NONE; 1750} /* end IterateOverHeap */ 1751 1752 1753// k_mirror - may be primitive, this must be checked 1754// heap_object_callback - pre-checked for NULL 1755// user_data - NULL is a valid value, must be checked 1756jvmtiError 1757JvmtiEnv::IterateOverInstancesOfClass(oop k_mirror, jvmtiHeapObjectFilter object_filter, jvmtiHeapObjectCallback heap_object_callback, const void* user_data) { 1758 if (java_lang_Class::is_primitive(k_mirror)) { 1759 // DO PRIMITIVE CLASS PROCESSING 1760 return JVMTI_ERROR_NONE; 1761 } 1762 klassOop k_oop = java_lang_Class::as_klassOop(k_mirror); 1763 if (k_oop == NULL) { 1764 return JVMTI_ERROR_INVALID_CLASS; 1765 } 1766 Thread *thread = Thread::current(); 1767 HandleMark hm(thread); 1768 KlassHandle klass (thread, k_oop); 1769 TraceTime t("IterateOverInstancesOfClass", TraceJVMTIObjectTagging); 1770 JvmtiTagMap::tag_map_for(this)->iterate_over_heap(object_filter, klass, heap_object_callback, user_data); 1771 return JVMTI_ERROR_NONE; 1772} /* end IterateOverInstancesOfClass */ 1773 1774 1775 // 1776 // Local Variable functions 1777 // 1778 1779// Threads_lock NOT held, java_thread not protected by lock 1780// java_thread - pre-checked 1781// java_thread - unchecked 1782// depth - pre-checked as non-negative 1783// value_ptr - pre-checked for NULL 1784jvmtiError 1785JvmtiEnv::GetLocalObject(JavaThread* java_thread, jint depth, jint slot, jobject* value_ptr) { 1786 JavaThread* current_thread = JavaThread::current(); 1787 // rm object is created to clean up the javaVFrame created in 1788 // doit_prologue(), but after doit() is finished with it. 1789 ResourceMark rm(current_thread); 1790 1791 VM_GetOrSetLocal op(java_thread, current_thread, depth, slot); 1792 VMThread::execute(&op); 1793 jvmtiError err = op.result(); 1794 if (err != JVMTI_ERROR_NONE) { 1795 return err; 1796 } else { 1797 *value_ptr = op.value().l; 1798 return JVMTI_ERROR_NONE; 1799 } 1800} /* end GetLocalObject */ 1801 1802// Threads_lock NOT held, java_thread not protected by lock 1803// java_thread - pre-checked 1804// java_thread - unchecked 1805// depth - pre-checked as non-negative 1806// value - pre-checked for NULL 1807jvmtiError 1808JvmtiEnv::GetLocalInstance(JavaThread* java_thread, jint depth, jobject* value_ptr){ 1809 JavaThread* current_thread = JavaThread::current(); 1810 // rm object is created to clean up the javaVFrame created in 1811 // doit_prologue(), but after doit() is finished with it. 1812 ResourceMark rm(current_thread); 1813 1814 VM_GetReceiver op(java_thread, current_thread, depth); 1815 VMThread::execute(&op); 1816 jvmtiError err = op.result(); 1817 if (err != JVMTI_ERROR_NONE) { 1818 return err; 1819 } else { 1820 *value_ptr = op.value().l; 1821 return JVMTI_ERROR_NONE; 1822 } 1823} /* end GetLocalInstance */ 1824 1825 1826// Threads_lock NOT held, java_thread not protected by lock 1827// java_thread - pre-checked 1828// java_thread - unchecked 1829// depth - pre-checked as non-negative 1830// value_ptr - pre-checked for NULL 1831jvmtiError 1832JvmtiEnv::GetLocalInt(JavaThread* java_thread, jint depth, jint slot, jint* value_ptr) { 1833 // rm object is created to clean up the javaVFrame created in 1834 // doit_prologue(), but after doit() is finished with it. 1835 ResourceMark rm; 1836 1837 VM_GetOrSetLocal op(java_thread, depth, slot, T_INT); 1838 VMThread::execute(&op); 1839 *value_ptr = op.value().i; 1840 return op.result(); 1841} /* end GetLocalInt */ 1842 1843 1844// Threads_lock NOT held, java_thread not protected by lock 1845// java_thread - pre-checked 1846// java_thread - unchecked 1847// depth - pre-checked as non-negative 1848// value_ptr - pre-checked for NULL 1849jvmtiError 1850JvmtiEnv::GetLocalLong(JavaThread* java_thread, jint depth, jint slot, jlong* value_ptr) { 1851 // rm object is created to clean up the javaVFrame created in 1852 // doit_prologue(), but after doit() is finished with it. 1853 ResourceMark rm; 1854 1855 VM_GetOrSetLocal op(java_thread, depth, slot, T_LONG); 1856 VMThread::execute(&op); 1857 *value_ptr = op.value().j; 1858 return op.result(); 1859} /* end GetLocalLong */ 1860 1861 1862// Threads_lock NOT held, java_thread not protected by lock 1863// java_thread - pre-checked 1864// java_thread - unchecked 1865// depth - pre-checked as non-negative 1866// value_ptr - pre-checked for NULL 1867jvmtiError 1868JvmtiEnv::GetLocalFloat(JavaThread* java_thread, jint depth, jint slot, jfloat* value_ptr) { 1869 // rm object is created to clean up the javaVFrame created in 1870 // doit_prologue(), but after doit() is finished with it. 1871 ResourceMark rm; 1872 1873 VM_GetOrSetLocal op(java_thread, depth, slot, T_FLOAT); 1874 VMThread::execute(&op); 1875 *value_ptr = op.value().f; 1876 return op.result(); 1877} /* end GetLocalFloat */ 1878 1879 1880// Threads_lock NOT held, java_thread not protected by lock 1881// java_thread - pre-checked 1882// java_thread - unchecked 1883// depth - pre-checked as non-negative 1884// value_ptr - pre-checked for NULL 1885jvmtiError 1886JvmtiEnv::GetLocalDouble(JavaThread* java_thread, jint depth, jint slot, jdouble* value_ptr) { 1887 // rm object is created to clean up the javaVFrame created in 1888 // doit_prologue(), but after doit() is finished with it. 1889 ResourceMark rm; 1890 1891 VM_GetOrSetLocal op(java_thread, depth, slot, T_DOUBLE); 1892 VMThread::execute(&op); 1893 *value_ptr = op.value().d; 1894 return op.result(); 1895} /* end GetLocalDouble */ 1896 1897 1898// Threads_lock NOT held, java_thread not protected by lock 1899// java_thread - pre-checked 1900// java_thread - unchecked 1901// depth - pre-checked as non-negative 1902jvmtiError 1903JvmtiEnv::SetLocalObject(JavaThread* java_thread, jint depth, jint slot, jobject value) { 1904 // rm object is created to clean up the javaVFrame created in 1905 // doit_prologue(), but after doit() is finished with it. 1906 ResourceMark rm; 1907 jvalue val; 1908 val.l = value; 1909 VM_GetOrSetLocal op(java_thread, depth, slot, T_OBJECT, val); 1910 VMThread::execute(&op); 1911 return op.result(); 1912} /* end SetLocalObject */ 1913 1914 1915// Threads_lock NOT held, java_thread not protected by lock 1916// java_thread - pre-checked 1917// java_thread - unchecked 1918// depth - pre-checked as non-negative 1919jvmtiError 1920JvmtiEnv::SetLocalInt(JavaThread* java_thread, jint depth, jint slot, jint value) { 1921 // rm object is created to clean up the javaVFrame created in 1922 // doit_prologue(), but after doit() is finished with it. 1923 ResourceMark rm; 1924 jvalue val; 1925 val.i = value; 1926 VM_GetOrSetLocal op(java_thread, depth, slot, T_INT, val); 1927 VMThread::execute(&op); 1928 return op.result(); 1929} /* end SetLocalInt */ 1930 1931 1932// Threads_lock NOT held, java_thread not protected by lock 1933// java_thread - pre-checked 1934// java_thread - unchecked 1935// depth - pre-checked as non-negative 1936jvmtiError 1937JvmtiEnv::SetLocalLong(JavaThread* java_thread, jint depth, jint slot, jlong value) { 1938 // rm object is created to clean up the javaVFrame created in 1939 // doit_prologue(), but after doit() is finished with it. 1940 ResourceMark rm; 1941 jvalue val; 1942 val.j = value; 1943 VM_GetOrSetLocal op(java_thread, depth, slot, T_LONG, val); 1944 VMThread::execute(&op); 1945 return op.result(); 1946} /* end SetLocalLong */ 1947 1948 1949// Threads_lock NOT held, java_thread not protected by lock 1950// java_thread - pre-checked 1951// java_thread - unchecked 1952// depth - pre-checked as non-negative 1953jvmtiError 1954JvmtiEnv::SetLocalFloat(JavaThread* java_thread, jint depth, jint slot, jfloat value) { 1955 // rm object is created to clean up the javaVFrame created in 1956 // doit_prologue(), but after doit() is finished with it. 1957 ResourceMark rm; 1958 jvalue val; 1959 val.f = value; 1960 VM_GetOrSetLocal op(java_thread, depth, slot, T_FLOAT, val); 1961 VMThread::execute(&op); 1962 return op.result(); 1963} /* end SetLocalFloat */ 1964 1965 1966// Threads_lock NOT held, java_thread not protected by lock 1967// java_thread - pre-checked 1968// java_thread - unchecked 1969// depth - pre-checked as non-negative 1970jvmtiError 1971JvmtiEnv::SetLocalDouble(JavaThread* java_thread, jint depth, jint slot, jdouble value) { 1972 // rm object is created to clean up the javaVFrame created in 1973 // doit_prologue(), but after doit() is finished with it. 1974 ResourceMark rm; 1975 jvalue val; 1976 val.d = value; 1977 VM_GetOrSetLocal op(java_thread, depth, slot, T_DOUBLE, val); 1978 VMThread::execute(&op); 1979 return op.result(); 1980} /* end SetLocalDouble */ 1981 1982 1983 // 1984 // Breakpoint functions 1985 // 1986 1987// method_oop - pre-checked for validity, but may be NULL meaning obsolete method 1988jvmtiError 1989JvmtiEnv::SetBreakpoint(methodOop method_oop, jlocation location) { 1990 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); 1991 if (location < 0) { // simple invalid location check first 1992 return JVMTI_ERROR_INVALID_LOCATION; 1993 } 1994 // verify that the breakpoint is not past the end of the method 1995 if (location >= (jlocation) method_oop->code_size()) { 1996 return JVMTI_ERROR_INVALID_LOCATION; 1997 } 1998 1999 ResourceMark rm; 2000 JvmtiBreakpoint bp(method_oop, location); 2001 JvmtiBreakpoints& jvmti_breakpoints = JvmtiCurrentBreakpoints::get_jvmti_breakpoints(); 2002 if (jvmti_breakpoints.set(bp) == JVMTI_ERROR_DUPLICATE) 2003 return JVMTI_ERROR_DUPLICATE; 2004 2005 if (TraceJVMTICalls) { 2006 jvmti_breakpoints.print(); 2007 } 2008 2009 return JVMTI_ERROR_NONE; 2010} /* end SetBreakpoint */ 2011 2012 2013// method_oop - pre-checked for validity, but may be NULL meaning obsolete method 2014jvmtiError 2015JvmtiEnv::ClearBreakpoint(methodOop method_oop, jlocation location) { 2016 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); 2017 2018 if (location < 0) { // simple invalid location check first 2019 return JVMTI_ERROR_INVALID_LOCATION; 2020 } 2021 2022 // verify that the breakpoint is not past the end of the method 2023 if (location >= (jlocation) method_oop->code_size()) { 2024 return JVMTI_ERROR_INVALID_LOCATION; 2025 } 2026 2027 JvmtiBreakpoint bp(method_oop, location); 2028 2029 JvmtiBreakpoints& jvmti_breakpoints = JvmtiCurrentBreakpoints::get_jvmti_breakpoints(); 2030 if (jvmti_breakpoints.clear(bp) == JVMTI_ERROR_NOT_FOUND) 2031 return JVMTI_ERROR_NOT_FOUND; 2032 2033 if (TraceJVMTICalls) { 2034 jvmti_breakpoints.print(); 2035 } 2036 2037 return JVMTI_ERROR_NONE; 2038} /* end ClearBreakpoint */ 2039 2040 2041 // 2042 // Watched Field functions 2043 // 2044 2045jvmtiError 2046JvmtiEnv::SetFieldAccessWatch(fieldDescriptor* fdesc_ptr) { 2047 // make sure we haven't set this watch before 2048 if (fdesc_ptr->is_field_access_watched()) return JVMTI_ERROR_DUPLICATE; 2049 fdesc_ptr->set_is_field_access_watched(true); 2050 2051 JvmtiEventController::change_field_watch(JVMTI_EVENT_FIELD_ACCESS, true); 2052 2053 return JVMTI_ERROR_NONE; 2054} /* end SetFieldAccessWatch */ 2055 2056 2057jvmtiError 2058JvmtiEnv::ClearFieldAccessWatch(fieldDescriptor* fdesc_ptr) { 2059 // make sure we have a watch to clear 2060 if (!fdesc_ptr->is_field_access_watched()) return JVMTI_ERROR_NOT_FOUND; 2061 fdesc_ptr->set_is_field_access_watched(false); 2062 2063 JvmtiEventController::change_field_watch(JVMTI_EVENT_FIELD_ACCESS, false); 2064 2065 return JVMTI_ERROR_NONE; 2066} /* end ClearFieldAccessWatch */ 2067 2068 2069jvmtiError 2070JvmtiEnv::SetFieldModificationWatch(fieldDescriptor* fdesc_ptr) { 2071 // make sure we haven't set this watch before 2072 if (fdesc_ptr->is_field_modification_watched()) return JVMTI_ERROR_DUPLICATE; 2073 fdesc_ptr->set_is_field_modification_watched(true); 2074 2075 JvmtiEventController::change_field_watch(JVMTI_EVENT_FIELD_MODIFICATION, true); 2076 2077 return JVMTI_ERROR_NONE; 2078} /* end SetFieldModificationWatch */ 2079 2080 2081jvmtiError 2082JvmtiEnv::ClearFieldModificationWatch(fieldDescriptor* fdesc_ptr) { 2083 // make sure we have a watch to clear 2084 if (!fdesc_ptr->is_field_modification_watched()) return JVMTI_ERROR_NOT_FOUND; 2085 fdesc_ptr->set_is_field_modification_watched(false); 2086 2087 JvmtiEventController::change_field_watch(JVMTI_EVENT_FIELD_MODIFICATION, false); 2088 2089 return JVMTI_ERROR_NONE; 2090} /* end ClearFieldModificationWatch */ 2091 2092 // 2093 // Class functions 2094 // 2095 2096 2097// k_mirror - may be primitive, this must be checked 2098// signature_ptr - NULL is a valid value, must be checked 2099// generic_ptr - NULL is a valid value, must be checked 2100jvmtiError 2101JvmtiEnv::GetClassSignature(oop k_mirror, char** signature_ptr, char** generic_ptr) { 2102 ResourceMark rm; 2103 bool isPrimitive = java_lang_Class::is_primitive(k_mirror); 2104 klassOop k = NULL; 2105 if (!isPrimitive) { 2106 k = java_lang_Class::as_klassOop(k_mirror); 2107 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); 2108 } 2109 if (signature_ptr != NULL) { 2110 char* result = NULL; 2111 if (isPrimitive) { 2112 char tchar = type2char(java_lang_Class::primitive_type(k_mirror)); 2113 result = (char*) jvmtiMalloc(2); 2114 result[0] = tchar; 2115 result[1] = '\0'; 2116 } else { 2117 const char* class_sig = Klass::cast(k)->signature_name(); 2118 result = (char *) jvmtiMalloc(strlen(class_sig)+1); 2119 strcpy(result, class_sig); 2120 } 2121 *signature_ptr = result; 2122 } 2123 if (generic_ptr != NULL) { 2124 *generic_ptr = NULL; 2125 if (!isPrimitive && Klass::cast(k)->oop_is_instance()) { 2126 Symbol* soo = instanceKlass::cast(k)->generic_signature(); 2127 if (soo != NULL) { 2128 const char *gen_sig = soo->as_C_string(); 2129 if (gen_sig != NULL) { 2130 char* gen_result; 2131 jvmtiError err = allocate(strlen(gen_sig) + 1, 2132 (unsigned char **)&gen_result); 2133 if (err != JVMTI_ERROR_NONE) { 2134 return err; 2135 } 2136 strcpy(gen_result, gen_sig); 2137 *generic_ptr = gen_result; 2138 } 2139 } 2140 } 2141 } 2142 return JVMTI_ERROR_NONE; 2143} /* end GetClassSignature */ 2144 2145 2146// k_mirror - may be primitive, this must be checked 2147// status_ptr - pre-checked for NULL 2148jvmtiError 2149JvmtiEnv::GetClassStatus(oop k_mirror, jint* status_ptr) { 2150 jint result = 0; 2151 if (java_lang_Class::is_primitive(k_mirror)) { 2152 result |= JVMTI_CLASS_STATUS_PRIMITIVE; 2153 } else { 2154 klassOop k = java_lang_Class::as_klassOop(k_mirror); 2155 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); 2156 result = Klass::cast(k)->jvmti_class_status(); 2157 } 2158 *status_ptr = result; 2159 2160 return JVMTI_ERROR_NONE; 2161} /* end GetClassStatus */ 2162 2163 2164// k_mirror - may be primitive, this must be checked 2165// source_name_ptr - pre-checked for NULL 2166jvmtiError 2167JvmtiEnv::GetSourceFileName(oop k_mirror, char** source_name_ptr) { 2168 if (java_lang_Class::is_primitive(k_mirror)) { 2169 return JVMTI_ERROR_ABSENT_INFORMATION; 2170 } 2171 klassOop k_klass = java_lang_Class::as_klassOop(k_mirror); 2172 NULL_CHECK(k_klass, JVMTI_ERROR_INVALID_CLASS); 2173 2174 if (!Klass::cast(k_klass)->oop_is_instance()) { 2175 return JVMTI_ERROR_ABSENT_INFORMATION; 2176 } 2177 2178 Symbol* sfnOop = instanceKlass::cast(k_klass)->source_file_name(); 2179 NULL_CHECK(sfnOop, JVMTI_ERROR_ABSENT_INFORMATION); 2180 { 2181 JavaThread* current_thread = JavaThread::current(); 2182 ResourceMark rm(current_thread); 2183 const char* sfncp = (const char*) sfnOop->as_C_string(); 2184 *source_name_ptr = (char *) jvmtiMalloc(strlen(sfncp)+1); 2185 strcpy(*source_name_ptr, sfncp); 2186 } 2187 2188 return JVMTI_ERROR_NONE; 2189} /* end GetSourceFileName */ 2190 2191 2192// k_mirror - may be primitive, this must be checked 2193// modifiers_ptr - pre-checked for NULL 2194jvmtiError 2195JvmtiEnv::GetClassModifiers(oop k_mirror, jint* modifiers_ptr) { 2196 JavaThread* current_thread = JavaThread::current(); 2197 jint result = 0; 2198 if (!java_lang_Class::is_primitive(k_mirror)) { 2199 klassOop k = java_lang_Class::as_klassOop(k_mirror); 2200 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); 2201 assert((Klass::cast(k)->oop_is_instance() || Klass::cast(k)->oop_is_array()), "should be an instance or an array klass"); 2202 result = Klass::cast(k)->compute_modifier_flags(current_thread); 2203 JavaThread* THREAD = current_thread; // pass to macros 2204 if (HAS_PENDING_EXCEPTION) { 2205 CLEAR_PENDING_EXCEPTION; 2206 return JVMTI_ERROR_INTERNAL; 2207 }; 2208 2209 // Reset the deleted ACC_SUPER bit ( deleted in compute_modifier_flags()). 2210 if(Klass::cast(k)->is_super()) { 2211 result |= JVM_ACC_SUPER; 2212 } 2213 } else { 2214 result = (JVM_ACC_ABSTRACT | JVM_ACC_FINAL | JVM_ACC_PUBLIC); 2215 } 2216 *modifiers_ptr = result; 2217 2218 return JVMTI_ERROR_NONE; 2219} /* end GetClassModifiers */ 2220 2221 2222// k_mirror - may be primitive, this must be checked 2223// method_count_ptr - pre-checked for NULL 2224// methods_ptr - pre-checked for NULL 2225jvmtiError 2226JvmtiEnv::GetClassMethods(oop k_mirror, jint* method_count_ptr, jmethodID** methods_ptr) { 2227 JavaThread* current_thread = JavaThread::current(); 2228 HandleMark hm(current_thread); 2229 2230 if (java_lang_Class::is_primitive(k_mirror)) { 2231 *method_count_ptr = 0; 2232 *methods_ptr = (jmethodID*) jvmtiMalloc(0 * sizeof(jmethodID)); 2233 return JVMTI_ERROR_NONE; 2234 } 2235 klassOop k = java_lang_Class::as_klassOop(k_mirror); 2236 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); 2237 2238 // Return CLASS_NOT_PREPARED error as per JVMTI spec. 2239 if (!(Klass::cast(k)->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) { 2240 return JVMTI_ERROR_CLASS_NOT_PREPARED; 2241 } 2242 2243 if (!Klass::cast(k)->oop_is_instance()) { 2244 *method_count_ptr = 0; 2245 *methods_ptr = (jmethodID*) jvmtiMalloc(0 * sizeof(jmethodID)); 2246 return JVMTI_ERROR_NONE; 2247 } 2248 instanceKlassHandle instanceK_h(current_thread, k); 2249 // Allocate the result and fill it in 2250 int result_length = instanceK_h->methods()->length(); 2251 jmethodID* result_list = (jmethodID*)jvmtiMalloc(result_length * sizeof(jmethodID)); 2252 int index; 2253 if (JvmtiExport::can_maintain_original_method_order()) { 2254 // Use the original method ordering indices stored in the class, so we can emit 2255 // jmethodIDs in the order they appeared in the class file 2256 for (index = 0; index < result_length; index++) { 2257 methodOop m = methodOop(instanceK_h->methods()->obj_at(index)); 2258 int original_index = instanceK_h->method_ordering()->int_at(index); 2259 assert(original_index >= 0 && original_index < result_length, "invalid original method index"); 2260 jmethodID id = m->jmethod_id(); 2261 result_list[original_index] = id; 2262 } 2263 } else { 2264 // otherwise just copy in any order 2265 for (index = 0; index < result_length; index++) { 2266 methodOop m = methodOop(instanceK_h->methods()->obj_at(index)); 2267 jmethodID id = m->jmethod_id(); 2268 result_list[index] = id; 2269 } 2270 } 2271 // Fill in return value. 2272 *method_count_ptr = result_length; 2273 *methods_ptr = result_list; 2274 2275 return JVMTI_ERROR_NONE; 2276} /* end GetClassMethods */ 2277 2278 2279// k_mirror - may be primitive, this must be checked 2280// field_count_ptr - pre-checked for NULL 2281// fields_ptr - pre-checked for NULL 2282jvmtiError 2283JvmtiEnv::GetClassFields(oop k_mirror, jint* field_count_ptr, jfieldID** fields_ptr) { 2284 if (java_lang_Class::is_primitive(k_mirror)) { 2285 *field_count_ptr = 0; 2286 *fields_ptr = (jfieldID*) jvmtiMalloc(0 * sizeof(jfieldID)); 2287 return JVMTI_ERROR_NONE; 2288 } 2289 JavaThread* current_thread = JavaThread::current(); 2290 HandleMark hm(current_thread); 2291 klassOop k = java_lang_Class::as_klassOop(k_mirror); 2292 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); 2293 2294 // Return CLASS_NOT_PREPARED error as per JVMTI spec. 2295 if (!(Klass::cast(k)->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) { 2296 return JVMTI_ERROR_CLASS_NOT_PREPARED; 2297 } 2298 2299 if (!Klass::cast(k)->oop_is_instance()) { 2300 *field_count_ptr = 0; 2301 *fields_ptr = (jfieldID*) jvmtiMalloc(0 * sizeof(jfieldID)); 2302 return JVMTI_ERROR_NONE; 2303 } 2304 2305 2306 instanceKlassHandle instanceK_h(current_thread, k); 2307 2308 int result_count = 0; 2309 // First, count the fields. 2310 FilteredFieldStream flds(instanceK_h, true, true); 2311 result_count = flds.field_count(); 2312 2313 // Allocate the result and fill it in 2314 jfieldID* result_list = (jfieldID*) jvmtiMalloc(result_count * sizeof(jfieldID)); 2315 // The JVMTI spec requires fields in the order they occur in the class file, 2316 // this is the reverse order of what FieldStream hands out. 2317 int id_index = (result_count - 1); 2318 2319 for (FilteredFieldStream src_st(instanceK_h, true, true); !src_st.eos(); src_st.next()) { 2320 result_list[id_index--] = jfieldIDWorkaround::to_jfieldID( 2321 instanceK_h, src_st.offset(), 2322 src_st.access_flags().is_static()); 2323 } 2324 assert(id_index == -1, "just checking"); 2325 // Fill in the results 2326 *field_count_ptr = result_count; 2327 *fields_ptr = result_list; 2328 2329 return JVMTI_ERROR_NONE; 2330} /* end GetClassFields */ 2331 2332 2333// k_mirror - may be primitive, this must be checked 2334// interface_count_ptr - pre-checked for NULL 2335// interfaces_ptr - pre-checked for NULL 2336jvmtiError 2337JvmtiEnv::GetImplementedInterfaces(oop k_mirror, jint* interface_count_ptr, jclass** interfaces_ptr) { 2338 { 2339 if (java_lang_Class::is_primitive(k_mirror)) { 2340 *interface_count_ptr = 0; 2341 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass)); 2342 return JVMTI_ERROR_NONE; 2343 } 2344 JavaThread* current_thread = JavaThread::current(); 2345 HandleMark hm(current_thread); 2346 klassOop k = java_lang_Class::as_klassOop(k_mirror); 2347 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); 2348 2349 // Return CLASS_NOT_PREPARED error as per JVMTI spec. 2350 if (!(Klass::cast(k)->jvmti_class_status() & (JVMTI_CLASS_STATUS_PREPARED|JVMTI_CLASS_STATUS_ARRAY) )) 2351 return JVMTI_ERROR_CLASS_NOT_PREPARED; 2352 2353 if (!Klass::cast(k)->oop_is_instance()) { 2354 *interface_count_ptr = 0; 2355 *interfaces_ptr = (jclass*) jvmtiMalloc(0 * sizeof(jclass)); 2356 return JVMTI_ERROR_NONE; 2357 } 2358 2359 objArrayHandle interface_list(current_thread, instanceKlass::cast(k)->local_interfaces()); 2360 const int result_length = (interface_list.is_null() ? 0 : interface_list->length()); 2361 jclass* result_list = (jclass*) jvmtiMalloc(result_length * sizeof(jclass)); 2362 for (int i_index = 0; i_index < result_length; i_index += 1) { 2363 oop oop_at = interface_list->obj_at(i_index); 2364 assert(oop_at->is_klass(), "interfaces must be klassOops"); 2365 klassOop klassOop_at = klassOop(oop_at); // ???: is there a better way? 2366 assert(Klass::cast(klassOop_at)->is_interface(), "interfaces must be interfaces"); 2367 oop mirror_at = Klass::cast(klassOop_at)->java_mirror(); 2368 Handle handle_at = Handle(current_thread, mirror_at); 2369 result_list[i_index] = (jclass) jni_reference(handle_at); 2370 } 2371 *interface_count_ptr = result_length; 2372 *interfaces_ptr = result_list; 2373 } 2374 2375 return JVMTI_ERROR_NONE; 2376} /* end GetImplementedInterfaces */ 2377 2378 2379// k_mirror - may be primitive, this must be checked 2380// minor_version_ptr - pre-checked for NULL 2381// major_version_ptr - pre-checked for NULL 2382jvmtiError 2383JvmtiEnv::GetClassVersionNumbers(oop k_mirror, jint* minor_version_ptr, jint* major_version_ptr) { 2384 if (java_lang_Class::is_primitive(k_mirror)) { 2385 return JVMTI_ERROR_ABSENT_INFORMATION; 2386 } 2387 klassOop k_oop = java_lang_Class::as_klassOop(k_mirror); 2388 Thread *thread = Thread::current(); 2389 HandleMark hm(thread); 2390 KlassHandle klass(thread, k_oop); 2391 2392 jint status = klass->jvmti_class_status(); 2393 if (status & (JVMTI_CLASS_STATUS_ERROR)) { 2394 return JVMTI_ERROR_INVALID_CLASS; 2395 } 2396 if (status & (JVMTI_CLASS_STATUS_ARRAY)) { 2397 return JVMTI_ERROR_ABSENT_INFORMATION; 2398 } 2399 2400 instanceKlassHandle ik(thread, k_oop); 2401 *minor_version_ptr = ik->minor_version(); 2402 *major_version_ptr = ik->major_version(); 2403 2404 return JVMTI_ERROR_NONE; 2405} /* end GetClassVersionNumbers */ 2406 2407 2408// k_mirror - may be primitive, this must be checked 2409// constant_pool_count_ptr - pre-checked for NULL 2410// constant_pool_byte_count_ptr - pre-checked for NULL 2411// constant_pool_bytes_ptr - pre-checked for NULL 2412jvmtiError 2413JvmtiEnv::GetConstantPool(oop k_mirror, jint* constant_pool_count_ptr, jint* constant_pool_byte_count_ptr, unsigned char** constant_pool_bytes_ptr) { 2414 if (java_lang_Class::is_primitive(k_mirror)) { 2415 return JVMTI_ERROR_ABSENT_INFORMATION; 2416 } 2417 2418 klassOop k_oop = java_lang_Class::as_klassOop(k_mirror); 2419 Thread *thread = Thread::current(); 2420 HandleMark hm(thread); 2421 ResourceMark rm(thread); 2422 KlassHandle klass(thread, k_oop); 2423 2424 jint status = klass->jvmti_class_status(); 2425 if (status & (JVMTI_CLASS_STATUS_ERROR)) { 2426 return JVMTI_ERROR_INVALID_CLASS; 2427 } 2428 if (status & (JVMTI_CLASS_STATUS_ARRAY)) { 2429 return JVMTI_ERROR_ABSENT_INFORMATION; 2430 } 2431 2432 instanceKlassHandle ikh(thread, k_oop); 2433 constantPoolHandle constants(thread, ikh->constants()); 2434 ObjectLocker ol(constants, thread); // lock constant pool while we query it 2435 2436 JvmtiConstantPoolReconstituter reconstituter(ikh); 2437 if (reconstituter.get_error() != JVMTI_ERROR_NONE) { 2438 return reconstituter.get_error(); 2439 } 2440 2441 unsigned char *cpool_bytes; 2442 int cpool_size = reconstituter.cpool_size(); 2443 if (reconstituter.get_error() != JVMTI_ERROR_NONE) { 2444 return reconstituter.get_error(); 2445 } 2446 jvmtiError res = allocate(cpool_size, &cpool_bytes); 2447 if (res != JVMTI_ERROR_NONE) { 2448 return res; 2449 } 2450 reconstituter.copy_cpool_bytes(cpool_bytes); 2451 if (reconstituter.get_error() != JVMTI_ERROR_NONE) { 2452 return reconstituter.get_error(); 2453 } 2454 2455 *constant_pool_count_ptr = constants->length(); 2456 *constant_pool_byte_count_ptr = cpool_size; 2457 *constant_pool_bytes_ptr = cpool_bytes; 2458 2459 return JVMTI_ERROR_NONE; 2460} /* end GetConstantPool */ 2461 2462 2463// k_mirror - may be primitive, this must be checked 2464// is_interface_ptr - pre-checked for NULL 2465jvmtiError 2466JvmtiEnv::IsInterface(oop k_mirror, jboolean* is_interface_ptr) { 2467 { 2468 bool result = false; 2469 if (!java_lang_Class::is_primitive(k_mirror)) { 2470 klassOop k = java_lang_Class::as_klassOop(k_mirror); 2471 if (k != NULL && Klass::cast(k)->is_interface()) { 2472 result = true; 2473 } 2474 } 2475 *is_interface_ptr = result; 2476 } 2477 2478 return JVMTI_ERROR_NONE; 2479} /* end IsInterface */ 2480 2481 2482// k_mirror - may be primitive, this must be checked 2483// is_array_class_ptr - pre-checked for NULL 2484jvmtiError 2485JvmtiEnv::IsArrayClass(oop k_mirror, jboolean* is_array_class_ptr) { 2486 { 2487 bool result = false; 2488 if (!java_lang_Class::is_primitive(k_mirror)) { 2489 klassOop k = java_lang_Class::as_klassOop(k_mirror); 2490 if (k != NULL && Klass::cast(k)->oop_is_array()) { 2491 result = true; 2492 } 2493 } 2494 *is_array_class_ptr = result; 2495 } 2496 2497 return JVMTI_ERROR_NONE; 2498} /* end IsArrayClass */ 2499 2500 2501// k_mirror - may be primitive, this must be checked 2502// classloader_ptr - pre-checked for NULL 2503jvmtiError 2504JvmtiEnv::GetClassLoader(oop k_mirror, jobject* classloader_ptr) { 2505 { 2506 if (java_lang_Class::is_primitive(k_mirror)) { 2507 *classloader_ptr = (jclass) jni_reference(Handle()); 2508 return JVMTI_ERROR_NONE; 2509 } 2510 JavaThread* current_thread = JavaThread::current(); 2511 HandleMark hm(current_thread); 2512 klassOop k = java_lang_Class::as_klassOop(k_mirror); 2513 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); 2514 2515 oop result_oop = Klass::cast(k)->class_loader(); 2516 if (result_oop == NULL) { 2517 *classloader_ptr = (jclass) jni_reference(Handle()); 2518 return JVMTI_ERROR_NONE; 2519 } 2520 Handle result_handle = Handle(current_thread, result_oop); 2521 jclass result_jnihandle = (jclass) jni_reference(result_handle); 2522 *classloader_ptr = result_jnihandle; 2523 } 2524 return JVMTI_ERROR_NONE; 2525} /* end GetClassLoader */ 2526 2527 2528// k_mirror - may be primitive, this must be checked 2529// source_debug_extension_ptr - pre-checked for NULL 2530jvmtiError 2531JvmtiEnv::GetSourceDebugExtension(oop k_mirror, char** source_debug_extension_ptr) { 2532 { 2533 if (java_lang_Class::is_primitive(k_mirror)) { 2534 return JVMTI_ERROR_ABSENT_INFORMATION; 2535 } 2536 klassOop k = java_lang_Class::as_klassOop(k_mirror); 2537 NULL_CHECK(k, JVMTI_ERROR_INVALID_CLASS); 2538 if (!Klass::cast(k)->oop_is_instance()) { 2539 return JVMTI_ERROR_ABSENT_INFORMATION; 2540 } 2541 Symbol* sdeOop = instanceKlass::cast(k)->source_debug_extension(); 2542 NULL_CHECK(sdeOop, JVMTI_ERROR_ABSENT_INFORMATION); 2543 2544 { 2545 JavaThread* current_thread = JavaThread::current(); 2546 ResourceMark rm(current_thread); 2547 const char* sdecp = (const char*) sdeOop->as_C_string(); 2548 *source_debug_extension_ptr = (char *) jvmtiMalloc(strlen(sdecp)+1); 2549 strcpy(*source_debug_extension_ptr, sdecp); 2550 } 2551 } 2552 2553 return JVMTI_ERROR_NONE; 2554} /* end GetSourceDebugExtension */ 2555 2556 // 2557 // Object functions 2558 // 2559 2560// hash_code_ptr - pre-checked for NULL 2561jvmtiError 2562JvmtiEnv::GetObjectHashCode(jobject object, jint* hash_code_ptr) { 2563 oop mirror = JNIHandles::resolve_external_guard(object); 2564 NULL_CHECK(mirror, JVMTI_ERROR_INVALID_OBJECT); 2565 NULL_CHECK(hash_code_ptr, JVMTI_ERROR_NULL_POINTER); 2566 2567 { 2568 jint result = (jint) mirror->identity_hash(); 2569 *hash_code_ptr = result; 2570 } 2571 return JVMTI_ERROR_NONE; 2572} /* end GetObjectHashCode */ 2573 2574 2575// info_ptr - pre-checked for NULL 2576jvmtiError 2577JvmtiEnv::GetObjectMonitorUsage(jobject object, jvmtiMonitorUsage* info_ptr) { 2578 JavaThread* calling_thread = JavaThread::current(); 2579 jvmtiError err = get_object_monitor_usage(calling_thread, object, info_ptr); 2580 if (err == JVMTI_ERROR_THREAD_NOT_SUSPENDED) { 2581 // Some of the critical threads were not suspended. go to a safepoint and try again 2582 VM_GetObjectMonitorUsage op(this, calling_thread, object, info_ptr); 2583 VMThread::execute(&op); 2584 err = op.result(); 2585 } 2586 return err; 2587} /* end GetObjectMonitorUsage */ 2588 2589 2590 // 2591 // Field functions 2592 // 2593 2594// name_ptr - NULL is a valid value, must be checked 2595// signature_ptr - NULL is a valid value, must be checked 2596// generic_ptr - NULL is a valid value, must be checked 2597jvmtiError 2598JvmtiEnv::GetFieldName(fieldDescriptor* fdesc_ptr, char** name_ptr, char** signature_ptr, char** generic_ptr) { 2599 JavaThread* current_thread = JavaThread::current(); 2600 ResourceMark rm(current_thread); 2601 if (name_ptr == NULL) { 2602 // just don't return the name 2603 } else { 2604 const char* fieldName = fdesc_ptr->name()->as_C_string(); 2605 *name_ptr = (char*) jvmtiMalloc(strlen(fieldName) + 1); 2606 if (*name_ptr == NULL) 2607 return JVMTI_ERROR_OUT_OF_MEMORY; 2608 strcpy(*name_ptr, fieldName); 2609 } 2610 if (signature_ptr== NULL) { 2611 // just don't return the signature 2612 } else { 2613 const char* fieldSignature = fdesc_ptr->signature()->as_C_string(); 2614 *signature_ptr = (char*) jvmtiMalloc(strlen(fieldSignature) + 1); 2615 if (*signature_ptr == NULL) 2616 return JVMTI_ERROR_OUT_OF_MEMORY; 2617 strcpy(*signature_ptr, fieldSignature); 2618 } 2619 if (generic_ptr != NULL) { 2620 *generic_ptr = NULL; 2621 Symbol* soop = fdesc_ptr->generic_signature(); 2622 if (soop != NULL) { 2623 const char* gen_sig = soop->as_C_string(); 2624 if (gen_sig != NULL) { 2625 jvmtiError err = allocate(strlen(gen_sig) + 1, (unsigned char **)generic_ptr); 2626 if (err != JVMTI_ERROR_NONE) { 2627 return err; 2628 } 2629 strcpy(*generic_ptr, gen_sig); 2630 } 2631 } 2632 } 2633 return JVMTI_ERROR_NONE; 2634} /* end GetFieldName */ 2635 2636 2637// declaring_class_ptr - pre-checked for NULL 2638jvmtiError 2639JvmtiEnv::GetFieldDeclaringClass(fieldDescriptor* fdesc_ptr, jclass* declaring_class_ptr) { 2640 2641 *declaring_class_ptr = get_jni_class_non_null(fdesc_ptr->field_holder()); 2642 return JVMTI_ERROR_NONE; 2643} /* end GetFieldDeclaringClass */ 2644 2645 2646// modifiers_ptr - pre-checked for NULL 2647jvmtiError 2648JvmtiEnv::GetFieldModifiers(fieldDescriptor* fdesc_ptr, jint* modifiers_ptr) { 2649 2650 AccessFlags resultFlags = fdesc_ptr->access_flags(); 2651 jint result = resultFlags.as_int(); 2652 *modifiers_ptr = result; 2653 2654 return JVMTI_ERROR_NONE; 2655} /* end GetFieldModifiers */ 2656 2657 2658// is_synthetic_ptr - pre-checked for NULL 2659jvmtiError 2660JvmtiEnv::IsFieldSynthetic(fieldDescriptor* fdesc_ptr, jboolean* is_synthetic_ptr) { 2661 *is_synthetic_ptr = fdesc_ptr->is_synthetic(); 2662 return JVMTI_ERROR_NONE; 2663} /* end IsFieldSynthetic */ 2664 2665 2666 // 2667 // Method functions 2668 // 2669 2670// method_oop - pre-checked for validity, but may be NULL meaning obsolete method 2671// name_ptr - NULL is a valid value, must be checked 2672// signature_ptr - NULL is a valid value, must be checked 2673// generic_ptr - NULL is a valid value, must be checked 2674jvmtiError 2675JvmtiEnv::GetMethodName(methodOop method_oop, char** name_ptr, char** signature_ptr, char** generic_ptr) { 2676 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); 2677 JavaThread* current_thread = JavaThread::current(); 2678 2679 ResourceMark rm(current_thread); // get the utf8 name and signature 2680 if (name_ptr == NULL) { 2681 // just don't return the name 2682 } else { 2683 const char* utf8_name = (const char *) method_oop->name()->as_utf8(); 2684 *name_ptr = (char *) jvmtiMalloc(strlen(utf8_name)+1); 2685 strcpy(*name_ptr, utf8_name); 2686 } 2687 if (signature_ptr == NULL) { 2688 // just don't return the signature 2689 } else { 2690 const char* utf8_signature = (const char *) method_oop->signature()->as_utf8(); 2691 *signature_ptr = (char *) jvmtiMalloc(strlen(utf8_signature) + 1); 2692 strcpy(*signature_ptr, utf8_signature); 2693 } 2694 2695 if (generic_ptr != NULL) { 2696 *generic_ptr = NULL; 2697 Symbol* soop = method_oop->generic_signature(); 2698 if (soop != NULL) { 2699 const char* gen_sig = soop->as_C_string(); 2700 if (gen_sig != NULL) { 2701 jvmtiError err = allocate(strlen(gen_sig) + 1, (unsigned char **)generic_ptr); 2702 if (err != JVMTI_ERROR_NONE) { 2703 return err; 2704 } 2705 strcpy(*generic_ptr, gen_sig); 2706 } 2707 } 2708 } 2709 return JVMTI_ERROR_NONE; 2710} /* end GetMethodName */ 2711 2712 2713// method_oop - pre-checked for validity, but may be NULL meaning obsolete method 2714// declaring_class_ptr - pre-checked for NULL 2715jvmtiError 2716JvmtiEnv::GetMethodDeclaringClass(methodOop method_oop, jclass* declaring_class_ptr) { 2717 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); 2718 (*declaring_class_ptr) = get_jni_class_non_null(method_oop->method_holder()); 2719 return JVMTI_ERROR_NONE; 2720} /* end GetMethodDeclaringClass */ 2721 2722 2723// method_oop - pre-checked for validity, but may be NULL meaning obsolete method 2724// modifiers_ptr - pre-checked for NULL 2725jvmtiError 2726JvmtiEnv::GetMethodModifiers(methodOop method_oop, jint* modifiers_ptr) { 2727 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); 2728 (*modifiers_ptr) = method_oop->access_flags().as_int() & JVM_RECOGNIZED_METHOD_MODIFIERS; 2729 return JVMTI_ERROR_NONE; 2730} /* end GetMethodModifiers */ 2731 2732 2733// method_oop - pre-checked for validity, but may be NULL meaning obsolete method 2734// max_ptr - pre-checked for NULL 2735jvmtiError 2736JvmtiEnv::GetMaxLocals(methodOop method_oop, jint* max_ptr) { 2737 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); 2738 // get max stack 2739 (*max_ptr) = method_oop->max_locals(); 2740 return JVMTI_ERROR_NONE; 2741} /* end GetMaxLocals */ 2742 2743 2744// method_oop - pre-checked for validity, but may be NULL meaning obsolete method 2745// size_ptr - pre-checked for NULL 2746jvmtiError 2747JvmtiEnv::GetArgumentsSize(methodOop method_oop, jint* size_ptr) { 2748 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); 2749 // get size of arguments 2750 2751 (*size_ptr) = method_oop->size_of_parameters(); 2752 return JVMTI_ERROR_NONE; 2753} /* end GetArgumentsSize */ 2754 2755 2756// method_oop - pre-checked for validity, but may be NULL meaning obsolete method 2757// entry_count_ptr - pre-checked for NULL 2758// table_ptr - pre-checked for NULL 2759jvmtiError 2760JvmtiEnv::GetLineNumberTable(methodOop method_oop, jint* entry_count_ptr, jvmtiLineNumberEntry** table_ptr) { 2761 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); 2762 if (!method_oop->has_linenumber_table()) { 2763 return (JVMTI_ERROR_ABSENT_INFORMATION); 2764 } 2765 2766 // The line number table is compressed so we don't know how big it is until decompressed. 2767 // Decompression is really fast so we just do it twice. 2768 2769 // Compute size of table 2770 jint num_entries = 0; 2771 CompressedLineNumberReadStream stream(method_oop->compressed_linenumber_table()); 2772 while (stream.read_pair()) { 2773 num_entries++; 2774 } 2775 jvmtiLineNumberEntry *jvmti_table = 2776 (jvmtiLineNumberEntry *)jvmtiMalloc(num_entries * (sizeof(jvmtiLineNumberEntry))); 2777 2778 // Fill jvmti table 2779 if (num_entries > 0) { 2780 int index = 0; 2781 CompressedLineNumberReadStream stream(method_oop->compressed_linenumber_table()); 2782 while (stream.read_pair()) { 2783 jvmti_table[index].start_location = (jlocation) stream.bci(); 2784 jvmti_table[index].line_number = (jint) stream.line(); 2785 index++; 2786 } 2787 assert(index == num_entries, "sanity check"); 2788 } 2789 2790 // Set up results 2791 (*entry_count_ptr) = num_entries; 2792 (*table_ptr) = jvmti_table; 2793 2794 return JVMTI_ERROR_NONE; 2795} /* end GetLineNumberTable */ 2796 2797 2798// method_oop - pre-checked for validity, but may be NULL meaning obsolete method 2799// start_location_ptr - pre-checked for NULL 2800// end_location_ptr - pre-checked for NULL 2801jvmtiError 2802JvmtiEnv::GetMethodLocation(methodOop method_oop, jlocation* start_location_ptr, jlocation* end_location_ptr) { 2803 2804 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); 2805 // get start and end location 2806 (*end_location_ptr) = (jlocation) (method_oop->code_size() - 1); 2807 if (method_oop->code_size() == 0) { 2808 // there is no code so there is no start location 2809 (*start_location_ptr) = (jlocation)(-1); 2810 } else { 2811 (*start_location_ptr) = (jlocation)(0); 2812 } 2813 2814 return JVMTI_ERROR_NONE; 2815} /* end GetMethodLocation */ 2816 2817 2818// method_oop - pre-checked for validity, but may be NULL meaning obsolete method 2819// entry_count_ptr - pre-checked for NULL 2820// table_ptr - pre-checked for NULL 2821jvmtiError 2822JvmtiEnv::GetLocalVariableTable(methodOop method_oop, jint* entry_count_ptr, jvmtiLocalVariableEntry** table_ptr) { 2823 2824 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); 2825 JavaThread* current_thread = JavaThread::current(); 2826 2827 // does the klass have any local variable information? 2828 instanceKlass* ik = instanceKlass::cast(method_oop->method_holder()); 2829 if (!ik->access_flags().has_localvariable_table()) { 2830 return (JVMTI_ERROR_ABSENT_INFORMATION); 2831 } 2832 2833 constantPoolOop constants = method_oop->constants(); 2834 NULL_CHECK(constants, JVMTI_ERROR_ABSENT_INFORMATION); 2835 2836 // in the vm localvariable table representation, 6 consecutive elements in the table 2837 // represent a 6-tuple of shorts 2838 // [start_pc, length, name_index, descriptor_index, signature_index, index] 2839 jint num_entries = method_oop->localvariable_table_length(); 2840 jvmtiLocalVariableEntry *jvmti_table = (jvmtiLocalVariableEntry *) 2841 jvmtiMalloc(num_entries * (sizeof(jvmtiLocalVariableEntry))); 2842 2843 if (num_entries > 0) { 2844 LocalVariableTableElement* table = method_oop->localvariable_table_start(); 2845 for (int i = 0; i < num_entries; i++) { 2846 // get the 5 tuple information from the vm table 2847 jlocation start_location = (jlocation) table[i].start_bci; 2848 jint length = (jint) table[i].length; 2849 int name_index = (int) table[i].name_cp_index; 2850 int signature_index = (int) table[i].descriptor_cp_index; 2851 int generic_signature_index = (int) table[i].signature_cp_index; 2852 jint slot = (jint) table[i].slot; 2853 2854 // get utf8 name and signature 2855 char *name_buf = NULL; 2856 char *sig_buf = NULL; 2857 char *gen_sig_buf = NULL; 2858 { 2859 ResourceMark rm(current_thread); 2860 2861 const char *utf8_name = (const char *) constants->symbol_at(name_index)->as_utf8(); 2862 name_buf = (char *) jvmtiMalloc(strlen(utf8_name)+1); 2863 strcpy(name_buf, utf8_name); 2864 2865 const char *utf8_signature = (const char *) constants->symbol_at(signature_index)->as_utf8(); 2866 sig_buf = (char *) jvmtiMalloc(strlen(utf8_signature)+1); 2867 strcpy(sig_buf, utf8_signature); 2868 2869 if (generic_signature_index > 0) { 2870 const char *utf8_gen_sign = (const char *) 2871 constants->symbol_at(generic_signature_index)->as_utf8(); 2872 gen_sig_buf = (char *) jvmtiMalloc(strlen(utf8_gen_sign)+1); 2873 strcpy(gen_sig_buf, utf8_gen_sign); 2874 } 2875 } 2876 2877 // fill in the jvmti local variable table 2878 jvmti_table[i].start_location = start_location; 2879 jvmti_table[i].length = length; 2880 jvmti_table[i].name = name_buf; 2881 jvmti_table[i].signature = sig_buf; 2882 jvmti_table[i].generic_signature = gen_sig_buf; 2883 jvmti_table[i].slot = slot; 2884 } 2885 } 2886 2887 // set results 2888 (*entry_count_ptr) = num_entries; 2889 (*table_ptr) = jvmti_table; 2890 2891 return JVMTI_ERROR_NONE; 2892} /* end GetLocalVariableTable */ 2893 2894 2895// method_oop - pre-checked for validity, but may be NULL meaning obsolete method 2896// bytecode_count_ptr - pre-checked for NULL 2897// bytecodes_ptr - pre-checked for NULL 2898jvmtiError 2899JvmtiEnv::GetBytecodes(methodOop method_oop, jint* bytecode_count_ptr, unsigned char** bytecodes_ptr) { 2900 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); 2901 2902 HandleMark hm; 2903 methodHandle method(method_oop); 2904 jint size = (jint)method->code_size(); 2905 jvmtiError err = allocate(size, bytecodes_ptr); 2906 if (err != JVMTI_ERROR_NONE) { 2907 return err; 2908 } 2909 2910 (*bytecode_count_ptr) = size; 2911 // get byte codes 2912 JvmtiClassFileReconstituter::copy_bytecodes(method, *bytecodes_ptr); 2913 2914 return JVMTI_ERROR_NONE; 2915} /* end GetBytecodes */ 2916 2917 2918// method_oop - pre-checked for validity, but may be NULL meaning obsolete method 2919// is_native_ptr - pre-checked for NULL 2920jvmtiError 2921JvmtiEnv::IsMethodNative(methodOop method_oop, jboolean* is_native_ptr) { 2922 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); 2923 (*is_native_ptr) = method_oop->is_native(); 2924 return JVMTI_ERROR_NONE; 2925} /* end IsMethodNative */ 2926 2927 2928// method_oop - pre-checked for validity, but may be NULL meaning obsolete method 2929// is_synthetic_ptr - pre-checked for NULL 2930jvmtiError 2931JvmtiEnv::IsMethodSynthetic(methodOop method_oop, jboolean* is_synthetic_ptr) { 2932 NULL_CHECK(method_oop, JVMTI_ERROR_INVALID_METHODID); 2933 (*is_synthetic_ptr) = method_oop->is_synthetic(); 2934 return JVMTI_ERROR_NONE; 2935} /* end IsMethodSynthetic */ 2936 2937 2938// method_oop - pre-checked for validity, but may be NULL meaning obsolete method 2939// is_obsolete_ptr - pre-checked for NULL 2940jvmtiError 2941JvmtiEnv::IsMethodObsolete(methodOop method_oop, jboolean* is_obsolete_ptr) { 2942 if (use_version_1_0_semantics() && 2943 get_capabilities()->can_redefine_classes == 0) { 2944 // This JvmtiEnv requested version 1.0 semantics and this function 2945 // requires the can_redefine_classes capability in version 1.0 so 2946 // we need to return an error here. 2947 return JVMTI_ERROR_MUST_POSSESS_CAPABILITY; 2948 } 2949 2950 if (method_oop == NULL || method_oop->is_obsolete()) { 2951 *is_obsolete_ptr = true; 2952 } else { 2953 *is_obsolete_ptr = false; 2954 } 2955 return JVMTI_ERROR_NONE; 2956} /* end IsMethodObsolete */ 2957 2958 // 2959 // Raw Monitor functions 2960 // 2961 2962// name - pre-checked for NULL 2963// monitor_ptr - pre-checked for NULL 2964jvmtiError 2965JvmtiEnv::CreateRawMonitor(const char* name, jrawMonitorID* monitor_ptr) { 2966 JvmtiRawMonitor* rmonitor = new JvmtiRawMonitor(name); 2967 NULL_CHECK(rmonitor, JVMTI_ERROR_OUT_OF_MEMORY); 2968 2969 *monitor_ptr = (jrawMonitorID)rmonitor; 2970 2971 return JVMTI_ERROR_NONE; 2972} /* end CreateRawMonitor */ 2973 2974 2975// rmonitor - pre-checked for validity 2976jvmtiError 2977JvmtiEnv::DestroyRawMonitor(JvmtiRawMonitor * rmonitor) { 2978 if (Threads::number_of_threads() == 0) { 2979 // Remove this monitor from pending raw monitors list 2980 // if it has entered in onload or start phase. 2981 JvmtiPendingMonitors::destroy(rmonitor); 2982 } else { 2983 Thread* thread = Thread::current(); 2984 if (rmonitor->is_entered(thread)) { 2985 // The caller owns this monitor which we are about to destroy. 2986 // We exit the underlying synchronization object so that the 2987 // "delete monitor" call below can work without an assertion 2988 // failure on systems that don't like destroying synchronization 2989 // objects that are locked. 2990 int r; 2991 intptr_t recursion = rmonitor->recursions(); 2992 for (intptr_t i=0; i <= recursion; i++) { 2993 r = rmonitor->raw_exit(thread); 2994 assert(r == ObjectMonitor::OM_OK, "raw_exit should have worked"); 2995 if (r != ObjectMonitor::OM_OK) { // robustness 2996 return JVMTI_ERROR_INTERNAL; 2997 } 2998 } 2999 } 3000 if (rmonitor->owner() != NULL) { 3001 // The caller is trying to destroy a monitor that is locked by 3002 // someone else. While this is not forbidden by the JVMTI 3003 // spec, it will cause an assertion failure on systems that don't 3004 // like destroying synchronization objects that are locked. 3005 // We indicate a problem with the error return (and leak the 3006 // monitor's memory). 3007 return JVMTI_ERROR_NOT_MONITOR_OWNER; 3008 } 3009 } 3010 3011 delete rmonitor; 3012 3013 return JVMTI_ERROR_NONE; 3014} /* end DestroyRawMonitor */ 3015 3016 3017// rmonitor - pre-checked for validity 3018jvmtiError 3019JvmtiEnv::RawMonitorEnter(JvmtiRawMonitor * rmonitor) { 3020 if (Threads::number_of_threads() == 0) { 3021 // No JavaThreads exist so ObjectMonitor enter cannot be 3022 // used, add this raw monitor to the pending list. 3023 // The pending monitors will be actually entered when 3024 // the VM is setup. 3025 // See transition_pending_raw_monitors in create_vm() 3026 // in thread.cpp. 3027 JvmtiPendingMonitors::enter(rmonitor); 3028 } else { 3029 int r; 3030 Thread* thread = Thread::current(); 3031 3032 if (thread->is_Java_thread()) { 3033 JavaThread* current_thread = (JavaThread*)thread; 3034 3035#ifdef PROPER_TRANSITIONS 3036 // Not really unknown but ThreadInVMfromNative does more than we want 3037 ThreadInVMfromUnknown __tiv; 3038 { 3039 ThreadBlockInVM __tbivm(current_thread); 3040 r = rmonitor->raw_enter(current_thread); 3041 } 3042#else 3043 /* Transition to thread_blocked without entering vm state */ 3044 /* This is really evil. Normally you can't undo _thread_blocked */ 3045 /* transitions like this because it would cause us to miss a */ 3046 /* safepoint but since the thread was already in _thread_in_native */ 3047 /* the thread is not leaving a safepoint safe state and it will */ 3048 /* block when it tries to return from native. We can't safepoint */ 3049 /* block in here because we could deadlock the vmthread. Blech. */ 3050 3051 JavaThreadState state = current_thread->thread_state(); 3052 assert(state == _thread_in_native, "Must be _thread_in_native"); 3053 // frame should already be walkable since we are in native 3054 assert(!current_thread->has_last_Java_frame() || 3055 current_thread->frame_anchor()->walkable(), "Must be walkable"); 3056 current_thread->set_thread_state(_thread_blocked); 3057 3058 r = rmonitor->raw_enter(current_thread); 3059 // restore state, still at a safepoint safe state 3060 current_thread->set_thread_state(state); 3061 3062#endif /* PROPER_TRANSITIONS */ 3063 assert(r == ObjectMonitor::OM_OK, "raw_enter should have worked"); 3064 } else { 3065 if (thread->is_VM_thread() || thread->is_ConcurrentGC_thread()) { 3066 r = rmonitor->raw_enter(thread); 3067 } else { 3068 ShouldNotReachHere(); 3069 } 3070 } 3071 3072 if (r != ObjectMonitor::OM_OK) { // robustness 3073 return JVMTI_ERROR_INTERNAL; 3074 } 3075 } 3076 return JVMTI_ERROR_NONE; 3077} /* end RawMonitorEnter */ 3078 3079 3080// rmonitor - pre-checked for validity 3081jvmtiError 3082JvmtiEnv::RawMonitorExit(JvmtiRawMonitor * rmonitor) { 3083 jvmtiError err = JVMTI_ERROR_NONE; 3084 3085 if (Threads::number_of_threads() == 0) { 3086 // No JavaThreads exist so just remove this monitor from the pending list. 3087 // Bool value from exit is false if rmonitor is not in the list. 3088 if (!JvmtiPendingMonitors::exit(rmonitor)) { 3089 err = JVMTI_ERROR_NOT_MONITOR_OWNER; 3090 } 3091 } else { 3092 int r; 3093 Thread* thread = Thread::current(); 3094 3095 if (thread->is_Java_thread()) { 3096 JavaThread* current_thread = (JavaThread*)thread; 3097#ifdef PROPER_TRANSITIONS 3098 // Not really unknown but ThreadInVMfromNative does more than we want 3099 ThreadInVMfromUnknown __tiv; 3100#endif /* PROPER_TRANSITIONS */ 3101 r = rmonitor->raw_exit(current_thread); 3102 } else { 3103 if (thread->is_VM_thread() || thread->is_ConcurrentGC_thread()) { 3104 r = rmonitor->raw_exit(thread); 3105 } else { 3106 ShouldNotReachHere(); 3107 } 3108 } 3109 3110 if (r == ObjectMonitor::OM_ILLEGAL_MONITOR_STATE) { 3111 err = JVMTI_ERROR_NOT_MONITOR_OWNER; 3112 } else { 3113 assert(r == ObjectMonitor::OM_OK, "raw_exit should have worked"); 3114 if (r != ObjectMonitor::OM_OK) { // robustness 3115 err = JVMTI_ERROR_INTERNAL; 3116 } 3117 } 3118 } 3119 return err; 3120} /* end RawMonitorExit */ 3121 3122 3123// rmonitor - pre-checked for validity 3124jvmtiError 3125JvmtiEnv::RawMonitorWait(JvmtiRawMonitor * rmonitor, jlong millis) { 3126 int r; 3127 Thread* thread = Thread::current(); 3128 3129 if (thread->is_Java_thread()) { 3130 JavaThread* current_thread = (JavaThread*)thread; 3131#ifdef PROPER_TRANSITIONS 3132 // Not really unknown but ThreadInVMfromNative does more than we want 3133 ThreadInVMfromUnknown __tiv; 3134 { 3135 ThreadBlockInVM __tbivm(current_thread); 3136 r = rmonitor->raw_wait(millis, true, current_thread); 3137 } 3138#else 3139 /* Transition to thread_blocked without entering vm state */ 3140 /* This is really evil. Normally you can't undo _thread_blocked */ 3141 /* transitions like this because it would cause us to miss a */ 3142 /* safepoint but since the thread was already in _thread_in_native */ 3143 /* the thread is not leaving a safepoint safe state and it will */ 3144 /* block when it tries to return from native. We can't safepoint */ 3145 /* block in here because we could deadlock the vmthread. Blech. */ 3146 3147 JavaThreadState state = current_thread->thread_state(); 3148 assert(state == _thread_in_native, "Must be _thread_in_native"); 3149 // frame should already be walkable since we are in native 3150 assert(!current_thread->has_last_Java_frame() || 3151 current_thread->frame_anchor()->walkable(), "Must be walkable"); 3152 current_thread->set_thread_state(_thread_blocked); 3153 3154 r = rmonitor->raw_wait(millis, true, current_thread); 3155 // restore state, still at a safepoint safe state 3156 current_thread->set_thread_state(state); 3157 3158#endif /* PROPER_TRANSITIONS */ 3159 } else { 3160 if (thread->is_VM_thread() || thread->is_ConcurrentGC_thread()) { 3161 r = rmonitor->raw_wait(millis, true, thread); 3162 } else { 3163 ShouldNotReachHere(); 3164 } 3165 } 3166 3167 switch (r) { 3168 case ObjectMonitor::OM_INTERRUPTED: 3169 return JVMTI_ERROR_INTERRUPT; 3170 case ObjectMonitor::OM_ILLEGAL_MONITOR_STATE: 3171 return JVMTI_ERROR_NOT_MONITOR_OWNER; 3172 } 3173 assert(r == ObjectMonitor::OM_OK, "raw_wait should have worked"); 3174 if (r != ObjectMonitor::OM_OK) { // robustness 3175 return JVMTI_ERROR_INTERNAL; 3176 } 3177 3178 return JVMTI_ERROR_NONE; 3179} /* end RawMonitorWait */ 3180 3181 3182// rmonitor - pre-checked for validity 3183jvmtiError 3184JvmtiEnv::RawMonitorNotify(JvmtiRawMonitor * rmonitor) { 3185 int r; 3186 Thread* thread = Thread::current(); 3187 3188 if (thread->is_Java_thread()) { 3189 JavaThread* current_thread = (JavaThread*)thread; 3190 // Not really unknown but ThreadInVMfromNative does more than we want 3191 ThreadInVMfromUnknown __tiv; 3192 r = rmonitor->raw_notify(current_thread); 3193 } else { 3194 if (thread->is_VM_thread() || thread->is_ConcurrentGC_thread()) { 3195 r = rmonitor->raw_notify(thread); 3196 } else { 3197 ShouldNotReachHere(); 3198 } 3199 } 3200 3201 if (r == ObjectMonitor::OM_ILLEGAL_MONITOR_STATE) { 3202 return JVMTI_ERROR_NOT_MONITOR_OWNER; 3203 } 3204 assert(r == ObjectMonitor::OM_OK, "raw_notify should have worked"); 3205 if (r != ObjectMonitor::OM_OK) { // robustness 3206 return JVMTI_ERROR_INTERNAL; 3207 } 3208 3209 return JVMTI_ERROR_NONE; 3210} /* end RawMonitorNotify */ 3211 3212 3213// rmonitor - pre-checked for validity 3214jvmtiError 3215JvmtiEnv::RawMonitorNotifyAll(JvmtiRawMonitor * rmonitor) { 3216 int r; 3217 Thread* thread = Thread::current(); 3218 3219 if (thread->is_Java_thread()) { 3220 JavaThread* current_thread = (JavaThread*)thread; 3221 ThreadInVMfromUnknown __tiv; 3222 r = rmonitor->raw_notifyAll(current_thread); 3223 } else { 3224 if (thread->is_VM_thread() || thread->is_ConcurrentGC_thread()) { 3225 r = rmonitor->raw_notifyAll(thread); 3226 } else { 3227 ShouldNotReachHere(); 3228 } 3229 } 3230 3231 if (r == ObjectMonitor::OM_ILLEGAL_MONITOR_STATE) { 3232 return JVMTI_ERROR_NOT_MONITOR_OWNER; 3233 } 3234 assert(r == ObjectMonitor::OM_OK, "raw_notifyAll should have worked"); 3235 if (r != ObjectMonitor::OM_OK) { // robustness 3236 return JVMTI_ERROR_INTERNAL; 3237 } 3238 3239 return JVMTI_ERROR_NONE; 3240} /* end RawMonitorNotifyAll */ 3241 3242 3243 // 3244 // JNI Function Interception functions 3245 // 3246 3247 3248// function_table - pre-checked for NULL 3249jvmtiError 3250JvmtiEnv::SetJNIFunctionTable(const jniNativeInterface* function_table) { 3251 // Copy jni function table at safepoint. 3252 VM_JNIFunctionTableCopier copier(function_table); 3253 VMThread::execute(&copier); 3254 3255 return JVMTI_ERROR_NONE; 3256} /* end SetJNIFunctionTable */ 3257 3258 3259// function_table - pre-checked for NULL 3260jvmtiError 3261JvmtiEnv::GetJNIFunctionTable(jniNativeInterface** function_table) { 3262 *function_table=(jniNativeInterface*)jvmtiMalloc(sizeof(jniNativeInterface)); 3263 if (*function_table == NULL) 3264 return JVMTI_ERROR_OUT_OF_MEMORY; 3265 memcpy(*function_table,(JavaThread::current())->get_jni_functions(),sizeof(jniNativeInterface)); 3266 return JVMTI_ERROR_NONE; 3267} /* end GetJNIFunctionTable */ 3268 3269 3270 // 3271 // Event Management functions 3272 // 3273 3274jvmtiError 3275JvmtiEnv::GenerateEvents(jvmtiEvent event_type) { 3276 // can only generate two event types 3277 if (event_type != JVMTI_EVENT_COMPILED_METHOD_LOAD && 3278 event_type != JVMTI_EVENT_DYNAMIC_CODE_GENERATED) { 3279 return JVMTI_ERROR_ILLEGAL_ARGUMENT; 3280 } 3281 3282 // for compiled_method_load events we must check that the environment 3283 // has the can_generate_compiled_method_load_events capability. 3284 if (event_type == JVMTI_EVENT_COMPILED_METHOD_LOAD) { 3285 if (get_capabilities()->can_generate_compiled_method_load_events == 0) { 3286 return JVMTI_ERROR_MUST_POSSESS_CAPABILITY; 3287 } 3288 return JvmtiCodeBlobEvents::generate_compiled_method_load_events(this); 3289 } else { 3290 return JvmtiCodeBlobEvents::generate_dynamic_code_events(this); 3291 } 3292 3293} /* end GenerateEvents */ 3294 3295 3296 // 3297 // Extension Mechanism functions 3298 // 3299 3300// extension_count_ptr - pre-checked for NULL 3301// extensions - pre-checked for NULL 3302jvmtiError 3303JvmtiEnv::GetExtensionFunctions(jint* extension_count_ptr, jvmtiExtensionFunctionInfo** extensions) { 3304 return JvmtiExtensions::get_functions(this, extension_count_ptr, extensions); 3305} /* end GetExtensionFunctions */ 3306 3307 3308// extension_count_ptr - pre-checked for NULL 3309// extensions - pre-checked for NULL 3310jvmtiError 3311JvmtiEnv::GetExtensionEvents(jint* extension_count_ptr, jvmtiExtensionEventInfo** extensions) { 3312 return JvmtiExtensions::get_events(this, extension_count_ptr, extensions); 3313} /* end GetExtensionEvents */ 3314 3315 3316// callback - NULL is a valid value, must be checked 3317jvmtiError 3318JvmtiEnv::SetExtensionEventCallback(jint extension_event_index, jvmtiExtensionEvent callback) { 3319 return JvmtiExtensions::set_event_callback(this, extension_event_index, callback); 3320} /* end SetExtensionEventCallback */ 3321 3322 // 3323 // Timers functions 3324 // 3325 3326// info_ptr - pre-checked for NULL 3327jvmtiError 3328JvmtiEnv::GetCurrentThreadCpuTimerInfo(jvmtiTimerInfo* info_ptr) { 3329 os::current_thread_cpu_time_info(info_ptr); 3330 return JVMTI_ERROR_NONE; 3331} /* end GetCurrentThreadCpuTimerInfo */ 3332 3333 3334// nanos_ptr - pre-checked for NULL 3335jvmtiError 3336JvmtiEnv::GetCurrentThreadCpuTime(jlong* nanos_ptr) { 3337 *nanos_ptr = os::current_thread_cpu_time(); 3338 return JVMTI_ERROR_NONE; 3339} /* end GetCurrentThreadCpuTime */ 3340 3341 3342// info_ptr - pre-checked for NULL 3343jvmtiError 3344JvmtiEnv::GetThreadCpuTimerInfo(jvmtiTimerInfo* info_ptr) { 3345 os::thread_cpu_time_info(info_ptr); 3346 return JVMTI_ERROR_NONE; 3347} /* end GetThreadCpuTimerInfo */ 3348 3349 3350// Threads_lock NOT held, java_thread not protected by lock 3351// java_thread - pre-checked 3352// nanos_ptr - pre-checked for NULL 3353jvmtiError 3354JvmtiEnv::GetThreadCpuTime(JavaThread* java_thread, jlong* nanos_ptr) { 3355 *nanos_ptr = os::thread_cpu_time(java_thread); 3356 return JVMTI_ERROR_NONE; 3357} /* end GetThreadCpuTime */ 3358 3359 3360// info_ptr - pre-checked for NULL 3361jvmtiError 3362JvmtiEnv::GetTimerInfo(jvmtiTimerInfo* info_ptr) { 3363 os::javaTimeNanos_info(info_ptr); 3364 return JVMTI_ERROR_NONE; 3365} /* end GetTimerInfo */ 3366 3367 3368// nanos_ptr - pre-checked for NULL 3369jvmtiError 3370JvmtiEnv::GetTime(jlong* nanos_ptr) { 3371 *nanos_ptr = os::javaTimeNanos(); 3372 return JVMTI_ERROR_NONE; 3373} /* end GetTime */ 3374 3375 3376// processor_count_ptr - pre-checked for NULL 3377jvmtiError 3378JvmtiEnv::GetAvailableProcessors(jint* processor_count_ptr) { 3379 *processor_count_ptr = os::active_processor_count(); 3380 return JVMTI_ERROR_NONE; 3381} /* end GetAvailableProcessors */ 3382 3383 // 3384 // System Properties functions 3385 // 3386 3387// count_ptr - pre-checked for NULL 3388// property_ptr - pre-checked for NULL 3389jvmtiError 3390JvmtiEnv::GetSystemProperties(jint* count_ptr, char*** property_ptr) { 3391 jvmtiError err = JVMTI_ERROR_NONE; 3392 3393 *count_ptr = Arguments::PropertyList_count(Arguments::system_properties()); 3394 3395 err = allocate(*count_ptr * sizeof(char *), (unsigned char **)property_ptr); 3396 if (err != JVMTI_ERROR_NONE) { 3397 return err; 3398 } 3399 int i = 0 ; 3400 for (SystemProperty* p = Arguments::system_properties(); p != NULL && i < *count_ptr; p = p->next(), i++) { 3401 const char *key = p->key(); 3402 char **tmp_value = *property_ptr+i; 3403 err = allocate((strlen(key)+1) * sizeof(char), (unsigned char**)tmp_value); 3404 if (err == JVMTI_ERROR_NONE) { 3405 strcpy(*tmp_value, key); 3406 } else { 3407 // clean up previously allocated memory. 3408 for (int j=0; j<i; j++) { 3409 Deallocate((unsigned char*)*property_ptr+j); 3410 } 3411 Deallocate((unsigned char*)property_ptr); 3412 break; 3413 } 3414 } 3415 return err; 3416} /* end GetSystemProperties */ 3417 3418 3419// property - pre-checked for NULL 3420// value_ptr - pre-checked for NULL 3421jvmtiError 3422JvmtiEnv::GetSystemProperty(const char* property, char** value_ptr) { 3423 jvmtiError err = JVMTI_ERROR_NONE; 3424 const char *value; 3425 3426 value = Arguments::PropertyList_get_value(Arguments::system_properties(), property); 3427 if (value == NULL) { 3428 err = JVMTI_ERROR_NOT_AVAILABLE; 3429 } else { 3430 err = allocate((strlen(value)+1) * sizeof(char), (unsigned char **)value_ptr); 3431 if (err == JVMTI_ERROR_NONE) { 3432 strcpy(*value_ptr, value); 3433 } 3434 } 3435 return err; 3436} /* end GetSystemProperty */ 3437 3438 3439// property - pre-checked for NULL 3440// value - NULL is a valid value, must be checked 3441jvmtiError 3442JvmtiEnv::SetSystemProperty(const char* property, const char* value_ptr) { 3443 jvmtiError err =JVMTI_ERROR_NOT_AVAILABLE; 3444 3445 for (SystemProperty* p = Arguments::system_properties(); p != NULL; p = p->next()) { 3446 if (strcmp(property, p->key()) == 0) { 3447 if (p->set_value((char *)value_ptr)) { 3448 err = JVMTI_ERROR_NONE; 3449 } 3450 } 3451 } 3452 return err; 3453} /* end SetSystemProperty */ 3454 3455#endif // !JVMTI_KERNEL 3456