/*

 * Copyright 2003-2009 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 *

 */

# include "incls/_precompiled.incl"

# include "incls/_jvmtiExport.cpp.incl"

#ifdef JVMTI_TRACE

#define EVT_TRACE(evt,out) if ((JvmtiTrace::event_trace_flags(evt) & JvmtiTrace::SHOW_EVENT_SENT) != 0) { SafeResourceMark rm; tty->print_cr out; }

#define EVT_TRIG_TRACE(evt,out) if ((JvmtiTrace::event_trace_flags(evt) & JvmtiTrace::SHOW_EVENT_TRIGGER) != 0) { SafeResourceMark rm; tty->print_cr out; }

#else

#define EVT_TRIG_TRACE(evt,out)

#define EVT_TRACE(evt,out)

#endif

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

//

// JvmtiEventTransition

//

// TO DO --

//  more handle purging

// Use this for JavaThreads and state is  _thread_in_vm.

class JvmtiJavaThreadEventTransition : StackObj {

private:

  ResourceMark _rm;

  ThreadToNativeFromVM _transition;

  HandleMark _hm;

public:

  JvmtiJavaThreadEventTransition(JavaThread *thread) :

    _rm(),

    _transition(thread),

    _hm(thread)  {};

};

// For JavaThreads which are not in _thread_in_vm state

// and other system threads use this.

class JvmtiThreadEventTransition : StackObj {

private:

  ResourceMark _rm;

  HandleMark _hm;

  JavaThreadState _saved_state;

  JavaThread *_jthread;

public:

  JvmtiThreadEventTransition(Thread *thread) : _rm(), _hm() {

    if (thread->is_Java_thread()) {

       _jthread = (JavaThread *)thread;

       _saved_state = _jthread->thread_state();

       if (_saved_state == _thread_in_Java) {

         ThreadStateTransition::transition_from_java(_jthread, _thread_in_native);

       } else {

         ThreadStateTransition::transition(_jthread, _saved_state, _thread_in_native);

       }

    } else {

      _jthread = NULL;

    }

  }

  ~JvmtiThreadEventTransition() {

    if (_jthread != NULL)

      ThreadStateTransition::transition_from_native(_jthread, _saved_state);

  }

};

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

//

// JvmtiEventMark

//

class JvmtiEventMark : public StackObj {

private:

  JavaThread *_thread;

  JNIEnv* _jni_env;

  bool _exception_detected;

  bool _exception_caught;

#if 0

  JNIHandleBlock* _hblock;

#endif

public:

  JvmtiEventMark(JavaThread *thread) :  _thread(thread),

                                         _jni_env(thread->jni_environment()) {

#if 0

    _hblock = thread->active_handles();

    _hblock->clear_thoroughly(); // so we can be safe

#else

    // we want to use the code above - but that needs the JNIHandle changes - later...

    // for now, steal JNI push local frame code

    JvmtiThreadState *state = thread->jvmti_thread_state();

    // we are before an event.

    // Save current jvmti thread exception state.

    if (state != NULL) {

      _exception_detected = state->is_exception_detected();

      _exception_caught = state->is_exception_caught();

    } else {

      _exception_detected = false;

      _exception_caught = false;

    }

    JNIHandleBlock* old_handles = thread->active_handles();

    JNIHandleBlock* new_handles = JNIHandleBlock::allocate_block(thread);

    assert(new_handles != NULL, "should not be NULL");

    new_handles->set_pop_frame_link(old_handles);

    thread->set_active_handles(new_handles);

#endif

    assert(thread == JavaThread::current(), "thread must be current!");

    thread->frame_anchor()->make_walkable(thread);

  };

  ~JvmtiEventMark() {

#if 0

    _hblock->clear(); // for consistency with future correct behavior

#else

    // we want to use the code above - but that needs the JNIHandle changes - later...

    // for now, steal JNI pop local frame code

    JNIHandleBlock* old_handles = _thread->active_handles();

    JNIHandleBlock* new_handles = old_handles->pop_frame_link();

    assert(new_handles != NULL, "should not be NULL");

    _thread->set_active_handles(new_handles);

    // Note that we set the pop_frame_link to NULL explicitly, otherwise

    // the release_block call will release the blocks.

    old_handles->set_pop_frame_link(NULL);

    JNIHandleBlock::release_block(old_handles, _thread); // may block

#endif

    JvmtiThreadState* state = _thread->jvmti_thread_state();

    // we are continuing after an event.

    if (state != NULL) {

      // Restore the jvmti thread exception state.

      if (_exception_detected) {

        state->set_exception_detected();

      }

      if (_exception_caught) {

        state->set_exception_caught();

      }

    }

  }

#if 0

  jobject to_jobject(oop obj) { return obj == NULL? NULL : _hblock->allocate_handle_fast(obj); }

#else

  // we want to use the code above - but that needs the JNIHandle changes - later...

  // for now, use regular make_local

  jobject to_jobject(oop obj) { return JNIHandles::make_local(_thread,obj); }

#endif

  jclass to_jclass(klassOop klass) { return (klass == NULL ? NULL : (jclass)to_jobject(Klass::cast(klass)->java_mirror())); }

  jmethodID to_jmethodID(methodHandle method) { return method->jmethod_id(); }

  JNIEnv* jni_env() { return _jni_env; }

};

class JvmtiThreadEventMark : public JvmtiEventMark {

private:

  jthread _jt;

public:

  JvmtiThreadEventMark(JavaThread *thread) :

    JvmtiEventMark(thread) {

    _jt = (jthread)(to_jobject(thread->threadObj()));

  };

 jthread jni_thread() { return _jt; }

};

class JvmtiClassEventMark : public JvmtiThreadEventMark {

private:

  jclass _jc;

public:

  JvmtiClassEventMark(JavaThread *thread, klassOop klass) :

    JvmtiThreadEventMark(thread) {

    _jc = to_jclass(klass);

  };

  jclass jni_class() { return _jc; }

};

class JvmtiMethodEventMark : public JvmtiThreadEventMark {

private:

  jmethodID _mid;

public:

  JvmtiMethodEventMark(JavaThread *thread, methodHandle method) :

    JvmtiThreadEventMark(thread),

    _mid(to_jmethodID(method)) {};

  jmethodID jni_methodID() { return _mid; }

};

class JvmtiLocationEventMark : public JvmtiMethodEventMark {

private:

  jlocation _loc;

public:

  JvmtiLocationEventMark(JavaThread *thread, methodHandle method, address location) :

    JvmtiMethodEventMark(thread, method),

    _loc(location - method->code_base()) {};

  jlocation location() { return _loc; }

};

class JvmtiExceptionEventMark : public JvmtiLocationEventMark {

private:

  jobject _exc;

public:

  JvmtiExceptionEventMark(JavaThread *thread, methodHandle method, address location, Handle exception) :

    JvmtiLocationEventMark(thread, method, location),

    _exc(to_jobject(exception())) {};

  jobject exception() { return _exc; }

};

class JvmtiClassFileLoadEventMark : public JvmtiThreadEventMark {

private:

  const char *_class_name;

  jobject _jloader;

  jobject _protection_domain;

  jclass  _class_being_redefined;

public:

  JvmtiClassFileLoadEventMark(JavaThread *thread, symbolHandle name,

     Handle class_loader, Handle prot_domain, KlassHandle *class_being_redefined) : JvmtiThreadEventMark(thread) {

      _class_name = name() != NULL? name->as_utf8() : NULL;

      _jloader = (jobject)to_jobject(class_loader());

      _protection_domain = (jobject)to_jobject(prot_domain());

      if (class_being_redefined == NULL) {

        _class_being_redefined = NULL;

      } else {

        _class_being_redefined = (jclass)to_jclass((*class_being_redefined)());

      }

  };

  const char *class_name() {

    return _class_name;

  }

  jobject jloader() {

    return _jloader;

  }

  jobject protection_domain() {

    return _protection_domain;

  }

  jclass class_being_redefined() {

    return _class_being_redefined;

  }

};

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

int               JvmtiExport::_field_access_count                        = 0;

int               JvmtiExport::_field_modification_count                  = 0;

bool              JvmtiExport::_can_access_local_variables                = false;

bool              JvmtiExport::_can_examine_or_deopt_anywhere             = false;

bool              JvmtiExport::_can_hotswap_or_post_breakpoint            = false;

bool              JvmtiExport::_can_modify_any_class                      = false;

bool              JvmtiExport::_can_walk_any_space                        = false;

bool              JvmtiExport::_has_redefined_a_class                     = false;

bool              JvmtiExport::_all_dependencies_are_recorded             = false;

//

// field access management

//

// interpreter generator needs the address of the counter

address JvmtiExport::get_field_access_count_addr() {

  // We don't grab a lock because we don't want to

  // serialize field access between all threads. This means that a

  // thread on another processor can see the wrong count value and

  // may either miss making a needed call into post_field_access()

  // or will make an unneeded call into post_field_access(). We pay

  // this price to avoid slowing down the VM when we aren't watching

  // field accesses.

  // Other access/mutation safe by virtue of being in VM state.

  return (address)(&_field_access_count);

}

//

// field modification management

//

// interpreter generator needs the address of the counter

address JvmtiExport::get_field_modification_count_addr() {

  // We don't grab a lock because we don't

  // want to serialize field modification between all threads. This

  // means that a thread on another processor can see the wrong

  // count value and may either miss making a needed call into

  // post_field_modification() or will make an unneeded call into

  // post_field_modification(). We pay this price to avoid slowing

  // down the VM when we aren't watching field modifications.

  // Other access/mutation safe by virtue of being in VM state.

  return (address)(&_field_modification_count);

}

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

// Functions needed by java.lang.instrument for starting up javaagent.

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

jint

JvmtiExport::get_jvmti_interface(JavaVM *jvm, void **penv, jint version) {

  /* To Do: add version checks */

  if (JvmtiEnv::get_phase() == JVMTI_PHASE_LIVE) {

    JavaThread* current_thread = (JavaThread*) ThreadLocalStorage::thread();

    // transition code: native to VM

    ThreadInVMfromNative __tiv(current_thread);

    __ENTRY(jvmtiEnv*, JvmtiExport::get_jvmti_interface, current_thread)

    debug_only(VMNativeEntryWrapper __vew;)

    JvmtiEnv *jvmti_env = JvmtiEnv::create_a_jvmti();

    *penv = jvmti_env->jvmti_external();  // actual type is jvmtiEnv* -- not to be confused with JvmtiEnv*

    return JNI_OK;

  } else if (JvmtiEnv::get_phase() == JVMTI_PHASE_ONLOAD) {

    // not live, no thread to transition

    JvmtiEnv *jvmti_env = JvmtiEnv::create_a_jvmti();

    *penv = jvmti_env->jvmti_external();  // actual type is jvmtiEnv* -- not to be confused with JvmtiEnv*

    return JNI_OK;

  } else {

    // Called at the wrong time

    *penv = NULL;

    return JNI_EDETACHED;

  }

}

void JvmtiExport::enter_primordial_phase() {

  JvmtiEnvBase::set_phase(JVMTI_PHASE_PRIMORDIAL);

}

void JvmtiExport::enter_start_phase() {

  JvmtiManageCapabilities::recompute_always_capabilities();

  JvmtiEnvBase::set_phase(JVMTI_PHASE_START);

}

void JvmtiExport::enter_onload_phase() {

  JvmtiEnvBase::set_phase(JVMTI_PHASE_ONLOAD);

}

void JvmtiExport::enter_live_phase() {

  JvmtiEnvBase::set_phase(JVMTI_PHASE_LIVE);

}

//

// JVMTI events that the VM posts to the debugger and also startup agent

// and call the agent's premain() for java.lang.instrument.

//

void JvmtiExport::post_vm_start() {

  EVT_TRIG_TRACE(JVMTI_EVENT_VM_START, ("JVMTI Trg VM start event triggered" ));

  // can now enable some events

  JvmtiEventController::vm_start();

  JvmtiEnvIterator it;

  for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {

    if (env->is_enabled(JVMTI_EVENT_VM_START)) {

      EVT_TRACE(JVMTI_EVENT_VM_START, ("JVMTI Evt VM start event sent" ));

      JavaThread *thread  = JavaThread::current();

      JvmtiThreadEventMark jem(thread);

      JvmtiJavaThreadEventTransition jet(thread);

      jvmtiEventVMStart callback = env->callbacks()->VMStart;

      if (callback != NULL) {

        (*callback)(env->jvmti_external(), jem.jni_env());

      }

    }

  }

}

void JvmtiExport::post_vm_initialized() {

  EVT_TRIG_TRACE(JVMTI_EVENT_VM_INIT, ("JVMTI Trg VM init event triggered" ));

  // can now enable events

  JvmtiEventController::vm_init();

  JvmtiEnvIterator it;

  for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {

    if (env->is_enabled(JVMTI_EVENT_VM_INIT)) {

      EVT_TRACE(JVMTI_EVENT_VM_INIT, ("JVMTI Evt VM init event sent" ));

      JavaThread *thread  = JavaThread::current();

      JvmtiThreadEventMark jem(thread);

      JvmtiJavaThreadEventTransition jet(thread);

      jvmtiEventVMInit callback = env->callbacks()->VMInit;

      if (callback != NULL) {

        (*callback)(env->jvmti_external(), jem.jni_env(), jem.jni_thread());

      }

    }

  }

}

void JvmtiExport::post_vm_death() {

  EVT_TRIG_TRACE(JVMTI_EVENT_VM_DEATH, ("JVMTI Trg VM death event triggered" ));

  JvmtiEnvIterator it;

  for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {

    if (env->is_enabled(JVMTI_EVENT_VM_DEATH)) {

      EVT_TRACE(JVMTI_EVENT_VM_DEATH, ("JVMTI Evt VM death event sent" ));

      JavaThread *thread  = JavaThread::current();

      JvmtiEventMark jem(thread);

      JvmtiJavaThreadEventTransition jet(thread);

      jvmtiEventVMDeath callback = env->callbacks()->VMDeath;

      if (callback != NULL) {

        (*callback)(env->jvmti_external(), jem.jni_env());

      }

    }

  }

  JvmtiEnvBase::set_phase(JVMTI_PHASE_DEAD);

  JvmtiEventController::vm_death();

}

char**

JvmtiExport::get_all_native_method_prefixes(int* count_ptr) {

  // Have to grab JVMTI thread state lock to be sure environment doesn't

  // go away while we iterate them.  No locks during VM bring-up.

  if (Threads::number_of_threads() == 0 || SafepointSynchronize::is_at_safepoint()) {

    return JvmtiEnvBase::get_all_native_method_prefixes(count_ptr);

  } else {

    MutexLocker mu(JvmtiThreadState_lock);

    return JvmtiEnvBase::get_all_native_method_prefixes(count_ptr);

  }

}

class JvmtiClassFileLoadHookPoster : public StackObj {

 private:

  symbolHandle         _h_name;

  Handle               _class_loader;

  Handle               _h_protection_domain;

  unsigned char **     _data_ptr;

  unsigned char **     _end_ptr;

  JavaThread *         _thread;

  jint                 _curr_len;

  unsigned char *      _curr_data;

  JvmtiEnv *           _curr_env;

  jint *               _cached_length_ptr;

  unsigned char **     _cached_data_ptr;

  JvmtiThreadState *   _state;

  KlassHandle *        _h_class_being_redefined;

  JvmtiClassLoadKind   _load_kind;

 public:

  inline JvmtiClassFileLoadHookPoster(symbolHandle h_name, Handle class_loader,

                                      Handle h_protection_domain,

                                      unsigned char **data_ptr, unsigned char **end_ptr,

                                      unsigned char **cached_data_ptr,

                                      jint *cached_length_ptr) {

    _h_name = h_name;

    _class_loader = class_loader;

    _h_protection_domain = h_protection_domain;

    _data_ptr = data_ptr;

    _end_ptr = end_ptr;

    _thread = JavaThread::current();

    _curr_len = *end_ptr - *data_ptr;

    _curr_data = *data_ptr;

    _curr_env = NULL;

    _cached_length_ptr = cached_length_ptr;

    _cached_data_ptr = cached_data_ptr;

    *_cached_length_ptr = 0;

    *_cached_data_ptr = NULL;

    _state = _thread->jvmti_thread_state();

    if (_state != NULL) {

      _h_class_being_redefined = _state->get_class_being_redefined();

      _load_kind = _state->get_class_load_kind();

      // Clear class_being_redefined flag here. The action

      // from agent handler could generate a new class file load

      // hook event and if it is not cleared the new event generated

      // from regular class file load could have this stale redefined

      // class handle info.

      _state->clear_class_being_redefined();

    } else {

      // redefine and retransform will always set the thread state

      _h_class_being_redefined = (KlassHandle *) NULL;

      _load_kind = jvmti_class_load_kind_load;

    }

  }

  void post() {

//    EVT_TRIG_TRACE(JVMTI_EVENT_CLASS_FILE_LOAD_HOOK,

//                   ("JVMTI [%s] class file load hook event triggered",

//                    JvmtiTrace::safe_get_thread_name(_thread)));

    post_all_envs();

    copy_modified_data();

  }

 private:

  void post_all_envs() {

    if (_load_kind != jvmti_class_load_kind_retransform) {

      // for class load and redefine,

      // call the non-retransformable agents

      JvmtiEnvIterator it;

      for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {

        if (!env->is_retransformable() && env->is_enabled(JVMTI_EVENT_CLASS_FILE_LOAD_HOOK)) {

          // non-retransformable agents cannot retransform back,

          // so no need to cache the original class file bytes

          post_to_env(env, false);

        }

      }

    }

    JvmtiEnvIterator it;

    for (JvmtiEnv* env = it.first(); env != NULL; env = it.next(env)) {

      // retransformable agents get all events