/*

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

#include "compiler/compilerOracle.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/cardTableRS.hpp"

#include "memory/referenceProcessor.hpp"

#include "memory/universe.inline.hpp"

#include "oops/oop.inline.hpp"

#include "prims/jvmtiExport.hpp"

#include "runtime/arguments.hpp"

#include "runtime/globals_extension.hpp"

#include "runtime/java.hpp"

#include "services/management.hpp"

#include "utilities/defaultStream.hpp"

#include "utilities/taskqueue.hpp"

#ifdef TARGET_OS_FAMILY_linux

# include "os_linux.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_solaris

# include "os_solaris.inline.hpp"

#endif

#ifdef TARGET_OS_FAMILY_windows

# include "os_windows.inline.hpp"

#endif

#ifndef SERIALGC

#include "gc_implementation/concurrentMarkSweep/compactibleFreeListSpace.hpp"

#endif

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

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

#define DEFAULT_JAVA_LAUNCHER  "generic"

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;

bool   Arguments::_has_profile                  = false;

bool   Arguments::_has_alloc_profile            = false;

uintx  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::_created_by_gamma_launcher    = false;

// These parameters are reset in method parse_vm_init_args(JavaVMInitArgs*)

bool   Arguments::_AlwaysCompileLoopMethods     = AlwaysCompileLoopMethods;

bool   Arguments::_UseOnStackReplacement        = UseOnStackReplacement;

bool   Arguments::_BackgroundCompilation        = BackgroundCompilation;

bool   Arguments::_ClipInlining                 = ClipInlining;

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::_java_ext_dirs = NULL;

SystemProperty *Arguments::_java_endorsed_dirs = 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::_sun_boot_class_path = NULL;

char* Arguments::_meta_index_path = NULL;

char* Arguments::_meta_index_dir = NULL;

static bool force_client_mode = false;

// Check if head of 'option' matches 'name', and sets 'tail' remaining part of option string

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

                         const char** tail) {

  int len = (int)strlen(name);

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

    *tail = option->optionString + len;

    return true;

  } else {

    return false;

  }

}

static void logOption(const char* opt) {

  if (PrintVMOptions) {

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

  }

}

// Process java launcher properties.

void Arguments::process_sun_java_launcher_properties(JavaVMInitArgs* args) {

  // See if sun.java.launcher 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.pid=", &tail)) {

      _sun_java_launcher_pid = atoi(tail);

      continue;

    }

  }

}

// Initialize system properties key and value.

void Arguments::init_system_properties() {

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

  // following are JVMTI agent writeable properties.

  // Properties values are set to NULL and they are

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

  _java_ext_dirs = new SystemProperty("java.ext.dirs", NULL,  true);

  _java_endorsed_dirs = new SystemProperty("java.endorsed.dirs", NULL,  true);

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

  _sun_boot_class_path = new SystemProperty("sun.boot.class.path", NULL,  true);

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

  // Add to System Property list.

  PropertyList_add(&_system_properties, _java_ext_dirs);

  PropertyList_add(&_system_properties, _java_endorsed_dirs);

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

  // 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 = "Sun Microsystems Inc.";

  uint32_t spec_version = 0;

  if (JDK_Version::is_gte_jdk17x_version()) {

    spec_vendor = "Oracle Corporation";

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

  }

  jio_snprintf(buffer, bufsz, "1." 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));

}

/**

 * Provide a slightly more user-friendly way of eliminating -XX flags.

 * When a flag is eliminated, it can be added to this list in order to

 * continue accepting this flag on the command-line, while issuing a warning

 * and ignoring the value.  Once the JDK version reaches the 'accept_until'

 * limit, we flatly refuse to admit the existence of the flag.  This allows

 * a flag to die correctly over JDK releases using HSX.

 */

typedef struct {

  const char* name;

  JDK_Version obsoleted_in; // when the flag went away

  JDK_Version accept_until; // which version to start denying the existence

} ObsoleteFlag;

static ObsoleteFlag obsolete_jvm_flags[] = {

  { "UseTrainGC",                    JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "UseSpecialLargeObjectHandling", JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "UseOversizedCarHandling",       JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "TraceCarAllocation",            JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "PrintTrainGCProcessingStats",   JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "LogOfCarSpaceSize",             JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "OversizedCarThreshold",         JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "MinTickInterval",               JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "DefaultTickInterval",           JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "MaxTickInterval",               JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "DelayTickAdjustment",           JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "ProcessingToTenuringRatio",     JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "MinTrainLength",                JDK_Version::jdk(5), JDK_Version::jdk(7) },

  { "AppendRatio",         JDK_Version::jdk_update(6,10), JDK_Version::jdk(7) },

  { "DefaultMaxRAM",       JDK_Version::jdk_update(6,18), JDK_Version::jdk(7) },

  { "DefaultInitialRAMFraction",

                           JDK_Version::jdk_update(6,18), JDK_Version::jdk(7) },

  { "UseDepthFirstScavengeOrder",

                           JDK_Version::jdk_update(6,22), JDK_Version::jdk(7) },

  { "HandlePromotionFailure",

                           JDK_Version::jdk_update(6,24), JDK_Version::jdk(8) },

  { "MaxLiveObjectEvacuationRatio",

                           JDK_Version::jdk_update(6,24), JDK_Version::jdk(8) },

  { "ForceSharedSpaces",   JDK_Version::jdk_update(6,25), JDK_Version::jdk(8) },

  { "UseParallelOldGCCompacting",

                           JDK_Version::jdk_update(6,27), JDK_Version::jdk(8) },

  { "UseParallelDensePrefixUpdate",

                           JDK_Version::jdk_update(6,27), JDK_Version::jdk(8) },

  { "UseParallelOldGCDensePrefix",

                           JDK_Version::jdk_update(6,27), JDK_Version::jdk(8) },

  { "AllowTransitionalJSR292",       JDK_Version::jdk(7), JDK_Version::jdk(8) },

  { "UseCompressedStrings",          JDK_Version::jdk(7), JDK_Version::jdk(8) },

#ifdef PRODUCT

  { "DesiredMethodLimit",

                           JDK_Version::jdk_update(7, 2), JDK_Version::jdk(8) },

#endif // PRODUCT

  { NULL, JDK_Version(0), JDK_Version(0) }

};

// Returns true if the flag is obsolete and fits into the range specified

// for being ignored.  In the case that the flag is ignored, the 'version'

// value is filled in with the version number when the flag became

// obsolete so that that value can be displayed to the user.

bool Arguments::is_newly_obsolete(const char *s, JDK_Version* version) {

  int i = 0;

  assert(version != NULL, "Must provide a version buffer");

  while (obsolete_jvm_flags[i].name != NULL) {

    const ObsoleteFlag& flag_status = obsolete_jvm_flags[i];

    // <flag>=xxx form

    // [-|+]<flag> form

    if ((strncmp(flag_status.name, s, strlen(flag_status.name)) == 0) ||

        ((s[0] == '+' || s[0] == '-') &&

        (strncmp(flag_status.name, &s[1], strlen(flag_status.name)) == 0))) {

      if (JDK_Version::current().compare(flag_status.accept_until) == -1) {

          *version = flag_status.obsoleted_in;

          return true;

      }

    }

    i++;

  }

  return false;

}

// Constructs the system class path (aka boot class path) from the following

// components, in order:

//

//     prefix           // from -Xbootclasspath/p:...

//     endorsed         // the expansion of -Djava.endorsed.dirs=...

//     base             // from os::get_system_properties() or -Xbootclasspath=

//     suffix           // from -Xbootclasspath/a:...

//

// java.endorsed.dirs is a list of directories; any jar or zip files in the

// directories are added to the sysclasspath just before the base.

//

// This could be AllStatic, but it isn't needed after argument processing is

// complete.

class SysClassPath: public StackObj {

public:

  SysClassPath(const char* base);

  ~SysClassPath();

  inline void set_base(const char* base);

  inline void add_prefix(const char* prefix);

  inline void add_suffix_to_prefix(const char* suffix);

  inline void add_suffix(const char* suffix);

  inline void reset_path(const char* base);

  // Expand the jar/zip files in each directory listed by the java.endorsed.dirs

  // property.  Must be called after all command-line arguments have been

  // processed (in particular, -Djava.endorsed.dirs=...) and before calling

  // combined_path().

  void expand_endorsed();

  inline const char* get_base()     const { return _items[_scp_base]; }

  inline const char* get_prefix()   const { return _items[_scp_prefix]; }

  inline const char* get_suffix()   const { return _items[_scp_suffix]; }

  inline const char* get_endorsed() const { return _items[_scp_endorsed]; }

  // Combine all the components into a single c-heap-allocated string; caller

  // must free the string if/when no longer needed.

  char* combined_path();

private:

  // Utility routines.

  static char* add_to_path(const char* path, const char* str, bool prepend);

  static char* add_jars_to_path(char* path, const char* directory);

  inline void reset_item_at(int index);

  // Array indices for the items that make up the sysclasspath.  All except the

  // base are allocated in the C heap and freed by this class.

  enum {

    _scp_prefix,        // from -Xbootclasspath/p:...

    _scp_endorsed,      // the expansion of -Djava.endorsed.dirs=...

    _scp_base,          // the default sysclasspath

    _scp_suffix,        // from -Xbootclasspath/a:...

    _scp_nitems         // the number of items, must be last.

  };

  const char* _items[_scp_nitems];

  DEBUG_ONLY(bool _expansion_done;)

};

SysClassPath::SysClassPath(const char* base) {

  memset(_items, 0, sizeof(_items));

  _items[_scp_base] = base;

  DEBUG_ONLY(_expansion_done = false;)

}

SysClassPath::~SysClassPath() {

  // Free everything except the base.

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

    if (i != _scp_base) reset_item_at(i);

  }

  DEBUG_ONLY(_expansion_done = false;)

}

inline void SysClassPath::set_base(const char* base) {

  _items[_scp_base] = base;

}

inline void SysClassPath::add_prefix(const char* prefix) {

  _items[_scp_prefix] = add_to_path(_items[_scp_prefix], prefix, true);

}

inline void SysClassPath::add_suffix_to_prefix(const char* suffix) {

  _items[_scp_prefix] = add_to_path(_items[_scp_prefix], suffix, false);

}

inline void SysClassPath::add_suffix(const char* suffix) {

  _items[_scp_suffix] = add_to_path(_items[_scp_suffix], suffix, false);

}

inline void SysClassPath::reset_item_at(int index) {

  assert(index < _scp_nitems && index != _scp_base, "just checking");

  if (_items[index] != NULL) {

    FREE_C_HEAP_ARRAY(char, _items[index]);

    _items[index] = NULL;

  }

}

inline void SysClassPath::reset_path(const char* base) {

  // Clear the prefix and suffix.

  reset_item_at(_scp_prefix);

  reset_item_at(_scp_suffix);

  set_base(base);

}

//------------------------------------------------------------------------------

void SysClassPath::expand_endorsed() {

  assert(_items[_scp_endorsed] == NULL, "can only be called once.");

  const char* path = Arguments::get_property("java.endorsed.dirs");

  if (path == NULL) {

    path = Arguments::get_endorsed_dir();

    assert(path != NULL, "no default for java.endorsed.dirs");

  }

  char* expanded_path = NULL;

  const char separator = *os::path_separator();

  const char* const end = path + strlen(path);

  while (path < end) {

    const char* tmp_end = strchr(path, separator);

    if (tmp_end == NULL) {

      expanded_path = add_jars_to_path(expanded_path, path);

      path = end;

    } else {

      char* dirpath = NEW_C_HEAP_ARRAY(char, tmp_end - path + 1);

      memcpy(dirpath, path, tmp_end - path);

      dirpath[tmp_end - path] = '\0';

      expanded_path = add_jars_to_path(expanded_path, dirpath);

      FREE_C_HEAP_ARRAY(char, dirpath);

      path = tmp_end + 1;

    }

  }

  _items[_scp_endorsed] = expanded_path;

  DEBUG_ONLY(_expansion_done = true;)

}

// Combine the bootclasspath elements, some of which may be null, into a single

// c-heap-allocated string.

char* SysClassPath::combined_path() {

  assert(_items[_scp_base] != NULL, "empty default sysclasspath");

  assert(_expansion_done, "must call expand_endorsed() first.");

  size_t lengths[_scp_nitems];

  size_t total_len = 0;

  const char separator = *os::path_separator();

  // Get the lengths.

  int i;

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

    if (_items[i] != NULL) {

      lengths[i] = strlen(_items[i]);

      // Include space for the separator char (or a NULL for the last item).

      total_len += lengths[i] + 1;

    }

  }

  assert(total_len > 0, "empty sysclasspath not allowed");

  // Copy the _items to a single string.

  char* cp = NEW_C_HEAP_ARRAY(char, total_len);

  char* cp_tmp = cp;

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

    if (_items[i] != NULL) {

      memcpy(cp_tmp, _items[i], lengths[i]);

      cp_tmp += lengths[i];

      *cp_tmp++ = separator;

    }

  }

  *--cp_tmp = '\0';     // Replace the extra separator.

  return cp;

}

// Note:  path must be c-heap-allocated (or NULL); it is freed if non-null.

char*

SysClassPath::add_to_path(const char* path, const char* str, bool prepend) {

  char *cp;

  assert(str != NULL, "just checking");

  if (path == NULL) {

    size_t len = strlen(str) + 1;

    cp = NEW_C_HEAP_ARRAY(char, len);

    memcpy(cp, str, len);                       // copy the trailing null

  } else {

    const char separator = *os::path_separator();

    size_t old_len = strlen(path);

    size_t str_len = strlen(str);

    size_t len = old_len + str_len + 2;

    if (prepend) {

      cp = NEW_C_HEAP_ARRAY(char, len);

      char* cp_tmp = cp;

      memcpy(cp_tmp, str, str_len);

      cp_tmp += str_len;

      *cp_tmp = separator;

      memcpy(++cp_tmp, path, old_len + 1);      // copy the trailing null

      FREE_C_HEAP_ARRAY(char, path);

    } else {

      cp = REALLOC_C_HEAP_ARRAY(char, path, len);

      char* cp_tmp = cp + old_len;

      *cp_tmp = separator;

      memcpy(++cp_tmp, str, str_len + 1);       // copy the trailing null

    }

  }

  return cp;

}

// Scan the directory and append any jar or zip files found to path.

// Note:  path must be c-heap-allocated (or NULL); it is freed if non-null.

char* SysClassPath::add_jars_to_path(char* path, const char* directory) {

  DIR* dir = os::opendir(directory);

  if (dir == NULL) return path;

  char dir_sep[2] = { '\0', '\0' };

  size_t directory_len = strlen(directory);

  const char fileSep = *os::file_separator();

  if (directory[directory_len - 1] != fileSep) dir_sep[0] = fileSep;

  /* Scan the directory for jars/zips, appending them to path. */

  struct dirent *entry;

  char *dbuf = NEW_C_HEAP_ARRAY(char, os::readdir_buf_size(directory));

  while ((entry = os::readdir(dir, (dirent *) dbuf)) != NULL) {

    const char* name = entry->d_name;

    const char* ext = name + strlen(name) - 4;

    bool isJarOrZip = ext > name &&

      (os::file_name_strcmp(ext, ".jar") == 0 ||

       os::file_name_strcmp(ext, ".zip") == 0);

    if (isJarOrZip) {

      char* jarpath = NEW_C_HEAP_ARRAY(char, directory_len + 2 + strlen(name));

      sprintf(jarpath, "%s%s%s", directory, dir_sep, name);

      path = add_to_path(path, jarpath, false);

      FREE_C_HEAP_ARRAY(char, jarpath);

    }

  }

  FREE_C_HEAP_ARRAY(char, dbuf);

  os::closedir(dir);

  return path;

}

// Parses a memory size specification string.

static bool atomull(const char *s, julong* result) {