/*

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

#include "interpreter/bytecodeStream.hpp"

#include "interpreter/interpreter.hpp"

#include "jvmtifiles/jvmtiEnv.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.inline.hpp"

#include "oops/cpCacheOop.hpp"

#include "oops/instanceKlass.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/interfaceSupport.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/jfieldIDWorkaround.hpp"

#include "runtime/osThread.hpp"

#include "runtime/reflectionUtils.hpp"

#include "runtime/signature.hpp"

#include "runtime/vframe.hpp"

#include "runtime/vmThread.hpp"

#include "services/threadService.hpp"

#include "utilities/exceptions.hpp"

#include "utilities/preserveException.hpp"

#ifdef TARGET_OS_FAMILY_linux

# include "thread_linux.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_solaris

# include "thread_solaris.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_windows

# include "thread_windows.inline.hpp"

#endif

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

    __ENTRY(jvmtiError, JvmtiEnv::GetThreadLocalStorage , current_thread)

    debug_only(VMNativeEntryWrapper __vew;)

    oop thread_oop = JNIHandles::resolve_external_guard(thread);

    if (thread_oop == NULL) {

      return JVMTI_ERROR_INVALID_THREAD;

    }

    if (!thread_oop->is_a(SystemDictionary::Thread_klass())) {

      return JVMTI_ERROR_INVALID_THREAD;

    }

    JavaThread* java_thread = java_lang_Thread::thread(thread_oop);

    if (java_thread == NULL) {

      return JVMTI_ERROR_THREAD_NOT_ALIVE;

    }

    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 */

  //

  // 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 (java_lang_Class::is_primitive(k_mirror)) {

      return JVMTI_ERROR_UNMODIFIABLE_CLASS;

    }

    klassOop k_oop = java_lang_Class::as_klassOop(k_mirror);

    KlassHandle klass(current_thread, k_oop);

    jint status = klass->jvmti_class_status();

    if (status & (JVMTI_CLASS_STATUS_ERROR)) {

      return JVMTI_ERROR_INVALID_CLASS;

    }

    if (status & (JVMTI_CLASS_STATUS_ARRAY)) {

      return JVMTI_ERROR_UNMODIFIABLE_CLASS;

    }

    instanceKlassHandle ikh(current_thread, k_oop);

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

      // not cached, we need to reconstitute the class file from VM representation

      constantPoolHandle  constants(current_thread, ikh->constants());

      ObjectLocker ol(constants, current_thread);    // lock constant pool while we query it

      JvmtiClassFileReconstituter reconstituter(ikh);

      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 = ikh->get_cached_class_file_len();

      class_definitions[index].class_bytes      = ikh->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);

  if (mirror->klass() == SystemDictionary::Class_klass()) {

    if (!java_lang_Class::is_primitive(mirror)) {

        mirror = java_lang_Class::as_klassOop(mirror);

        assert(mirror != NULL, "class for non-primitive mirror must exist");

    }

  }

  *size_ptr = mirror->size() * 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 */

  //

  // Event Management functions

  //

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

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

jvmtiError

JvmtiEnv::SetEventCallbacks(const jvmtiEventCallbacks* callbacks, jint size_of_callbacks) {

  JvmtiEventController::set_event_callbacks(this, callbacks, size_of_callbacks);

  return JVMTI_ERROR_NONE;

} /* end SetEventCallbacks */

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

jvmtiError

JvmtiEnv::SetEventNotificationMode(jvmtiEventMode mode, jvmtiEvent event_type, jthread event_thread,   ...) {

  JavaThread* java_thread = NULL;

  if (event_thread != NULL) {

    oop thread_oop = JNIHandles::resolve_external_guard(event_thread);

    if (thread_oop == NULL) {

      return JVMTI_ERROR_INVALID_THREAD;

    }

    if (!thread_oop->is_a(SystemDictionary::Thread_klass())) {

      return JVMTI_ERROR_INVALID_THREAD;

    }

    java_thread = java_lang_Thread::thread(thread_oop);

    if (java_thread == NULL) {

      return JVMTI_ERROR_THREAD_NOT_ALIVE;

    }

  }

  // event_type must be valid

  if (!JvmtiEventController::is_valid_event_type(event_type)) {

    return JVMTI_ERROR_INVALID_EVENT_TYPE;

  }

  // global events cannot be controlled at thread level.

  if (java_thread != NULL && JvmtiEventController::is_global_event(event_type)) {

    return JVMTI_ERROR_ILLEGAL_ARGUMENT;

  }

  bool enabled = (mode == JVMTI_ENABLE);

  // assure that needed capabilities are present

  if (enabled && !JvmtiUtil::has_event_capability(event_type, get_capabilities())) {

    return JVMTI_ERROR_MUST_POSSESS_CAPABILITY;

  }

  if (event_type == JVMTI_EVENT_CLASS_FILE_LOAD_HOOK && enabled) {

    record_class_file_load_hook_enabled();

  }

  JvmtiEventController::set_user_enabled(this, java_thread, event_type, enabled);

  return JVMTI_ERROR_NONE;

} /* end SetEventNotificationMode */

  //

  // Capability functions

  //

// capabilities_ptr - pre-checked for NULL

jvmtiError

JvmtiEnv::GetPotentialCapabilities(jvmtiCapabilities* capabilities_ptr) {

  JvmtiManageCapabilities::get_potential_capabilities(get_capabilities(),

                                                      get_prohibited_capabilities(),

                                                      capabilities_ptr);

  return JVMTI_ERROR_NONE;

} /* end GetPotentialCapabilities */

// capabilities_ptr - pre-checked for NULL

jvmtiError

JvmtiEnv::AddCapabilities(const jvmtiCapabilities* capabilities_ptr) {

  return JvmtiManageCapabilities::add_capabilities(get_capabilities(),

                                                   get_prohibited_capabilities(),

                                                   capabilities_ptr,

                                                   get_capabilities());

} /* end AddCapabilities */

// capabilities_ptr - pre-checked for NULL

jvmtiError

JvmtiEnv::RelinquishCapabilities(const jvmtiCapabilities* capabilities_ptr) {

  JvmtiManageCapabilities::relinquish_capabilities(get_capabilities(), capabilities_ptr, get_capabilities());

  return JVMTI_ERROR_NONE;

} /* end RelinquishCapabilities */

// capabilities_ptr - pre-checked for NULL

jvmtiError

JvmtiEnv::GetCapabilities(jvmtiCapabilities* capabilities_ptr) {

  JvmtiManageCapabilities::copy_capabilities(get_capabilities(), capabilities_ptr);

  return JVMTI_ERROR_NONE;

} /* end GetCapabilities */

  //

  // Class Loader Search functions

  //

// segment - pre-checked for NULL

jvmtiError

JvmtiEnv::AddToBootstrapClassLoaderSearch(const char* segment) {

  jvmtiPhase phase = get_phase();

  if (phase == JVMTI_PHASE_ONLOAD) {

    Arguments::append_sysclasspath(segment);

    return JVMTI_ERROR_NONE;

  } else if (use_version_1_0_semantics()) {

    // This JvmtiEnv requested version 1.0 semantics and this function

    // is only allowed in the ONLOAD phase in version 1.0 so we need to

    // return an error here.

    return JVMTI_ERROR_WRONG_PHASE;

  } else if (phase == JVMTI_PHASE_LIVE) {

    // The phase is checked by the wrapper that called this function,

    // but this thread could be racing with the thread that is

    // terminating the VM so we check one more time.

    // create the zip entry

    ClassPathZipEntry* zip_entry = ClassLoader::create_class_path_zip_entry(segment);

    if (zip_entry == NULL) {

      return JVMTI_ERROR_ILLEGAL_ARGUMENT;

    }

    // lock the loader

    Thread* thread = Thread::current();

    HandleMark hm;

    Handle loader_lock = Handle(thread, SystemDictionary::system_loader_lock());

    ObjectLocker ol(loader_lock, thread);

    // add the jar file to the bootclasspath

    if (TraceClassLoading) {

      tty->print_cr("[Opened %s]", zip_entry->name());

    }

    ClassLoader::add_to_list(zip_entry);

    return JVMTI_ERROR_NONE;

  } else {

    return JVMTI_ERROR_WRONG_PHASE;

  }

} /* end AddToBootstrapClassLoaderSearch */

// segment - pre-checked for NULL

jvmtiError

JvmtiEnv::AddToSystemClassLoaderSearch(const char* segment) {

  jvmtiPhase phase = get_phase();

  if (phase == JVMTI_PHASE_ONLOAD) {

    for (SystemProperty* p = Arguments::system_properties(); p != NULL; p = p->next()) {

      if (strcmp("java.class.path", p->key()) == 0) {

        p->append_value(segment);

        break;

      }

    }

    return JVMTI_ERROR_NONE;

  } else if (phase == JVMTI_PHASE_LIVE) {

    // The phase is checked by the wrapper that called this function,

    // but this thread could be racing with the thread that is

    // terminating the VM so we check one more time.

    HandleMark hm;

    // create the zip entry (which will open the zip file and hence

    // check that the segment is indeed a zip file).

    ClassPathZipEntry* zip_entry = ClassLoader::create_class_path_zip_entry(segment);

    if (zip_entry == NULL) {

      return JVMTI_ERROR_ILLEGAL_ARGUMENT;

    }