/*

 * 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 "jmm.h"

#include "classfile/systemDictionary.hpp"

#include "compiler/compileBroker.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/iterator.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "oops/klass.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/objArrayOop.inline.hpp"

#include "oops/oop.inline.hpp"

#include "oops/typeArrayOop.inline.hpp"

#include "runtime/arguments.hpp"

#include "runtime/flags/jvmFlag.hpp"

#include "runtime/globals.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/interfaceSupport.inline.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/jniHandles.inline.hpp"

#include "runtime/os.hpp"

#include "runtime/serviceThread.hpp"

#include "runtime/thread.inline.hpp"

#include "runtime/threadSMR.hpp"

#include "services/classLoadingService.hpp"

#include "services/diagnosticCommand.hpp"

#include "services/diagnosticFramework.hpp"

#include "services/writeableFlags.hpp"

#include "services/heapDumper.hpp"

#include "services/lowMemoryDetector.hpp"

#include "services/gcNotifier.hpp"

#include "services/nmtDCmd.hpp"

#include "services/management.hpp"

#include "services/memoryManager.hpp"

#include "services/memoryPool.hpp"

#include "services/memoryService.hpp"

#include "services/runtimeService.hpp"

#include "services/threadService.hpp"

#include "utilities/debug.hpp"

#include "utilities/formatBuffer.hpp"

#include "utilities/macros.hpp"

PerfVariable* Management::_begin_vm_creation_time = NULL;

PerfVariable* Management::_end_vm_creation_time = NULL;

PerfVariable* Management::_vm_init_done_time = NULL;

InstanceKlass* Management::_diagnosticCommandImpl_klass = NULL;

InstanceKlass* Management::_garbageCollectorExtImpl_klass = NULL;

InstanceKlass* Management::_garbageCollectorMXBean_klass = NULL;

InstanceKlass* Management::_gcInfo_klass = NULL;

InstanceKlass* Management::_managementFactoryHelper_klass = NULL;

InstanceKlass* Management::_memoryManagerMXBean_klass = NULL;

InstanceKlass* Management::_memoryPoolMXBean_klass = NULL;

InstanceKlass* Management::_memoryUsage_klass = NULL;

InstanceKlass* Management::_sensor_klass = NULL;

InstanceKlass* Management::_threadInfo_klass = NULL;

jmmOptionalSupport Management::_optional_support = {0};

TimeStamp Management::_stamp;

void management_init() {

#if INCLUDE_MANAGEMENT

  Management::init();

  ThreadService::init();

  RuntimeService::init();

  ClassLoadingService::init();

#else

  ThreadService::init();

#endif // INCLUDE_MANAGEMENT

}

#if INCLUDE_MANAGEMENT

void Management::init() {

  EXCEPTION_MARK;

  // These counters are for java.lang.management API support.

  // They are created even if -XX:-UsePerfData is set and in

  // that case, they will be allocated on C heap.

  _begin_vm_creation_time =

            PerfDataManager::create_variable(SUN_RT, "createVmBeginTime",

                                             PerfData::U_None, CHECK);

  _end_vm_creation_time =

            PerfDataManager::create_variable(SUN_RT, "createVmEndTime",

                                             PerfData::U_None, CHECK);

  _vm_init_done_time =

            PerfDataManager::create_variable(SUN_RT, "vmInitDoneTime",

                                             PerfData::U_None, CHECK);

  // Initialize optional support

  _optional_support.isLowMemoryDetectionSupported = 1;

  _optional_support.isCompilationTimeMonitoringSupported = 1;

  _optional_support.isThreadContentionMonitoringSupported = 1;

  if (os::is_thread_cpu_time_supported()) {

    _optional_support.isCurrentThreadCpuTimeSupported = 1;

    _optional_support.isOtherThreadCpuTimeSupported = 1;

  } else {

    _optional_support.isCurrentThreadCpuTimeSupported = 0;

    _optional_support.isOtherThreadCpuTimeSupported = 0;

  }

  _optional_support.isObjectMonitorUsageSupported = 1;

#if INCLUDE_SERVICES

  // This depends on the heap inspector

  _optional_support.isSynchronizerUsageSupported = 1;

#endif // INCLUDE_SERVICES

  _optional_support.isThreadAllocatedMemorySupported = 1;

  _optional_support.isRemoteDiagnosticCommandsSupported = 1;

  // Registration of the diagnostic commands

  DCmdRegistrant::register_dcmds();

  DCmdRegistrant::register_dcmds_ext();

  uint32_t full_export = DCmd_Source_Internal | DCmd_Source_AttachAPI

                         | DCmd_Source_MBean;

  DCmdFactory::register_DCmdFactory(new DCmdFactoryImpl<NMTDCmd>(full_export, true, false));

}

void Management::initialize(TRAPS) {

  // Start the service thread

  ServiceThread::initialize();

  if (ManagementServer) {

    ResourceMark rm(THREAD);

    HandleMark hm(THREAD);

    // Load and initialize the jdk.internal.agent.Agent class

    // invoke startAgent method to start the management server

    Handle loader = Handle(THREAD, SystemDictionary::java_system_loader());

    Klass* k = SystemDictionary::resolve_or_null(vmSymbols::jdk_internal_agent_Agent(),

                                                   loader,

                                                   Handle(),

                                                   THREAD);

    if (k == NULL) {

      vm_exit_during_initialization("Management agent initialization failure: "

          "class jdk.internal.agent.Agent not found.");

    }

    JavaValue result(T_VOID);

    JavaCalls::call_static(&result,

                           k,

                           vmSymbols::startAgent_name(),

                           vmSymbols::void_method_signature(),

                           CHECK);

  }

}

void Management::get_optional_support(jmmOptionalSupport* support) {

  memcpy(support, &_optional_support, sizeof(jmmOptionalSupport));

}

InstanceKlass* Management::load_and_initialize_klass(Symbol* sh, TRAPS) {

  Klass* k = SystemDictionary::resolve_or_fail(sh, true, CHECK_NULL);

  return initialize_klass(k, THREAD);

}

InstanceKlass* Management::load_and_initialize_klass_or_null(Symbol* sh, TRAPS) {

  Klass* k = SystemDictionary::resolve_or_null(sh, CHECK_NULL);

  if (k == NULL) {

     return NULL;

  }

  return initialize_klass(k, THREAD);

}

InstanceKlass* Management::initialize_klass(Klass* k, TRAPS) {

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

  if (ik->should_be_initialized()) {

    ik->initialize(CHECK_NULL);

  }

  // If these classes change to not be owned by the boot loader, they need

  // to be walked to keep their class loader alive in oops_do.

  assert(ik->class_loader() == NULL, "need to follow in oops_do");

  return ik;

}

void Management::record_vm_startup_time(jlong begin, jlong duration) {

  // if the performance counter is not initialized,

  // then vm initialization failed; simply return.

  if (_begin_vm_creation_time == NULL) return;

  _begin_vm_creation_time->set_value(begin);

  _end_vm_creation_time->set_value(begin + duration);

  PerfMemory::set_accessible(true);

}

jlong Management::timestamp() {

  TimeStamp t;

  t.update();

  return t.ticks() - _stamp.ticks();

}

void Management::oops_do(OopClosure* f) {

  MemoryService::oops_do(f);

  ThreadService::oops_do(f);

}

InstanceKlass* Management::java_lang_management_ThreadInfo_klass(TRAPS) {

  if (_threadInfo_klass == NULL) {

    _threadInfo_klass = load_and_initialize_klass(vmSymbols::java_lang_management_ThreadInfo(), CHECK_NULL);

  }

  return _threadInfo_klass;

}

InstanceKlass* Management::java_lang_management_MemoryUsage_klass(TRAPS) {

  if (_memoryUsage_klass == NULL) {

    _memoryUsage_klass = load_and_initialize_klass(vmSymbols::java_lang_management_MemoryUsage(), CHECK_NULL);

  }

  return _memoryUsage_klass;

}

InstanceKlass* Management::java_lang_management_MemoryPoolMXBean_klass(TRAPS) {

  if (_memoryPoolMXBean_klass == NULL) {

    _memoryPoolMXBean_klass = load_and_initialize_klass(vmSymbols::java_lang_management_MemoryPoolMXBean(), CHECK_NULL);

  }

  return _memoryPoolMXBean_klass;

}

InstanceKlass* Management::java_lang_management_MemoryManagerMXBean_klass(TRAPS) {

  if (_memoryManagerMXBean_klass == NULL) {

    _memoryManagerMXBean_klass = load_and_initialize_klass(vmSymbols::java_lang_management_MemoryManagerMXBean(), CHECK_NULL);

  }

  return _memoryManagerMXBean_klass;

}

InstanceKlass* Management::java_lang_management_GarbageCollectorMXBean_klass(TRAPS) {

  if (_garbageCollectorMXBean_klass == NULL) {

      _garbageCollectorMXBean_klass = load_and_initialize_klass(vmSymbols::java_lang_management_GarbageCollectorMXBean(), CHECK_NULL);

  }

  return _garbageCollectorMXBean_klass;

}

InstanceKlass* Management::sun_management_Sensor_klass(TRAPS) {

  if (_sensor_klass == NULL) {

    _sensor_klass = load_and_initialize_klass(vmSymbols::sun_management_Sensor(), CHECK_NULL);

  }

  return _sensor_klass;

}

InstanceKlass* Management::sun_management_ManagementFactoryHelper_klass(TRAPS) {

  if (_managementFactoryHelper_klass == NULL) {

    _managementFactoryHelper_klass = load_and_initialize_klass(vmSymbols::sun_management_ManagementFactoryHelper(), CHECK_NULL);

  }

  return _managementFactoryHelper_klass;

}

InstanceKlass* Management::com_sun_management_internal_GarbageCollectorExtImpl_klass(TRAPS) {

  if (_garbageCollectorExtImpl_klass == NULL) {

    _garbageCollectorExtImpl_klass =

                load_and_initialize_klass_or_null(vmSymbols::com_sun_management_internal_GarbageCollectorExtImpl(), CHECK_NULL);

  }

  return _garbageCollectorExtImpl_klass;

}

InstanceKlass* Management::com_sun_management_GcInfo_klass(TRAPS) {

  if (_gcInfo_klass == NULL) {

    _gcInfo_klass = load_and_initialize_klass(vmSymbols::com_sun_management_GcInfo(), CHECK_NULL);

  }

  return _gcInfo_klass;

}

InstanceKlass* Management::com_sun_management_internal_DiagnosticCommandImpl_klass(TRAPS) {

  if (_diagnosticCommandImpl_klass == NULL) {

    _diagnosticCommandImpl_klass = load_and_initialize_klass(vmSymbols::com_sun_management_internal_DiagnosticCommandImpl(), CHECK_NULL);

  }

  return _diagnosticCommandImpl_klass;

}

static void initialize_ThreadInfo_constructor_arguments(JavaCallArguments* args, ThreadSnapshot* snapshot, TRAPS) {

  Handle snapshot_thread(THREAD, snapshot->threadObj());

  jlong contended_time;

  jlong waited_time;

  if (ThreadService::is_thread_monitoring_contention()) {

    contended_time = Management::ticks_to_ms(snapshot->contended_enter_ticks());

    waited_time = Management::ticks_to_ms(snapshot->monitor_wait_ticks() + snapshot->sleep_ticks());

  } else {

    // set them to -1 if thread contention monitoring is disabled.

    contended_time = max_julong;

    waited_time = max_julong;

  }

  int thread_status = snapshot->thread_status();

  assert((thread_status & JMM_THREAD_STATE_FLAG_MASK) == 0, "Flags already set in thread_status in Thread object");

  if (snapshot->is_ext_suspended()) {

    thread_status |= JMM_THREAD_STATE_FLAG_SUSPENDED;

  }

  if (snapshot->is_in_native()) {

    thread_status |= JMM_THREAD_STATE_FLAG_NATIVE;

  }

  ThreadStackTrace* st = snapshot->get_stack_trace();

  Handle stacktrace_h;

  if (st != NULL) {

    stacktrace_h = st->allocate_fill_stack_trace_element_array(CHECK);

  } else {

    stacktrace_h = Handle();

  }

  args->push_oop(snapshot_thread);

  args->push_int(thread_status);

  args->push_oop(Handle(THREAD, snapshot->blocker_object()));

  args->push_oop(Handle(THREAD, snapshot->blocker_object_owner()));

  args->push_long(snapshot->contended_enter_count());

  args->push_long(contended_time);

  args->push_long(snapshot->monitor_wait_count() + snapshot->sleep_count());

  args->push_long(waited_time);

  args->push_oop(stacktrace_h);

}

// Helper function to construct a ThreadInfo object

instanceOop Management::create_thread_info_instance(ThreadSnapshot* snapshot, TRAPS) {

  InstanceKlass* ik = Management::java_lang_management_ThreadInfo_klass(CHECK_NULL);

  JavaCallArguments args(14);

  // initialize the arguments for the ThreadInfo constructor

  initialize_ThreadInfo_constructor_arguments(&args, snapshot, CHECK_NULL);

  // Call ThreadInfo constructor with no locked monitors and synchronizers

  Handle element = JavaCalls::construct_new_instance(

                          ik,

                          vmSymbols::java_lang_management_ThreadInfo_constructor_signature(),

                          &args,

                          CHECK_NULL);

  return (instanceOop) element();

}

instanceOop Management::create_thread_info_instance(ThreadSnapshot* snapshot,

                                                    objArrayHandle monitors_array,

                                                    typeArrayHandle depths_array,

                                                    objArrayHandle synchronizers_array,

                                                    TRAPS) {

  InstanceKlass* ik = Management::java_lang_management_ThreadInfo_klass(CHECK_NULL);

  JavaCallArguments args(17);

  // initialize the arguments for the ThreadInfo constructor

  initialize_ThreadInfo_constructor_arguments(&args, snapshot, CHECK_NULL);

  // push the locked monitors and synchronizers in the arguments

  args.push_oop(monitors_array);

  args.push_oop(depths_array);

  args.push_oop(synchronizers_array);

  // Call ThreadInfo constructor with locked monitors and synchronizers

  Handle element = JavaCalls::construct_new_instance(

                          ik,

                          vmSymbols::java_lang_management_ThreadInfo_with_locks_constructor_signature(),

                          &args,

                          CHECK_NULL);

  return (instanceOop) element();

}

static GCMemoryManager* get_gc_memory_manager_from_jobject(jobject mgr, TRAPS) {

  if (mgr == NULL) {

    THROW_(vmSymbols::java_lang_NullPointerException(), NULL);

  }

  oop mgr_obj = JNIHandles::resolve(mgr);

  instanceHandle h(THREAD, (instanceOop) mgr_obj);

  InstanceKlass* k = Management::java_lang_management_GarbageCollectorMXBean_klass(CHECK_NULL);

  if (!h->is_a(k)) {

    THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),

               "the object is not an instance of java.lang.management.GarbageCollectorMXBean class",

               NULL);

  }

  MemoryManager* gc = MemoryService::get_memory_manager(h);

  if (gc == NULL || !gc->is_gc_memory_manager()) {

    THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(),

               "Invalid GC memory manager",

               NULL);

  }

  return (GCMemoryManager*) gc;

}

static MemoryPool* get_memory_pool_from_jobject(jobject obj, TRAPS) {

  if (obj == NULL) {

    THROW_(vmSymbols::java_lang_NullPointerException(), NULL);

  }

  oop pool_obj = JNIHandles::resolve(obj);

  assert(pool_obj->is_instance(), "Should be an instanceOop");

  instanceHandle ph(THREAD, (instanceOop) pool_obj);

  return MemoryService::get_memory_pool(ph);

}

#endif // INCLUDE_MANAGEMENT

static void validate_thread_id_array(typeArrayHandle ids_ah, TRAPS) {

  int num_threads = ids_ah->length();

  // Validate input thread IDs

  int i = 0;

  for (i = 0; i < num_threads; i++) {

    jlong tid = ids_ah->long_at(i);

    if (tid <= 0) {

      // throw exception if invalid thread id.

      THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),

                "Invalid thread ID entry");

    }

  }

}

#if INCLUDE_MANAGEMENT

static void validate_thread_info_array(objArrayHandle infoArray_h, TRAPS) {

  // check if the element of infoArray is of type ThreadInfo class

  Klass* threadinfo_klass = Management::java_lang_management_ThreadInfo_klass(CHECK);

  Klass* element_klass = ObjArrayKlass::cast(infoArray_h->klass())->element_klass();

  if (element_klass != threadinfo_klass) {

    THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),

              "infoArray element type is not ThreadInfo class");

  }

}

static MemoryManager* get_memory_manager_from_jobject(jobject obj, TRAPS) {

  if (obj == NULL) {

    THROW_(vmSymbols::java_lang_NullPointerException(), NULL);

  }

  oop mgr_obj = JNIHandles::resolve(obj);

  assert(mgr_obj->is_instance(), "Should be an instanceOop");

  instanceHandle mh(THREAD, (instanceOop) mgr_obj);

  return MemoryService::get_memory_manager(mh);

}

// Returns a version string and sets major and minor version if

// the input parameters are non-null.

JVM_LEAF(jint, jmm_GetVersion(JNIEnv *env))

  return JMM_VERSION;

JVM_END

// Gets the list of VM monitoring and management optional supports

// Returns 0 if succeeded; otherwise returns non-zero.

JVM_LEAF(jint, jmm_GetOptionalSupport(JNIEnv *env, jmmOptionalSupport* support))

  if (support == NULL) {

    return -1;

  }

  Management::get_optional_support(support);

  return 0;

JVM_END

// Returns an array of java/lang/management/MemoryPoolMXBean object

// one for each memory pool if obj == null; otherwise returns

// an array of memory pools for a given memory manager if

// it is a valid memory manager.

JVM_ENTRY(jobjectArray, jmm_GetMemoryPools(JNIEnv* env, jobject obj))

  ResourceMark rm(THREAD);

  int num_memory_pools;

  MemoryManager* mgr = NULL;

  if (obj == NULL) {

    num_memory_pools = MemoryService::num_memory_pools();

  } else {

    mgr = get_memory_manager_from_jobject(obj, CHECK_NULL);

    if (mgr == NULL) {

      return NULL;

    }

    num_memory_pools = mgr->num_memory_pools();

  }

  // Allocate the resulting MemoryPoolMXBean[] object

  InstanceKlass* ik = Management::java_lang_management_MemoryPoolMXBean_klass(CHECK_NULL);

  objArrayOop r = oopFactory::new_objArray(ik, num_memory_pools, CHECK_NULL);

  objArrayHandle poolArray(THREAD, r);

  if (mgr == NULL) {

    // Get all memory pools

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

      MemoryPool* pool = MemoryService::get_memory_pool(i);

      instanceOop p = pool->get_memory_pool_instance(CHECK_NULL);

      instanceHandle ph(THREAD, p);

      poolArray->obj_at_put(i, ph());

    }

  } else {

    // Get memory pools managed by a given memory manager

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

      MemoryPool* pool = mgr->get_memory_pool(i);