/*

 * Copyright (c) 2003, 2018, 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 "classfile/systemDictionary.hpp"

#include "code/nmethod.hpp"

#include "code/pcDesc.hpp"

#include "code/scopeDesc.hpp"

#include "interpreter/interpreter.hpp"

#include "jvmtifiles/jvmtiEnv.hpp"

#include "logging/log.hpp"

#include "logging/logStream.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/resourceArea.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/objArrayOop.hpp"

#include "oops/oop.inline.hpp"

#include "prims/jvmtiCodeBlobEvents.hpp"

#include "prims/jvmtiEventController.hpp"

#include "prims/jvmtiEventController.inline.hpp"

#include "prims/jvmtiExport.hpp"

#include "prims/jvmtiImpl.hpp"

#include "prims/jvmtiManageCapabilities.hpp"

#include "prims/jvmtiRawMonitor.hpp"

#include "prims/jvmtiRedefineClasses.hpp"

#include "prims/jvmtiTagMap.hpp"

#include "prims/jvmtiThreadState.inline.hpp"

#include "runtime/arguments.hpp"

#include "runtime/handles.hpp"

#include "runtime/interfaceSupport.inline.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/jniHandles.inline.hpp"

#include "runtime/objectMonitor.hpp"

#include "runtime/objectMonitor.inline.hpp"

#include "runtime/os.inline.hpp"

#include "runtime/safepointVerifiers.hpp"

#include "runtime/thread.inline.hpp"

#include "runtime/threadSMR.hpp"

#include "runtime/vframe.inline.hpp"

#include "utilities/macros.hpp"

#ifdef JVMTI_TRACE

#define EVT_TRACE(evt,out) if ((JvmtiTrace::event_trace_flags(evt) & JvmtiTrace::SHOW_EVENT_SENT) != 0) { SafeResourceMark rm; log_trace(jvmti) out; }

#define EVT_TRIG_TRACE(evt,out) if ((JvmtiTrace::event_trace_flags(evt) & JvmtiTrace::SHOW_EVENT_TRIGGER) != 0) { SafeResourceMark rm; log_trace(jvmti) 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;

  JvmtiThreadState::ExceptionState _saved_exception_state;

#if 0

  JNIHandleBlock* _hblock;

#endif

public:

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

                                        _jni_env(thread->jni_environment()),

                                        _saved_exception_state(JvmtiThreadState::ES_CLEARED) {

#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) {

      _saved_exception_state = state->get_exception_state();

    }

    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.

      state->restore_exception_state(_saved_exception_state);

    }

  }

#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(Klass* klass) { return (klass == NULL ? NULL : (jclass)to_jobject(klass->java_mirror())); }

  jmethodID to_jmethodID(const 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, Klass* klass) :

    JvmtiThreadEventMark(thread) {

    _jc = to_jclass(klass);

  };

  jclass jni_class() { return _jc; }

};

class JvmtiMethodEventMark : public JvmtiThreadEventMark {

private:

  jmethodID _mid;

public:

  JvmtiMethodEventMark(JavaThread *thread, const methodHandle& method) :

    JvmtiThreadEventMark(thread),

    _mid(to_jmethodID(method)) {};

  jmethodID jni_methodID() { return _mid; }

};

class JvmtiLocationEventMark : public JvmtiMethodEventMark {

private:

  jlocation _loc;

public:

  JvmtiLocationEventMark(JavaThread *thread, const 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, const 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, Symbol* name,

     Handle class_loader, Handle prot_domain, Klass* 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_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) {

  // The JVMTI_VERSION_INTERFACE_JVMTI part of the version number

  // has already been validated in JNI GetEnv().

  int major, minor, micro;

  // micro version doesn't matter here (yet?)

  decode_version_values(version, &major, &minor, &micro);

  switch (major) {

    case 1:

      switch (minor) {

        case 0:  // version 1.0.<micro> is recognized

        case 1:  // version 1.1.<micro> is recognized

        case 2:  // version 1.2.<micro> is recognized

          break;

        default:

          return JNI_EVERSION;  // unsupported minor version number

      }

      break;

    case 9:

      switch (minor) {

        case 0:  // version 9.0.<micro> is recognized

          break;

        default:

          return JNI_EVERSION;  // unsupported minor version number

      }

      break;

    default:

      return JNI_EVERSION;  // unsupported major version number

  }

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

    JavaThread* current_thread = JavaThread::current();

    // transition code: native to VM

    ThreadInVMfromNative __tiv(current_thread);

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

    debug_only(VMNativeEntryWrapper __vew;)

    JvmtiEnv *jvmti_env = JvmtiEnv::create_a_jvmti(version);

    *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(version);

    *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::add_default_read_edges(Handle h_module, TRAPS) {

  if (!Universe::is_module_initialized()) {

    return; // extra safety

  }

  assert(!h_module.is_null(), "module should always be set");

  // Invoke the transformedByAgent method

  JavaValue result(T_VOID);

  JavaCalls::call_static(&result,

                         SystemDictionary::module_Modules_klass(),

                         vmSymbols::transformedByAgent_name(),

                         vmSymbols::transformedByAgent_signature(),

                         h_module,

                         THREAD);

  if (HAS_PENDING_EXCEPTION) {

    LogTarget(Trace, jvmti) log;

    LogStream log_stream(log);

    java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream);

    log_stream.cr();

    CLEAR_PENDING_EXCEPTION;

    return;

  }

}

jvmtiError

JvmtiExport::add_module_reads(Handle module, Handle to_module, TRAPS) {

  if (!Universe::is_module_initialized()) {

    return JVMTI_ERROR_NONE; // extra safety

  }

  assert(!module.is_null(), "module should always be set");

  assert(!to_module.is_null(), "to_module should always be set");

  // Invoke the addReads method

  JavaValue result(T_VOID);

  JavaCalls::call_static(&result,

                         SystemDictionary::module_Modules_klass(),

                         vmSymbols::addReads_name(),

                         vmSymbols::addReads_signature(),

                         module,

                         to_module,

                         THREAD);

  if (HAS_PENDING_EXCEPTION) {

    LogTarget(Trace, jvmti) log;

    LogStream log_stream(log);

    java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream);

    log_stream.cr();

    CLEAR_PENDING_EXCEPTION;

    return JVMTI_ERROR_INTERNAL;

  }

  return JVMTI_ERROR_NONE;

}

jvmtiError

JvmtiExport::add_module_exports(Handle module, Handle pkg_name, Handle to_module, TRAPS) {

  if (!Universe::is_module_initialized()) {

    return JVMTI_ERROR_NONE; // extra safety

  }

  assert(!module.is_null(), "module should always be set");

  assert(!to_module.is_null(), "to_module should always be set");

  assert(!pkg_name.is_null(), "pkg_name should always be set");

  // Invoke the addExports method

  JavaValue result(T_VOID);

  JavaCalls::call_static(&result,

                         SystemDictionary::module_Modules_klass(),

                         vmSymbols::addExports_name(),

                         vmSymbols::addExports_signature(),

                         module,

                         pkg_name,

                         to_module,

                         THREAD);

  if (HAS_PENDING_EXCEPTION) {

    Symbol* ex_name = PENDING_EXCEPTION->klass()->name();

    LogTarget(Trace, jvmti) log;

    LogStream log_stream(log);

    java_lang_Throwable::print(PENDING_EXCEPTION, &log_stream);

    log_stream.cr();

    CLEAR_PENDING_EXCEPTION;

    if (ex_name == vmSymbols::java_lang_IllegalArgumentException()) {

      return JVMTI_ERROR_ILLEGAL_ARGUMENT;

    }

    return JVMTI_ERROR_INTERNAL;

  }

  return JVMTI_ERROR_NONE;

}

jvmtiError

JvmtiExport::add_module_opens(Handle module, Handle pkg_name, Handle to_module, TRAPS) {

  if (!Universe::is_module_initialized()) {

    return JVMTI_ERROR_NONE; // extra safety

  }

  assert(!module.is_null(), "module should always be set");

  assert(!to_module.is_null(), "to_module should always be set");

  assert(!pkg_name.is_null(), "pkg_name should always be set");

  // Invoke the addOpens method

  JavaValue result(T_VOID);

  JavaCalls::call_static(&result,

                         SystemDictionary::module_Modules_klass(),

                         vmSymbols::addOpens_name(),

                         vmSymbols::addExports_signature(),

                         module,

                         pkg_name,

                         to_module,

                         THREAD);