/*

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

#include "classfile/classFileStream.hpp"

#include "classfile/classLoader.hpp"

#include "classfile/classLoaderData.inline.hpp"

#include "classfile/classLoaderExt.hpp"

#include "classfile/imageFile.hpp"

#include "classfile/javaClasses.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "compiler/compileBroker.hpp"

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

#include "gc/shared/generation.hpp"

#include "interpreter/bytecodeStream.hpp"

#include "interpreter/oopMapCache.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/filemap.hpp"

#include "memory/oopFactory.hpp"

#include "memory/universe.inline.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/instanceRefKlass.hpp"

#include "oops/oop.inline.hpp"

#include "oops/symbol.hpp"

#include "prims/jvm_misc.hpp"

#include "runtime/arguments.hpp"

#include "runtime/compilationPolicy.hpp"

#include "runtime/fprofiler.hpp"

#include "runtime/handles.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/init.hpp"

#include "runtime/interfaceSupport.hpp"

#include "runtime/java.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/os.hpp"

#include "runtime/threadCritical.hpp"

#include "runtime/timer.hpp"

#include "services/management.hpp"

#include "services/threadService.hpp"

#include "utilities/events.hpp"

#include "utilities/hashtable.inline.hpp"

#include "utilities/macros.hpp"

#if INCLUDE_CDS

#include "classfile/sharedClassUtil.hpp"

#include "classfile/sharedPathsMiscInfo.hpp"

#endif

// Entry points in zip.dll for loading zip/jar file entries and image file entries

typedef void * * (JNICALL *ZipOpen_t)(const char *name, char **pmsg);

typedef void (JNICALL *ZipClose_t)(jzfile *zip);

typedef jzentry* (JNICALL *FindEntry_t)(jzfile *zip, const char *name, jint *sizeP, jint *nameLen);

typedef jboolean (JNICALL *ReadEntry_t)(jzfile *zip, jzentry *entry, unsigned char *buf, char *namebuf);

typedef jboolean (JNICALL *ReadMappedEntry_t)(jzfile *zip, jzentry *entry, unsigned char **buf, char *namebuf);

typedef jzentry* (JNICALL *GetNextEntry_t)(jzfile *zip, jint n);

typedef jboolean (JNICALL *ZipInflateFully_t)(void *inBuf, jlong inLen, void *outBuf, jlong outLen, char **pmsg);

typedef jint     (JNICALL *Crc32_t)(jint crc, const jbyte *buf, jint len);

static ZipOpen_t         ZipOpen            = NULL;

static ZipClose_t        ZipClose           = NULL;

static FindEntry_t       FindEntry          = NULL;

static ReadEntry_t       ReadEntry          = NULL;

static ReadMappedEntry_t ReadMappedEntry    = NULL;

static GetNextEntry_t    GetNextEntry       = NULL;

static canonicalize_fn_t CanonicalizeEntry  = NULL;

static ZipInflateFully_t ZipInflateFully    = NULL;

static Crc32_t           Crc32              = NULL;

// Globals

PerfCounter*    ClassLoader::_perf_accumulated_time = NULL;

PerfCounter*    ClassLoader::_perf_classes_inited = NULL;

PerfCounter*    ClassLoader::_perf_class_init_time = NULL;

PerfCounter*    ClassLoader::_perf_class_init_selftime = NULL;

PerfCounter*    ClassLoader::_perf_classes_verified = NULL;

PerfCounter*    ClassLoader::_perf_class_verify_time = NULL;

PerfCounter*    ClassLoader::_perf_class_verify_selftime = NULL;

PerfCounter*    ClassLoader::_perf_classes_linked = NULL;

PerfCounter*    ClassLoader::_perf_class_link_time = NULL;

PerfCounter*    ClassLoader::_perf_class_link_selftime = NULL;

PerfCounter*    ClassLoader::_perf_class_parse_time = NULL;

PerfCounter*    ClassLoader::_perf_class_parse_selftime = NULL;

PerfCounter*    ClassLoader::_perf_sys_class_lookup_time = NULL;

PerfCounter*    ClassLoader::_perf_shared_classload_time = NULL;

PerfCounter*    ClassLoader::_perf_sys_classload_time = NULL;

PerfCounter*    ClassLoader::_perf_app_classload_time = NULL;

PerfCounter*    ClassLoader::_perf_app_classload_selftime = NULL;

PerfCounter*    ClassLoader::_perf_app_classload_count = NULL;

PerfCounter*    ClassLoader::_perf_define_appclasses = NULL;

PerfCounter*    ClassLoader::_perf_define_appclass_time = NULL;

PerfCounter*    ClassLoader::_perf_define_appclass_selftime = NULL;

PerfCounter*    ClassLoader::_perf_app_classfile_bytes_read = NULL;

PerfCounter*    ClassLoader::_perf_sys_classfile_bytes_read = NULL;

PerfCounter*    ClassLoader::_sync_systemLoaderLockContentionRate = NULL;

PerfCounter*    ClassLoader::_sync_nonSystemLoaderLockContentionRate = NULL;

PerfCounter*    ClassLoader::_sync_JVMFindLoadedClassLockFreeCounter = NULL;

PerfCounter*    ClassLoader::_sync_JVMDefineClassLockFreeCounter = NULL;

PerfCounter*    ClassLoader::_sync_JNIDefineClassLockFreeCounter = NULL;

PerfCounter*    ClassLoader::_unsafe_defineClassCallCounter = NULL;

PerfCounter*    ClassLoader::_isUnsyncloadClass = NULL;

PerfCounter*    ClassLoader::_load_instance_class_failCounter = NULL;

ClassPathEntry* ClassLoader::_first_entry         = NULL;

ClassPathEntry* ClassLoader::_last_entry          = NULL;

int             ClassLoader::_num_entries         = 0;

PackageHashtable* ClassLoader::_package_hash_table = NULL;

#if INCLUDE_CDS

SharedPathsMiscInfo* ClassLoader::_shared_paths_misc_info = NULL;

#endif

// helper routines

bool string_starts_with(const char* str, const char* str_to_find) {

  size_t str_len = strlen(str);

  size_t str_to_find_len = strlen(str_to_find);

  if (str_to_find_len > str_len) {

    return false;

  }

  return (strncmp(str, str_to_find, str_to_find_len) == 0);

}

bool string_ends_with(const char* str, const char* str_to_find) {

  size_t str_len = strlen(str);

  size_t str_to_find_len = strlen(str_to_find);

  if (str_to_find_len > str_len) {

    return false;

  }

  return (strncmp(str + (str_len - str_to_find_len), str_to_find, str_to_find_len) == 0);

}

ClassPathEntry::ClassPathEntry() {

  set_next(NULL);

}

ClassPathDirEntry::ClassPathDirEntry(const char* dir) : ClassPathEntry() {

  char* copy = NEW_C_HEAP_ARRAY(char, strlen(dir)+1, mtClass);

  strcpy(copy, dir);

  _dir = copy;

}

ClassFileStream* ClassPathDirEntry::open_stream(const char* name, TRAPS) {

  // construct full path name

  char path[JVM_MAXPATHLEN];

  if (jio_snprintf(path, sizeof(path), "%s%s%s", _dir, os::file_separator(), name) == -1) {

    return NULL;

  }

  // check if file exists

  struct stat st;

  if (os::stat(path, &st) == 0) {

#if INCLUDE_CDS

    if (DumpSharedSpaces) {

      // We have already check in ClassLoader::check_shared_classpath() that the directory is empty, so

      // we should never find a file underneath it -- unless user has added a new file while we are running

      // the dump, in which case let's quit!

      ShouldNotReachHere();

    }

#endif

    // found file, open it

    int file_handle = os::open(path, 0, 0);

    if (file_handle != -1) {

      // read contents into resource array

      u1* buffer = NEW_RESOURCE_ARRAY(u1, st.st_size);

      size_t num_read = os::read(file_handle, (char*) buffer, st.st_size);

      // close file

      os::close(file_handle);

      // construct ClassFileStream

      if (num_read == (size_t)st.st_size) {

        if (UsePerfData) {

          ClassLoader::perf_sys_classfile_bytes_read()->inc(num_read);

        }

        return new ClassFileStream(buffer, st.st_size, _dir);    // Resource allocated

      }

    }

  }

  return NULL;

}

ClassPathZipEntry::ClassPathZipEntry(jzfile* zip, const char* zip_name) : ClassPathEntry() {

  _zip = zip;

  char *copy = NEW_C_HEAP_ARRAY(char, strlen(zip_name)+1, mtClass);

  strcpy(copy, zip_name);

  _zip_name = copy;

}

ClassPathZipEntry::~ClassPathZipEntry() {

  if (ZipClose != NULL) {

    (*ZipClose)(_zip);

  }

  FREE_C_HEAP_ARRAY(char, _zip_name);

}

u1* ClassPathZipEntry::open_entry(const char* name, jint* filesize, bool nul_terminate, TRAPS) {

    // enable call to C land

  JavaThread* thread = JavaThread::current();

  ThreadToNativeFromVM ttn(thread);

  // check whether zip archive contains name

  jint name_len;

  jzentry* entry = (*FindEntry)(_zip, name, filesize, &name_len);

  if (entry == NULL) return NULL;

  u1* buffer;

  char name_buf[128];

  char* filename;

  if (name_len < 128) {

    filename = name_buf;

  } else {

    filename = NEW_RESOURCE_ARRAY(char, name_len + 1);

  }

  // file found, get pointer to the entry in mmapped jar file.

  if (ReadMappedEntry == NULL ||

      !(*ReadMappedEntry)(_zip, entry, &buffer, filename)) {

      // mmapped access not available, perhaps due to compression,

      // read contents into resource array

      int size = (*filesize) + ((nul_terminate) ? 1 : 0);

      buffer = NEW_RESOURCE_ARRAY(u1, size);

      if (!(*ReadEntry)(_zip, entry, buffer, filename)) return NULL;

  }

  // return result

  if (nul_terminate) {

    buffer[*filesize] = 0;

  }

  return buffer;

}

ClassFileStream* ClassPathZipEntry::open_stream(const char* name, TRAPS) {

  jint filesize;

  u1* buffer = open_entry(name, &filesize, false, CHECK_NULL);

  if (buffer == NULL) {

    return NULL;

  }

  if (UsePerfData) {

    ClassLoader::perf_sys_classfile_bytes_read()->inc(filesize);

  }

  return new ClassFileStream(buffer, filesize, _zip_name); // Resource allocated

}

// invoke function for each entry in the zip file

void ClassPathZipEntry::contents_do(void f(const char* name, void* context), void* context) {

  JavaThread* thread = JavaThread::current();

  HandleMark  handle_mark(thread);

  ThreadToNativeFromVM ttn(thread);

  for (int n = 0; ; n++) {

    jzentry * ze = ((*GetNextEntry)(_zip, n));

    if (ze == NULL) break;

    (*f)(ze->name, context);

  }

}

ClassPathImageEntry::ClassPathImageEntry(ImageFileReader* image) :

  ClassPathEntry(),

  _image(image),

  _module_data(NULL) {

  guarantee(image != NULL, "image file is null");

  char module_data_name[JVM_MAXPATHLEN];

  ImageModuleData::module_data_name(module_data_name, _image->name());

  _module_data = new ImageModuleData(_image, module_data_name);

}

ClassPathImageEntry::~ClassPathImageEntry() {

  if (_module_data != NULL) {

    delete _module_data;

    _module_data = NULL;

  }

  if (_image != NULL) {

    ImageFileReader::close(_image);

    _image = NULL;

  }

}

const char* ClassPathImageEntry::name() {

  return _image ? _image->name() : "";

}

ClassFileStream* ClassPathImageEntry::open_stream(const char* name, TRAPS) {

  ImageLocation location;

  bool found = _image->find_location(name, location);

  if (!found) {

    const char *pslash = strrchr(name, '/');

    int len = pslash - name;

    // NOTE: IMAGE_MAX_PATH is used here since this path is internal to the jimage

    // (effectively unlimited.)  There are several JCK tests that use paths over

    // 1024 characters long, the limit on Windows systems.

    if (pslash && 0 < len && len < IMAGE_MAX_PATH) {

      char path[IMAGE_MAX_PATH];

      strncpy(path, name, len);

      path[len] = '\0';

      const char* moduleName = _module_data->package_to_module(path);

      if (moduleName != NULL && (len + strlen(moduleName) + 2) < IMAGE_MAX_PATH) {

        jio_snprintf(path, IMAGE_MAX_PATH - 1, "/%s/%s", moduleName, name);

        location.clear_data();

        found = _image->find_location(path, location);

      }

    }

  }

  if (found) {

    u8 size = location.get_attribute(ImageLocation::ATTRIBUTE_UNCOMPRESSED);

    if (UsePerfData) {

      ClassLoader::perf_sys_classfile_bytes_read()->inc(size);

    }

    u1* data = NEW_RESOURCE_ARRAY(u1, size);

    _image->get_resource(location, data);

    return new ClassFileStream(data, (int)size, _image->name());  // Resource allocated

  }

  return NULL;

}

#ifndef PRODUCT

void ClassPathImageEntry::compile_the_world(Handle loader, TRAPS) {

  tty->print_cr("CompileTheWorld : Compiling all classes in %s", name());

  tty->cr();

  const ImageStrings strings = _image->get_strings();

  // Retrieve each path component string.

  u4 length = _image->table_length();

  for (u4 i = 0; i < length; i++) {

    u1* location_data = _image->get_location_data(i);

    if (location_data != NULL) {

       ImageLocation location(location_data);

       char path[IMAGE_MAX_PATH];

       _image->location_path(location, path, IMAGE_MAX_PATH);

       ClassLoader::compile_the_world_in(path, loader, CHECK);

    }

  }

  if (HAS_PENDING_EXCEPTION) {

  if (PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())) {

    CLEAR_PENDING_EXCEPTION;

    tty->print_cr("\nCompileTheWorld : Ran out of memory\n");

    tty->print_cr("Increase class metadata storage if a limit was set");

  } else {

    tty->print_cr("\nCompileTheWorld : Unexpected exception occurred\n");

  }

  }

}

bool ClassPathImageEntry::is_jrt() {

  return string_ends_with(name(), BOOT_IMAGE_NAME);

}

#endif

#if INCLUDE_CDS

void ClassLoader::exit_with_path_failure(const char* error, const char* message) {

  assert(DumpSharedSpaces, "only called at dump time");

  tty->print_cr("Hint: enable -XX:+TraceClassPaths to diagnose the failure");

  vm_exit_during_initialization(error, message);

}

#endif

void ClassLoader::trace_class_path(const char* msg, const char* name) {

  if (!TraceClassPaths) {

    return;

  }

  if (msg) {

    tty->print("%s", msg);

  }

  if (name) {

    if (strlen(name) < 256) {

      tty->print("%s", name);

    } else {

      // For very long paths, we need to print each character separately,

      // as print_cr() has a length limit

      while (name[0] != '\0') {

        tty->print("%c", name[0]);

        name++;

      }

    }

  }

  if (msg && msg[0] == '[') {

    tty->print_cr("]");

  } else {

    tty->cr();

  }

}

#if INCLUDE_CDS

void ClassLoader::check_shared_classpath(const char *path) {

  if (strcmp(path, "") == 0) {

    exit_with_path_failure("Cannot have empty path in archived classpaths", NULL);

  }

  struct stat st;

  if (os::stat(path, &st) == 0) {

    if ((st.st_mode & S_IFREG) != S_IFREG) { // is directory

      if (!os::dir_is_empty(path)) {

        tty->print_cr("Error: non-empty directory '%s'", path);

        exit_with_path_failure("CDS allows only empty directories in archived classpaths", NULL);

      }

    }

  }

}

#endif

void ClassLoader::setup_bootstrap_search_path() {

  assert(_first_entry == NULL, "should not setup bootstrap class search path twice");

  const char* sys_class_path = Arguments::get_sysclasspath();

  if (PrintSharedArchiveAndExit) {

    // Don't print sys_class_path - this is the bootcp of this current VM process, not necessarily

    // the same as the bootcp of the shared archive.

  } else {

    trace_class_path("[Bootstrap loader class path=", sys_class_path);

  }

#if INCLUDE_CDS

  if (DumpSharedSpaces) {

    _shared_paths_misc_info->add_boot_classpath(sys_class_path);

  }

#endif

  setup_search_path(sys_class_path);

}

#if INCLUDE_CDS

int ClassLoader::get_shared_paths_misc_info_size() {

  return _shared_paths_misc_info->get_used_bytes();

}

void* ClassLoader::get_shared_paths_misc_info() {

  return _shared_paths_misc_info->buffer();

}

bool ClassLoader::check_shared_paths_misc_info(void *buf, int size) {

  SharedPathsMiscInfo* checker = SharedClassUtil::allocate_shared_paths_misc_info((char*)buf, size);

  bool result = checker->check();

  delete checker;

  return result;

}

#endif

void ClassLoader::setup_search_path(const char *class_path) {

  int offset = 0;

  int len = (int)strlen(class_path);

  int end = 0;

  // Iterate over class path entries

  for (int start = 0; start < len; start = end) {

    while (class_path[end] && class_path[end] != os::path_separator()[0]) {

      end++;

    }

    EXCEPTION_MARK;

    ResourceMark rm(THREAD);

    char* path = NEW_RESOURCE_ARRAY(char, end - start + 1);

    strncpy(path, &class_path[start], end - start);

    path[end - start] = '\0';

    update_class_path_entry_list(path, false);

#if INCLUDE_CDS

    if (DumpSharedSpaces) {

      check_shared_classpath(path);

    }

#endif

    while (class_path[end] == os::path_separator()[0]) {

      end++;

    }

  }

}

ClassPathEntry* ClassLoader::create_class_path_entry(const char *path, const struct stat* st,

  JavaThread* thread = JavaThread::current();

  ClassPathEntry* new_entry = NULL;

  if ((st->st_mode & S_IFREG) == S_IFREG) {

    // Regular file, should be a zip or image file

    // Canonicalized filename

    char canonical_path[JVM_MAXPATHLEN];

    if (!get_canonical_path(path, canonical_path, JVM_MAXPATHLEN)) {

      // This matches the classic VM

      if (throw_exception) {

        THROW_MSG_(vmSymbols::java_io_IOException(), "Bad pathname", NULL);