/*

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

#include "classfile/javaAssertions.hpp"

#include "classfile/moduleEntry.hpp"

#include "classfile/stringTable.hpp"

#include "classfile/symbolTable.hpp"

#include "gc/shared/gcArguments.hpp"

#include "gc/shared/gcConfig.hpp"

#include "gc/shared/genCollectedHeap.hpp"

#include "gc/shared/referenceProcessor.hpp"

#include "gc/shared/taskqueue.hpp"

#include "logging/log.hpp"

#include "logging/logConfiguration.hpp"

#include "logging/logStream.hpp"

#include "logging/logTag.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/universe.hpp"

#include "oops/oop.inline.hpp"

#include "prims/jvmtiExport.hpp"

#include "runtime/arguments.hpp"

#include "runtime/arguments_ext.hpp"

#include "runtime/commandLineFlagConstraintList.hpp"

#include "runtime/commandLineFlagWriteableList.hpp"

#include "runtime/commandLineFlagRangeList.hpp"

#include "runtime/globals.hpp"

#include "runtime/globals_extension.hpp"

#include "runtime/java.hpp"

#include "runtime/os.inline.hpp"

#include "runtime/safepoint.hpp"

#include "runtime/safepointMechanism.hpp"

#include "runtime/vm_version.hpp"

#include "services/management.hpp"

#include "services/memTracker.hpp"

#include "utilities/align.hpp"

#include "utilities/defaultStream.hpp"

#include "utilities/macros.hpp"

#include "utilities/stringUtils.hpp"

#if INCLUDE_JVMCI

#include "jvmci/jvmciRuntime.hpp"

#endif

// Note: This is a special bug reporting site for the JVM

#ifdef VENDOR_URL_VM_BUG

# define DEFAULT_VENDOR_URL_BUG VENDOR_URL_VM_BUG

#else

# define DEFAULT_VENDOR_URL_BUG "http://bugreport.java.com/bugreport/crash.jsp"

#endif

#define DEFAULT_JAVA_LAUNCHER  "generic"

char*  Arguments::_jvm_flags_file               = NULL;

char** Arguments::_jvm_flags_array              = NULL;

int    Arguments::_num_jvm_flags                = 0;

char** Arguments::_jvm_args_array               = NULL;

int    Arguments::_num_jvm_args                 = 0;

char*  Arguments::_java_command                 = NULL;

SystemProperty* Arguments::_system_properties   = NULL;

const char*  Arguments::_gc_log_filename        = NULL;

size_t Arguments::_conservative_max_heap_alignment = 0;

size_t Arguments::_min_heap_size                = 0;

Arguments::Mode Arguments::_mode                = _mixed;

bool   Arguments::_java_compiler                = false;

bool   Arguments::_xdebug_mode                  = false;

const char*  Arguments::_java_vendor_url_bug    = DEFAULT_VENDOR_URL_BUG;

const char*  Arguments::_sun_java_launcher      = DEFAULT_JAVA_LAUNCHER;

int    Arguments::_sun_java_launcher_pid        = -1;

bool   Arguments::_sun_java_launcher_is_altjvm  = false;

// These parameters are reset in method parse_vm_init_args()

bool   Arguments::_AlwaysCompileLoopMethods     = AlwaysCompileLoopMethods;

bool   Arguments::_UseOnStackReplacement        = UseOnStackReplacement;

bool   Arguments::_BackgroundCompilation        = BackgroundCompilation;

bool   Arguments::_ClipInlining                 = ClipInlining;

intx   Arguments::_Tier3InvokeNotifyFreqLog     = Tier3InvokeNotifyFreqLog;

intx   Arguments::_Tier4InvocationThreshold     = Tier4InvocationThreshold;

char*  Arguments::SharedArchivePath             = NULL;

AgentLibraryList Arguments::_libraryList;

AgentLibraryList Arguments::_agentList;

abort_hook_t     Arguments::_abort_hook         = NULL;

exit_hook_t      Arguments::_exit_hook          = NULL;

vfprintf_hook_t  Arguments::_vfprintf_hook      = NULL;

SystemProperty *Arguments::_sun_boot_library_path = NULL;

SystemProperty *Arguments::_java_library_path = NULL;

SystemProperty *Arguments::_java_home = NULL;

SystemProperty *Arguments::_java_class_path = NULL;

SystemProperty *Arguments::_jdk_boot_class_path_append = NULL;

GrowableArray<ModulePatchPath*> *Arguments::_patch_mod_prefix = NULL;

PathString *Arguments::_system_boot_class_path = NULL;

bool Arguments::_has_jimage = false;

char* Arguments::_ext_dirs = NULL;

bool PathString::set_value(const char *value) {

  if (_value != NULL) {

    FreeHeap(_value);

  }

  _value = AllocateHeap(strlen(value)+1, mtArguments);

  assert(_value != NULL, "Unable to allocate space for new path value");

  if (_value != NULL) {

    strcpy(_value, value);

  } else {

    // not able to allocate

    return false;

  }

  return true;

}

void PathString::append_value(const char *value) {

  char *sp;

  size_t len = 0;

  if (value != NULL) {

    len = strlen(value);

    if (_value != NULL) {

      len += strlen(_value);

    }

    sp = AllocateHeap(len+2, mtArguments);

    assert(sp != NULL, "Unable to allocate space for new append path value");

    if (sp != NULL) {

      if (_value != NULL) {

        strcpy(sp, _value);

        strcat(sp, os::path_separator());

        strcat(sp, value);

        FreeHeap(_value);

      } else {

        strcpy(sp, value);

      }

      _value = sp;

    }

  }

}

PathString::PathString(const char* value) {

  if (value == NULL) {

    _value = NULL;

  } else {

    _value = AllocateHeap(strlen(value)+1, mtArguments);

    strcpy(_value, value);

  }

}

PathString::~PathString() {

  if (_value != NULL) {

    FreeHeap(_value);

    _value = NULL;

  }

}

ModulePatchPath::ModulePatchPath(const char* module_name, const char* path) {

  assert(module_name != NULL && path != NULL, "Invalid module name or path value");

  size_t len = strlen(module_name) + 1;

  _module_name = AllocateHeap(len, mtInternal);

  strncpy(_module_name, module_name, len); // copy the trailing null

  _path =  new PathString(path);

}

ModulePatchPath::~ModulePatchPath() {

  if (_module_name != NULL) {

    FreeHeap(_module_name);

    _module_name = NULL;

  }

  if (_path != NULL) {

    delete _path;

    _path = NULL;

  }

}

SystemProperty::SystemProperty(const char* key, const char* value, bool writeable, bool internal) : PathString(value) {

  if (key == NULL) {

    _key = NULL;

  } else {

    _key = AllocateHeap(strlen(key)+1, mtArguments);

    strcpy(_key, key);

  }

  _next = NULL;

  _internal = internal;

  _writeable = writeable;

}

AgentLibrary::AgentLibrary(const char* name, const char* options,

               bool is_absolute_path, void* os_lib,

               bool instrument_lib) {

  _name = AllocateHeap(strlen(name)+1, mtArguments);

  strcpy(_name, name);

  if (options == NULL) {

    _options = NULL;

  } else {

    _options = AllocateHeap(strlen(options)+1, mtArguments);

    strcpy(_options, options);

  }

  _is_absolute_path = is_absolute_path;

  _os_lib = os_lib;

  _next = NULL;

  _state = agent_invalid;

  _is_static_lib = false;

  _is_instrument_lib = instrument_lib;

}

// Check if head of 'option' matches 'name', and sets 'tail' to the remaining

// part of the option string.

static bool match_option(const JavaVMOption *option, const char* name,

                         const char** tail) {

  size_t len = strlen(name);

  if (strncmp(option->optionString, name, len) == 0) {

    *tail = option->optionString + len;

    return true;

  } else {

    return false;

  }

}

// Check if 'option' matches 'name'. No "tail" is allowed.

static bool match_option(const JavaVMOption *option, const char* name) {

  const char* tail = NULL;

  bool result = match_option(option, name, &tail);

  if (tail != NULL && *tail == '\0') {

    return result;

  } else {

    return false;

  }

}

// Return true if any of the strings in null-terminated array 'names' matches.

// If tail_allowed is true, then the tail must begin with a colon; otherwise,

// the option must match exactly.

static bool match_option(const JavaVMOption* option, const char** names, const char** tail,

  bool tail_allowed) {

  for (/* empty */; *names != NULL; ++names) {

  if (match_option(option, *names, tail)) {

      if (**tail == '\0' || (tail_allowed && **tail == ':')) {

        return true;

      }

    }

  }

  return false;

}

static void logOption(const char* opt) {

  if (PrintVMOptions) {

    jio_fprintf(defaultStream::output_stream(), "VM option '%s'\n", opt);

  }

}

bool needs_module_property_warning = false;

#define MODULE_PROPERTY_PREFIX "jdk.module."

#define MODULE_PROPERTY_PREFIX_LEN 11

#define ADDEXPORTS "addexports"

#define ADDEXPORTS_LEN 10

#define ADDREADS "addreads"

#define ADDREADS_LEN 8

#define ADDOPENS "addopens"

#define ADDOPENS_LEN 8

#define PATCH "patch"

#define PATCH_LEN 5

#define ADDMODS "addmods"

#define ADDMODS_LEN 7

#define LIMITMODS "limitmods"

#define LIMITMODS_LEN 9

#define PATH "path"

#define PATH_LEN 4

#define UPGRADE_PATH "upgrade.path"

#define UPGRADE_PATH_LEN 12

void Arguments::add_init_library(const char* name, char* options) {

  _libraryList.add(new AgentLibrary(name, options, false, NULL));

}

void Arguments::add_init_agent(const char* name, char* options, bool absolute_path) {

  _agentList.add(new AgentLibrary(name, options, absolute_path, NULL));

}

void Arguments::add_instrument_agent(const char* name, char* options, bool absolute_path) {

  _agentList.add(new AgentLibrary(name, options, absolute_path, NULL, true));

}

// Late-binding agents not started via arguments

void Arguments::add_loaded_agent(AgentLibrary *agentLib) {

  _agentList.add(agentLib);

}

void Arguments::add_loaded_agent(const char* name, char* options, bool absolute_path, void* os_lib) {

  _agentList.add(new AgentLibrary(name, options, absolute_path, os_lib));

}

// Return TRUE if option matches 'property', or 'property=', or 'property.'.

static bool matches_property_suffix(const char* option, const char* property, size_t len) {

  return ((strncmp(option, property, len) == 0) &&

          (option[len] == '=' || option[len] == '.' || option[len] == '\0'));

}

// Return true if property starts with "jdk.module." and its ensuing chars match

// any of the reserved module properties.

// property should be passed without the leading "-D".

bool Arguments::is_internal_module_property(const char* property) {

  assert((strncmp(property, "-D", 2) != 0), "Unexpected leading -D");

  if  (strncmp(property, MODULE_PROPERTY_PREFIX, MODULE_PROPERTY_PREFIX_LEN) == 0) {

    const char* property_suffix = property + MODULE_PROPERTY_PREFIX_LEN;

    if (matches_property_suffix(property_suffix, ADDEXPORTS, ADDEXPORTS_LEN) ||

        matches_property_suffix(property_suffix, ADDREADS, ADDREADS_LEN) ||

        matches_property_suffix(property_suffix, ADDOPENS, ADDOPENS_LEN) ||

        matches_property_suffix(property_suffix, PATCH, PATCH_LEN) ||

        matches_property_suffix(property_suffix, ADDMODS, ADDMODS_LEN) ||

        matches_property_suffix(property_suffix, LIMITMODS, LIMITMODS_LEN) ||

        matches_property_suffix(property_suffix, PATH, PATH_LEN) ||

        matches_property_suffix(property_suffix, UPGRADE_PATH, UPGRADE_PATH_LEN)) {

      return true;

    }

  }

  return false;

}

// Process java launcher properties.

void Arguments::process_sun_java_launcher_properties(JavaVMInitArgs* args) {

  // See if sun.java.launcher, sun.java.launcher.is_altjvm or

  // sun.java.launcher.pid is defined.

  // Must do this before setting up other system properties,

  // as some of them may depend on launcher type.

  for (int index = 0; index < args->nOptions; index++) {

    const JavaVMOption* option = args->options + index;

    const char* tail;

    if (match_option(option, "-Dsun.java.launcher=", &tail)) {

      process_java_launcher_argument(tail, option->extraInfo);

      continue;

    }

    if (match_option(option, "-Dsun.java.launcher.is_altjvm=", &tail)) {

      if (strcmp(tail, "true") == 0) {

        _sun_java_launcher_is_altjvm = true;

      }

      continue;

    }

    if (match_option(option, "-Dsun.java.launcher.pid=", &tail)) {

      _sun_java_launcher_pid = atoi(tail);

      continue;

    }

  }

}

// Initialize system properties key and value.

void Arguments::init_system_properties() {

  // Set up _system_boot_class_path which is not a property but

  // relies heavily on argument processing and the jdk.boot.class.path.append

  // property. It is used to store the underlying system boot class path.

  _system_boot_class_path = new PathString(NULL);

  PropertyList_add(&_system_properties, new SystemProperty("java.vm.specification.name",

                                                           "Java Virtual Machine Specification",  false));

  PropertyList_add(&_system_properties, new SystemProperty("java.vm.version", VM_Version::vm_release(),  false));

  PropertyList_add(&_system_properties, new SystemProperty("java.vm.name", VM_Version::vm_name(),  false));

  PropertyList_add(&_system_properties, new SystemProperty("java.vm.info", VM_Version::vm_info_string(),  true));

  PropertyList_add(&_system_properties, new SystemProperty("jdk.debug", VM_Version::jdk_debug_level(),  false));

  // Following are JVMTI agent writable properties.

  // Properties values are set to NULL and they are

  // os specific they are initialized in os::init_system_properties_values().

  _sun_boot_library_path = new SystemProperty("sun.boot.library.path", NULL,  true);

  _java_library_path = new SystemProperty("java.library.path", NULL,  true);

  _java_home =  new SystemProperty("java.home", NULL,  true);

  _java_class_path = new SystemProperty("java.class.path", "",  true);

  // jdk.boot.class.path.append is a non-writeable, internal property.

  // It can only be set by either:

  //    - -Xbootclasspath/a:

  //    - AddToBootstrapClassLoaderSearch during JVMTI OnLoad phase

  _jdk_boot_class_path_append = new SystemProperty("jdk.boot.class.path.append", "", false, true);

  // Add to System Property list.

  PropertyList_add(&_system_properties, _sun_boot_library_path);

  PropertyList_add(&_system_properties, _java_library_path);

  PropertyList_add(&_system_properties, _java_home);

  PropertyList_add(&_system_properties, _java_class_path);

  PropertyList_add(&_system_properties, _jdk_boot_class_path_append);

  // Set OS specific system properties values

  os::init_system_properties_values();

}

// Update/Initialize System properties after JDK version number is known

void Arguments::init_version_specific_system_properties() {

  enum { bufsz = 16 };

  char buffer[bufsz];

  const char* spec_vendor = "Oracle Corporation";

  uint32_t spec_version = JDK_Version::current().major_version();

  jio_snprintf(buffer, bufsz, UINT32_FORMAT, spec_version);

  PropertyList_add(&_system_properties,

      new SystemProperty("java.vm.specification.vendor",  spec_vendor, false));

  PropertyList_add(&_system_properties,

      new SystemProperty("java.vm.specification.version", buffer, false));

  PropertyList_add(&_system_properties,

      new SystemProperty("java.vm.vendor", VM_Version::vm_vendor(),  false));

}

/*

 *  -XX argument processing:

 *

 *  -XX arguments are defined in several places, such as:

 *      globals.hpp, globals_<cpu>.hpp, globals_<os>.hpp, <compiler>_globals.hpp, or <gc>_globals.hpp.

 *  -XX arguments are parsed in parse_argument().

 *  -XX argument bounds checking is done in check_vm_args_consistency().

 *

 * Over time -XX arguments may change. There are mechanisms to handle common cases:

 *

 *      ALIASED: An option that is simply another name for another option. This is often

 *               part of the process of deprecating a flag, but not all aliases need

 *               to be deprecated.

 *

 *               Create an alias for an option by adding the old and new option names to the

 *               "aliased_jvm_flags" table. Delete the old variable from globals.hpp (etc).

 *

 *   DEPRECATED: An option that is supported, but a warning is printed to let the user know that

 *               support may be removed in the future. Both regular and aliased options may be

 *               deprecated.

 *

 *               Add a deprecation warning for an option (or alias) by adding an entry in the

 *               "special_jvm_flags" table and setting the "deprecated_in" field.

 *               Often an option "deprecated" in one major release will

 *               be made "obsolete" in the next. In this case the entry should also have its

 *               "obsolete_in" field set.

 *

 *     OBSOLETE: An option that has been removed (and deleted from globals.hpp), but is still accepted

 *               on the command line. A warning is printed to let the user know that option might not

 *               be accepted in the future.

 *

 *               Add an obsolete warning for an option by adding an entry in the "special_jvm_flags"

 *               table and setting the "obsolete_in" field.

 *

 *      EXPIRED: A deprecated or obsolete option that has an "accept_until" version less than or equal

 *               to the current JDK version. The system will flatly refuse to admit the existence of

 *               the flag. This allows a flag to die automatically over JDK releases.

 *

 *               Note that manual cleanup of expired options should be done at major JDK version upgrades:

 *                  - Newly expired options should be removed from the special_jvm_flags and aliased_jvm_flags tables.

 *                  - Newly obsolete or expired deprecated options should have their global variable

 *                    definitions removed (from globals.hpp, etc) and related implementations removed.

 *

 * Recommended approach for removing options:

 *

 * To remove options commonly used by customers (e.g. product, commercial -XX options), use

 * the 3-step model adding major release numbers to the deprecate, obsolete and expire columns.

 *

 * To remove internal options (e.g. diagnostic, experimental, develop options), use

 * a 2-step model adding major release numbers to the obsolete and expire columns.

 *

 * To change the name of an option, use the alias table as well as a 2-step

 * model adding major release numbers to the deprecate and expire columns.

 * Think twice about aliasing commonly used customer options.

 *

 * There are times when it is appropriate to leave a future release number as undefined.

 *

 * Tests:  Aliases should be tested in VMAliasOptions.java.

 *         Deprecated options should be tested in VMDeprecatedOptions.java.

 */

// The special_jvm_flags table declares options that are being deprecated and/or obsoleted. The

// "deprecated_in" or "obsolete_in" fields may be set to "undefined", but not both.

// When the JDK version reaches 'deprecated_in' limit, the JVM will process this flag on

// the command-line as usual, but will issue a warning.

// When the JDK version reaches 'obsolete_in' limit, the JVM will continue accepting this flag on

// the command-line, while issuing a warning and ignoring the flag value.

// Once the JDK version reaches 'expired_in' limit, the JVM will flatly refuse to admit the

// existence of the flag.

//

// MANUAL CLEANUP ON JDK VERSION UPDATES: