/*

 * Copyright (c) 1997, 2018, 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 "jvm.h"

#include "classfile/classFileStream.hpp"

#include "classfile/classLoader.hpp"

#include "classfile/classLoaderData.inline.hpp"

#include "classfile/javaAssertions.hpp"

#include "classfile/javaClasses.inline.hpp"

#include "classfile/moduleEntry.hpp"

#include "classfile/modules.hpp"

#include "classfile/packageEntry.hpp"

#include "classfile/stringTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "gc/shared/collectedHeap.inline.hpp"

#include "interpreter/bytecode.hpp"

#include "jfr/jfrEvents.hpp"

#include "logging/log.hpp"

#include "memory/heapShared.hpp"

#include "memory/oopFactory.hpp"

#include "memory/referenceType.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.hpp"

#include "oops/access.inline.hpp"

#include "oops/fieldStreams.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/method.hpp"

#include "oops/objArrayKlass.hpp"

#include "oops/objArrayOop.inline.hpp"

#include "oops/oop.inline.hpp"

#include "prims/jvm_misc.hpp"

#include "prims/jvmtiExport.hpp"

#include "prims/jvmtiThreadState.hpp"

#include "prims/nativeLookup.hpp"

#include "prims/privilegedStack.hpp"

#include "prims/stackwalk.hpp"

#include "runtime/arguments.hpp"

#include "runtime/atomic.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/init.hpp"

#include "runtime/interfaceSupport.inline.hpp"

#include "runtime/java.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/jfieldIDWorkaround.hpp"

#include "runtime/jniHandles.inline.hpp"

#include "runtime/orderAccess.hpp"

#include "runtime/os.inline.hpp"

#include "runtime/perfData.hpp"

#include "runtime/reflection.hpp"

#include "runtime/thread.inline.hpp"

#include "runtime/threadSMR.hpp"

#include "runtime/vframe.inline.hpp"

#include "runtime/vm_operations.hpp"

#include "runtime/vm_version.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/macros.hpp"

#include "utilities/utf8.hpp"

#if INCLUDE_CDS

#include "classfile/systemDictionaryShared.hpp"

#endif

#include <errno.h>

/*

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

        log_debug(class, resolve)("%s %s %s:%d (%s)", from, to, source_file, line_number, trace);

      } else {

        log_debug(class, resolve)("%s %s (%s)", 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

  Histogram* JVMHistogram;

  volatile int 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(arg) JVMCountWrapper(arg);

#else

  #define JVMWrapper(arg)

#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

// The function below is actually exposed by jdk.internal.misc.VM and not

// java.lang.System, but we choose to keep it here so that it stays next

// to JVM_CurrentTimeMillis and JVM_NanoTime

const jlong MAX_DIFF_SECS = CONST64(0x0100000000); //  2^32

const jlong MIN_DIFF_SECS = -MAX_DIFF_SECS; // -2^32

JVM_LEAF(jlong, JVM_GetNanoTimeAdjustment(JNIEnv *env, jclass ignored, jlong offset_secs))

  JVMWrapper("JVM_GetNanoTimeAdjustment");

  jlong seconds;

  jlong nanos;

  os::javaTimeSystemUTC(seconds, nanos);

  // We're going to verify that the result can fit in a long.

  // For that we need the difference in seconds between 'seconds'

  // and 'offset_secs' to be such that:

  //     |seconds - offset_secs| < (2^63/10^9)

  // We're going to approximate 10^9 ~< 2^30 (1000^3 ~< 1024^3)

  // which makes |seconds - offset_secs| < 2^33

  // and we will prefer +/- 2^32 as the maximum acceptable diff

  // as 2^32 has a more natural feel than 2^33...

  //

  // So if |seconds - offset_secs| >= 2^32 - we return a special

  // sentinel value (-1) which the caller should take as an

  // exception value indicating that the offset given to us is

  // too far from range of the current time - leading to too big

  // a nano adjustment. The caller is expected to recover by

  // computing a more accurate offset and calling this method

  // again. (For the record 2^32 secs is ~136 years, so that

  // should rarely happen)

  //

  jlong diff = seconds - offset_secs;

  if (diff >= MAX_DIFF_SECS || diff <= MIN_DIFF_SECS) {

     return -1; // sentinel value: the offset is too far off the target

  }

  // return the adjustment. If you compute a time by adding

  // this number of nanoseconds along with the number of seconds

  // in the offset you should get the current UTC time.

  return (diff * (jlong)1000000000) + nanos;

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(oopDesc::is_oop(s), "JVM_ArrayCopy: src not an oop");

  assert(oopDesc::is_oop(d), "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,

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

#elif INCLUDE_JVMCI

    #error "INCLUDE_JVMCI should imply TIERED"

#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

/*

 * Return the temporary directory that the VM uses for the attach

 * and perf data files.

 *

 * It is important that this directory is well-known and the

 * same for all VM instances. It cannot be affected by configuration

 * variables such as java.io.tmpdir.

 */

JVM_ENTRY(jstring, JVM_GetTemporaryDirectory(JNIEnv *env))

  JVMWrapper("JVM_GetTemporaryDirectory");

  HandleMark hm(THREAD);

  const char* temp_dir = os::get_temp_directory();

  Handle h = java_lang_String::create_from_platform_dependent_str(temp_dir, CHECK_NULL);

  return (jstring) JNIHandles::make_local(env, h());

JVM_END

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

extern volatile jint vm_created;

JVM_ENTRY_NO_ENV(void, JVM_BeforeHalt())

  JVMWrapper("JVM_BeforeHalt");

  EventShutdown event;

  if (event.should_commit()) {

    event.set_reason("Shutdown requested from Java");

    event.commit();

  }

JVM_END

JVM_ENTRY_NO_ENV(void, JVM_Halt(jint code))

  before_exit(thread);

  vm_exit(code);

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

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