1 /* 2 * Copyright (c) 2003, 2015, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "jvmtifiles/jvmtiEnv.hpp" 27 #include "memory/resourceArea.hpp" 28 #include "prims/jvmtiEventController.inline.hpp" 29 #include "prims/jvmtiImpl.hpp" 30 #include "prims/jvmtiThreadState.inline.hpp" 31 #include "runtime/safepointVerifiers.hpp" 32 #include "runtime/vframe.hpp" 33 34 // marker for when the stack depth has been reset and is now unknown. 35 // any negative number would work but small ones might obscure an 36 // underrun error. 37 static const int UNKNOWN_STACK_DEPTH = -99; 38 39 /////////////////////////////////////////////////////////////// 40 // 41 // class JvmtiThreadState 42 // 43 // Instances of JvmtiThreadState hang off of each thread. 44 // Thread local storage for JVMTI. 45 // 46 47 JvmtiThreadState *JvmtiThreadState::_head = NULL; 48 49 JvmtiThreadState::JvmtiThreadState(JavaThread* thread) 50 : _thread_event_enable() { 51 assert(JvmtiThreadState_lock->is_locked(), "sanity check"); 52 _thread = thread; 53 _exception_state = ES_CLEARED; 54 _debuggable = true; 55 _hide_single_stepping = false; 56 _hide_level = 0; 57 _pending_step_for_popframe = false; 58 _class_being_redefined = NULL; 59 _class_load_kind = jvmti_class_load_kind_load; 60 _head_env_thread_state = NULL; 61 _dynamic_code_event_collector = NULL; 62 _vm_object_alloc_event_collector = NULL; 63 _the_class_for_redefinition_verification = NULL; 64 _scratch_class_for_redefinition_verification = NULL; 65 _cur_stack_depth = UNKNOWN_STACK_DEPTH; 66 67 // JVMTI ForceEarlyReturn support 68 _pending_step_for_earlyret = false; 69 _earlyret_state = earlyret_inactive; 70 _earlyret_tos = ilgl; 71 _earlyret_value.j = 0L; 72 _earlyret_oop = NULL; 73 74 // add all the JvmtiEnvThreadState to the new JvmtiThreadState 75 { 76 JvmtiEnvIterator it; 77 for (JvmtiEnvBase* env = it.first(); env != NULL; env = it.next(env)) { 78 if (env->is_valid()) { 79 add_env(env); 80 } 81 } 82 } 83 84 // link us into the list 85 { 86 // The thread state list manipulation code must not have safepoints. 87 // See periodic_clean_up(). 88 debug_only(NoSafepointVerifier nosafepoint;) 89 90 _prev = NULL; 91 _next = _head; 92 if (_head != NULL) { 93 _head->_prev = this; 94 } 95 _head = this; 96 } 97 98 // set this as the state for the thread 99 thread->set_jvmti_thread_state(this); 100 } 101 102 103 JvmtiThreadState::~JvmtiThreadState() { 104 assert(JvmtiThreadState_lock->is_locked(), "sanity check"); 105 106 // clear this as the state for the thread 107 get_thread()->set_jvmti_thread_state(NULL); 108 109 // zap our env thread states 110 { 111 JvmtiEnvBase::entering_dying_thread_env_iteration(); 112 JvmtiEnvThreadStateIterator it(this); 113 for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ) { 114 JvmtiEnvThreadState* zap = ets; 115 ets = it.next(ets); 116 delete zap; 117 } 118 JvmtiEnvBase::leaving_dying_thread_env_iteration(); 119 } 120 121 // remove us from the list 122 { 123 // The thread state list manipulation code must not have safepoints. 124 // See periodic_clean_up(). 125 debug_only(NoSafepointVerifier nosafepoint;) 126 127 if (_prev == NULL) { 128 assert(_head == this, "sanity check"); 129 _head = _next; 130 } else { 131 assert(_head != this, "sanity check"); 132 _prev->_next = _next; 133 } 134 if (_next != NULL) { 135 _next->_prev = _prev; 136 } 137 _next = NULL; 138 _prev = NULL; 139 } 140 } 141 142 143 void 144 JvmtiThreadState::periodic_clean_up() { 145 assert(SafepointSynchronize::is_at_safepoint(), "at safepoint"); 146 147 // This iteration is initialized with "_head" instead of "JvmtiThreadState::first()" 148 // because the latter requires the JvmtiThreadState_lock. 149 // This iteration is safe at a safepoint as well, see the NoSafepointVerifier 150 // asserts at all list manipulation sites. 151 for (JvmtiThreadState *state = _head; state != NULL; state = state->next()) { 152 // For each environment thread state corresponding to an invalid environment 153 // unlink it from the list and deallocate it. 154 JvmtiEnvThreadStateIterator it(state); 155 JvmtiEnvThreadState* previous_ets = NULL; 156 JvmtiEnvThreadState* ets = it.first(); 157 while (ets != NULL) { 158 if (ets->get_env()->is_valid()) { 159 previous_ets = ets; 160 ets = it.next(ets); 161 } else { 162 // This one isn't valid, remove it from the list and deallocate it 163 JvmtiEnvThreadState* defunct_ets = ets; 164 ets = ets->next(); 165 if (previous_ets == NULL) { 166 assert(state->head_env_thread_state() == defunct_ets, "sanity check"); 167 state->set_head_env_thread_state(ets); 168 } else { 169 previous_ets->set_next(ets); 170 } 171 delete defunct_ets; 172 } 173 } 174 } 175 } 176 177 void JvmtiThreadState::add_env(JvmtiEnvBase *env) { 178 assert(JvmtiThreadState_lock->is_locked(), "sanity check"); 179 180 JvmtiEnvThreadState *new_ets = new JvmtiEnvThreadState(_thread, env); 181 // add this environment thread state to the end of the list (order is important) 182 { 183 // list deallocation (which occurs at a safepoint) cannot occur simultaneously 184 debug_only(NoSafepointVerifier nosafepoint;) 185 186 JvmtiEnvThreadStateIterator it(this); 187 JvmtiEnvThreadState* previous_ets = NULL; 188 for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { 189 previous_ets = ets; 190 } 191 if (previous_ets == NULL) { 192 set_head_env_thread_state(new_ets); 193 } else { 194 previous_ets->set_next(new_ets); 195 } 196 } 197 } 198 199 200 201 202 void JvmtiThreadState::enter_interp_only_mode() { 203 assert(_thread->get_interp_only_mode() == 0, "entering interp only when mode not zero"); 204 _thread->increment_interp_only_mode(); 205 } 206 207 208 void JvmtiThreadState::leave_interp_only_mode() { 209 assert(_thread->get_interp_only_mode() == 1, "leaving interp only when mode not one"); 210 _thread->decrement_interp_only_mode(); 211 } 212 213 214 // Helper routine used in several places 215 int JvmtiThreadState::count_frames() { 216 guarantee(SafepointSynchronize::is_at_safepoint() || 217 (JavaThread *)Thread::current() == get_thread(), 218 "must be current thread or at safepoint"); 219 220 if (!get_thread()->has_last_Java_frame()) return 0; // no Java frames 221 222 ResourceMark rm; 223 RegisterMap reg_map(get_thread()); 224 javaVFrame *jvf = get_thread()->last_java_vframe(®_map); 225 int n = 0; 226 while (jvf != NULL) { 227 Method* method = jvf->method(); 228 jvf = jvf->java_sender(); 229 n++; 230 } 231 return n; 232 } 233 234 235 void JvmtiThreadState::invalidate_cur_stack_depth() { 236 guarantee(SafepointSynchronize::is_at_safepoint() || 237 (JavaThread *)Thread::current() == get_thread(), 238 "must be current thread or at safepoint"); 239 240 _cur_stack_depth = UNKNOWN_STACK_DEPTH; 241 } 242 243 void JvmtiThreadState::incr_cur_stack_depth() { 244 guarantee(JavaThread::current() == get_thread(), "must be current thread"); 245 246 if (!is_interp_only_mode()) { 247 _cur_stack_depth = UNKNOWN_STACK_DEPTH; 248 } 249 if (_cur_stack_depth != UNKNOWN_STACK_DEPTH) { 250 ++_cur_stack_depth; 251 } 252 } 253 254 void JvmtiThreadState::decr_cur_stack_depth() { 255 guarantee(JavaThread::current() == get_thread(), "must be current thread"); 256 257 if (!is_interp_only_mode()) { 258 _cur_stack_depth = UNKNOWN_STACK_DEPTH; 259 } 260 if (_cur_stack_depth != UNKNOWN_STACK_DEPTH) { 261 --_cur_stack_depth; 262 assert(_cur_stack_depth >= 0, "incr/decr_cur_stack_depth mismatch"); 263 } 264 } 265 266 int JvmtiThreadState::cur_stack_depth() { 267 guarantee(SafepointSynchronize::is_at_safepoint() || 268 (JavaThread *)Thread::current() == get_thread(), 269 "must be current thread or at safepoint"); 270 271 if (!is_interp_only_mode() || _cur_stack_depth == UNKNOWN_STACK_DEPTH) { 272 _cur_stack_depth = count_frames(); 273 } else { 274 // heavy weight assert 275 assert(_cur_stack_depth == count_frames(), 276 "cur_stack_depth out of sync"); 277 } 278 return _cur_stack_depth; 279 } 280 281 bool JvmtiThreadState::may_be_walked() { 282 return (get_thread()->is_being_ext_suspended() || (JavaThread::current() == get_thread())); 283 } 284 285 286 void JvmtiThreadState::process_pending_step_for_popframe() { 287 // We are single stepping as the last part of the PopFrame() dance 288 // so we have some house keeping to do. 289 290 JavaThread *thr = get_thread(); 291 if (thr->popframe_condition() != JavaThread::popframe_inactive) { 292 // If the popframe_condition field is not popframe_inactive, then 293 // we missed all of the popframe_field cleanup points: 294 // 295 // - unpack_frames() was not called (nothing to deopt) 296 // - remove_activation_preserving_args_entry() was not called 297 // (did not get suspended in a call_vm() family call and did 298 // not complete a call_vm() family call on the way here) 299 thr->clear_popframe_condition(); 300 } 301 302 // clearing the flag indicates we are done with the PopFrame() dance 303 clr_pending_step_for_popframe(); 304 305 // If exception was thrown in this frame, need to reset jvmti thread state. 306 // Single stepping may not get enabled correctly by the agent since 307 // exception state is passed in MethodExit event which may be sent at some 308 // time in the future. JDWP agent ignores MethodExit events if caused by 309 // an exception. 310 // 311 if (is_exception_detected()) { 312 clear_exception_state(); 313 } 314 // If step is pending for popframe then it may not be 315 // a repeat step. The new_bci and method_id is same as current_bci 316 // and current method_id after pop and step for recursive calls. 317 // Force the step by clearing the last location. 318 JvmtiEnvThreadStateIterator it(this); 319 for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { 320 ets->clear_current_location(); 321 } 322 } 323 324 325 // Class: JvmtiThreadState 326 // Function: update_for_pop_top_frame 327 // Description: 328 // This function removes any frame pop notification request for 329 // the top frame and invalidates both the current stack depth and 330 // all cached frameIDs. 331 // 332 // Called by: PopFrame 333 // 334 void JvmtiThreadState::update_for_pop_top_frame() { 335 if (is_interp_only_mode()) { 336 // remove any frame pop notification request for the top frame 337 // in any environment 338 int popframe_number = cur_stack_depth(); 339 { 340 JvmtiEnvThreadStateIterator it(this); 341 for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { 342 if (ets->is_frame_pop(popframe_number)) { 343 ets->clear_frame_pop(popframe_number); 344 } 345 } 346 } 347 // force stack depth to be recalculated 348 invalidate_cur_stack_depth(); 349 } else { 350 assert(!is_enabled(JVMTI_EVENT_FRAME_POP), "Must have no framepops set"); 351 } 352 } 353 354 355 void JvmtiThreadState::process_pending_step_for_earlyret() { 356 // We are single stepping as the last part of the ForceEarlyReturn 357 // dance so we have some house keeping to do. 358 359 if (is_earlyret_pending()) { 360 // If the earlyret_state field is not earlyret_inactive, then 361 // we missed all of the earlyret_field cleanup points: 362 // 363 // - remove_activation() was not called 364 // (did not get suspended in a call_vm() family call and did 365 // not complete a call_vm() family call on the way here) 366 // 367 // One legitimate way for us to miss all the cleanup points is 368 // if we got here right after handling a compiled return. If that 369 // is the case, then we consider our return from compiled code to 370 // complete the ForceEarlyReturn request and we clear the condition. 371 clr_earlyret_pending(); 372 set_earlyret_oop(NULL); 373 clr_earlyret_value(); 374 } 375 376 // clearing the flag indicates we are done with 377 // the ForceEarlyReturn() dance 378 clr_pending_step_for_earlyret(); 379 380 // If exception was thrown in this frame, need to reset jvmti thread state. 381 // Single stepping may not get enabled correctly by the agent since 382 // exception state is passed in MethodExit event which may be sent at some 383 // time in the future. JDWP agent ignores MethodExit events if caused by 384 // an exception. 385 // 386 if (is_exception_detected()) { 387 clear_exception_state(); 388 } 389 // If step is pending for earlyret then it may not be a repeat step. 390 // The new_bci and method_id is same as current_bci and current 391 // method_id after earlyret and step for recursive calls. 392 // Force the step by clearing the last location. 393 JvmtiEnvThreadStateIterator it(this); 394 for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) { 395 ets->clear_current_location(); 396 } 397 } 398 399 void JvmtiThreadState::oops_do(OopClosure* f) { 400 f->do_oop((oop*) &_earlyret_oop); 401 }