/*

 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "precompiled.hpp"

#include "interpreter/interpreter.hpp"

#include "jvmtifiles/jvmtiEnv.hpp"

#include "memory/resourceArea.hpp"

#include "prims/jvmtiEventController.hpp"

#include "prims/jvmtiEventController.inline.hpp"

#include "prims/jvmtiExport.hpp"

#include "prims/jvmtiImpl.hpp"

#include "prims/jvmtiThreadState.inline.hpp"

#include "runtime/frame.hpp"

#include "runtime/thread.hpp"

#include "runtime/vframe.hpp"

#include "runtime/vframe_hp.hpp"

#include "runtime/vmThread.hpp"

#include "runtime/vm_operations.hpp"

#ifdef JVMTI_TRACE

#define EC_TRACE(out) if (JvmtiTrace::trace_event_controller()) { SafeResourceMark rm; tty->print_cr out; } while (0)

#else

#define EC_TRACE(out)

#endif /*JVMTI_TRACE */

// bits for standard events

static const jlong  SINGLE_STEP_BIT = (((jlong)1) << (JVMTI_EVENT_SINGLE_STEP - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  FRAME_POP_BIT = (((jlong)1) << (JVMTI_EVENT_FRAME_POP - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  BREAKPOINT_BIT = (((jlong)1) << (JVMTI_EVENT_BREAKPOINT - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  FIELD_ACCESS_BIT = (((jlong)1) << (JVMTI_EVENT_FIELD_ACCESS - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  FIELD_MODIFICATION_BIT = (((jlong)1) << (JVMTI_EVENT_FIELD_MODIFICATION - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  METHOD_ENTRY_BIT = (((jlong)1) << (JVMTI_EVENT_METHOD_ENTRY - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  METHOD_EXIT_BIT = (((jlong)1) << (JVMTI_EVENT_METHOD_EXIT - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  CLASS_FILE_LOAD_HOOK_BIT = (((jlong)1) << (JVMTI_EVENT_CLASS_FILE_LOAD_HOOK - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  NATIVE_METHOD_BIND_BIT = (((jlong)1) << (JVMTI_EVENT_NATIVE_METHOD_BIND - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  VM_START_BIT = (((jlong)1) << (JVMTI_EVENT_VM_START - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  VM_INIT_BIT = (((jlong)1) << (JVMTI_EVENT_VM_INIT - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  VM_DEATH_BIT = (((jlong)1) << (JVMTI_EVENT_VM_DEATH - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  CLASS_LOAD_BIT = (((jlong)1) << (JVMTI_EVENT_CLASS_LOAD - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  CLASS_PREPARE_BIT = (((jlong)1) << (JVMTI_EVENT_CLASS_PREPARE - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  THREAD_START_BIT = (((jlong)1) << (JVMTI_EVENT_THREAD_START - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  THREAD_END_BIT = (((jlong)1) << (JVMTI_EVENT_THREAD_END - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  EXCEPTION_THROW_BIT = (((jlong)1) << (JVMTI_EVENT_EXCEPTION - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  EXCEPTION_CATCH_BIT = (((jlong)1) << (JVMTI_EVENT_EXCEPTION_CATCH - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  MONITOR_CONTENDED_ENTER_BIT = (((jlong)1) << (JVMTI_EVENT_MONITOR_CONTENDED_ENTER - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  MONITOR_CONTENDED_ENTERED_BIT = (((jlong)1) << (JVMTI_EVENT_MONITOR_CONTENDED_ENTERED - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  MONITOR_WAIT_BIT = (((jlong)1) << (JVMTI_EVENT_MONITOR_WAIT - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  MONITOR_WAITED_BIT = (((jlong)1) << (JVMTI_EVENT_MONITOR_WAITED - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  DYNAMIC_CODE_GENERATED_BIT = (((jlong)1) << (JVMTI_EVENT_DYNAMIC_CODE_GENERATED - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  DATA_DUMP_BIT = (((jlong)1) << (JVMTI_EVENT_DATA_DUMP_REQUEST - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  COMPILED_METHOD_LOAD_BIT = (((jlong)1) << (JVMTI_EVENT_COMPILED_METHOD_LOAD - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  COMPILED_METHOD_UNLOAD_BIT = (((jlong)1) << (JVMTI_EVENT_COMPILED_METHOD_UNLOAD - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  GARBAGE_COLLECTION_START_BIT = (((jlong)1) << (JVMTI_EVENT_GARBAGE_COLLECTION_START - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  GARBAGE_COLLECTION_FINISH_BIT = (((jlong)1) << (JVMTI_EVENT_GARBAGE_COLLECTION_FINISH - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  OBJECT_FREE_BIT = (((jlong)1) << (JVMTI_EVENT_OBJECT_FREE - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  RESOURCE_EXHAUSTED_BIT = (((jlong)1) << (JVMTI_EVENT_RESOURCE_EXHAUSTED - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  VM_OBJECT_ALLOC_BIT = (((jlong)1) << (JVMTI_EVENT_VM_OBJECT_ALLOC - TOTAL_MIN_EVENT_TYPE_VAL));

// bits for extension events

static const jlong  CLASS_UNLOAD_BIT = (((jlong)1) << (EXT_EVENT_CLASS_UNLOAD - TOTAL_MIN_EVENT_TYPE_VAL));

static const jlong  MONITOR_BITS = MONITOR_CONTENDED_ENTER_BIT | MONITOR_CONTENDED_ENTERED_BIT |

                          MONITOR_WAIT_BIT | MONITOR_WAITED_BIT;

static const jlong  EXCEPTION_BITS = EXCEPTION_THROW_BIT | EXCEPTION_CATCH_BIT;

static const jlong  INTERP_EVENT_BITS =  SINGLE_STEP_BIT | METHOD_ENTRY_BIT | METHOD_EXIT_BIT |

                                FRAME_POP_BIT | FIELD_ACCESS_BIT | FIELD_MODIFICATION_BIT;

static const jlong  THREAD_FILTERED_EVENT_BITS = INTERP_EVENT_BITS | EXCEPTION_BITS | MONITOR_BITS |

                                        BREAKPOINT_BIT | CLASS_LOAD_BIT | CLASS_PREPARE_BIT | THREAD_END_BIT;

static const jlong  NEED_THREAD_LIFE_EVENTS = THREAD_FILTERED_EVENT_BITS | THREAD_START_BIT;

static const jlong  EARLY_EVENT_BITS = CLASS_FILE_LOAD_HOOK_BIT |

                               VM_START_BIT | VM_INIT_BIT | VM_DEATH_BIT | NATIVE_METHOD_BIND_BIT |

                               THREAD_START_BIT | THREAD_END_BIT |

                               DYNAMIC_CODE_GENERATED_BIT;

static const jlong  GLOBAL_EVENT_BITS = ~THREAD_FILTERED_EVENT_BITS;

static const jlong  SHOULD_POST_ON_EXCEPTIONS_BITS = EXCEPTION_BITS | METHOD_EXIT_BIT | FRAME_POP_BIT;

///////////////////////////////////////////////////////////////

//

// JvmtiEventEnabled

//

JvmtiEventEnabled::JvmtiEventEnabled() {

  clear();

}

void JvmtiEventEnabled::clear() {

  _enabled_bits = 0;

#ifndef PRODUCT

  _init_guard = JEE_INIT_GUARD;

#endif

}

void JvmtiEventEnabled::set_enabled(jvmtiEvent event_type, bool enabled) {

  jlong bits = get_bits();

  jlong mask = bit_for(event_type);

  if (enabled) {

    bits |= mask;

  } else {

    bits &= ~mask;

  }

  set_bits(bits);

}

///////////////////////////////////////////////////////////////

//

// JvmtiEnvThreadEventEnable

//

JvmtiEnvThreadEventEnable::JvmtiEnvThreadEventEnable() {

  _event_user_enabled.clear();

  _event_enabled.clear();

}

JvmtiEnvThreadEventEnable::~JvmtiEnvThreadEventEnable() {

  _event_user_enabled.clear();

  _event_enabled.clear();

}

///////////////////////////////////////////////////////////////

//

// JvmtiThreadEventEnable

//

JvmtiThreadEventEnable::JvmtiThreadEventEnable() {

  _event_enabled.clear();

}

JvmtiThreadEventEnable::~JvmtiThreadEventEnable() {

  _event_enabled.clear();

}

///////////////////////////////////////////////////////////////

//

// JvmtiEnvEventEnable

//

JvmtiEnvEventEnable::JvmtiEnvEventEnable() {

  _event_user_enabled.clear();

  _event_callback_enabled.clear();

  _event_enabled.clear();

}

JvmtiEnvEventEnable::~JvmtiEnvEventEnable() {

  _event_user_enabled.clear();

  _event_callback_enabled.clear();

  _event_enabled.clear();

}

///////////////////////////////////////////////////////////////

//

// VM_EnterInterpOnlyMode

//

class VM_EnterInterpOnlyMode : public VM_Operation {

private:

  JvmtiThreadState *_state;

public:

  VM_EnterInterpOnlyMode(JvmtiThreadState *state);

  bool allow_nested_vm_operations() const        { return true; }

  VMOp_Type type() const { return VMOp_EnterInterpOnlyMode; }

  void doit();

  // to do: this same function is in jvmtiImpl - should be in one place

  bool can_be_deoptimized(vframe* vf) {

    return (vf->is_compiled_frame() && vf->fr().can_be_deoptimized());

  }

};

VM_EnterInterpOnlyMode::VM_EnterInterpOnlyMode(JvmtiThreadState *state)

  : _state(state)

{

}

void VM_EnterInterpOnlyMode::doit() {

  // Set up the current stack depth for later tracking

  _state->invalidate_cur_stack_depth();

  _state->enter_interp_only_mode();

  JavaThread *thread = _state->get_thread();

  if (thread->has_last_Java_frame()) {

    // If running in fullspeed mode, single stepping is implemented

    // as follows: first, the interpreter does not dispatch to

    // compiled code for threads that have single stepping enabled;

    // second, we deoptimize all methods on the thread's stack when

    // interpreted-only mode is enabled the first time for a given

    // thread (nothing to do if no Java frames yet).

    int num_marked = 0;

    ResourceMark resMark;

    RegisterMap rm(thread, false);

    for (vframe* vf = thread->last_java_vframe(&rm); vf; vf = vf->sender()) {

      if (can_be_deoptimized(vf)) {

        ((compiledVFrame*) vf)->code()->mark_for_deoptimization();

        ++num_marked;

      }

    }

    if (num_marked > 0) {

      VM_Deoptimize op;

      VMThread::execute(&op);

    }

  }

}

///////////////////////////////////////////////////////////////

//

// VM_ChangeSingleStep

//

class VM_ChangeSingleStep : public VM_Operation {

private:

  bool _on;

public:

  VM_ChangeSingleStep(bool on);

  VMOp_Type type() const                         { return VMOp_ChangeSingleStep; }

  bool allow_nested_vm_operations() const        { return true; }

  void doit();   // method definition is after definition of JvmtiEventControllerPrivate because of scoping

};

VM_ChangeSingleStep::VM_ChangeSingleStep(bool on)

  : _on(on != 0)

{

}

///////////////////////////////////////////////////////////////

//

// JvmtiEventControllerPrivate

//

// Private internal implementation methods for JvmtiEventController.

//

// These methods are thread safe either because they are called

// in early VM initialization which is single threaded, or they

// hold the JvmtiThreadState_lock.

//

class JvmtiEventControllerPrivate : public AllStatic {

  static bool _initialized;

public:

  static void set_should_post_single_step(bool on);

  static void enter_interp_only_mode(JvmtiThreadState *state);

  static void leave_interp_only_mode(JvmtiThreadState *state);

  static void recompute_enabled();

  static jlong recompute_env_enabled(JvmtiEnvBase* env);

  static jlong recompute_env_thread_enabled(JvmtiEnvThreadState* ets, JvmtiThreadState* state);

  static jlong recompute_thread_enabled(JvmtiThreadState *state);

  static void event_init();

  static void set_user_enabled(JvmtiEnvBase *env, JavaThread *thread,

                        jvmtiEvent event_type, bool enabled);

  static void set_event_callbacks(JvmtiEnvBase *env,

                                  const jvmtiEventCallbacks* callbacks,

                                  jint size_of_callbacks);

  static void set_extension_event_callback(JvmtiEnvBase *env,

                                           jint extension_event_index,

                                           jvmtiExtensionEvent callback);

  static void set_frame_pop(JvmtiEnvThreadState *env_thread, JvmtiFramePop fpop);

  static void clear_frame_pop(JvmtiEnvThreadState *env_thread, JvmtiFramePop fpop);

  static void clear_to_frame_pop(JvmtiEnvThreadState *env_thread, JvmtiFramePop fpop);

  static void change_field_watch(jvmtiEvent event_type, bool added);

  static void thread_started(JavaThread *thread);

  static void thread_ended(JavaThread *thread);

  static void env_initialize(JvmtiEnvBase *env);

  static void env_dispose(JvmtiEnvBase *env);

  static void vm_start();

  static void vm_init();

  static void vm_death();

  static void trace_changed(JvmtiThreadState *state, jlong now_enabled, jlong changed);

  static void trace_changed(jlong now_enabled, jlong changed);

};

bool JvmtiEventControllerPrivate::_initialized = false;

void JvmtiEventControllerPrivate::set_should_post_single_step(bool on) {

  // we have permission to do this, VM op doesn't

  JvmtiExport::set_should_post_single_step(on);

}

// This change must always be occur when at a safepoint.

// Being at a safepoint causes the interpreter to use the

// safepoint dispatch table which we overload to find single

// step points.  Just to be sure that it has been set, we

// call notice_safepoints when turning on single stepping.

// When we leave our current safepoint, should_post_single_step

// will be checked by the interpreter, and the table kept

// or changed accordingly.

void VM_ChangeSingleStep::doit() {

  JvmtiEventControllerPrivate::set_should_post_single_step(_on);

  if (_on) {

    Interpreter::notice_safepoints();

  }

}

void JvmtiEventControllerPrivate::enter_interp_only_mode(JvmtiThreadState *state) {

  EC_TRACE(("JVMTI [%s] # Entering interpreter only mode",

            JvmtiTrace::safe_get_thread_name(state->get_thread())));

  VM_EnterInterpOnlyMode op(state);

  VMThread::execute(&op);

}

void

JvmtiEventControllerPrivate::leave_interp_only_mode(JvmtiThreadState *state) {

  EC_TRACE(("JVMTI [%s] # Leaving interpreter only mode",

            JvmtiTrace::safe_get_thread_name(state->get_thread())));

  state->leave_interp_only_mode();

}

void

JvmtiEventControllerPrivate::trace_changed(JvmtiThreadState *state, jlong now_enabled, jlong changed) {

#ifdef JVMTI_TRACE

  if (JvmtiTrace::trace_event_controller()) {

    SafeResourceMark rm;

    // traces standard events only

    for (int ei = JVMTI_MIN_EVENT_TYPE_VAL; ei <= JVMTI_MAX_EVENT_TYPE_VAL; ++ei) {

      jlong bit = JvmtiEventEnabled::bit_for((jvmtiEvent)ei);

      if (changed & bit) {

        // it changed, print it

        tty->print_cr("JVMTI [%s] # %s event %s",

                      JvmtiTrace::safe_get_thread_name(state->get_thread()),

                      (now_enabled & bit)? "Enabling" : "Disabling", JvmtiTrace::event_name((jvmtiEvent)ei));

      }

    }

  }

#endif /*JVMTI_TRACE */

}

void

JvmtiEventControllerPrivate::trace_changed(jlong now_enabled, jlong changed) {

#ifdef JVMTI_TRACE

  if (JvmtiTrace::trace_event_controller()) {

    SafeResourceMark rm;

    // traces standard events only

    for (int ei = JVMTI_MIN_EVENT_TYPE_VAL; ei <= JVMTI_MAX_EVENT_TYPE_VAL; ++ei) {

      jlong bit = JvmtiEventEnabled::bit_for((jvmtiEvent)ei);

      if (changed & bit) {

        // it changed, print it

        tty->print_cr("JVMTI [-] # %s event %s",

                      (now_enabled & bit)? "Enabling" : "Disabling", JvmtiTrace::event_name((jvmtiEvent)ei));

      }

    }

  }

#endif /*JVMTI_TRACE */

}

// For the specified env: compute the currently truly enabled events

// set external state accordingly.

// Return value and set value must include all events.

// But outside this class, only non-thread-filtered events can be queried..

jlong

JvmtiEventControllerPrivate::recompute_env_enabled(JvmtiEnvBase* env) {

  jlong was_enabled = env->env_event_enable()->_event_enabled.get_bits();

  jlong now_enabled =

    env->env_event_enable()->_event_callback_enabled.get_bits() &

    env->env_event_enable()->_event_user_enabled.get_bits();

  switch (JvmtiEnv::get_phase()) {

  case JVMTI_PHASE_PRIMORDIAL:

  case JVMTI_PHASE_ONLOAD:

    // only these events allowed in primordial or onload phase

    now_enabled &= (EARLY_EVENT_BITS & ~THREAD_FILTERED_EVENT_BITS);

    break;

  case JVMTI_PHASE_START:

    // only these events allowed in start phase

    now_enabled &= EARLY_EVENT_BITS;

    break;

  case JVMTI_PHASE_LIVE:

    // all events allowed during live phase

    break;

  case JVMTI_PHASE_DEAD:

    // no events allowed when dead

    now_enabled = 0;

    break;

  default:

    assert(false, "no other phases - sanity check");

    break;

  }

  // will we really send these events to this env

  env->env_event_enable()->_event_enabled.set_bits(now_enabled);

  trace_changed(now_enabled, (now_enabled ^ was_enabled)  & ~THREAD_FILTERED_EVENT_BITS);

  return now_enabled;

}

// For the specified env and thread: compute the currently truly enabled events

// set external state accordingly.  Only thread-filtered events are included.

jlong

JvmtiEventControllerPrivate::recompute_env_thread_enabled(JvmtiEnvThreadState* ets, JvmtiThreadState* state) {

  JvmtiEnv *env = ets->get_env();

  jlong was_enabled = ets->event_enable()->_event_enabled.get_bits();

  jlong now_enabled =  THREAD_FILTERED_EVENT_BITS &

    env->env_event_enable()->_event_callback_enabled.get_bits() &

    (env->env_event_enable()->_event_user_enabled.get_bits() |

     ets->event_enable()->_event_user_enabled.get_bits());

  // for frame pops and field watchs, computed enabled state

  // is only true if an event has been requested

  if (!ets->has_frame_pops()) {

    now_enabled &= ~FRAME_POP_BIT;

  }

  if (*((int *)JvmtiExport::get_field_access_count_addr()) == 0) {

    now_enabled &= ~FIELD_ACCESS_BIT;

  }

  if (*((int *)JvmtiExport::get_field_modification_count_addr()) == 0) {

    now_enabled &= ~FIELD_MODIFICATION_BIT;

  }

  switch (JvmtiEnv::get_phase()) {

  case JVMTI_PHASE_DEAD:

    // no events allowed when dead

    now_enabled = 0;

    break;

  }

  // if anything changed do update

  if (now_enabled != was_enabled) {

    // will we really send these events to this thread x env

    ets->event_enable()->_event_enabled.set_bits(now_enabled);

    // If the enabled status of the single step or breakpoint events changed,

    // the location status may need to change as well.

    jlong changed = now_enabled ^ was_enabled;

    if (changed & SINGLE_STEP_BIT) {

      ets->reset_current_location(JVMTI_EVENT_SINGLE_STEP, (now_enabled & SINGLE_STEP_BIT) != 0);

    }

    if (changed & BREAKPOINT_BIT) {

      ets->reset_current_location(JVMTI_EVENT_BREAKPOINT,  (now_enabled & BREAKPOINT_BIT) != 0);

    }

    trace_changed(state, now_enabled, changed);

  }

  return now_enabled;

}

// For the specified thread: compute the currently truly enabled events

// set external state accordingly.  Only thread-filtered events are included.

jlong

JvmtiEventControllerPrivate::recompute_thread_enabled(JvmtiThreadState *state) {

  if (state == NULL) {

    // associated JavaThread is exiting

    return (jlong)0;

  }

  jlong was_any_env_enabled = state->thread_event_enable()->_event_enabled.get_bits();

  jlong any_env_enabled = 0;

  {

    // This iteration will include JvmtiEnvThreadStates whoses environments

    // have been disposed.  These JvmtiEnvThreadStates must not be filtered

    // as recompute must be called on them to disable their events,

    JvmtiEnvThreadStateIterator it(state);

    for (JvmtiEnvThreadState* ets = it.first(); ets != NULL; ets = it.next(ets)) {

      any_env_enabled |= recompute_env_thread_enabled(ets, state);

    }

  }

  if (any_env_enabled != was_any_env_enabled) {

    // mark if event is truly enabled on this thread in any environment

    state->thread_event_enable()->_event_enabled.set_bits(any_env_enabled);

    // compute interp_only mode

    bool should_be_interp = (any_env_enabled & INTERP_EVENT_BITS) != 0;

    bool is_now_interp = state->is_interp_only_mode();

    if (should_be_interp != is_now_interp) {

      if (should_be_interp) {

        enter_interp_only_mode(state);

      } else {

        leave_interp_only_mode(state);

      }

    }