/*

 * Copyright (c) 2003, 2019, 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/classLoaderExt.hpp"

#include "classfile/javaClasses.inline.hpp"

#include "classfile/stringTable.hpp"

#include "classfile/modules.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "interpreter/bytecodeStream.hpp"

#include "interpreter/interpreter.hpp"

#include "jvmtifiles/jvmtiEnv.hpp"

#include "logging/log.hpp"

#include "logging/logConfiguration.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/objArrayOop.inline.hpp"

#include "oops/oop.inline.hpp"

#include "prims/jniCheck.hpp"

#include "prims/jvm_misc.hpp"

#include "prims/jvmtiAgentThread.hpp"

#include "prims/jvmtiClassFileReconstituter.hpp"

#include "prims/jvmtiCodeBlobEvents.hpp"

#include "prims/jvmtiExtensions.hpp"

#include "prims/jvmtiGetLoadedClasses.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 "prims/jvmtiUtil.hpp"

#include "runtime/arguments.hpp"

#include "runtime/deoptimization.hpp"

#include "runtime/fieldDescriptor.inline.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/interfaceSupport.inline.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/jfieldIDWorkaround.hpp"

#include "runtime/jniHandles.inline.hpp"

#include "runtime/objectMonitor.inline.hpp"

#include "runtime/osThread.hpp"

#include "runtime/reflectionUtils.hpp"

#include "runtime/signature.hpp"

#include "runtime/thread.inline.hpp"

#include "runtime/threadHeapSampler.hpp"

#include "runtime/threadSMR.hpp"

#include "runtime/timerTrace.hpp"

#include "runtime/vframe.inline.hpp"

#include "runtime/vmThread.hpp"

#include "services/threadService.hpp"

#include "utilities/exceptions.hpp"

#include "utilities/preserveException.hpp"

#include "utilities/utf8.hpp"

#define FIXLATER 0 // REMOVE this when completed.

 // FIXLATER: hook into JvmtiTrace

#define TraceJVMTICalls false

JvmtiEnv::JvmtiEnv(jint version) : JvmtiEnvBase(version) {

}

JvmtiEnv::~JvmtiEnv() {

}

JvmtiEnv*

JvmtiEnv::create_a_jvmti(jint version) {

  return new JvmtiEnv(version);

}

// VM operation class to copy jni function table at safepoint.

// More than one java threads or jvmti agents may be reading/

// modifying jni function tables. To reduce the risk of bad

// interaction b/w these threads it is copied at safepoint.

class VM_JNIFunctionTableCopier : public VM_Operation {

 private:

  const struct JNINativeInterface_ *_function_table;

 public:

  VM_JNIFunctionTableCopier(const struct JNINativeInterface_ *func_tbl) {

    _function_table = func_tbl;

  };

  VMOp_Type type() const { return VMOp_JNIFunctionTableCopier; }

  void doit() {

    copy_jni_function_table(_function_table);

  };

};

//

// Do not change the "prefix" marker below, everything above it is copied

// unchanged into the filled stub, everything below is controlled by the

// stub filler (only method bodies are carried forward, and then only for

// functionality still in the spec).

//

// end file prefix

  //

  // Memory Management functions

  //

// mem_ptr - pre-checked for NULL

jvmtiError

JvmtiEnv::Allocate(jlong size, unsigned char** mem_ptr) {

  return allocate(size, mem_ptr);

} /* end Allocate */

// mem - NULL is a valid value, must be checked

jvmtiError

JvmtiEnv::Deallocate(unsigned char* mem) {

  return deallocate(mem);

} /* end Deallocate */

// Threads_lock NOT held, java_thread not protected by lock

// java_thread - pre-checked

// data - NULL is a valid value, must be checked

jvmtiError

JvmtiEnv::SetThreadLocalStorage(JavaThread* java_thread, const void* data) {

  JvmtiThreadState* state = java_thread->jvmti_thread_state();

  if (state == NULL) {

    if (data == NULL) {

      // leaving state unset same as data set to NULL

      return JVMTI_ERROR_NONE;

    }

    // otherwise, create the state

    state = JvmtiThreadState::state_for(java_thread);

    if (state == NULL) {

      return JVMTI_ERROR_THREAD_NOT_ALIVE;

    }

  }

  state->env_thread_state(this)->set_agent_thread_local_storage_data((void*)data);

  return JVMTI_ERROR_NONE;

} /* end SetThreadLocalStorage */

// Threads_lock NOT held

// thread - NOT pre-checked

// data_ptr - pre-checked for NULL

jvmtiError

JvmtiEnv::GetThreadLocalStorage(jthread thread, void** data_ptr) {

  JavaThread* current_thread = JavaThread::current();

  if (thread == NULL) {

    JvmtiThreadState* state = current_thread->jvmti_thread_state();

    *data_ptr = (state == NULL) ? NULL :

      state->env_thread_state(this)->get_agent_thread_local_storage_data();

  } else {

    // jvmti_GetThreadLocalStorage is "in native" and doesn't transition

    // the thread to _thread_in_vm. However, when the TLS for a thread

    // other than the current thread is required we need to transition

    // from native so as to resolve the jthread.

    ThreadInVMfromNative __tiv(current_thread);

    VM_ENTRY_BASE(jvmtiError, JvmtiEnv::GetThreadLocalStorage , current_thread)

    debug_only(VMNativeEntryWrapper __vew;)

    JavaThread* java_thread = NULL;

    ThreadsListHandle tlh(current_thread);

    jvmtiError err = JvmtiExport::cv_external_thread_to_JavaThread(tlh.list(), thread, &java_thread, NULL);

    if (err != JVMTI_ERROR_NONE) {

      return err;

    }

    JvmtiThreadState* state = java_thread->jvmti_thread_state();

    *data_ptr = (state == NULL) ? NULL :

      state->env_thread_state(this)->get_agent_thread_local_storage_data();

  }

  return JVMTI_ERROR_NONE;

} /* end GetThreadLocalStorage */

  //

  // Module functions

  //

// module_count_ptr - pre-checked for NULL

// modules_ptr - pre-checked for NULL

jvmtiError

JvmtiEnv::GetAllModules(jint* module_count_ptr, jobject** modules_ptr) {

    JvmtiModuleClosure jmc;

    return jmc.get_all_modules(this, module_count_ptr, modules_ptr);

} /* end GetAllModules */

// class_loader - NULL is a valid value, must be pre-checked

// package_name - pre-checked for NULL

// module_ptr - pre-checked for NULL

jvmtiError

JvmtiEnv::GetNamedModule(jobject class_loader, const char* package_name, jobject* module_ptr) {

  JavaThread* THREAD = JavaThread::current(); // pass to macros

  ResourceMark rm(THREAD);

  Handle h_loader (THREAD, JNIHandles::resolve(class_loader));

  // Check that loader is a subclass of java.lang.ClassLoader.

  if (h_loader.not_null() && !java_lang_ClassLoader::is_subclass(h_loader->klass())) {

    return JVMTI_ERROR_ILLEGAL_ARGUMENT;

  }

  jobject module = Modules::get_named_module(h_loader, package_name, THREAD);

  if (HAS_PENDING_EXCEPTION) {

    CLEAR_PENDING_EXCEPTION;

    return JVMTI_ERROR_INTERNAL; // unexpected exception

  }

  *module_ptr = module;

  return JVMTI_ERROR_NONE;

} /* end GetNamedModule */

// module - pre-checked for NULL

// to_module - pre-checked for NULL

jvmtiError

JvmtiEnv::AddModuleReads(jobject module, jobject to_module) {

  JavaThread* THREAD = JavaThread::current();

  // check module

  Handle h_module(THREAD, JNIHandles::resolve(module));

  if (!java_lang_Module::is_instance(h_module())) {

    return JVMTI_ERROR_INVALID_MODULE;

  }

  // check to_module

  Handle h_to_module(THREAD, JNIHandles::resolve(to_module));

  if (!java_lang_Module::is_instance(h_to_module())) {

    return JVMTI_ERROR_INVALID_MODULE;

  }

  return JvmtiExport::add_module_reads(h_module, h_to_module, THREAD);

} /* end AddModuleReads */

// module - pre-checked for NULL

// pkg_name - pre-checked for NULL

// to_module - pre-checked for NULL

jvmtiError

JvmtiEnv::AddModuleExports(jobject module, const char* pkg_name, jobject to_module) {

  JavaThread* THREAD = JavaThread::current();

  Handle h_pkg = java_lang_String::create_from_str(pkg_name, THREAD);

  // check module

  Handle h_module(THREAD, JNIHandles::resolve(module));

  if (!java_lang_Module::is_instance(h_module())) {

    return JVMTI_ERROR_INVALID_MODULE;

  }

  // check to_module

  Handle h_to_module(THREAD, JNIHandles::resolve(to_module));

  if (!java_lang_Module::is_instance(h_to_module())) {

    return JVMTI_ERROR_INVALID_MODULE;

  }

  return JvmtiExport::add_module_exports(h_module, h_pkg, h_to_module, THREAD);

} /* end AddModuleExports */

// module - pre-checked for NULL

// pkg_name - pre-checked for NULL

// to_module - pre-checked for NULL

jvmtiError

JvmtiEnv::AddModuleOpens(jobject module, const char* pkg_name, jobject to_module) {

  JavaThread* THREAD = JavaThread::current();

  Handle h_pkg = java_lang_String::create_from_str(pkg_name, THREAD);

  // check module

  Handle h_module(THREAD, JNIHandles::resolve(module));

  if (!java_lang_Module::is_instance(h_module())) {

    return JVMTI_ERROR_INVALID_MODULE;

  }

  // check to_module

  Handle h_to_module(THREAD, JNIHandles::resolve(to_module));

  if (!java_lang_Module::is_instance(h_to_module())) {

    return JVMTI_ERROR_INVALID_MODULE;

  }

  return JvmtiExport::add_module_opens(h_module, h_pkg, h_to_module, THREAD);

} /* end AddModuleOpens */

// module - pre-checked for NULL

// service - pre-checked for NULL

jvmtiError

JvmtiEnv::AddModuleUses(jobject module, jclass service) {

  JavaThread* THREAD = JavaThread::current();

  // check module

  Handle h_module(THREAD, JNIHandles::resolve(module));

  if (!java_lang_Module::is_instance(h_module())) {

    return JVMTI_ERROR_INVALID_MODULE;

  }

  // check service

  Handle h_service(THREAD, JNIHandles::resolve_external_guard(service));

  if (!java_lang_Class::is_instance(h_service()) ||

      java_lang_Class::is_primitive(h_service())) {

    return JVMTI_ERROR_INVALID_CLASS;

  }

  return JvmtiExport::add_module_uses(h_module, h_service, THREAD);

} /* end AddModuleUses */

// module - pre-checked for NULL

// service - pre-checked for NULL

// impl_class - pre-checked for NULL

jvmtiError

JvmtiEnv::AddModuleProvides(jobject module, jclass service, jclass impl_class) {

  JavaThread* THREAD = JavaThread::current();

  // check module

  Handle h_module(THREAD, JNIHandles::resolve(module));

  if (!java_lang_Module::is_instance(h_module())) {

    return JVMTI_ERROR_INVALID_MODULE;

  }

  // check service

  Handle h_service(THREAD, JNIHandles::resolve_external_guard(service));

  if (!java_lang_Class::is_instance(h_service()) ||

      java_lang_Class::is_primitive(h_service())) {

    return JVMTI_ERROR_INVALID_CLASS;

  }

  // check impl_class

  Handle h_impl_class(THREAD, JNIHandles::resolve_external_guard(impl_class));

  if (!java_lang_Class::is_instance(h_impl_class()) ||

      java_lang_Class::is_primitive(h_impl_class())) {

    return JVMTI_ERROR_INVALID_CLASS;

  }

  return JvmtiExport::add_module_provides(h_module, h_service, h_impl_class, THREAD);

} /* end AddModuleProvides */

// module - pre-checked for NULL

// is_modifiable_class_ptr - pre-checked for NULL

jvmtiError

JvmtiEnv::IsModifiableModule(jobject module, jboolean* is_modifiable_module_ptr) {

  JavaThread* THREAD = JavaThread::current();

  // check module

  Handle h_module(THREAD, JNIHandles::resolve(module));

  if (!java_lang_Module::is_instance(h_module())) {

    return JVMTI_ERROR_INVALID_MODULE;

  }

  *is_modifiable_module_ptr = JNI_TRUE;

  return JVMTI_ERROR_NONE;

} /* end IsModifiableModule */

  //

  // Class functions

  //

// class_count_ptr - pre-checked for NULL

// classes_ptr - pre-checked for NULL

jvmtiError

JvmtiEnv::GetLoadedClasses(jint* class_count_ptr, jclass** classes_ptr) {

  return JvmtiGetLoadedClasses::getLoadedClasses(this, class_count_ptr, classes_ptr);

} /* end GetLoadedClasses */

// initiating_loader - NULL is a valid value, must be checked

// class_count_ptr - pre-checked for NULL

// classes_ptr - pre-checked for NULL

jvmtiError

JvmtiEnv::GetClassLoaderClasses(jobject initiating_loader, jint* class_count_ptr, jclass** classes_ptr) {

  return JvmtiGetLoadedClasses::getClassLoaderClasses(this, initiating_loader,

                                                  class_count_ptr, classes_ptr);

} /* end GetClassLoaderClasses */

// k_mirror - may be primitive, this must be checked

// is_modifiable_class_ptr - pre-checked for NULL

jvmtiError

JvmtiEnv::IsModifiableClass(oop k_mirror, jboolean* is_modifiable_class_ptr) {

  *is_modifiable_class_ptr = VM_RedefineClasses::is_modifiable_class(k_mirror)?

                                                       JNI_TRUE : JNI_FALSE;

  return JVMTI_ERROR_NONE;

} /* end IsModifiableClass */

// class_count - pre-checked to be greater than or equal to 0

// classes - pre-checked for NULL

jvmtiError

JvmtiEnv::RetransformClasses(jint class_count, const jclass* classes) {

//TODO: add locking

  int index;

  JavaThread* current_thread = JavaThread::current();

  ResourceMark rm(current_thread);

  jvmtiClassDefinition* class_definitions =

                            NEW_RESOURCE_ARRAY(jvmtiClassDefinition, class_count);

  NULL_CHECK(class_definitions, JVMTI_ERROR_OUT_OF_MEMORY);

  for (index = 0; index < class_count; index++) {

    HandleMark hm(current_thread);

    jclass jcls = classes[index];

    oop k_mirror = JNIHandles::resolve_external_guard(jcls);

    if (k_mirror == NULL) {

      return JVMTI_ERROR_INVALID_CLASS;

    }

    if (!k_mirror->is_a(SystemDictionary::Class_klass())) {

      return JVMTI_ERROR_INVALID_CLASS;

    }

    if (!VM_RedefineClasses::is_modifiable_class(k_mirror)) {

      return JVMTI_ERROR_UNMODIFIABLE_CLASS;

    }

    Klass* klass = java_lang_Class::as_Klass(k_mirror);

    jint status = klass->jvmti_class_status();

    if (status & (JVMTI_CLASS_STATUS_ERROR)) {

      return JVMTI_ERROR_INVALID_CLASS;

    }

    InstanceKlass* ik = InstanceKlass::cast(klass);

    if (ik->get_cached_class_file_bytes() == NULL) {

      // Not cached, we need to reconstitute the class file from the

      // VM representation. We don't attach the reconstituted class

      // bytes to the InstanceKlass here because they have not been

      // validated and we're not at a safepoint.

      JvmtiClassFileReconstituter reconstituter(ik);

      if (reconstituter.get_error() != JVMTI_ERROR_NONE) {

        return reconstituter.get_error();

      }

      class_definitions[index].class_byte_count = (jint)reconstituter.class_file_size();

      class_definitions[index].class_bytes      = (unsigned char*)

                                                       reconstituter.class_file_bytes();

    } else {

      // it is cached, get it from the cache

      class_definitions[index].class_byte_count = ik->get_cached_class_file_len();

      class_definitions[index].class_bytes      = ik->get_cached_class_file_bytes();

    }

    class_definitions[index].klass              = jcls;

  }

  VM_RedefineClasses op(class_count, class_definitions, jvmti_class_load_kind_retransform);

  VMThread::execute(&op);

  return (op.check_error());

} /* end RetransformClasses */

// class_count - pre-checked to be greater than or equal to 0

// class_definitions - pre-checked for NULL

jvmtiError

JvmtiEnv::RedefineClasses(jint class_count, const jvmtiClassDefinition* class_definitions) {

//TODO: add locking

  VM_RedefineClasses op(class_count, class_definitions, jvmti_class_load_kind_redefine);

  VMThread::execute(&op);

  return (op.check_error());

} /* end RedefineClasses */

  //

  // Object functions

  //

// size_ptr - pre-checked for NULL

jvmtiError

JvmtiEnv::GetObjectSize(jobject object, jlong* size_ptr) {

  oop mirror = JNIHandles::resolve_external_guard(object);

  NULL_CHECK(mirror, JVMTI_ERROR_INVALID_OBJECT);

  *size_ptr = (jlong)Universe::heap()->obj_size(mirror) * wordSize;

  return JVMTI_ERROR_NONE;

} /* end GetObjectSize */

  //

  // Method functions

  //

// prefix - NULL is a valid value, must be checked

jvmtiError

JvmtiEnv::SetNativeMethodPrefix(const char* prefix) {

  return prefix == NULL?

              SetNativeMethodPrefixes(0, NULL) :

              SetNativeMethodPrefixes(1, (char**)&prefix);

} /* end SetNativeMethodPrefix */

// prefix_count - pre-checked to be greater than or equal to 0

// prefixes - pre-checked for NULL

jvmtiError

JvmtiEnv::SetNativeMethodPrefixes(jint prefix_count, char** prefixes) {

  // Have to grab JVMTI thread state lock to be sure that some thread

  // isn't accessing the prefixes at the same time we are setting them.

  // No locks during VM bring-up.

  if (Threads::number_of_threads() == 0) {

    return set_native_method_prefixes(prefix_count, prefixes);

  } else {

    MutexLocker mu(JvmtiThreadState_lock);

    return set_native_method_prefixes(prefix_count, prefixes);

  }

} /* end SetNativeMethodPrefixes */