Mercurial > hg > truffle
annotate src/share/vm/prims/jvmtiEnvBase.cpp @ 8733:9def4075da6d
8008079: G1: Add nextObject routine to CMBitMapRO and replace nextWord
Summary: Update the task local finger to the start of the next object when marking aborts, in order to avoid the redundant scanning of all 0's when the marking task restarts, if otherwise updating to the next word. In addition, reuse the routine nextObject() in routine iterate().
Reviewed-by: johnc, ysr
Contributed-by: tamao <tao.mao@oracle.com>
| author | tamao |
|---|---|
| date | Tue, 05 Mar 2013 15:36:56 -0800 |
| parents | 8b46b0196eb0 |
| children | 5fc51c1ecdeb 5ee250974db9 |
| rev | line source |
|---|---|
| 0 | 1 /* |
| 7951 | 2 * Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved. |
| 0 | 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| 4 * | |
| 5 * This code is free software; you can redistribute it and/or modify it | |
| 6 * under the terms of the GNU General Public License version 2 only, as | |
| 7 * published by the Free Software Foundation. | |
| 8 * | |
| 9 * This code is distributed in the hope that it will be useful, but WITHOUT | |
| 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 12 * version 2 for more details (a copy is included in the LICENSE file that | |
| 13 * accompanied this code). | |
| 14 * | |
| 15 * You should have received a copy of the GNU General Public License version | |
| 16 * 2 along with this work; if not, write to the Free Software Foundation, | |
| 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. | |
| 18 * | |
|
1552
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1144
diff
changeset
|
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1144
diff
changeset
|
20 * or visit www.oracle.com if you need additional information or have any |
|
c18cbe5936b8
6941466: Oracle rebranding changes for Hotspot repositories
trims
parents:
1144
diff
changeset
|
21 * questions. |
| 0 | 22 * |
| 23 */ | |
| 24 | |
| 1972 | 25 #include "precompiled.hpp" |
| 26 #include "classfile/systemDictionary.hpp" | |
| 27 #include "jvmtifiles/jvmtiEnv.hpp" | |
| 28 #include "oops/objArrayKlass.hpp" | |
| 29 #include "oops/objArrayOop.hpp" | |
| 30 #include "prims/jvmtiEnvBase.hpp" | |
| 31 #include "prims/jvmtiEventController.inline.hpp" | |
| 32 #include "prims/jvmtiExtensions.hpp" | |
| 33 #include "prims/jvmtiImpl.hpp" | |
| 34 #include "prims/jvmtiManageCapabilities.hpp" | |
| 35 #include "prims/jvmtiTagMap.hpp" | |
| 36 #include "prims/jvmtiThreadState.inline.hpp" | |
| 37 #include "runtime/biasedLocking.hpp" | |
| 38 #include "runtime/deoptimization.hpp" | |
| 39 #include "runtime/interfaceSupport.hpp" | |
| 40 #include "runtime/jfieldIDWorkaround.hpp" | |
| 41 #include "runtime/objectMonitor.hpp" | |
| 42 #include "runtime/objectMonitor.inline.hpp" | |
| 43 #include "runtime/signature.hpp" | |
| 44 #include "runtime/vframe.hpp" | |
| 45 #include "runtime/vframe_hp.hpp" | |
| 46 #include "runtime/vmThread.hpp" | |
| 47 #include "runtime/vm_operations.hpp" | |
| 0 | 48 |
| 49 /////////////////////////////////////////////////////////////// | |
| 50 // | |
| 51 // JvmtiEnvBase | |
| 52 // | |
| 53 | |
| 54 JvmtiEnvBase* JvmtiEnvBase::_head_environment = NULL; | |
| 55 | |
| 56 bool JvmtiEnvBase::_globally_initialized = false; | |
| 57 volatile bool JvmtiEnvBase::_needs_clean_up = false; | |
| 58 | |
| 59 jvmtiPhase JvmtiEnvBase::_phase = JVMTI_PHASE_PRIMORDIAL; | |
| 60 | |
| 61 volatile int JvmtiEnvBase::_dying_thread_env_iteration_count = 0; | |
| 62 | |
| 63 extern jvmtiInterface_1_ jvmti_Interface; | |
| 64 extern jvmtiInterface_1_ jvmtiTrace_Interface; | |
| 65 | |
| 66 | |
| 67 // perform initializations that must occur before any JVMTI environments | |
| 68 // are released but which should only be initialized once (no matter | |
| 69 // how many environments are created). | |
| 70 void | |
| 71 JvmtiEnvBase::globally_initialize() { | |
| 72 assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check"); | |
| 73 assert(_globally_initialized == false, "bad call"); | |
| 74 | |
| 75 JvmtiManageCapabilities::initialize(); | |
| 76 | |
| 77 // register extension functions and events | |
| 78 JvmtiExtensions::register_extensions(); | |
| 79 | |
| 80 #ifdef JVMTI_TRACE | |
| 81 JvmtiTrace::initialize(); | |
| 82 #endif | |
| 83 | |
| 84 _globally_initialized = true; | |
| 85 } | |
| 86 | |
| 87 | |
| 88 void | |
| 89 JvmtiEnvBase::initialize() { | |
| 90 assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check"); | |
| 91 | |
| 92 // Add this environment to the end of the environment list (order is important) | |
| 93 { | |
| 94 // This block of code must not contain any safepoints, as list deallocation | |
| 95 // (which occurs at a safepoint) cannot occur simultaneously with this list | |
| 96 // addition. Note: No_Safepoint_Verifier cannot, currently, be used before | |
| 97 // threads exist. | |
| 98 JvmtiEnvIterator it; | |
| 99 JvmtiEnvBase *previous_env = NULL; | |
| 100 for (JvmtiEnvBase* env = it.first(); env != NULL; env = it.next(env)) { | |
| 101 previous_env = env; | |
| 102 } | |
| 103 if (previous_env == NULL) { | |
| 104 _head_environment = this; | |
| 105 } else { | |
| 106 previous_env->set_next_environment(this); | |
| 107 } | |
| 108 } | |
| 109 | |
| 110 if (_globally_initialized == false) { | |
| 111 globally_initialize(); | |
| 112 } | |
| 113 } | |
| 114 | |
| 115 | |
|
611
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
116 bool |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
117 JvmtiEnvBase::is_valid() { |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
118 jint value = 0; |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
119 |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
120 // This object might not be a JvmtiEnvBase so we can't assume |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
121 // the _magic field is properly aligned. Get the value in a safe |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
122 // way and then check against JVMTI_MAGIC. |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
123 |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
124 switch (sizeof(_magic)) { |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
125 case 2: |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
126 value = Bytes::get_native_u2((address)&_magic); |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
127 break; |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
128 |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
129 case 4: |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
130 value = Bytes::get_native_u4((address)&_magic); |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
131 break; |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
132 |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
133 case 8: |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
134 value = Bytes::get_native_u8((address)&_magic); |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
135 break; |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
136 |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
137 default: |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
138 guarantee(false, "_magic field is an unexpected size"); |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
139 } |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
140 |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
141 return value == JVMTI_MAGIC; |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
142 } |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
143 |
|
2f716c0acb64
6567360: 3/4 SIGBUS in jvmti RawMonitor magic check for unaligned bad monitor pointer
dcubed
parents:
609
diff
changeset
|
144 |
| 1122 | 145 bool |
| 1121 | 146 JvmtiEnvBase::use_version_1_0_semantics() { |
| 147 int major, minor, micro; | |
| 148 | |
| 149 JvmtiExport::decode_version_values(_version, &major, &minor, µ); | |
| 150 return major == 1 && minor == 0; // micro version doesn't matter here | |
| 151 } | |
| 152 | |
| 153 | |
| 154 bool | |
| 155 JvmtiEnvBase::use_version_1_1_semantics() { | |
| 156 int major, minor, micro; | |
| 157 | |
| 158 JvmtiExport::decode_version_values(_version, &major, &minor, µ); | |
| 159 return major == 1 && minor == 1; // micro version doesn't matter here | |
| 160 } | |
| 161 | |
| 1988 | 162 bool |
| 163 JvmtiEnvBase::use_version_1_2_semantics() { | |
| 164 int major, minor, micro; | |
| 165 | |
| 166 JvmtiExport::decode_version_values(_version, &major, &minor, µ); | |
| 167 return major == 1 && minor == 2; // micro version doesn't matter here | |
| 168 } | |
| 169 | |
| 1121 | 170 |
| 171 JvmtiEnvBase::JvmtiEnvBase(jint version) : _env_event_enable() { | |
| 172 _version = version; | |
| 0 | 173 _env_local_storage = NULL; |
| 174 _tag_map = NULL; | |
| 175 _native_method_prefix_count = 0; | |
| 176 _native_method_prefixes = NULL; | |
| 177 _next = NULL; | |
| 178 _class_file_load_hook_ever_enabled = false; | |
| 179 | |
| 180 // Moot since ClassFileLoadHook not yet enabled. | |
| 181 // But "true" will give a more predictable ClassFileLoadHook behavior | |
| 182 // for environment creation during ClassFileLoadHook. | |
| 183 _is_retransformable = true; | |
| 184 | |
| 185 // all callbacks initially NULL | |
| 186 memset(&_event_callbacks,0,sizeof(jvmtiEventCallbacks)); | |
| 187 | |
| 188 // all capabilities initially off | |
| 189 memset(&_current_capabilities, 0, sizeof(_current_capabilities)); | |
| 190 | |
| 191 // all prohibited capabilities initially off | |
| 192 memset(&_prohibited_capabilities, 0, sizeof(_prohibited_capabilities)); | |
| 193 | |
| 194 _magic = JVMTI_MAGIC; | |
| 195 | |
| 196 JvmtiEventController::env_initialize((JvmtiEnv*)this); | |
| 197 | |
| 198 #ifdef JVMTI_TRACE | |
| 371 | 199 _jvmti_external.functions = TraceJVMTI != NULL ? &jvmtiTrace_Interface : &jvmti_Interface; |
| 0 | 200 #else |
| 201 _jvmti_external.functions = &jvmti_Interface; | |
| 202 #endif | |
| 203 } | |
| 204 | |
| 205 | |
| 206 void | |
| 207 JvmtiEnvBase::dispose() { | |
| 208 | |
| 209 #ifdef JVMTI_TRACE | |
| 210 JvmtiTrace::shutdown(); | |
| 211 #endif | |
| 212 | |
| 213 // Dispose of event info and let the event controller call us back | |
| 214 // in a locked state (env_dispose, below) | |
| 215 JvmtiEventController::env_dispose(this); | |
| 216 } | |
| 217 | |
| 218 void | |
| 219 JvmtiEnvBase::env_dispose() { | |
| 220 assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check"); | |
| 221 | |
| 222 // We have been entered with all events disabled on this environment. | |
| 223 // A race to re-enable events (by setting callbacks) is prevented by | |
| 224 // checking for a valid environment when setting callbacks (while | |
| 225 // holding the JvmtiThreadState_lock). | |
| 226 | |
| 227 // Mark as invalid. | |
| 228 _magic = DISPOSED_MAGIC; | |
| 229 | |
| 230 // Relinquish all capabilities. | |
| 231 jvmtiCapabilities *caps = get_capabilities(); | |
| 232 JvmtiManageCapabilities::relinquish_capabilities(caps, caps, caps); | |
| 233 | |
| 234 // Same situation as with events (see above) | |
| 235 set_native_method_prefixes(0, NULL); | |
| 236 | |
| 237 JvmtiTagMap* tag_map_to_deallocate = _tag_map; | |
| 238 set_tag_map(NULL); | |
| 239 // A tag map can be big, deallocate it now | |
| 240 if (tag_map_to_deallocate != NULL) { | |
| 241 delete tag_map_to_deallocate; | |
| 242 } | |
| 243 | |
| 244 _needs_clean_up = true; | |
| 245 } | |
| 246 | |
| 247 | |
| 248 JvmtiEnvBase::~JvmtiEnvBase() { | |
| 249 assert(SafepointSynchronize::is_at_safepoint(), "sanity check"); | |
| 250 | |
| 251 // There is a small window of time during which the tag map of a | |
| 252 // disposed environment could have been reallocated. | |
| 253 // Make sure it is gone. | |
| 254 JvmtiTagMap* tag_map_to_deallocate = _tag_map; | |
| 255 set_tag_map(NULL); | |
| 256 // A tag map can be big, deallocate it now | |
| 257 if (tag_map_to_deallocate != NULL) { | |
| 258 delete tag_map_to_deallocate; | |
| 259 } | |
| 260 | |
| 261 _magic = BAD_MAGIC; | |
| 262 } | |
| 263 | |
| 264 | |
| 265 void | |
| 266 JvmtiEnvBase::periodic_clean_up() { | |
| 267 assert(SafepointSynchronize::is_at_safepoint(), "sanity check"); | |
| 268 | |
| 269 // JvmtiEnvBase reference is saved in JvmtiEnvThreadState. So | |
| 270 // clean up JvmtiThreadState before deleting JvmtiEnv pointer. | |
| 271 JvmtiThreadState::periodic_clean_up(); | |
| 272 | |
| 273 // Unlink all invalid environments from the list of environments | |
| 274 // and deallocate them | |
| 275 JvmtiEnvIterator it; | |
| 276 JvmtiEnvBase* previous_env = NULL; | |
| 277 JvmtiEnvBase* env = it.first(); | |
| 278 while (env != NULL) { | |
| 279 if (env->is_valid()) { | |
| 280 previous_env = env; | |
| 281 env = it.next(env); | |
| 282 } else { | |
| 283 // This one isn't valid, remove it from the list and deallocate it | |
| 284 JvmtiEnvBase* defunct_env = env; | |
| 285 env = it.next(env); | |
| 286 if (previous_env == NULL) { | |
| 287 _head_environment = env; | |
| 288 } else { | |
| 289 previous_env->set_next_environment(env); | |
| 290 } | |
| 291 delete defunct_env; | |
| 292 } | |
| 293 } | |
| 294 | |
| 295 } | |
| 296 | |
| 297 | |
| 298 void | |
| 299 JvmtiEnvBase::check_for_periodic_clean_up() { | |
| 300 assert(SafepointSynchronize::is_at_safepoint(), "sanity check"); | |
| 301 | |
| 302 class ThreadInsideIterationClosure: public ThreadClosure { | |
| 303 private: | |
| 304 bool _inside; | |
| 305 public: | |
| 306 ThreadInsideIterationClosure() : _inside(false) {}; | |
| 307 | |
| 308 void do_thread(Thread* thread) { | |
| 309 _inside |= thread->is_inside_jvmti_env_iteration(); | |
| 310 } | |
| 311 | |
| 312 bool is_inside_jvmti_env_iteration() { | |
| 313 return _inside; | |
| 314 } | |
| 315 }; | |
| 316 | |
| 317 if (_needs_clean_up) { | |
| 318 // Check if we are currently iterating environment, | |
| 319 // deallocation should not occur if we are | |
| 320 ThreadInsideIterationClosure tiic; | |
| 321 Threads::threads_do(&tiic); | |
| 322 if (!tiic.is_inside_jvmti_env_iteration() && | |
| 323 !is_inside_dying_thread_env_iteration()) { | |
| 324 _needs_clean_up = false; | |
| 325 JvmtiEnvBase::periodic_clean_up(); | |
| 326 } | |
| 327 } | |
| 328 } | |
| 329 | |
| 330 | |
| 331 void | |
| 332 JvmtiEnvBase::record_first_time_class_file_load_hook_enabled() { | |
| 333 assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), | |
| 334 "sanity check"); | |
| 335 | |
| 336 if (!_class_file_load_hook_ever_enabled) { | |
| 337 _class_file_load_hook_ever_enabled = true; | |
| 338 | |
| 339 if (get_capabilities()->can_retransform_classes) { | |
| 340 _is_retransformable = true; | |
| 341 } else { | |
| 342 _is_retransformable = false; | |
| 343 | |
| 344 // cannot add retransform capability after ClassFileLoadHook has been enabled | |
| 345 get_prohibited_capabilities()->can_retransform_classes = 1; | |
| 346 } | |
| 347 } | |
| 348 } | |
| 349 | |
| 350 | |
| 351 void | |
| 352 JvmtiEnvBase::record_class_file_load_hook_enabled() { | |
| 353 if (!_class_file_load_hook_ever_enabled) { | |
| 354 if (Threads::number_of_threads() == 0) { | |
| 355 record_first_time_class_file_load_hook_enabled(); | |
| 356 } else { | |
| 357 MutexLocker mu(JvmtiThreadState_lock); | |
| 358 record_first_time_class_file_load_hook_enabled(); | |
| 359 } | |
| 360 } | |
| 361 } | |
| 362 | |
| 363 | |
| 364 jvmtiError | |
| 365 JvmtiEnvBase::set_native_method_prefixes(jint prefix_count, char** prefixes) { | |
| 366 assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), | |
| 367 "sanity check"); | |
| 368 | |
| 369 int old_prefix_count = get_native_method_prefix_count(); | |
| 370 char **old_prefixes = get_native_method_prefixes(); | |
| 371 | |
| 372 // allocate and install the new prefixex | |
| 373 if (prefix_count == 0 || !is_valid()) { | |
| 374 _native_method_prefix_count = 0; | |
| 375 _native_method_prefixes = NULL; | |
| 376 } else { | |
| 377 // there are prefixes, allocate an array to hold them, and fill it | |
| 6197 | 378 char** new_prefixes = (char**)os::malloc((prefix_count) * sizeof(char*), mtInternal); |
| 0 | 379 if (new_prefixes == NULL) { |
| 380 return JVMTI_ERROR_OUT_OF_MEMORY; | |
| 381 } | |
| 382 for (int i = 0; i < prefix_count; i++) { | |
| 383 char* prefix = prefixes[i]; | |
| 384 if (prefix == NULL) { | |
| 385 for (int j = 0; j < (i-1); j++) { | |
| 386 os::free(new_prefixes[j]); | |
| 387 } | |
| 388 os::free(new_prefixes); | |
| 389 return JVMTI_ERROR_NULL_POINTER; | |
| 390 } | |
| 391 prefix = os::strdup(prefixes[i]); | |
| 392 if (prefix == NULL) { | |
| 393 for (int j = 0; j < (i-1); j++) { | |
| 394 os::free(new_prefixes[j]); | |
| 395 } | |
| 396 os::free(new_prefixes); | |
| 397 return JVMTI_ERROR_OUT_OF_MEMORY; | |
| 398 } | |
| 399 new_prefixes[i] = prefix; | |
| 400 } | |
| 401 _native_method_prefix_count = prefix_count; | |
| 402 _native_method_prefixes = new_prefixes; | |
| 403 } | |
| 404 | |
| 405 // now that we know the new prefixes have been successfully installed we can | |
| 406 // safely remove the old ones | |
| 407 if (old_prefix_count != 0) { | |
| 408 for (int i = 0; i < old_prefix_count; i++) { | |
| 409 os::free(old_prefixes[i]); | |
| 410 } | |
| 411 os::free(old_prefixes); | |
| 412 } | |
| 413 | |
| 414 return JVMTI_ERROR_NONE; | |
| 415 } | |
| 416 | |
| 417 | |
| 418 // Collect all the prefixes which have been set in any JVM TI environments | |
| 419 // by the SetNativeMethodPrefix(es) functions. Be sure to maintain the | |
| 420 // order of environments and the order of prefixes within each environment. | |
| 421 // Return in a resource allocated array. | |
| 422 char** | |
| 423 JvmtiEnvBase::get_all_native_method_prefixes(int* count_ptr) { | |
| 424 assert(Threads::number_of_threads() == 0 || | |
| 425 SafepointSynchronize::is_at_safepoint() || | |
| 426 JvmtiThreadState_lock->is_locked(), | |
| 427 "sanity check"); | |
| 428 | |
| 429 int total_count = 0; | |
| 430 GrowableArray<char*>* prefix_array =new GrowableArray<char*>(5); | |
| 431 | |
| 432 JvmtiEnvIterator it; | |
| 433 for (JvmtiEnvBase* env = it.first(); env != NULL; env = it.next(env)) { | |
| 434 int prefix_count = env->get_native_method_prefix_count(); | |
| 435 char** prefixes = env->get_native_method_prefixes(); | |
| 436 for (int j = 0; j < prefix_count; j++) { | |
| 437 // retrieve a prefix and so that it is safe against asynchronous changes | |
| 438 // copy it into the resource area | |
| 439 char* prefix = prefixes[j]; | |
| 440 char* prefix_copy = NEW_RESOURCE_ARRAY(char, strlen(prefix)+1); | |
| 441 strcpy(prefix_copy, prefix); | |
| 442 prefix_array->at_put_grow(total_count++, prefix_copy); | |
| 443 } | |
| 444 } | |
| 445 | |
| 446 char** all_prefixes = NEW_RESOURCE_ARRAY(char*, total_count); | |
| 447 char** p = all_prefixes; | |
| 448 for (int i = 0; i < total_count; ++i) { | |
| 449 *p++ = prefix_array->at(i); | |
| 450 } | |
| 451 *count_ptr = total_count; | |
| 452 return all_prefixes; | |
| 453 } | |
| 454 | |
| 455 void | |
| 456 JvmtiEnvBase::set_event_callbacks(const jvmtiEventCallbacks* callbacks, | |
| 457 jint size_of_callbacks) { | |
| 458 assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check"); | |
| 459 | |
| 460 size_t byte_cnt = sizeof(jvmtiEventCallbacks); | |
| 461 | |
| 462 // clear in either case to be sure we got any gap between sizes | |
| 463 memset(&_event_callbacks, 0, byte_cnt); | |
| 464 | |
| 465 // Now that JvmtiThreadState_lock is held, prevent a possible race condition where events | |
| 466 // are re-enabled by a call to set event callbacks where the DisposeEnvironment | |
| 467 // occurs after the boiler-plate environment check and before the lock is acquired. | |
| 468 if (callbacks != NULL && is_valid()) { | |
| 469 if (size_of_callbacks < (jint)byte_cnt) { | |
| 470 byte_cnt = size_of_callbacks; | |
| 471 } | |
| 472 memcpy(&_event_callbacks, callbacks, byte_cnt); | |
| 473 } | |
| 474 } | |
| 475 | |
| 476 // Called from JVMTI entry points which perform stack walking. If the | |
| 477 // associated JavaThread is the current thread, then wait_for_suspend | |
| 478 // is not used. Otherwise, it determines if we should wait for the | |
| 479 // "other" thread to complete external suspension. (NOTE: in future | |
| 480 // releases the suspension mechanism should be reimplemented so this | |
| 481 // is not necessary.) | |
| 482 // | |
| 483 bool | |
| 484 JvmtiEnvBase::is_thread_fully_suspended(JavaThread* thr, bool wait_for_suspend, uint32_t *bits) { | |
| 485 // "other" threads require special handling | |
| 486 if (thr != JavaThread::current()) { | |
| 487 if (wait_for_suspend) { | |
| 488 // We are allowed to wait for the external suspend to complete | |
| 489 // so give the other thread a chance to get suspended. | |
| 490 if (!thr->wait_for_ext_suspend_completion(SuspendRetryCount, | |
| 491 SuspendRetryDelay, bits)) { | |
| 492 // didn't make it so let the caller know | |
| 493 return false; | |
| 494 } | |
| 495 } | |
| 496 // We aren't allowed to wait for the external suspend to complete | |
| 497 // so if the other thread isn't externally suspended we need to | |
| 498 // let the caller know. | |
| 499 else if (!thr->is_ext_suspend_completed_with_lock(bits)) { | |
| 500 return false; | |
| 501 } | |
| 502 } | |
| 503 | |
| 504 return true; | |
| 505 } | |
| 506 | |
| 507 | |
| 508 // In the fullness of time, all users of the method should instead | |
| 509 // directly use allocate, besides being cleaner and faster, this will | |
| 510 // mean much better out of memory handling | |
| 511 unsigned char * | |
| 512 JvmtiEnvBase::jvmtiMalloc(jlong size) { | |
| 513 unsigned char* mem; | |
| 514 jvmtiError result = allocate(size, &mem); | |
| 515 assert(result == JVMTI_ERROR_NONE, "Allocate failed"); | |
| 516 return mem; | |
| 517 } | |
| 518 | |
| 519 | |
| 520 // | |
| 521 // Threads | |
| 522 // | |
| 523 | |
| 524 jobject * | |
| 525 JvmtiEnvBase::new_jobjectArray(int length, Handle *handles) { | |
| 526 if (length == 0) { | |
| 527 return NULL; | |
| 528 } | |
| 529 | |
| 530 jobject *objArray = (jobject *) jvmtiMalloc(sizeof(jobject) * length); | |
| 531 NULL_CHECK(objArray, NULL); | |
| 532 | |
| 533 for (int i=0; i<length; i++) { | |
| 534 objArray[i] = jni_reference(handles[i]); | |
| 535 } | |
| 536 return objArray; | |
| 537 } | |
| 538 | |
| 539 jthread * | |
| 540 JvmtiEnvBase::new_jthreadArray(int length, Handle *handles) { | |
| 541 return (jthread *) new_jobjectArray(length,handles); | |
| 542 } | |
| 543 | |
| 544 jthreadGroup * | |
| 545 JvmtiEnvBase::new_jthreadGroupArray(int length, Handle *handles) { | |
| 546 return (jthreadGroup *) new_jobjectArray(length,handles); | |
| 547 } | |
| 548 | |
| 549 | |
| 550 JavaThread * | |
| 551 JvmtiEnvBase::get_JavaThread(jthread jni_thread) { | |
| 552 oop t = JNIHandles::resolve_external_guard(jni_thread); | |
| 1142 | 553 if (t == NULL || !t->is_a(SystemDictionary::Thread_klass())) { |
| 0 | 554 return NULL; |
| 555 } | |
| 556 // The following returns NULL if the thread has not yet run or is in | |
| 557 // process of exiting | |
| 558 return java_lang_Thread::thread(t); | |
| 559 } | |
| 560 | |
| 561 | |
| 562 // return the vframe on the specified thread and depth, NULL if no such frame | |
| 563 vframe* | |
| 564 JvmtiEnvBase::vframeFor(JavaThread* java_thread, jint depth) { | |
| 565 if (!java_thread->has_last_Java_frame()) { | |
| 566 return NULL; | |
| 567 } | |
| 568 RegisterMap reg_map(java_thread); | |
| 569 vframe *vf = java_thread->last_java_vframe(®_map); | |
| 570 int d = 0; | |
| 571 while ((vf != NULL) && (d < depth)) { | |
| 572 vf = vf->java_sender(); | |
| 573 d++; | |
| 574 } | |
| 575 return vf; | |
| 576 } | |
| 577 | |
| 578 | |
| 579 // | |
| 580 // utilities: JNI objects | |
| 581 // | |
| 582 | |
| 583 | |
| 584 jclass | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
585 JvmtiEnvBase::get_jni_class_non_null(Klass* k) { |
| 0 | 586 assert(k != NULL, "k != NULL"); |
| 6983 | 587 return (jclass)jni_reference(k->java_mirror()); |
| 0 | 588 } |
| 589 | |
| 590 // | |
| 591 // Field Information | |
| 592 // | |
| 593 | |
| 594 bool | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
595 JvmtiEnvBase::get_field_descriptor(Klass* k, jfieldID field, fieldDescriptor* fd) { |
| 0 | 596 if (!jfieldIDWorkaround::is_valid_jfieldID(k, field)) { |
| 597 return false; | |
| 598 } | |
| 599 bool found = false; | |
| 600 if (jfieldIDWorkaround::is_static_jfieldID(field)) { | |
| 601 JNIid* id = jfieldIDWorkaround::from_static_jfieldID(field); | |
|
2376
c7f3d0b4570f
7017732: move static fields into Class to prepare for perm gen removal
never
parents:
2177
diff
changeset
|
602 found = id->find_local_field(fd); |
| 0 | 603 } else { |
| 604 // Non-static field. The fieldID is really the offset of the field within the object. | |
| 605 int offset = jfieldIDWorkaround::from_instance_jfieldID(k, field); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
606 found = InstanceKlass::cast(k)->find_field_from_offset(offset, false, fd); |
| 0 | 607 } |
| 608 return found; | |
| 609 } | |
| 610 | |
| 611 // | |
| 612 // Object Monitor Information | |
| 613 // | |
| 614 | |
| 615 // | |
| 616 // Count the number of objects for a lightweight monitor. The hobj | |
| 617 // parameter is object that owns the monitor so this routine will | |
| 618 // count the number of times the same object was locked by frames | |
| 619 // in java_thread. | |
| 620 // | |
| 621 jint | |
| 622 JvmtiEnvBase::count_locked_objects(JavaThread *java_thread, Handle hobj) { | |
| 623 jint ret = 0; | |
| 624 if (!java_thread->has_last_Java_frame()) { | |
| 625 return ret; // no Java frames so no monitors | |
| 626 } | |
| 627 | |
| 628 ResourceMark rm; | |
| 629 HandleMark hm; | |
| 630 RegisterMap reg_map(java_thread); | |
| 631 | |
| 632 for(javaVFrame *jvf=java_thread->last_java_vframe(®_map); jvf != NULL; | |
| 633 jvf = jvf->java_sender()) { | |
| 634 GrowableArray<MonitorInfo*>* mons = jvf->monitors(); | |
| 635 if (!mons->is_empty()) { | |
| 636 for (int i = 0; i < mons->length(); i++) { | |
| 637 MonitorInfo *mi = mons->at(i); | |
|
818
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
611
diff
changeset
|
638 if (mi->owner_is_scalar_replaced()) continue; |
| 0 | 639 |
| 640 // see if owner of the monitor is our object | |
| 641 if (mi->owner() != NULL && mi->owner() == hobj()) { | |
| 642 ret++; | |
| 643 } | |
| 644 } | |
| 645 } | |
| 646 } | |
| 647 return ret; | |
| 648 } | |
| 649 | |
| 650 | |
| 651 | |
| 652 jvmtiError | |
| 653 JvmtiEnvBase::get_current_contended_monitor(JavaThread *calling_thread, JavaThread *java_thread, jobject *monitor_ptr) { | |
| 654 #ifdef ASSERT | |
| 655 uint32_t debug_bits = 0; | |
| 656 #endif | |
| 657 assert((SafepointSynchronize::is_at_safepoint() || | |
| 658 is_thread_fully_suspended(java_thread, false, &debug_bits)), | |
| 659 "at safepoint or target thread is suspended"); | |
| 660 oop obj = NULL; | |
| 661 ObjectMonitor *mon = java_thread->current_waiting_monitor(); | |
| 662 if (mon == NULL) { | |
| 663 // thread is not doing an Object.wait() call | |
| 664 mon = java_thread->current_pending_monitor(); | |
| 665 if (mon != NULL) { | |
| 666 // The thread is trying to enter() or raw_enter() an ObjectMonitor. | |
| 667 obj = (oop)mon->object(); | |
| 668 // If obj == NULL, then ObjectMonitor is raw which doesn't count | |
| 669 // as contended for this API | |
| 670 } | |
| 671 // implied else: no contended ObjectMonitor | |
| 672 } else { | |
| 673 // thread is doing an Object.wait() call | |
| 674 obj = (oop)mon->object(); | |
| 675 assert(obj != NULL, "Object.wait() should have an object"); | |
| 676 } | |
| 677 | |
| 678 if (obj == NULL) { | |
| 679 *monitor_ptr = NULL; | |
| 680 } else { | |
| 681 HandleMark hm; | |
| 682 Handle hobj(obj); | |
| 683 *monitor_ptr = jni_reference(calling_thread, hobj); | |
| 684 } | |
| 685 return JVMTI_ERROR_NONE; | |
| 686 } | |
| 687 | |
| 688 | |
| 689 jvmtiError | |
| 690 JvmtiEnvBase::get_owned_monitors(JavaThread *calling_thread, JavaThread* java_thread, | |
| 691 GrowableArray<jvmtiMonitorStackDepthInfo*> *owned_monitors_list) { | |
| 692 jvmtiError err = JVMTI_ERROR_NONE; | |
| 693 #ifdef ASSERT | |
| 694 uint32_t debug_bits = 0; | |
| 695 #endif | |
| 696 assert((SafepointSynchronize::is_at_safepoint() || | |
| 697 is_thread_fully_suspended(java_thread, false, &debug_bits)), | |
| 698 "at safepoint or target thread is suspended"); | |
| 699 | |
| 700 if (java_thread->has_last_Java_frame()) { | |
| 701 ResourceMark rm; | |
| 702 HandleMark hm; | |
| 703 RegisterMap reg_map(java_thread); | |
| 704 | |
| 705 int depth = 0; | |
| 706 for (javaVFrame *jvf = java_thread->last_java_vframe(®_map); jvf != NULL; | |
| 707 jvf = jvf->java_sender()) { | |
| 708 if (depth++ < MaxJavaStackTraceDepth) { // check for stack too deep | |
| 709 // add locked objects for this frame into list | |
| 710 err = get_locked_objects_in_frame(calling_thread, java_thread, jvf, owned_monitors_list, depth-1); | |
| 711 if (err != JVMTI_ERROR_NONE) { | |
| 712 return err; | |
| 713 } | |
| 714 } | |
| 715 } | |
| 716 } | |
| 717 | |
| 718 // Get off stack monitors. (e.g. acquired via jni MonitorEnter). | |
| 719 JvmtiMonitorClosure jmc(java_thread, calling_thread, owned_monitors_list, this); | |
| 720 ObjectSynchronizer::monitors_iterate(&jmc); | |
| 721 err = jmc.error(); | |
| 722 | |
| 723 return err; | |
| 724 } | |
| 725 | |
| 726 // Save JNI local handles for any objects that this frame owns. | |
| 727 jvmtiError | |
| 728 JvmtiEnvBase::get_locked_objects_in_frame(JavaThread* calling_thread, JavaThread* java_thread, | |
| 729 javaVFrame *jvf, GrowableArray<jvmtiMonitorStackDepthInfo*>* owned_monitors_list, int stack_depth) { | |
| 730 jvmtiError err = JVMTI_ERROR_NONE; | |
| 731 ResourceMark rm; | |
| 732 | |
| 733 GrowableArray<MonitorInfo*>* mons = jvf->monitors(); | |
| 734 if (mons->is_empty()) { | |
| 735 return err; // this javaVFrame holds no monitors | |
| 736 } | |
| 737 | |
| 738 HandleMark hm; | |
| 739 oop wait_obj = NULL; | |
| 740 { | |
| 741 // save object of current wait() call (if any) for later comparison | |
| 742 ObjectMonitor *mon = java_thread->current_waiting_monitor(); | |
| 743 if (mon != NULL) { | |
| 744 wait_obj = (oop)mon->object(); | |
| 745 } | |
| 746 } | |
| 747 oop pending_obj = NULL; | |
| 748 { | |
| 749 // save object of current enter() call (if any) for later comparison | |
| 750 ObjectMonitor *mon = java_thread->current_pending_monitor(); | |
| 751 if (mon != NULL) { | |
| 752 pending_obj = (oop)mon->object(); | |
| 753 } | |
| 754 } | |
| 755 | |
| 756 for (int i = 0; i < mons->length(); i++) { | |
| 757 MonitorInfo *mi = mons->at(i); | |
| 758 | |
|
818
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
611
diff
changeset
|
759 if (mi->owner_is_scalar_replaced()) continue; |
|
b109e761e927
6837472: com/sun/jdi/MonitorFrameInfo.java fails with AggressiveOpts in 6u14
kvn
parents:
611
diff
changeset
|
760 |
| 0 | 761 oop obj = mi->owner(); |
| 762 if (obj == NULL) { | |
| 763 // this monitor doesn't have an owning object so skip it | |
| 764 continue; | |
| 765 } | |
| 766 | |
| 767 if (wait_obj == obj) { | |
| 768 // the thread is waiting on this monitor so it isn't really owned | |
| 769 continue; | |
| 770 } | |
| 771 | |
| 772 if (pending_obj == obj) { | |
| 773 // the thread is pending on this monitor so it isn't really owned | |
| 774 continue; | |
| 775 } | |
| 776 | |
| 777 if (owned_monitors_list->length() > 0) { | |
| 778 // Our list has at least one object on it so we have to check | |
| 779 // for recursive object locking | |
| 780 bool found = false; | |
| 781 for (int j = 0; j < owned_monitors_list->length(); j++) { | |
| 782 jobject jobj = ((jvmtiMonitorStackDepthInfo*)owned_monitors_list->at(j))->monitor; | |
| 783 oop check = JNIHandles::resolve(jobj); | |
| 784 if (check == obj) { | |
| 785 found = true; // we found the object | |
| 786 break; | |
| 787 } | |
| 788 } | |
| 789 | |
| 790 if (found) { | |
| 791 // already have this object so don't include it | |
| 792 continue; | |
| 793 } | |
| 794 } | |
| 795 | |
| 796 // add the owning object to our list | |
| 797 jvmtiMonitorStackDepthInfo *jmsdi; | |
| 798 err = allocate(sizeof(jvmtiMonitorStackDepthInfo), (unsigned char **)&jmsdi); | |
| 799 if (err != JVMTI_ERROR_NONE) { | |
| 800 return err; | |
| 801 } | |
| 802 Handle hobj(obj); | |
| 803 jmsdi->monitor = jni_reference(calling_thread, hobj); | |
| 804 jmsdi->stack_depth = stack_depth; | |
| 805 owned_monitors_list->append(jmsdi); | |
| 806 } | |
| 807 | |
| 808 return err; | |
| 809 } | |
| 810 | |
| 811 jvmtiError | |
| 812 JvmtiEnvBase::get_stack_trace(JavaThread *java_thread, | |
| 813 jint start_depth, jint max_count, | |
| 814 jvmtiFrameInfo* frame_buffer, jint* count_ptr) { | |
| 815 #ifdef ASSERT | |
| 816 uint32_t debug_bits = 0; | |
| 817 #endif | |
| 818 assert((SafepointSynchronize::is_at_safepoint() || | |
| 819 is_thread_fully_suspended(java_thread, false, &debug_bits)), | |
| 820 "at safepoint or target thread is suspended"); | |
| 821 int count = 0; | |
| 822 if (java_thread->has_last_Java_frame()) { | |
| 823 RegisterMap reg_map(java_thread); | |
| 824 Thread* current_thread = Thread::current(); | |
| 825 ResourceMark rm(current_thread); | |
| 826 javaVFrame *jvf = java_thread->last_java_vframe(®_map); | |
| 827 HandleMark hm(current_thread); | |
| 828 if (start_depth != 0) { | |
| 829 if (start_depth > 0) { | |
| 830 for (int j = 0; j < start_depth && jvf != NULL; j++) { | |
| 831 jvf = jvf->java_sender(); | |
| 832 } | |
| 833 if (jvf == NULL) { | |
| 834 // start_depth is deeper than the stack depth | |
| 835 return JVMTI_ERROR_ILLEGAL_ARGUMENT; | |
| 836 } | |
| 837 } else { // start_depth < 0 | |
| 838 // we are referencing the starting depth based on the oldest | |
| 839 // part of the stack. | |
| 840 // optimize to limit the number of times that java_sender() is called | |
| 841 javaVFrame *jvf_cursor = jvf; | |
| 842 javaVFrame *jvf_prev = NULL; | |
| 843 javaVFrame *jvf_prev_prev; | |
| 844 int j = 0; | |
| 845 while (jvf_cursor != NULL) { | |
| 846 jvf_prev_prev = jvf_prev; | |
| 847 jvf_prev = jvf_cursor; | |
| 848 for (j = 0; j > start_depth && jvf_cursor != NULL; j--) { | |
| 849 jvf_cursor = jvf_cursor->java_sender(); | |
| 850 } | |
| 851 } | |
| 852 if (j == start_depth) { | |
| 853 // previous pointer is exactly where we want to start | |
| 854 jvf = jvf_prev; | |
| 855 } else { | |
| 856 // we need to back up further to get to the right place | |
| 857 if (jvf_prev_prev == NULL) { | |
| 858 // the -start_depth is greater than the stack depth | |
| 859 return JVMTI_ERROR_ILLEGAL_ARGUMENT; | |
| 860 } | |
| 861 // j now is the number of frames on the stack starting with | |
| 862 // jvf_prev, we start from jvf_prev_prev and move older on | |
| 863 // the stack that many, the result is -start_depth frames | |
| 864 // remaining. | |
| 865 jvf = jvf_prev_prev; | |
| 866 for (; j < 0; j++) { | |
| 867 jvf = jvf->java_sender(); | |
| 868 } | |
| 869 } | |
| 870 } | |
| 871 } | |
| 872 for (; count < max_count && jvf != NULL; count++) { | |
| 873 frame_buffer[count].method = jvf->method()->jmethod_id(); | |
| 874 frame_buffer[count].location = (jvf->method()->is_native() ? -1 : jvf->bci()); | |
| 875 jvf = jvf->java_sender(); | |
| 876 } | |
| 877 } else { | |
| 878 if (start_depth != 0) { | |
| 879 // no frames and there is a starting depth | |
| 880 return JVMTI_ERROR_ILLEGAL_ARGUMENT; | |
| 881 } | |
| 882 } | |
| 883 *count_ptr = count; | |
| 884 return JVMTI_ERROR_NONE; | |
| 885 } | |
| 886 | |
| 887 jvmtiError | |
| 888 JvmtiEnvBase::get_frame_count(JvmtiThreadState *state, jint *count_ptr) { | |
| 889 assert((state != NULL), | |
| 890 "JavaThread should create JvmtiThreadState before calling this method"); | |
| 891 *count_ptr = state->count_frames(); | |
| 892 return JVMTI_ERROR_NONE; | |
| 893 } | |
| 894 | |
| 895 jvmtiError | |
| 896 JvmtiEnvBase::get_frame_location(JavaThread *java_thread, jint depth, | |
| 897 jmethodID* method_ptr, jlocation* location_ptr) { | |
| 898 #ifdef ASSERT | |
| 899 uint32_t debug_bits = 0; | |
| 900 #endif | |
| 901 assert((SafepointSynchronize::is_at_safepoint() || | |
| 902 is_thread_fully_suspended(java_thread, false, &debug_bits)), | |
| 903 "at safepoint or target thread is suspended"); | |
| 904 Thread* current_thread = Thread::current(); | |
| 905 ResourceMark rm(current_thread); | |
| 906 | |
| 907 vframe *vf = vframeFor(java_thread, depth); | |
| 908 if (vf == NULL) { | |
| 909 return JVMTI_ERROR_NO_MORE_FRAMES; | |
| 910 } | |
| 911 | |
| 912 // vframeFor should return a java frame. If it doesn't | |
| 913 // it means we've got an internal error and we return the | |
| 914 // error in product mode. In debug mode we will instead | |
| 915 // attempt to cast the vframe to a javaVFrame and will | |
| 916 // cause an assertion/crash to allow further diagnosis. | |
| 917 #ifdef PRODUCT | |
| 918 if (!vf->is_java_frame()) { | |
| 919 return JVMTI_ERROR_INTERNAL; | |
| 920 } | |
| 921 #endif | |
| 922 | |
| 923 HandleMark hm(current_thread); | |
| 924 javaVFrame *jvf = javaVFrame::cast(vf); | |
|
6725
da91efe96a93
6964458: Reimplement class meta-data storage to use native memory
coleenp
parents:
6197
diff
changeset
|
925 Method* method = jvf->method(); |
| 0 | 926 if (method->is_native()) { |
| 927 *location_ptr = -1; | |
| 928 } else { | |
| 929 *location_ptr = jvf->bci(); | |
| 930 } | |
| 931 *method_ptr = method->jmethod_id(); | |
| 932 | |
| 933 return JVMTI_ERROR_NONE; | |
| 934 } | |
| 935 | |
| 936 | |
| 937 jvmtiError | |
| 938 JvmtiEnvBase::get_object_monitor_usage(JavaThread* calling_thread, jobject object, jvmtiMonitorUsage* info_ptr) { | |
| 939 HandleMark hm; | |
| 940 Handle hobj; | |
| 941 | |
| 942 bool at_safepoint = SafepointSynchronize::is_at_safepoint(); | |
| 943 | |
| 944 // Check arguments | |
| 945 { | |
| 946 oop mirror = JNIHandles::resolve_external_guard(object); | |
| 947 NULL_CHECK(mirror, JVMTI_ERROR_INVALID_OBJECT); | |
| 948 NULL_CHECK(info_ptr, JVMTI_ERROR_NULL_POINTER); | |
| 949 | |
| 950 hobj = Handle(mirror); | |
| 951 } | |
| 952 | |
| 953 JavaThread *owning_thread = NULL; | |
| 954 ObjectMonitor *mon = NULL; | |
| 955 jvmtiMonitorUsage ret = { | |
| 956 NULL, 0, 0, NULL, 0, NULL | |
| 957 }; | |
| 958 | |
| 959 uint32_t debug_bits = 0; | |
| 960 // first derive the object's owner and entry_count (if any) | |
| 961 { | |
| 962 // Revoke any biases before querying the mark word | |
| 963 if (SafepointSynchronize::is_at_safepoint()) { | |
| 964 BiasedLocking::revoke_at_safepoint(hobj); | |
| 965 } else { | |
| 966 BiasedLocking::revoke_and_rebias(hobj, false, calling_thread); | |
| 967 } | |
| 968 | |
| 969 address owner = NULL; | |
| 970 { | |
| 971 markOop mark = hobj()->mark(); | |
| 972 | |
| 973 if (!mark->has_monitor()) { | |
| 974 // this object has a lightweight monitor | |
| 975 | |
| 976 if (mark->has_locker()) { | |
| 977 owner = (address)mark->locker(); // save the address of the Lock word | |
| 978 } | |
| 979 // implied else: no owner | |
| 980 } else { | |
| 981 // this object has a heavyweight monitor | |
| 982 mon = mark->monitor(); | |
| 983 | |
| 984 // The owner field of a heavyweight monitor may be NULL for no | |
| 985 // owner, a JavaThread * or it may still be the address of the | |
| 986 // Lock word in a JavaThread's stack. A monitor can be inflated | |
| 987 // by a non-owning JavaThread, but only the owning JavaThread | |
| 988 // can change the owner field from the Lock word to the | |
| 989 // JavaThread * and it may not have done that yet. | |
| 990 owner = (address)mon->owner(); | |
| 991 } | |
| 992 } | |
| 993 | |
| 994 if (owner != NULL) { | |
| 995 // This monitor is owned so we have to find the owning JavaThread. | |
| 996 // Since owning_thread_from_monitor_owner() grabs a lock, GC can | |
| 997 // move our object at this point. However, our owner value is safe | |
| 998 // since it is either the Lock word on a stack or a JavaThread *. | |
| 999 owning_thread = Threads::owning_thread_from_monitor_owner(owner, !at_safepoint); | |
| 1000 assert(owning_thread != NULL, "sanity check"); | |
| 1001 if (owning_thread != NULL) { // robustness | |
| 1002 // The monitor's owner either has to be the current thread, at safepoint | |
| 1003 // or it has to be suspended. Any of these conditions will prevent both | |
| 1004 // contending and waiting threads from modifying the state of | |
| 1005 // the monitor. | |
| 1006 if (!at_safepoint && !JvmtiEnv::is_thread_fully_suspended(owning_thread, true, &debug_bits)) { | |
| 1007 return JVMTI_ERROR_THREAD_NOT_SUSPENDED; | |
| 1008 } | |
| 1009 HandleMark hm; | |
| 1010 Handle th(owning_thread->threadObj()); | |
| 1011 ret.owner = (jthread)jni_reference(calling_thread, th); | |
| 1012 } | |
| 1013 // implied else: no owner | |
| 1014 } | |
| 1015 | |
| 1016 if (owning_thread != NULL) { // monitor is owned | |
| 1017 if ((address)owning_thread == owner) { | |
| 1018 // the owner field is the JavaThread * | |
| 1019 assert(mon != NULL, | |
| 1020 "must have heavyweight monitor with JavaThread * owner"); | |
| 1021 ret.entry_count = mon->recursions() + 1; | |
| 1022 } else { | |
| 1023 // The owner field is the Lock word on the JavaThread's stack | |
| 1024 // so the recursions field is not valid. We have to count the | |
| 1025 // number of recursive monitor entries the hard way. We pass | |
| 1026 // a handle to survive any GCs along the way. | |
| 1027 ResourceMark rm; | |
| 1028 ret.entry_count = count_locked_objects(owning_thread, hobj); | |
| 1029 } | |
| 1030 } | |
| 1031 // implied else: entry_count == 0 | |
| 1032 } | |
| 1033 | |
| 1034 int nWant,nWait; | |
| 1035 if (mon != NULL) { | |
| 1036 // this object has a heavyweight monitor | |
| 1037 nWant = mon->contentions(); // # of threads contending for monitor | |
| 1038 nWait = mon->waiters(); // # of threads in Object.wait() | |
| 1039 ret.waiter_count = nWant + nWait; | |
| 1040 ret.notify_waiter_count = nWait; | |
| 1041 } else { | |
| 1042 // this object has a lightweight monitor | |
| 1043 ret.waiter_count = 0; | |
| 1044 ret.notify_waiter_count = 0; | |
| 1045 } | |
| 1046 | |
| 1047 // Allocate memory for heavyweight and lightweight monitor. | |
| 1048 jvmtiError err; | |
| 1049 err = allocate(ret.waiter_count * sizeof(jthread *), (unsigned char**)&ret.waiters); | |
| 1050 if (err != JVMTI_ERROR_NONE) { | |
| 1051 return err; | |
| 1052 } | |
| 1053 err = allocate(ret.notify_waiter_count * sizeof(jthread *), | |
| 1054 (unsigned char**)&ret.notify_waiters); | |
| 1055 if (err != JVMTI_ERROR_NONE) { | |
| 1056 deallocate((unsigned char*)ret.waiters); | |
| 1057 return err; | |
| 1058 } | |
| 1059 | |
| 1060 // now derive the rest of the fields | |
| 1061 if (mon != NULL) { | |
| 1062 // this object has a heavyweight monitor | |
| 1063 | |
| 1064 // Number of waiters may actually be less than the waiter count. | |
| 1065 // So NULL out memory so that unused memory will be NULL. | |
| 1066 memset(ret.waiters, 0, ret.waiter_count * sizeof(jthread *)); | |
| 1067 memset(ret.notify_waiters, 0, ret.notify_waiter_count * sizeof(jthread *)); | |
| 1068 | |
| 1069 if (ret.waiter_count > 0) { | |
| 1070 // we have contending and/or waiting threads | |
| 1071 HandleMark hm; | |
| 1072 if (nWant > 0) { | |
| 1073 // we have contending threads | |
| 1074 ResourceMark rm; | |
| 1075 // get_pending_threads returns only java thread so we do not need to | |
| 1076 // check for non java threads. | |
| 1077 GrowableArray<JavaThread*>* wantList = Threads::get_pending_threads( | |
| 1078 nWant, (address)mon, !at_safepoint); | |
| 1079 if (wantList->length() < nWant) { | |
| 1080 // robustness: the pending list has gotten smaller | |
| 1081 nWant = wantList->length(); | |
| 1082 } | |
| 1083 for (int i = 0; i < nWant; i++) { | |
| 1084 JavaThread *pending_thread = wantList->at(i); | |
| 1085 // If the monitor has no owner, then a non-suspended contending | |
| 1086 // thread could potentially change the state of the monitor by | |
| 1087 // entering it. The JVM/TI spec doesn't allow this. | |
| 1088 if (owning_thread == NULL && !at_safepoint & | |
| 1089 !JvmtiEnv::is_thread_fully_suspended(pending_thread, true, &debug_bits)) { | |
| 1090 if (ret.owner != NULL) { | |
| 1091 destroy_jni_reference(calling_thread, ret.owner); | |
| 1092 } | |
| 1093 for (int j = 0; j < i; j++) { | |
| 1094 destroy_jni_reference(calling_thread, ret.waiters[j]); | |
| 1095 } | |
| 1096 deallocate((unsigned char*)ret.waiters); | |
| 1097 deallocate((unsigned char*)ret.notify_waiters); | |
| 1098 return JVMTI_ERROR_THREAD_NOT_SUSPENDED; | |
| 1099 } | |
| 1100 Handle th(pending_thread->threadObj()); | |
| 1101 ret.waiters[i] = (jthread)jni_reference(calling_thread, th); | |
| 1102 } | |
| 1103 } | |
| 1104 if (nWait > 0) { | |
| 1105 // we have threads in Object.wait() | |
| 1106 int offset = nWant; // add after any contending threads | |
| 1107 ObjectWaiter *waiter = mon->first_waiter(); | |
| 1108 for (int i = 0, j = 0; i < nWait; i++) { | |
| 1109 if (waiter == NULL) { | |
| 1110 // robustness: the waiting list has gotten smaller | |
| 1111 nWait = j; | |
| 1112 break; | |
| 1113 } | |
| 1114 Thread *t = mon->thread_of_waiter(waiter); | |
| 1115 if (t != NULL && t->is_Java_thread()) { | |
| 1116 JavaThread *wjava_thread = (JavaThread *)t; | |
| 1117 // If the thread was found on the ObjectWaiter list, then | |
| 1118 // it has not been notified. This thread can't change the | |
| 1119 // state of the monitor so it doesn't need to be suspended. | |
| 1120 Handle th(wjava_thread->threadObj()); | |
| 1121 ret.waiters[offset + j] = (jthread)jni_reference(calling_thread, th); | |
| 1122 ret.notify_waiters[j++] = (jthread)jni_reference(calling_thread, th); | |
| 1123 } | |
| 1124 waiter = mon->next_waiter(waiter); | |
| 1125 } | |
| 1126 } | |
| 1127 } | |
| 1128 | |
| 1129 // Adjust count. nWant and nWait count values may be less than original. | |
| 1130 ret.waiter_count = nWant + nWait; | |
| 1131 ret.notify_waiter_count = nWait; | |
| 1132 } else { | |
| 1133 // this object has a lightweight monitor and we have nothing more | |
| 1134 // to do here because the defaults are just fine. | |
| 1135 } | |
| 1136 | |
| 1137 // we don't update return parameter unless everything worked | |
| 1138 *info_ptr = ret; | |
| 1139 | |
| 1140 return JVMTI_ERROR_NONE; | |
| 1141 } | |
| 1142 | |
| 1143 ResourceTracker::ResourceTracker(JvmtiEnv* env) { | |
| 1144 _env = env; | |
| 6197 | 1145 _allocations = new (ResourceObj::C_HEAP, mtInternal) GrowableArray<unsigned char*>(20, true); |
| 0 | 1146 _failed = false; |
| 1147 } | |
| 1148 ResourceTracker::~ResourceTracker() { | |
| 1149 if (_failed) { | |
| 1150 for (int i=0; i<_allocations->length(); i++) { | |
| 1151 _env->deallocate(_allocations->at(i)); | |
| 1152 } | |
| 1153 } | |
| 1154 delete _allocations; | |
| 1155 } | |
| 1156 | |
| 1157 jvmtiError ResourceTracker::allocate(jlong size, unsigned char** mem_ptr) { | |
| 1158 unsigned char *ptr; | |
| 1159 jvmtiError err = _env->allocate(size, &ptr); | |
| 1160 if (err == JVMTI_ERROR_NONE) { | |
| 1161 _allocations->append(ptr); | |
| 1162 *mem_ptr = ptr; | |
| 1163 } else { | |
| 1164 *mem_ptr = NULL; | |
| 1165 _failed = true; | |
| 1166 } | |
| 1167 return err; | |
| 1168 } | |
| 1169 | |
| 1170 unsigned char* ResourceTracker::allocate(jlong size) { | |
| 1171 unsigned char* ptr; | |
| 1172 allocate(size, &ptr); | |
| 1173 return ptr; | |
| 1174 } | |
| 1175 | |
| 1176 char* ResourceTracker::strdup(const char* str) { | |
| 1177 char *dup_str = (char*)allocate(strlen(str)+1); | |
| 1178 if (dup_str != NULL) { | |
| 1179 strcpy(dup_str, str); | |
| 1180 } | |
| 1181 return dup_str; | |
| 1182 } | |
| 1183 | |
| 1184 struct StackInfoNode { | |
| 1185 struct StackInfoNode *next; | |
| 1186 jvmtiStackInfo info; | |
| 1187 }; | |
| 1188 | |
| 1189 // Create a jvmtiStackInfo inside a linked list node and create a | |
| 1190 // buffer for the frame information, both allocated as resource objects. | |
| 1191 // Fill in both the jvmtiStackInfo and the jvmtiFrameInfo. | |
| 1192 // Note that either or both of thr and thread_oop | |
| 1193 // may be null if the thread is new or has exited. | |
| 1194 void | |
| 1195 VM_GetMultipleStackTraces::fill_frames(jthread jt, JavaThread *thr, oop thread_oop) { | |
| 1196 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); | |
| 1197 | |
| 1198 jint state = 0; | |
| 1199 struct StackInfoNode *node = NEW_RESOURCE_OBJ(struct StackInfoNode); | |
| 1200 jvmtiStackInfo *infop = &(node->info); | |
| 1201 node->next = head(); | |
| 1202 set_head(node); | |
| 1203 infop->frame_count = 0; | |
| 1204 infop->thread = jt; | |
| 1205 | |
| 1206 if (thread_oop != NULL) { | |
| 1207 // get most state bits | |
| 1208 state = (jint)java_lang_Thread::get_thread_status(thread_oop); | |
| 1209 } | |
| 1210 | |
| 1211 if (thr != NULL) { // add more state bits if there is a JavaThead to query | |
| 1212 // same as is_being_ext_suspended() but without locking | |
| 1213 if (thr->is_ext_suspended() || thr->is_external_suspend()) { | |
| 1214 state |= JVMTI_THREAD_STATE_SUSPENDED; | |
| 1215 } | |
| 1216 JavaThreadState jts = thr->thread_state(); | |
| 1217 if (jts == _thread_in_native) { | |
| 1218 state |= JVMTI_THREAD_STATE_IN_NATIVE; | |
| 1219 } | |
| 1220 OSThread* osThread = thr->osthread(); | |
| 1221 if (osThread != NULL && osThread->interrupted()) { | |
| 1222 state |= JVMTI_THREAD_STATE_INTERRUPTED; | |
| 1223 } | |
| 1224 } | |
| 1225 infop->state = state; | |
| 1226 | |
| 1227 if (thr != NULL || (state & JVMTI_THREAD_STATE_ALIVE) != 0) { | |
| 1228 infop->frame_buffer = NEW_RESOURCE_ARRAY(jvmtiFrameInfo, max_frame_count()); | |
| 1229 env()->get_stack_trace(thr, 0, max_frame_count(), | |
| 1230 infop->frame_buffer, &(infop->frame_count)); | |
| 1231 } else { | |
| 1232 infop->frame_buffer = NULL; | |
| 1233 infop->frame_count = 0; | |
| 1234 } | |
| 1235 _frame_count_total += infop->frame_count; | |
| 1236 } | |
| 1237 | |
| 1238 // Based on the stack information in the linked list, allocate memory | |
| 1239 // block to return and fill it from the info in the linked list. | |
| 1240 void | |
| 1241 VM_GetMultipleStackTraces::allocate_and_fill_stacks(jint thread_count) { | |
| 1242 // do I need to worry about alignment issues? | |
| 1243 jlong alloc_size = thread_count * sizeof(jvmtiStackInfo) | |
| 1244 + _frame_count_total * sizeof(jvmtiFrameInfo); | |
| 1245 env()->allocate(alloc_size, (unsigned char **)&_stack_info); | |
| 1246 | |
| 1247 // pointers to move through the newly allocated space as it is filled in | |
| 1248 jvmtiStackInfo *si = _stack_info + thread_count; // bottom of stack info | |
| 1249 jvmtiFrameInfo *fi = (jvmtiFrameInfo *)si; // is the top of frame info | |
| 1250 | |
| 1251 // copy information in resource area into allocated buffer | |
| 1252 // insert stack info backwards since linked list is backwards | |
| 1253 // insert frame info forwards | |
| 1254 // walk the StackInfoNodes | |
| 1255 for (struct StackInfoNode *sin = head(); sin != NULL; sin = sin->next) { | |
| 1256 jint frame_count = sin->info.frame_count; | |
| 1257 size_t frames_size = frame_count * sizeof(jvmtiFrameInfo); | |
| 1258 --si; | |
| 1259 memcpy(si, &(sin->info), sizeof(jvmtiStackInfo)); | |
| 1260 if (frames_size == 0) { | |
| 1261 si->frame_buffer = NULL; | |
| 1262 } else { | |
| 1263 memcpy(fi, sin->info.frame_buffer, frames_size); | |
| 1264 si->frame_buffer = fi; // point to the new allocated copy of the frames | |
| 1265 fi += frame_count; | |
| 1266 } | |
| 1267 } | |
| 1268 assert(si == _stack_info, "the last copied stack info must be the first record"); | |
| 1269 assert((unsigned char *)fi == ((unsigned char *)_stack_info) + alloc_size, | |
| 1270 "the last copied frame info must be the last record"); | |
| 1271 } | |
| 1272 | |
| 1273 | |
| 1274 void | |
| 1275 VM_GetThreadListStackTraces::doit() { | |
| 1276 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); | |
| 1277 | |
| 1278 ResourceMark rm; | |
| 1279 for (int i = 0; i < _thread_count; ++i) { | |
| 1280 jthread jt = _thread_list[i]; | |
| 1281 oop thread_oop = JNIHandles::resolve_external_guard(jt); | |
| 1142 | 1282 if (thread_oop == NULL || !thread_oop->is_a(SystemDictionary::Thread_klass())) { |
| 0 | 1283 set_result(JVMTI_ERROR_INVALID_THREAD); |
| 1284 return; | |
| 1285 } | |
| 1286 fill_frames(jt, java_lang_Thread::thread(thread_oop), thread_oop); | |
| 1287 } | |
| 1288 allocate_and_fill_stacks(_thread_count); | |
| 1289 } | |
| 1290 | |
| 1291 void | |
| 1292 VM_GetAllStackTraces::doit() { | |
| 1293 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); | |
| 1294 | |
| 1295 ResourceMark rm; | |
| 1296 _final_thread_count = 0; | |
| 1297 for (JavaThread *jt = Threads::first(); jt != NULL; jt = jt->next()) { | |
| 1298 oop thread_oop = jt->threadObj(); | |
| 1299 if (thread_oop != NULL && | |
| 1300 !jt->is_exiting() && | |
| 1301 java_lang_Thread::is_alive(thread_oop) && | |
| 1302 !jt->is_hidden_from_external_view()) { | |
| 1303 ++_final_thread_count; | |
| 1304 // Handle block of the calling thread is used to create local refs. | |
| 1305 fill_frames((jthread)JNIHandles::make_local(_calling_thread, thread_oop), | |
| 1306 jt, thread_oop); | |
| 1307 } | |
| 1308 } | |
| 1309 allocate_and_fill_stacks(_final_thread_count); | |
| 1310 } | |
| 1311 | |
| 1312 // Verifies that the top frame is a java frame in an expected state. | |
| 1313 // Deoptimizes frame if needed. | |
| 1314 // Checks that the frame method signature matches the return type (tos). | |
| 1315 // HandleMark must be defined in the caller only. | |
| 1316 // It is to keep a ret_ob_h handle alive after return to the caller. | |
| 1317 jvmtiError | |
| 1318 JvmtiEnvBase::check_top_frame(JavaThread* current_thread, JavaThread* java_thread, | |
| 1319 jvalue value, TosState tos, Handle* ret_ob_h) { | |
| 1320 ResourceMark rm(current_thread); | |
| 1321 | |
| 1322 vframe *vf = vframeFor(java_thread, 0); | |
| 1323 NULL_CHECK(vf, JVMTI_ERROR_NO_MORE_FRAMES); | |
| 1324 | |
| 1325 javaVFrame *jvf = (javaVFrame*) vf; | |
| 1326 if (!vf->is_java_frame() || jvf->method()->is_native()) { | |
| 1327 return JVMTI_ERROR_OPAQUE_FRAME; | |
| 1328 } | |
| 1329 | |
| 1330 // If the frame is a compiled one, need to deoptimize it. | |
| 1331 if (vf->is_compiled_frame()) { | |
| 1332 if (!vf->fr().can_be_deoptimized()) { | |
| 1333 return JVMTI_ERROR_OPAQUE_FRAME; | |
| 1334 } | |
|
1905
ce6848d0666d
6968367: can_post_on_exceptions is still using VM_DeoptimizeFrame in some places
never
parents:
1552
diff
changeset
|
1335 Deoptimization::deoptimize_frame(java_thread, jvf->fr().id()); |
| 0 | 1336 } |
| 1337 | |
| 1338 // Get information about method return type | |
|
2177
3582bf76420e
6990754: Use native memory and reference counting to implement SymbolTable
coleenp
parents:
1988
diff
changeset
|
1339 Symbol* signature = jvf->method()->signature(); |
| 0 | 1340 |
| 1341 ResultTypeFinder rtf(signature); | |
| 1342 TosState fr_tos = as_TosState(rtf.type()); | |
| 1343 if (fr_tos != tos) { | |
| 1344 if (tos != itos || (fr_tos != btos && fr_tos != ctos && fr_tos != stos)) { | |
| 1345 return JVMTI_ERROR_TYPE_MISMATCH; | |
| 1346 } | |
| 1347 } | |
| 1348 | |
| 1349 // Check that the jobject class matches the return type signature. | |
| 1350 jobject jobj = value.l; | |
| 1351 if (tos == atos && jobj != NULL) { // NULL reference is allowed | |
| 1352 Handle ob_h = Handle(current_thread, JNIHandles::resolve_external_guard(jobj)); | |
| 1353 NULL_CHECK(ob_h, JVMTI_ERROR_INVALID_OBJECT); | |
| 1354 KlassHandle ob_kh = KlassHandle(current_thread, ob_h()->klass()); | |
| 1355 NULL_CHECK(ob_kh, JVMTI_ERROR_INVALID_OBJECT); | |
| 1356 | |
| 1357 // Method return type signature. | |
| 1358 char* ty_sign = 1 + strchr(signature->as_C_string(), ')'); | |
| 1359 | |
| 6983 | 1360 if (!VM_GetOrSetLocal::is_assignable(ty_sign, ob_kh(), current_thread)) { |
| 0 | 1361 return JVMTI_ERROR_TYPE_MISMATCH; |
| 1362 } | |
| 1363 *ret_ob_h = ob_h; | |
| 1364 } | |
| 1365 return JVMTI_ERROR_NONE; | |
| 1366 } /* end check_top_frame */ | |
| 1367 | |
| 1368 | |
| 1369 // ForceEarlyReturn<type> follows the PopFrame approach in many aspects. | |
| 1370 // Main difference is on the last stage in the interpreter. | |
| 1371 // The PopFrame stops method execution to continue execution | |
| 1372 // from the same method call instruction. | |
| 1373 // The ForceEarlyReturn forces return from method so the execution | |
| 1374 // continues at the bytecode following the method call. | |
| 1375 | |
| 1376 // Threads_lock NOT held, java_thread not protected by lock | |
| 1377 // java_thread - pre-checked | |
| 1378 | |
| 1379 jvmtiError | |
| 1380 JvmtiEnvBase::force_early_return(JavaThread* java_thread, jvalue value, TosState tos) { | |
| 1381 JavaThread* current_thread = JavaThread::current(); | |
| 1382 HandleMark hm(current_thread); | |
| 1383 uint32_t debug_bits = 0; | |
| 1384 | |
|
609
ea20d7ce26b0
6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents:
470
diff
changeset
|
1385 // retrieve or create the state |
|
ea20d7ce26b0
6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents:
470
diff
changeset
|
1386 JvmtiThreadState* state = JvmtiThreadState::state_for(java_thread); |
|
ea20d7ce26b0
6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents:
470
diff
changeset
|
1387 if (state == NULL) { |
|
ea20d7ce26b0
6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents:
470
diff
changeset
|
1388 return JVMTI_ERROR_THREAD_NOT_ALIVE; |
|
ea20d7ce26b0
6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents:
470
diff
changeset
|
1389 } |
|
ea20d7ce26b0
6800721: 3/4 JavaThread::jvmti_thread_state() and JvmtiThreadState::state_for() robustness
dcubed
parents:
470
diff
changeset
|
1390 |
| 0 | 1391 // Check if java_thread is fully suspended |
| 1392 if (!is_thread_fully_suspended(java_thread, | |
| 1393 true /* wait for suspend completion */, | |
| 1394 &debug_bits)) { | |
| 1395 return JVMTI_ERROR_THREAD_NOT_SUSPENDED; | |
| 1396 } | |
| 1397 | |
| 1398 // Check to see if a ForceEarlyReturn was already in progress | |
| 1399 if (state->is_earlyret_pending()) { | |
| 1400 // Probably possible for JVMTI clients to trigger this, but the | |
| 1401 // JPDA backend shouldn't allow this to happen | |
| 1402 return JVMTI_ERROR_INTERNAL; | |
| 1403 } | |
| 1404 { | |
| 1405 // The same as for PopFrame. Workaround bug: | |
| 1406 // 4812902: popFrame hangs if the method is waiting at a synchronize | |
| 1407 // Catch this condition and return an error to avoid hanging. | |
| 1408 // Now JVMTI spec allows an implementation to bail out with an opaque | |
| 1409 // frame error. | |
| 1410 OSThread* osThread = java_thread->osthread(); | |
| 1411 if (osThread->get_state() == MONITOR_WAIT) { | |
| 1412 return JVMTI_ERROR_OPAQUE_FRAME; | |
| 1413 } | |
| 1414 } | |
| 1415 Handle ret_ob_h = Handle(); | |
| 1416 jvmtiError err = check_top_frame(current_thread, java_thread, value, tos, &ret_ob_h); | |
| 1417 if (err != JVMTI_ERROR_NONE) { | |
| 1418 return err; | |
| 1419 } | |
| 1420 assert(tos != atos || value.l == NULL || ret_ob_h() != NULL, | |
| 1421 "return object oop must not be NULL if jobject is not NULL"); | |
| 1422 | |
| 1423 // Update the thread state to reflect that the top frame must be | |
| 1424 // forced to return. | |
| 1425 // The current frame will be returned later when the suspended | |
| 1426 // thread is resumed and right before returning from VM to Java. | |
| 1427 // (see call_VM_base() in assembler_<cpu>.cpp). | |
| 1428 | |
| 1429 state->set_earlyret_pending(); | |
| 1430 state->set_earlyret_oop(ret_ob_h()); | |
| 1431 state->set_earlyret_value(value, tos); | |
| 1432 | |
| 1433 // Set pending step flag for this early return. | |
| 1434 // It is cleared when next step event is posted. | |
| 1435 state->set_pending_step_for_earlyret(); | |
| 1436 | |
| 1437 return JVMTI_ERROR_NONE; | |
| 1438 } /* end force_early_return */ | |
| 1439 | |
| 1440 void | |
| 1441 JvmtiMonitorClosure::do_monitor(ObjectMonitor* mon) { | |
| 1442 if ( _error != JVMTI_ERROR_NONE) { | |
| 1443 // Error occurred in previous iteration so no need to add | |
| 1444 // to the list. | |
| 1445 return; | |
| 1446 } | |
| 1447 if (mon->owner() == _java_thread ) { | |
| 1448 // Filter out on stack monitors collected during stack walk. | |
| 1449 oop obj = (oop)mon->object(); | |
| 1450 bool found = false; | |
| 1451 for (int j = 0; j < _owned_monitors_list->length(); j++) { | |
| 1452 jobject jobj = ((jvmtiMonitorStackDepthInfo*)_owned_monitors_list->at(j))->monitor; | |
| 1453 oop check = JNIHandles::resolve(jobj); | |
| 1454 if (check == obj) { | |
| 1455 // On stack monitor already collected during the stack walk. | |
| 1456 found = true; | |
| 1457 break; | |
| 1458 } | |
| 1459 } | |
| 1460 if (found == false) { | |
| 1461 // This is off stack monitor (e.g. acquired via jni MonitorEnter). | |
| 1462 jvmtiError err; | |
| 1463 jvmtiMonitorStackDepthInfo *jmsdi; | |
| 1464 err = _env->allocate(sizeof(jvmtiMonitorStackDepthInfo), (unsigned char **)&jmsdi); | |
| 1465 if (err != JVMTI_ERROR_NONE) { | |
| 1466 _error = err; | |
| 1467 return; | |
| 1468 } | |
| 1469 Handle hobj(obj); | |
| 1470 jmsdi->monitor = _env->jni_reference(_calling_thread, hobj); | |
| 1471 // stack depth is unknown for this monitor. | |
| 1472 jmsdi->stack_depth = -1; | |
| 1473 _owned_monitors_list->append(jmsdi); | |
| 1474 } | |
| 1475 } | |
| 1476 } |