/*

 * 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 "jvmtifiles/jvmtiEnv.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/objArrayOop.hpp"

#include "prims/jvmtiEnvBase.hpp"

#include "prims/jvmtiEventController.inline.hpp"

#include "prims/jvmtiExtensions.hpp"

#include "prims/jvmtiImpl.hpp"

#include "prims/jvmtiManageCapabilities.hpp"

#include "prims/jvmtiTagMap.hpp"

#include "prims/jvmtiThreadState.inline.hpp"

#include "runtime/biasedLocking.hpp"

#include "runtime/deoptimization.hpp"

#include "runtime/interfaceSupport.hpp"

#include "runtime/jfieldIDWorkaround.hpp"

#include "runtime/objectMonitor.hpp"

#include "runtime/objectMonitor.inline.hpp"

#include "runtime/signature.hpp"

#include "runtime/vframe.hpp"

#include "runtime/vframe_hp.hpp"

#include "runtime/vmThread.hpp"

#include "runtime/vm_operations.hpp"

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

//

// JvmtiEnvBase

//

JvmtiEnvBase* JvmtiEnvBase::_head_environment = NULL;

bool JvmtiEnvBase::_globally_initialized = false;

volatile bool JvmtiEnvBase::_needs_clean_up = false;

jvmtiPhase JvmtiEnvBase::_phase = JVMTI_PHASE_PRIMORDIAL;

volatile int JvmtiEnvBase::_dying_thread_env_iteration_count = 0;

extern jvmtiInterface_1_ jvmti_Interface;

extern jvmtiInterface_1_ jvmtiTrace_Interface;

// perform initializations that must occur before any JVMTI environments

// are released but which should only be initialized once (no matter

// how many environments are created).

void

JvmtiEnvBase::globally_initialize() {

  assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check");

  assert(_globally_initialized == false, "bad call");

  JvmtiManageCapabilities::initialize();

  // register extension functions and events

  JvmtiExtensions::register_extensions();

#ifdef JVMTI_TRACE

  JvmtiTrace::initialize();

#endif

  _globally_initialized = true;

}

void

JvmtiEnvBase::initialize() {

  assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check");

  // Add this environment to the end of the environment list (order is important)

  {

    // This block of code must not contain any safepoints, as list deallocation

    // (which occurs at a safepoint) cannot occur simultaneously with this list

    // addition.  Note: No_Safepoint_Verifier cannot, currently, be used before

    // threads exist.

    JvmtiEnvIterator it;

    JvmtiEnvBase *previous_env = NULL;

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

      previous_env = env;

    }

    if (previous_env == NULL) {

      _head_environment = this;

    } else {

      previous_env->set_next_environment(this);

    }

  }

  if (_globally_initialized == false) {

    globally_initialize();

  }

}

bool

JvmtiEnvBase::is_valid() {

  jint value = 0;

  // This object might not be a JvmtiEnvBase so we can't assume

  // the _magic field is properly aligned. Get the value in a safe

  // way and then check against JVMTI_MAGIC.

  switch (sizeof(_magic)) {

  case 2:

    value = Bytes::get_native_u2((address)&_magic);

    break;

  case 4:

    value = Bytes::get_native_u4((address)&_magic);

    break;

  case 8:

    value = Bytes::get_native_u8((address)&_magic);

    break;

  default:

    guarantee(false, "_magic field is an unexpected size");

  }

  return value == JVMTI_MAGIC;

}

bool

JvmtiEnvBase::use_version_1_0_semantics() {

  int major, minor, micro;

  JvmtiExport::decode_version_values(_version, &major, &minor, &micro);

  return major == 1 && minor == 0;  // micro version doesn't matter here

}

bool

JvmtiEnvBase::use_version_1_1_semantics() {

  int major, minor, micro;

  JvmtiExport::decode_version_values(_version, &major, &minor, &micro);

  return major == 1 && minor == 1;  // micro version doesn't matter here

}

bool

JvmtiEnvBase::use_version_1_2_semantics() {

  int major, minor, micro;

  JvmtiExport::decode_version_values(_version, &major, &minor, &micro);

  return major == 1 && minor == 2;  // micro version doesn't matter here

}

JvmtiEnvBase::JvmtiEnvBase(jint version) : _env_event_enable() {

  _version = version;

  _env_local_storage = NULL;

  _tag_map = NULL;

  _native_method_prefix_count = 0;

  _native_method_prefixes = NULL;

  _next = NULL;

  _class_file_load_hook_ever_enabled = false;

  // Moot since ClassFileLoadHook not yet enabled.

  // But "true" will give a more predictable ClassFileLoadHook behavior

  // for environment creation during ClassFileLoadHook.

  _is_retransformable = true;

  // all callbacks initially NULL

  memset(&_event_callbacks,0,sizeof(jvmtiEventCallbacks));

  // all capabilities initially off

  memset(&_current_capabilities, 0, sizeof(_current_capabilities));

  // all prohibited capabilities initially off

  memset(&_prohibited_capabilities, 0, sizeof(_prohibited_capabilities));

  _magic = JVMTI_MAGIC;

  JvmtiEventController::env_initialize((JvmtiEnv*)this);

#ifdef JVMTI_TRACE

  _jvmti_external.functions = TraceJVMTI != NULL ? &jvmtiTrace_Interface : &jvmti_Interface;

#else

  _jvmti_external.functions = &jvmti_Interface;

#endif

}

void

JvmtiEnvBase::dispose() {

#ifdef JVMTI_TRACE

  JvmtiTrace::shutdown();

#endif

  // Dispose of event info and let the event controller call us back

  // in a locked state (env_dispose, below)

  JvmtiEventController::env_dispose(this);

}

void

JvmtiEnvBase::env_dispose() {

  assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check");

  // We have been entered with all events disabled on this environment.

  // A race to re-enable events (by setting callbacks) is prevented by

  // checking for a valid environment when setting callbacks (while

  // holding the JvmtiThreadState_lock).

  // Mark as invalid.

  _magic = DISPOSED_MAGIC;

  // Relinquish all capabilities.

  jvmtiCapabilities *caps = get_capabilities();

  JvmtiManageCapabilities::relinquish_capabilities(caps, caps, caps);

  // Same situation as with events (see above)

  set_native_method_prefixes(0, NULL);

  JvmtiTagMap* tag_map_to_deallocate = _tag_map;

  set_tag_map(NULL);

  // A tag map can be big, deallocate it now

  if (tag_map_to_deallocate != NULL) {

    delete tag_map_to_deallocate;

  }

  _needs_clean_up = true;

}

JvmtiEnvBase::~JvmtiEnvBase() {

  assert(SafepointSynchronize::is_at_safepoint(), "sanity check");

  // There is a small window of time during which the tag map of a

  // disposed environment could have been reallocated.

  // Make sure it is gone.

  JvmtiTagMap* tag_map_to_deallocate = _tag_map;

  set_tag_map(NULL);

  // A tag map can be big, deallocate it now

  if (tag_map_to_deallocate != NULL) {

    delete tag_map_to_deallocate;

  }

  _magic = BAD_MAGIC;

}

void

JvmtiEnvBase::periodic_clean_up() {

  assert(SafepointSynchronize::is_at_safepoint(), "sanity check");

  // JvmtiEnvBase reference is saved in JvmtiEnvThreadState. So

  // clean up JvmtiThreadState before deleting JvmtiEnv pointer.

  JvmtiThreadState::periodic_clean_up();

  // Unlink all invalid environments from the list of environments

  // and deallocate them

  JvmtiEnvIterator it;

  JvmtiEnvBase* previous_env = NULL;

  JvmtiEnvBase* env = it.first();

  while (env != NULL) {

    if (env->is_valid()) {

      previous_env = env;

      env = it.next(env);

    } else {

      // This one isn't valid, remove it from the list and deallocate it

      JvmtiEnvBase* defunct_env = env;

      env = it.next(env);

      if (previous_env == NULL) {

        _head_environment = env;

      } else {

        previous_env->set_next_environment(env);

      }

      delete defunct_env;

    }

  }

}

void

JvmtiEnvBase::check_for_periodic_clean_up() {

  assert(SafepointSynchronize::is_at_safepoint(), "sanity check");

  class ThreadInsideIterationClosure: public ThreadClosure {

   private:

    bool _inside;

   public:

    ThreadInsideIterationClosure() : _inside(false) {};

    void do_thread(Thread* thread) {

      _inside |= thread->is_inside_jvmti_env_iteration();

    }

    bool is_inside_jvmti_env_iteration() {

      return _inside;

    }

  };

  if (_needs_clean_up) {

    // Check if we are currently iterating environment,

    // deallocation should not occur if we are

    ThreadInsideIterationClosure tiic;

    Threads::threads_do(&tiic);

    if (!tiic.is_inside_jvmti_env_iteration() &&

             !is_inside_dying_thread_env_iteration()) {

      _needs_clean_up = false;

      JvmtiEnvBase::periodic_clean_up();

    }

  }

}

void

JvmtiEnvBase::record_first_time_class_file_load_hook_enabled() {

  assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(),

         "sanity check");

  if (!_class_file_load_hook_ever_enabled) {

    _class_file_load_hook_ever_enabled = true;

    if (get_capabilities()->can_retransform_classes) {

      _is_retransformable = true;

    } else {

      _is_retransformable = false;

      // cannot add retransform capability after ClassFileLoadHook has been enabled

      get_prohibited_capabilities()->can_retransform_classes = 1;

    }

  }

}

void

JvmtiEnvBase::record_class_file_load_hook_enabled() {

  if (!_class_file_load_hook_ever_enabled) {

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

      record_first_time_class_file_load_hook_enabled();

    } else {

      MutexLocker mu(JvmtiThreadState_lock);

      record_first_time_class_file_load_hook_enabled();

    }

  }

}

jvmtiError

JvmtiEnvBase::set_native_method_prefixes(jint prefix_count, char** prefixes) {

  assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(),

         "sanity check");

  int old_prefix_count = get_native_method_prefix_count();

  char **old_prefixes = get_native_method_prefixes();

  // allocate and install the new prefixex

  if (prefix_count == 0 || !is_valid()) {

    _native_method_prefix_count = 0;

    _native_method_prefixes = NULL;

  } else {

    // there are prefixes, allocate an array to hold them, and fill it

    char** new_prefixes = (char**)os::malloc((prefix_count) * sizeof(char*), mtInternal);

    if (new_prefixes == NULL) {

      return JVMTI_ERROR_OUT_OF_MEMORY;

    }

    for (int i = 0; i < prefix_count; i++) {

      char* prefix = prefixes[i];

      if (prefix == NULL) {

        for (int j = 0; j < (i-1); j++) {

          os::free(new_prefixes[j]);

        }

        os::free(new_prefixes);

        return JVMTI_ERROR_NULL_POINTER;

      }

      prefix = os::strdup(prefixes[i]);

      if (prefix == NULL) {

        for (int j = 0; j < (i-1); j++) {

          os::free(new_prefixes[j]);

        }

        os::free(new_prefixes);

        return JVMTI_ERROR_OUT_OF_MEMORY;

      }

      new_prefixes[i] = prefix;

    }

    _native_method_prefix_count = prefix_count;

    _native_method_prefixes = new_prefixes;

  }

  // now that we know the new prefixes have been successfully installed we can

  // safely remove the old ones

  if (old_prefix_count != 0) {

    for (int i = 0; i < old_prefix_count; i++) {

      os::free(old_prefixes[i]);

    }

    os::free(old_prefixes);

  }

  return JVMTI_ERROR_NONE;

}

// Collect all the prefixes which have been set in any JVM TI environments

// by the SetNativeMethodPrefix(es) functions.  Be sure to maintain the

// order of environments and the order of prefixes within each environment.

// Return in a resource allocated array.

char**

JvmtiEnvBase::get_all_native_method_prefixes(int* count_ptr) {

  assert(Threads::number_of_threads() == 0 ||

         SafepointSynchronize::is_at_safepoint() ||

         JvmtiThreadState_lock->is_locked(),

         "sanity check");

  int total_count = 0;

  GrowableArray<char*>* prefix_array =new GrowableArray<char*>(5);

  JvmtiEnvIterator it;

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

    int prefix_count = env->get_native_method_prefix_count();

    char** prefixes = env->get_native_method_prefixes();

    for (int j = 0; j < prefix_count; j++) {

      // retrieve a prefix and so that it is safe against asynchronous changes

      // copy it into the resource area

      char* prefix = prefixes[j];

      char* prefix_copy = NEW_RESOURCE_ARRAY(char, strlen(prefix)+1);

      strcpy(prefix_copy, prefix);

      prefix_array->at_put_grow(total_count++, prefix_copy);

    }

  }

  char** all_prefixes = NEW_RESOURCE_ARRAY(char*, total_count);

  char** p = all_prefixes;

  for (int i = 0; i < total_count; ++i) {

    *p++ = prefix_array->at(i);

  }

  *count_ptr = total_count;

  return all_prefixes;

}

void

JvmtiEnvBase::set_event_callbacks(const jvmtiEventCallbacks* callbacks,

                                               jint size_of_callbacks) {

  assert(Threads::number_of_threads() == 0 || JvmtiThreadState_lock->is_locked(), "sanity check");

  size_t byte_cnt = sizeof(jvmtiEventCallbacks);

  // clear in either case to be sure we got any gap between sizes

  memset(&_event_callbacks, 0, byte_cnt);

  // Now that JvmtiThreadState_lock is held, prevent a possible race condition where events

  // are re-enabled by a call to set event callbacks where the DisposeEnvironment

  // occurs after the boiler-plate environment check and before the lock is acquired.

  if (callbacks != NULL && is_valid()) {

    if (size_of_callbacks < (jint)byte_cnt) {

      byte_cnt = size_of_callbacks;

    }

    memcpy(&_event_callbacks, callbacks, byte_cnt);

  }

}

// Called from JVMTI entry points which perform stack walking. If the

// associated JavaThread is the current thread, then wait_for_suspend

// is not used. Otherwise, it determines if we should wait for the

// "other" thread to complete external suspension. (NOTE: in future

// releases the suspension mechanism should be reimplemented so this

// is not necessary.)

//

bool

JvmtiEnvBase::is_thread_fully_suspended(JavaThread* thr, bool wait_for_suspend, uint32_t *bits) {

  // "other" threads require special handling

  if (thr != JavaThread::current()) {

    if (wait_for_suspend) {

      // We are allowed to wait for the external suspend to complete

      // so give the other thread a chance to get suspended.

      if (!thr->wait_for_ext_suspend_completion(SuspendRetryCount,

          SuspendRetryDelay, bits)) {

        // didn't make it so let the caller know

        return false;

      }

    }

    // We aren't allowed to wait for the external suspend to complete

    // so if the other thread isn't externally suspended we need to

    // let the caller know.

    else if (!thr->is_ext_suspend_completed_with_lock(bits)) {

      return false;

    }

  }

  return true;

}

// In the fullness of time, all users of the method should instead

// directly use allocate, besides being cleaner and faster, this will

// mean much better out of memory handling

unsigned char *

JvmtiEnvBase::jvmtiMalloc(jlong size) {

  unsigned char* mem;

  jvmtiError result = allocate(size, &mem);

  assert(result == JVMTI_ERROR_NONE, "Allocate failed");

  return mem;

}

//

// Threads

//