/*

 * Copyright (c) 2003, 2012, 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 "compiler/compileBroker.hpp"

#include "memory/iterator.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "oops/klass.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/oop.inline.hpp"

#include "runtime/arguments.hpp"

#include "runtime/globals.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/interfaceSupport.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/jniHandles.hpp"

#include "runtime/os.hpp"

#include "runtime/serviceThread.hpp"

#include "services/classLoadingService.hpp"

#include "services/diagnosticCommand.hpp"

#include "services/diagnosticFramework.hpp"

#include "services/heapDumper.hpp"

#include "services/jmm.h"

#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"

PerfVariable* Management::_begin_vm_creation_time = NULL;

PerfVariable* Management::_end_vm_creation_time = NULL;

PerfVariable* Management::_vm_init_done_time = NULL;

Klass* Management::_sensor_klass = NULL;

Klass* Management::_threadInfo_klass = NULL;

Klass* Management::_memoryUsage_klass = NULL;

Klass* Management::_memoryPoolMXBean_klass = NULL;

Klass* Management::_memoryManagerMXBean_klass = NULL;

Klass* Management::_garbageCollectorMXBean_klass = NULL;

Klass* Management::_managementFactory_klass = NULL;

Klass* Management::_garbageCollectorImpl_klass = NULL;

Klass* Management::_gcInfo_klass = NULL;

jmmOptionalSupport Management::_optional_support = {0};

TimeStamp Management::_stamp;

void management_init() {

  Management::init();

  ThreadService::init();

  RuntimeService::init();

  ClassLoadingService::init();

}

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.isBootClassPathSupported = 1;

  _optional_support.isObjectMonitorUsageSupported = 1;

#ifndef SERVICES_KERNEL

  // This depends on the heap inspector

  _optional_support.isSynchronizerUsageSupported = 1;

#endif // SERVICES_KERNEL

  _optional_support.isThreadAllocatedMemorySupported = 1;

  // Registration of the diagnostic commands

  DCmdRegistrant::register_dcmds();

  DCmdRegistrant::register_dcmds_ext();

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

}

void Management::initialize(TRAPS) {

  // Start the service thread

  ServiceThread::initialize();

  if (ManagementServer) {

    ResourceMark rm(THREAD);

    HandleMark hm(THREAD);

    // Load and initialize the sun.management.Agent class

    // invoke startAgent method to start the management server

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

    Klass* k = SystemDictionary::resolve_or_fail(vmSymbols::sun_management_Agent(),

                                                   loader,

                                                   Handle(),

                                                   true,

                                                   CHECK);

    instanceKlassHandle ik (THREAD, k);

    JavaValue result(T_VOID);

    JavaCalls::call_static(&result,

                           ik,

                           vmSymbols::startAgent_name(),

                           vmSymbols::void_method_signature(),

                           CHECK);

  }

}

void Management::get_optional_support(jmmOptionalSupport* support) {

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

}

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

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

  instanceKlassHandle ik (THREAD, 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);

}

Klass* 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;

}

Klass* 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;

}

Klass* 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;

}

Klass* 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;

}

Klass* 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;

}

Klass* 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;

}

Klass* Management::sun_management_ManagementFactory_klass(TRAPS) {

  if (_managementFactory_klass == NULL) {

    _managementFactory_klass = load_and_initialize_klass(vmSymbols::sun_management_ManagementFactory(), CHECK_NULL);

  }

  return _managementFactory_klass;

}

Klass* Management::sun_management_GarbageCollectorImpl_klass(TRAPS) {

  if (_garbageCollectorImpl_klass == NULL) {

    _garbageCollectorImpl_klass = load_and_initialize_klass(vmSymbols::sun_management_GarbageCollectorImpl(), CHECK_NULL);

  }

  return _garbageCollectorImpl_klass;

}

Klass* 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;

}

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

  Klass* k = Management::java_lang_management_ThreadInfo_klass(CHECK_NULL);

  instanceKlassHandle ik (THREAD, k);

  JavaValue result(T_VOID);

  JavaCallArguments args(14);

  // First allocate a ThreadObj object and

  // push the receiver as the first argument

  Handle element = ik->allocate_instance_handle(CHECK_NULL);

  args.push_oop(element);

  // initialize the arguments for the ThreadInfo constructor

  initialize_ThreadInfo_constructor_arguments(&args, snapshot, CHECK_NULL);

  // Call ThreadInfo constructor with no locked monitors and synchronizers

  JavaCalls::call_special(&result,

                          ik,

                          vmSymbols::object_initializer_name(),

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

  Klass* k = Management::java_lang_management_ThreadInfo_klass(CHECK_NULL);

  instanceKlassHandle ik (THREAD, k);

  JavaValue result(T_VOID);

  JavaCallArguments args(17);

  // First allocate a ThreadObj object and

  // push the receiver as the first argument

  Handle element = ik->allocate_instance_handle(CHECK_NULL);

  args.push_oop(element);

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

  JavaCalls::call_special(&result,

                          ik,

                          vmSymbols::object_initializer_name(),

                          vmSymbols::java_lang_management_ThreadInfo_with_locks_constructor_signature(),

                          &args,

                          CHECK_NULL);

  return (instanceOop) element();

}

// Helper functions

static JavaThread* find_java_thread_from_id(jlong thread_id) {

  assert(Threads_lock->owned_by_self(), "Must hold Threads_lock");

  JavaThread* java_thread = NULL;

  // Sequential search for now.  Need to do better optimization later.

  for (JavaThread* thread = Threads::first(); thread != NULL; thread = thread->next()) {

    oop tobj = thread->threadObj();

    if (!thread->is_exiting() &&

        tobj != NULL &&

        thread_id == java_lang_Thread::thread_id(tobj)) {

      java_thread = thread;

      break;

    }

  }

  return java_thread;

}

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

  Klass* 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);

}

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

    }

  }

}

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

  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 a java.lang.String object containing the input arguments to the VM.

JVM_ENTRY(jobject, jmm_GetInputArguments(JNIEnv *env))

  ResourceMark rm(THREAD);

  if (Arguments::num_jvm_args() == 0 && Arguments::num_jvm_flags() == 0) {

    return NULL;

  }

  char** vm_flags = Arguments::jvm_flags_array();

  char** vm_args  = Arguments::jvm_args_array();

  int num_flags   = Arguments::num_jvm_flags();

  int num_args    = Arguments::num_jvm_args();

  size_t length = 1; // null terminator

  int i;

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

    length += strlen(vm_flags[i]);

  }

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

    length += strlen(vm_args[i]);

  }

  // add a space between each argument

  length += num_flags + num_args - 1;

  // Return the list of input arguments passed to the VM

  // and preserve the order that the VM processes.

  char* args = NEW_RESOURCE_ARRAY(char, length);

  args[0] = '\0';

  // concatenate all jvm_flags

  if (num_flags > 0) {

    strcat(args, vm_flags[0]);

    for (i = 1; i < num_flags; i++) {

      strcat(args, " ");

      strcat(args, vm_flags[i]);

    }

  }

  if (num_args > 0 && num_flags > 0) {

    // append a space if args already contains one or more jvm_flags

    strcat(args, " ");

  }

  // concatenate all jvm_args

  if (num_args > 0) {

    strcat(args, vm_args[0]);

    for (i = 1; i < num_args; i++) {

      strcat(args, " ");

      strcat(args, vm_args[i]);

    }

  }

  Handle hargs = java_lang_String::create_from_platform_dependent_str(args, CHECK_NULL);