/*

 * Copyright (c) 1997, 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/classLoader.hpp"

#include "classfile/javaAssertions.hpp"

#include "classfile/javaClasses.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "gc_interface/collectedHeap.inline.hpp"

#include "memory/oopFactory.hpp"

#include "memory/universe.inline.hpp"

#include "oops/fieldStreams.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/method.hpp"

#include "prims/jvm.h"

#include "prims/jvm_misc.hpp"

#include "prims/jvmtiExport.hpp"

#include "prims/jvmtiThreadState.hpp"

#include "prims/nativeLookup.hpp"

#include "prims/privilegedStack.hpp"

#include "runtime/arguments.hpp"

#include "runtime/dtraceJSDT.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/init.hpp"

#include "runtime/interfaceSupport.hpp"

#include "runtime/java.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/jfieldIDWorkaround.hpp"

#include "runtime/os.hpp"

#include "runtime/perfData.hpp"

#include "runtime/reflection.hpp"

#include "runtime/vframe.hpp"

#include "runtime/vm_operations.hpp"

#include "services/attachListener.hpp"

#include "services/management.hpp"

#include "services/threadService.hpp"

#include "utilities/copy.hpp"

#include "utilities/defaultStream.hpp"

#include "utilities/dtrace.hpp"

#include "utilities/events.hpp"

#include "utilities/histogram.hpp"

#include "utilities/top.hpp"

#include "utilities/utf8.hpp"

#ifdef TARGET_OS_FAMILY_linux

# include "jvm_linux.h"

#endif

#ifdef TARGET_OS_FAMILY_solaris

# include "jvm_solaris.h"

#endif

#ifdef TARGET_OS_FAMILY_windows

# include "jvm_windows.h"

#endif

#ifdef TARGET_OS_FAMILY_bsd

# include "jvm_bsd.h"

#endif

#include <errno.h>

#ifndef USDT2

HS_DTRACE_PROBE_DECL1(hotspot, thread__sleep__begin, long long);

HS_DTRACE_PROBE_DECL1(hotspot, thread__sleep__end, int);

HS_DTRACE_PROBE_DECL0(hotspot, thread__yield);

#endif /* !USDT2 */

/*

  NOTE about use of any ctor or function call that can trigger a safepoint/GC:

  such ctors and calls MUST NOT come between an oop declaration/init and its

  usage because if objects are move this may cause various memory stomps, bus

  errors and segfaults. Here is a cookbook for causing so called "naked oop

  failures":

      JVM_ENTRY(jobjectArray, JVM_GetClassDeclaredFields<etc> {

          JVMWrapper("JVM_GetClassDeclaredFields");

          // Object address to be held directly in mirror & not visible to GC

          oop mirror = JNIHandles::resolve_non_null(ofClass);

          // If this ctor can hit a safepoint, moving objects around, then

          ComplexConstructor foo;

          // Boom! mirror may point to JUNK instead of the intended object

          (some dereference of mirror)

          // Here's another call that may block for GC, making mirror stale

          MutexLocker ml(some_lock);

          // And here's an initializer that can result in a stale oop

          // all in one step.

          oop o = call_that_can_throw_exception(TRAPS);

  The solution is to keep the oop declaration BELOW the ctor or function

  call that might cause a GC, do another resolve to reassign the oop, or

  consider use of a Handle instead of an oop so there is immunity from object

  motion. But note that the "QUICK" entries below do not have a handlemark

  and thus can only support use of handles passed in.

*/

static void trace_class_resolution_impl(Klass* to_class, TRAPS) {

  ResourceMark rm;

  int line_number = -1;

  const char * source_file = NULL;

  const char * trace = "explicit";

  InstanceKlass* caller = NULL;

  JavaThread* jthread = JavaThread::current();

  if (jthread->has_last_Java_frame()) {

    vframeStream vfst(jthread);

    // scan up the stack skipping ClassLoader, AccessController and PrivilegedAction frames

    TempNewSymbol access_controller = SymbolTable::new_symbol("java/security/AccessController", CHECK);

    Klass* access_controller_klass = SystemDictionary::resolve_or_fail(access_controller, false, CHECK);

    TempNewSymbol privileged_action = SymbolTable::new_symbol("java/security/PrivilegedAction", CHECK);

    Klass* privileged_action_klass = SystemDictionary::resolve_or_fail(privileged_action, false, CHECK);

    Method* last_caller = NULL;

    while (!vfst.at_end()) {

      Method* m = vfst.method();

      if (!vfst.method()->method_holder()->is_subclass_of(SystemDictionary::ClassLoader_klass())&&

          !vfst.method()->method_holder()->is_subclass_of(access_controller_klass) &&

          !vfst.method()->method_holder()->is_subclass_of(privileged_action_klass)) {

        break;

      }

      last_caller = m;

      vfst.next();

    }

    // if this is called from Class.forName0 and that is called from Class.forName,

    // then print the caller of Class.forName.  If this is Class.loadClass, then print

    // that caller, otherwise keep quiet since this should be picked up elsewhere.

    bool found_it = false;

    if (!vfst.at_end() &&

        vfst.method()->method_holder()->name() == vmSymbols::java_lang_Class() &&

        vfst.method()->name() == vmSymbols::forName0_name()) {

      vfst.next();

      if (!vfst.at_end() &&

          vfst.method()->method_holder()->name() == vmSymbols::java_lang_Class() &&

          vfst.method()->name() == vmSymbols::forName_name()) {

        vfst.next();

        found_it = true;

      }

    } else if (last_caller != NULL &&

               last_caller->method_holder()->name() ==

               vmSymbols::java_lang_ClassLoader() &&

               (last_caller->name() == vmSymbols::loadClassInternal_name() ||

                last_caller->name() == vmSymbols::loadClass_name())) {

      found_it = true;

    } else if (!vfst.at_end()) {

      if (vfst.method()->is_native()) {

        // JNI call

        found_it = true;

      }

    }

    if (found_it && !vfst.at_end()) {

      // found the caller

      caller = vfst.method()->method_holder();

      line_number = vfst.method()->line_number_from_bci(vfst.bci());

      if (line_number == -1) {

        // show method name if it's a native method

        trace = vfst.method()->name_and_sig_as_C_string();

      }

      Symbol* s = caller->source_file_name();

      if (s != NULL) {

        source_file = s->as_C_string();

      }

    }

  }

  if (caller != NULL) {

    if (to_class != caller) {

      const char * from = caller->external_name();

      const char * to = to_class->external_name();

      // print in a single call to reduce interleaving between threads

      if (source_file != NULL) {

        tty->print("RESOLVE %s %s %s:%d (%s)\n", from, to, source_file, line_number, trace);

      } else {

        tty->print("RESOLVE %s %s (%s)\n", from, to, trace);

      }

    }

  }

}

void trace_class_resolution(Klass* to_class) {

  EXCEPTION_MARK;

  trace_class_resolution_impl(to_class, THREAD);

  if (HAS_PENDING_EXCEPTION) {

    CLEAR_PENDING_EXCEPTION;

  }

}

// Wrapper to trace JVM functions

#ifdef ASSERT

  class JVMTraceWrapper : public StackObj {

   public:

    JVMTraceWrapper(const char* format, ...) {

      if (TraceJVMCalls) {

        va_list ap;

        va_start(ap, format);

        tty->print("JVM ");

        tty->vprint_cr(format, ap);

        va_end(ap);

      }

    }

  };

  Histogram* JVMHistogram;

  volatile jint JVMHistogram_lock = 0;

  class JVMHistogramElement : public HistogramElement {

    public:

     JVMHistogramElement(const char* name);

  };

  JVMHistogramElement::JVMHistogramElement(const char* elementName) {

    _name = elementName;

    uintx count = 0;

    while (Atomic::cmpxchg(1, &JVMHistogram_lock, 0) != 0) {

      while (OrderAccess::load_acquire(&JVMHistogram_lock) != 0) {

        count +=1;

        if ( (WarnOnStalledSpinLock > 0)

          && (count % WarnOnStalledSpinLock == 0)) {

          warning("JVMHistogram_lock seems to be stalled");

        }

      }

     }

    if(JVMHistogram == NULL)

      JVMHistogram = new Histogram("JVM Call Counts",100);

    JVMHistogram->add_element(this);

    Atomic::dec(&JVMHistogram_lock);

  }

  #define JVMCountWrapper(arg) \

      static JVMHistogramElement* e = new JVMHistogramElement(arg); \

      if (e != NULL) e->increment_count();  // Due to bug in VC++, we need a NULL check here eventhough it should never happen!

  #define JVMWrapper(arg1)                    JVMCountWrapper(arg1); JVMTraceWrapper(arg1)

  #define JVMWrapper2(arg1, arg2)             JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2)

  #define JVMWrapper3(arg1, arg2, arg3)       JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2, arg3)

  #define JVMWrapper4(arg1, arg2, arg3, arg4) JVMCountWrapper(arg1); JVMTraceWrapper(arg1, arg2, arg3, arg4)

#else

  #define JVMWrapper(arg1)

  #define JVMWrapper2(arg1, arg2)

  #define JVMWrapper3(arg1, arg2, arg3)

  #define JVMWrapper4(arg1, arg2, arg3, arg4)

#endif

// Interface version /////////////////////////////////////////////////////////////////////

JVM_LEAF(jint, JVM_GetInterfaceVersion())

  return JVM_INTERFACE_VERSION;

JVM_END

// java.lang.System //////////////////////////////////////////////////////////////////////

JVM_LEAF(jlong, JVM_CurrentTimeMillis(JNIEnv *env, jclass ignored))

  JVMWrapper("JVM_CurrentTimeMillis");

  return os::javaTimeMillis();

JVM_END

JVM_LEAF(jlong, JVM_NanoTime(JNIEnv *env, jclass ignored))

  JVMWrapper("JVM_NanoTime");

  return os::javaTimeNanos();

JVM_END

JVM_ENTRY(void, JVM_ArrayCopy(JNIEnv *env, jclass ignored, jobject src, jint src_pos,

                               jobject dst, jint dst_pos, jint length))

  JVMWrapper("JVM_ArrayCopy");

  // Check if we have null pointers

  if (src == NULL || dst == NULL) {

    THROW(vmSymbols::java_lang_NullPointerException());

  }

  arrayOop s = arrayOop(JNIHandles::resolve_non_null(src));

  arrayOop d = arrayOop(JNIHandles::resolve_non_null(dst));

  assert(s->is_oop(), "JVM_ArrayCopy: src not an oop");

  assert(d->is_oop(), "JVM_ArrayCopy: dst not an oop");

  // Do copy

  s->klass()->copy_array(s, src_pos, d, dst_pos, length, thread);

JVM_END

static void set_property(Handle props, const char* key, const char* value, TRAPS) {

  JavaValue r(T_OBJECT);

  // public synchronized Object put(Object key, Object value);

  HandleMark hm(THREAD);

  Handle key_str    = java_lang_String::create_from_platform_dependent_str(key, CHECK);

  Handle value_str  = java_lang_String::create_from_platform_dependent_str((value != NULL ? value : ""), CHECK);

  JavaCalls::call_virtual(&r,

                          props,

                          KlassHandle(THREAD, SystemDictionary::Properties_klass()),

                          vmSymbols::put_name(),

                          vmSymbols::object_object_object_signature(),

                          key_str,

                          value_str,

                          THREAD);

}

#define PUTPROP(props, name, value) set_property((props), (name), (value), CHECK_(properties));

JVM_ENTRY(jobject, JVM_InitProperties(JNIEnv *env, jobject properties))

  JVMWrapper("JVM_InitProperties");

  ResourceMark rm;

  Handle props(THREAD, JNIHandles::resolve_non_null(properties));

  // System property list includes both user set via -D option and

  // jvm system specific properties.

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

    PUTPROP(props, p->key(), p->value());

  }

  // Convert the -XX:MaxDirectMemorySize= command line flag

  // to the sun.nio.MaxDirectMemorySize property.

  // Do this after setting user properties to prevent people

  // from setting the value with a -D option, as requested.

  {

    if (FLAG_IS_DEFAULT(MaxDirectMemorySize)) {

      PUTPROP(props, "sun.nio.MaxDirectMemorySize", "-1");

    } else {

      char as_chars[256];

      jio_snprintf(as_chars, sizeof(as_chars), UINTX_FORMAT, MaxDirectMemorySize);

      PUTPROP(props, "sun.nio.MaxDirectMemorySize", as_chars);

    }

  }

  // JVM monitoring and management support

  // Add the sun.management.compiler property for the compiler's name

  {

#undef CSIZE

#if defined(_LP64) || defined(_WIN64)

  #define CSIZE "64-Bit "

#else

  #define CSIZE

#endif // 64bit

#ifdef TIERED

    const char* compiler_name = "HotSpot " CSIZE "Tiered Compilers";

#else

#if defined(COMPILER1)

    const char* compiler_name = "HotSpot " CSIZE "Client Compiler";

#elif defined(COMPILER2)

    const char* compiler_name = "HotSpot " CSIZE "Server Compiler";

#else

    const char* compiler_name = "";

#endif // compilers

#endif // TIERED

    if (*compiler_name != '\0' &&

        (Arguments::mode() != Arguments::_int)) {

      PUTPROP(props, "sun.management.compiler", compiler_name);

    }

  }

  return properties;

JVM_END

// java.lang.Runtime /////////////////////////////////////////////////////////////////////////

extern volatile jint vm_created;

JVM_ENTRY_NO_ENV(void, JVM_Exit(jint code))

  if (vm_created != 0 && (code == 0)) {

    // The VM is about to exit. We call back into Java to check whether finalizers should be run

    Universe::run_finalizers_on_exit();

  }

  before_exit(thread);

  vm_exit(code);

JVM_END

JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code))

  before_exit(thread);

  vm_exit(code);

JVM_END

JVM_LEAF(void, JVM_OnExit(void (*func)(void)))

  register_on_exit_function(func);

JVM_END

JVM_ENTRY_NO_ENV(void, JVM_GC(void))

  JVMWrapper("JVM_GC");

  if (!DisableExplicitGC) {

    Universe::heap()->collect(GCCause::_java_lang_system_gc);

  }

JVM_END

JVM_LEAF(jlong, JVM_MaxObjectInspectionAge(void))

  JVMWrapper("JVM_MaxObjectInspectionAge");

  return Universe::heap()->millis_since_last_gc();

JVM_END

JVM_LEAF(void, JVM_TraceInstructions(jboolean on))

  if (PrintJVMWarnings) warning("JVM_TraceInstructions not supported");

JVM_END

JVM_LEAF(void, JVM_TraceMethodCalls(jboolean on))

  if (PrintJVMWarnings) warning("JVM_TraceMethodCalls not supported");

JVM_END

static inline jlong convert_size_t_to_jlong(size_t val) {

  // In the 64-bit vm, a size_t can overflow a jlong (which is signed).

  NOT_LP64 (return (jlong)val;)

  LP64_ONLY(return (jlong)MIN2(val, (size_t)max_jlong);)

}

JVM_ENTRY_NO_ENV(jlong, JVM_TotalMemory(void))

  JVMWrapper("JVM_TotalMemory");

  size_t n = Universe::heap()->capacity();

  return convert_size_t_to_jlong(n);

JVM_END

JVM_ENTRY_NO_ENV(jlong, JVM_FreeMemory(void))

  JVMWrapper("JVM_FreeMemory");

  CollectedHeap* ch = Universe::heap();

  size_t n;

  {

     MutexLocker x(Heap_lock);

     n = ch->capacity() - ch->used();

  }

  return convert_size_t_to_jlong(n);

JVM_END

JVM_ENTRY_NO_ENV(jlong, JVM_MaxMemory(void))

  JVMWrapper("JVM_MaxMemory");

  size_t n = Universe::heap()->max_capacity();

  return convert_size_t_to_jlong(n);

JVM_END

JVM_ENTRY_NO_ENV(jint, JVM_ActiveProcessorCount(void))

  JVMWrapper("JVM_ActiveProcessorCount");

  return os::active_processor_count();

JVM_END

// java.lang.Throwable //////////////////////////////////////////////////////

JVM_ENTRY(void, JVM_FillInStackTrace(JNIEnv *env, jobject receiver))

  JVMWrapper("JVM_FillInStackTrace");

  Handle exception(thread, JNIHandles::resolve_non_null(receiver));

  java_lang_Throwable::fill_in_stack_trace(exception);

JVM_END

JVM_ENTRY(void, JVM_PrintStackTrace(JNIEnv *env, jobject receiver, jobject printable))

  JVMWrapper("JVM_PrintStackTrace");

  // Note: This is no longer used in Merlin, but we still support it for compatibility.

  oop exception = JNIHandles::resolve_non_null(receiver);

  oop stream    = JNIHandles::resolve_non_null(printable);

  java_lang_Throwable::print_stack_trace(exception, stream);

JVM_END

JVM_ENTRY(jint, JVM_GetStackTraceDepth(JNIEnv *env, jobject throwable))

  JVMWrapper("JVM_GetStackTraceDepth");

  oop exception = JNIHandles::resolve(throwable);

  return java_lang_Throwable::get_stack_trace_depth(exception, THREAD);

JVM_END

JVM_ENTRY(jobject, JVM_GetStackTraceElement(JNIEnv *env, jobject throwable, jint index))

  JVMWrapper("JVM_GetStackTraceElement");

  JvmtiVMObjectAllocEventCollector oam; // This ctor (throughout this module) may trigger a safepoint/GC

  oop exception = JNIHandles::resolve(throwable);

  oop element = java_lang_Throwable::get_stack_trace_element(exception, index, CHECK_NULL);

  return JNIHandles::make_local(env, element);

JVM_END

// java.lang.Object ///////////////////////////////////////////////

JVM_ENTRY(jint, JVM_IHashCode(JNIEnv* env, jobject handle))

  JVMWrapper("JVM_IHashCode");

  // as implemented in the classic virtual machine; return 0 if object is NULL