1 /*
   2  * Copyright (c) 2003, 2019, 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   _sampled_object_alloc_event_collector = NULL;
  64   _the_class_for_redefinition_verification = NULL;
  65   _scratch_class_for_redefinition_verification = NULL;
  66   _cur_stack_depth = UNKNOWN_STACK_DEPTH;
  67 
  68   // JVMTI ForceEarlyReturn support
  69   _pending_step_for_earlyret = false;
  70   _earlyret_state = earlyret_inactive;
  71   _earlyret_tos = ilgl;
  72   _earlyret_value.j = 0L;
  73   _earlyret_oop = NULL;
  74 
  75   // add all the JvmtiEnvThreadState to the new JvmtiThreadState
  76   {
  77     JvmtiEnvIterator it;
  78     for (JvmtiEnvBase* env = it.first(); env != NULL; env = it.next(env)) {
  79       if (env->is_valid()) {
  80         add_env(env);
  81       }
  82     }
  83   }
  84 
  85   // link us into the list
  86   {
  87     // The thread state list manipulation code must not have safepoints.
  88     // See periodic_clean_up().
  89     debug_only(NoSafepointVerifier nosafepoint;)
  90 
  91     _prev = NULL;
  92     _next = _head;
  93     if (_head != NULL) {
  94       _head->_prev = this;
  95     }
  96     _head = this;
  97   }
  98 
  99   // set this as the state for the thread
 100   thread->set_jvmti_thread_state(this);
 101 }
 102 
 103 
 104 JvmtiThreadState::~JvmtiThreadState()   {
 105   assert(JvmtiThreadState_lock->is_locked(), "sanity check");
 106 
 107   // clear this as the state for the thread
 108   get_thread()->set_jvmti_thread_state(NULL);
 109 
 110   // zap our env thread states
 111   {
 112     JvmtiEnvBase::entering_dying_thread_env_iteration();
 113     JvmtiEnvThreadStateIterator it(this);
 114     for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ) {
 115       JvmtiEnvThreadState* zap = ets;
 116       ets = it.next(ets);
 117       delete zap;
 118     }
 119     JvmtiEnvBase::leaving_dying_thread_env_iteration();
 120   }
 121 
 122   // remove us from the list
 123   {
 124     // The thread state list manipulation code must not have safepoints.
 125     // See periodic_clean_up().
 126     debug_only(NoSafepointVerifier nosafepoint;)
 127 
 128     if (_prev == NULL) {
 129       assert(_head == this, "sanity check");
 130       _head = _next;
 131     } else {
 132       assert(_head != this, "sanity check");
 133       _prev->_next = _next;
 134     }
 135     if (_next != NULL) {
 136       _next->_prev = _prev;
 137     }
 138     _next = NULL;
 139     _prev = NULL;
 140   }
 141 }
 142 
 143 
 144 void
 145 JvmtiThreadState::periodic_clean_up() {
 146   assert(SafepointSynchronize::is_at_safepoint(), "at safepoint");
 147 
 148   // This iteration is initialized with "_head" instead of "JvmtiThreadState::first()"
 149   // because the latter requires the JvmtiThreadState_lock.
 150   // This iteration is safe at a safepoint as well, see the NoSafepointVerifier
 151   // asserts at all list manipulation sites.
 152   for (JvmtiThreadState *state = _head; state != NULL; state = state->next()) {
 153     // For each environment thread state corresponding to an invalid environment
 154     // unlink it from the list and deallocate it.
 155     JvmtiEnvThreadStateIterator it(state);
 156     JvmtiEnvThreadState* previous_ets = NULL;
 157     JvmtiEnvThreadState* ets = it.first();
 158     while (ets != NULL) {
 159       if (ets->get_env()->is_valid()) {
 160         previous_ets = ets;
 161         ets = it.next(ets);
 162       } else {
 163         // This one isn't valid, remove it from the list and deallocate it
 164         JvmtiEnvThreadState* defunct_ets = ets;
 165         ets = ets->next();
 166         if (previous_ets == NULL) {
 167           assert(state->head_env_thread_state() == defunct_ets, "sanity check");
 168           state->set_head_env_thread_state(ets);
 169         } else {
 170           previous_ets->set_next(ets);
 171         }
 172         delete defunct_ets;
 173       }
 174     }
 175   }
 176 }
 177 
 178 void JvmtiThreadState::add_env(JvmtiEnvBase *env) {
 179   assert(JvmtiThreadState_lock->is_locked(), "sanity check");
 180 
 181   JvmtiEnvThreadState *new_ets = new JvmtiEnvThreadState(_thread, env);
 182   // add this environment thread state to the end of the list (order is important)
 183   {
 184     // list deallocation (which occurs at a safepoint) cannot occur simultaneously
 185     debug_only(NoSafepointVerifier nosafepoint;)
 186 
 187     JvmtiEnvThreadStateIterator it(this);
 188     JvmtiEnvThreadState* previous_ets = NULL;
 189     for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
 190       previous_ets = ets;
 191     }
 192     if (previous_ets == NULL) {
 193       set_head_env_thread_state(new_ets);
 194     } else {
 195       previous_ets->set_next(new_ets);
 196     }
 197   }
 198 }
 199 
 200 
 201 
 202 
 203 void JvmtiThreadState::enter_interp_only_mode() {
 204   assert(_thread->get_interp_only_mode() == 0, "entering interp only when mode not zero");
 205   _thread->increment_interp_only_mode();
 206   invalidate_cur_stack_depth();
 207 }
 208 
 209 
 210 void JvmtiThreadState::leave_interp_only_mode() {
 211   assert(_thread->get_interp_only_mode() == 1, "leaving interp only when mode not one");
 212   _thread->decrement_interp_only_mode();
 213 }
 214 
 215 
 216 // Helper routine used in several places
 217 int JvmtiThreadState::count_frames() {
 218   guarantee(SafepointSynchronize::is_at_safepoint() ||
 219     (JavaThread *)Thread::current() == get_thread(),
 220     "must be current thread or at safepoint");
 221 
 222   if (!get_thread()->has_last_Java_frame()) return 0;  // no Java frames
 223 
 224   ResourceMark rm;
 225   RegisterMap reg_map(get_thread(), true, true);
 226   javaVFrame *jvf = get_thread()->last_java_vframe(&reg_map);
 227   int n = 0;
 228   while (jvf != NULL) {
 229     Method* method = jvf->method();
 230     jvf = jvf->java_sender();
 231     n++;
 232   }
 233   return n;
 234 }
 235 
 236 
 237 void JvmtiThreadState::invalidate_cur_stack_depth() {
 238   guarantee(SafepointSynchronize::is_at_safepoint() ||
 239     (JavaThread *)Thread::current() == get_thread(),
 240     "must be current thread or at safepoint");
 241 
 242   _cur_stack_depth = UNKNOWN_STACK_DEPTH;
 243 }
 244 
 245 void JvmtiThreadState::incr_cur_stack_depth() {
 246   guarantee(JavaThread::current() == get_thread(), "must be current thread");
 247 
 248   if (!is_interp_only_mode()) {
 249     _cur_stack_depth = UNKNOWN_STACK_DEPTH;
 250   }
 251   if (_cur_stack_depth != UNKNOWN_STACK_DEPTH) {
 252     ++_cur_stack_depth;
 253 #ifdef ASSERT
 254     // heavy weight assert
 255     // fiber fixme: remove this before merging loom with main jdk repo
 256     jint num_frames = count_frames();
 257     assert(_cur_stack_depth == num_frames, "cur_stack_depth out of sync");
 258 #endif
 259   }
 260 }
 261 
 262 void JvmtiThreadState::decr_cur_stack_depth() {
 263   guarantee(JavaThread::current() == get_thread(), "must be current thread");
 264 
 265   if (!is_interp_only_mode()) {
 266     _cur_stack_depth = UNKNOWN_STACK_DEPTH;
 267   }
 268   if (_cur_stack_depth != UNKNOWN_STACK_DEPTH) {
 269 #ifdef ASSERT
 270     // heavy weight assert
 271     // fiber fixme: remove this before merging loom with main jdk repo
 272     jint num_frames = count_frames();
 273     assert(_cur_stack_depth == num_frames, "cur_stack_depth out of sync");
 274 #endif
 275     --_cur_stack_depth;
 276     assert(_cur_stack_depth >= 0, "incr/decr_cur_stack_depth mismatch");
 277   }
 278 }
 279 
 280 int JvmtiThreadState::cur_stack_depth() {
 281   guarantee(SafepointSynchronize::is_at_safepoint() ||
 282     (JavaThread *)Thread::current() == get_thread(),
 283     "must be current thread or at safepoint");
 284 
 285   if (!is_interp_only_mode() || _cur_stack_depth == UNKNOWN_STACK_DEPTH) {
 286     _cur_stack_depth = count_frames();
 287   } else {
 288 #ifdef ASSERT
 289     // heavy weight assert
 290     jint num_frames = count_frames();
 291     assert(_cur_stack_depth == num_frames, "cur_stack_depth out of sync");
 292 #endif
 293   }
 294   return _cur_stack_depth;
 295 }
 296 
 297 bool JvmtiThreadState::may_be_walked() {
 298   return (get_thread()->is_being_ext_suspended() || (JavaThread::current() == get_thread()));
 299 }
 300 
 301 
 302 void JvmtiThreadState::process_pending_step_for_popframe() {
 303   // We are single stepping as the last part of the PopFrame() dance
 304   // so we have some house keeping to do.
 305 
 306   JavaThread *thr = get_thread();
 307   if (thr->popframe_condition() != JavaThread::popframe_inactive) {
 308     // If the popframe_condition field is not popframe_inactive, then
 309     // we missed all of the popframe_field cleanup points:
 310     //
 311     // - unpack_frames() was not called (nothing to deopt)
 312     // - remove_activation_preserving_args_entry() was not called
 313     //   (did not get suspended in a call_vm() family call and did
 314     //   not complete a call_vm() family call on the way here)
 315     thr->clear_popframe_condition();
 316   }
 317 
 318   // clearing the flag indicates we are done with the PopFrame() dance
 319   clr_pending_step_for_popframe();
 320 
 321   // If exception was thrown in this frame, need to reset jvmti thread state.
 322   // Single stepping may not get enabled correctly by the agent since
 323   // exception state is passed in MethodExit event which may be sent at some
 324   // time in the future. JDWP agent ignores MethodExit events if caused by
 325   // an exception.
 326   //
 327   if (is_exception_detected()) {
 328     clear_exception_state();
 329   }
 330   // If step is pending for popframe then it may not be
 331   // a repeat step. The new_bci and method_id is same as current_bci
 332   // and current method_id after pop and step for recursive calls.
 333   // Force the step by clearing the last location.
 334   JvmtiEnvThreadStateIterator it(this);
 335   for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
 336     ets->clear_current_location();
 337   }
 338 }
 339 
 340 
 341 // Class:     JvmtiThreadState
 342 // Function:  update_for_pop_top_frame
 343 // Description:
 344 //   This function removes any frame pop notification request for
 345 //   the top frame and invalidates both the current stack depth and
 346 //   all cached frameIDs.
 347 //
 348 // Called by: PopFrame
 349 //
 350 void JvmtiThreadState::update_for_pop_top_frame() {
 351   if (is_interp_only_mode()) {
 352     // remove any frame pop notification request for the top frame
 353     // in any environment
 354     int popframe_number = cur_stack_depth();
 355     {
 356       JvmtiEnvThreadStateIterator it(this);
 357       for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
 358         if (ets->is_frame_pop(popframe_number)) {
 359           ets->clear_frame_pop(popframe_number);
 360         }
 361       }
 362     }
 363     // force stack depth to be recalculated
 364     invalidate_cur_stack_depth();
 365   } else {
 366     assert(!is_enabled(JVMTI_EVENT_FRAME_POP), "Must have no framepops set");
 367   }
 368 }
 369 
 370 
 371 void JvmtiThreadState::process_pending_step_for_earlyret() {
 372   // We are single stepping as the last part of the ForceEarlyReturn
 373   // dance so we have some house keeping to do.
 374 
 375   if (is_earlyret_pending()) {
 376     // If the earlyret_state field is not earlyret_inactive, then
 377     // we missed all of the earlyret_field cleanup points:
 378     //
 379     // - remove_activation() was not called
 380     //   (did not get suspended in a call_vm() family call and did
 381     //   not complete a call_vm() family call on the way here)
 382     //
 383     // One legitimate way for us to miss all the cleanup points is
 384     // if we got here right after handling a compiled return. If that
 385     // is the case, then we consider our return from compiled code to
 386     // complete the ForceEarlyReturn request and we clear the condition.
 387     clr_earlyret_pending();
 388     set_earlyret_oop(NULL);
 389     clr_earlyret_value();
 390   }
 391 
 392   // clearing the flag indicates we are done with
 393   // the ForceEarlyReturn() dance
 394   clr_pending_step_for_earlyret();
 395 
 396   // If exception was thrown in this frame, need to reset jvmti thread state.
 397   // Single stepping may not get enabled correctly by the agent since
 398   // exception state is passed in MethodExit event which may be sent at some
 399   // time in the future. JDWP agent ignores MethodExit events if caused by
 400   // an exception.
 401   //
 402   if (is_exception_detected()) {
 403     clear_exception_state();
 404   }
 405   // If step is pending for earlyret then it may not be a repeat step.
 406   // The new_bci and method_id is same as current_bci and current
 407   // method_id after earlyret and step for recursive calls.
 408   // Force the step by clearing the last location.
 409   JvmtiEnvThreadStateIterator it(this);
 410   for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {
 411     ets->clear_current_location();
 412   }
 413 }
 414 
 415 void JvmtiThreadState::oops_do(OopClosure* f) {
 416   f->do_oop((oop*) &_earlyret_oop);
 417 }