/*

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

#include "classfile/systemDictionary.hpp"

#include "classfile/vmSymbols.hpp"

#include "compiler/compileBroker.hpp"

#include "gc_interface/collectedHeap.inline.hpp"

#include "interpreter/bytecodeStream.hpp"

#include "interpreter/oopMapCache.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/generation.hpp"

#include "memory/oopFactory.hpp"

#include "memory/universe.inline.hpp"

#include "oops/constantPoolKlass.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/threadCritical.hpp"

#include "runtime/timer.hpp"

#include "services/management.hpp"

#include "services/threadService.hpp"

#include "utilities/events.hpp"

#include "utilities/hashtable.hpp"

#include "utilities/hashtable.inline.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

// Entry points in zip.dll for loading zip/jar 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);

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;

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

PackageHashtable* ClassLoader::_package_hash_table = NULL;

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

}

MetaIndex::MetaIndex(char** meta_package_names, int num_meta_package_names) {

  if (num_meta_package_names == 0) {

    _meta_package_names = NULL;

    _num_meta_package_names = 0;

  } else {

    _meta_package_names = NEW_C_HEAP_ARRAY(char*, num_meta_package_names);

    _num_meta_package_names = num_meta_package_names;

    memcpy(_meta_package_names, meta_package_names, num_meta_package_names * sizeof(char*));

  }

}

MetaIndex::~MetaIndex() {

  FREE_C_HEAP_ARRAY(char*, _meta_package_names);

}

bool MetaIndex::may_contain(const char* class_name) {

  if ( _num_meta_package_names == 0) {

    return false;

  }

  size_t class_name_len = strlen(class_name);

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

    char* pkg = _meta_package_names[i];

    size_t pkg_len = strlen(pkg);

    size_t min_len = MIN2(class_name_len, pkg_len);

    if (!strncmp(class_name, pkg, min_len)) {

      return true;

    }

  }

  return false;

}

ClassPathEntry::ClassPathEntry() {

  set_next(NULL);

}

bool ClassPathEntry::is_lazy() {

  return false;

}

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

  _dir = NEW_C_HEAP_ARRAY(char, strlen(dir)+1);

  strcpy(_dir, dir);

}

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

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

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

  _zip_name = NEW_C_HEAP_ARRAY(char, strlen(zip_name)+1);

  strcpy(_zip_name, zip_name);

}

ClassPathZipEntry::~ClassPathZipEntry() {

  if (ZipClose != NULL) {

    (*ZipClose)(_zip);

  }

  FREE_C_HEAP_ARRAY(char, _zip_name);

}

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

  // enable call to C land

  JavaThread* thread = JavaThread::current();

  ThreadToNativeFromVM ttn(thread);

  // check whether zip archive contains name

  jint filesize, 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 class in mmaped jar file.

  if (ReadMappedEntry == NULL ||

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

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

      // read contents into resource array

      buffer     = NEW_RESOURCE_ARRAY(u1, filesize);

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

  }

  if (UsePerfData) {

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

  }

  // return result

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

  }

}

LazyClassPathEntry::LazyClassPathEntry(char* path, struct stat st) : ClassPathEntry() {

  _path = strdup(path);

  _st = st;

  _meta_index = NULL;

  _resolved_entry = NULL;

}

bool LazyClassPathEntry::is_jar_file() {

  return ((_st.st_mode & S_IFREG) == S_IFREG);

}

ClassPathEntry* LazyClassPathEntry::resolve_entry() {

  if (_resolved_entry != NULL) {

    return (ClassPathEntry*) _resolved_entry;

  }

  ClassPathEntry* new_entry = NULL;

  ClassLoader::create_class_path_entry(_path, _st, &new_entry, false);

  assert(new_entry != NULL, "earlier code should have caught this");

  {

    ThreadCritical tc;

    if (_resolved_entry == NULL) {

      _resolved_entry = new_entry;

      return new_entry;

    }

  }

  assert(_resolved_entry != NULL, "bug in MT-safe resolution logic");

  delete new_entry;

  return (ClassPathEntry*) _resolved_entry;

}

ClassFileStream* LazyClassPathEntry::open_stream(const char* name) {

  if (_meta_index != NULL &&

      !_meta_index->may_contain(name)) {

    return NULL;

  }

  return resolve_entry()->open_stream(name);

}

bool LazyClassPathEntry::is_lazy() {

  return true;

}

static void print_meta_index(LazyClassPathEntry* entry,

                             GrowableArray<char*>& meta_packages) {

  tty->print("[Meta index for %s=", entry->name());

  for (int i = 0; i < meta_packages.length(); i++) {

    if (i > 0) tty->print(" ");

    tty->print(meta_packages.at(i));

  }

  tty->print_cr("]");

}

void ClassLoader::setup_meta_index() {

  // Set up meta index which allows us to open boot jars lazily if

  // class data sharing is enabled

  const char* known_version = "% VERSION 2";

  char* meta_index_path = Arguments::get_meta_index_path();

  char* meta_index_dir  = Arguments::get_meta_index_dir();

  FILE* file = fopen(meta_index_path, "r");

  int line_no = 0;

  if (file != NULL) {

    ResourceMark rm;

    LazyClassPathEntry* cur_entry = NULL;

    GrowableArray<char*> boot_class_path_packages(10);

    char package_name[256];

    bool skipCurrentJar = false;

    while (fgets(package_name, sizeof(package_name), file) != NULL) {

      ++line_no;

      // Remove trailing newline

      package_name[strlen(package_name) - 1] = '\0';

      switch(package_name[0]) {

        case '%':

        {

          if ((line_no == 1) && (strcmp(package_name, known_version) != 0)) {

            if (TraceClassLoading && Verbose) {

              tty->print("[Unsupported meta index version]");

            }

            fclose(file);

            return;

          }

        }

        // These directives indicate jar files which contain only

        // classes, only non-classfile resources, or a combination of

        // the two. See src/share/classes/sun/misc/MetaIndex.java and

        // make/tools/MetaIndex/BuildMetaIndex.java in the J2SE

        // workspace.

        case '#':

        case '!':

        case '@':

        {

          // Hand off current packages to current lazy entry (if any)

          if ((cur_entry != NULL) &&

              (boot_class_path_packages.length() > 0)) {

            if (TraceClassLoading && Verbose) {

              print_meta_index(cur_entry, boot_class_path_packages);

            }

            MetaIndex* index = new MetaIndex(boot_class_path_packages.adr_at(0),

                                             boot_class_path_packages.length());

            cur_entry->set_meta_index(index);

          }

          cur_entry = NULL;

          boot_class_path_packages.clear();

          // Find lazy entry corresponding to this jar file

          for (ClassPathEntry* entry = _first_entry; entry != NULL; entry = entry->next()) {

            if (entry->is_lazy() &&

                string_starts_with(entry->name(), meta_index_dir) &&

                string_ends_with(entry->name(), &package_name[2])) {

              cur_entry = (LazyClassPathEntry*) entry;

              break;

            }

          }

          // If the first character is '@', it indicates the following jar

          // file is a resource only jar file in which case, we should skip

          // reading the subsequent entries since the resource loading is

          // totally handled by J2SE side.

          if (package_name[0] == '@') {

            if (cur_entry != NULL) {

              cur_entry->set_meta_index(new MetaIndex(NULL, 0));

            }

            cur_entry = NULL;

            skipCurrentJar = true;

          } else {

            skipCurrentJar = false;

          }

          break;

        }

        default:

        {

          if (!skipCurrentJar && cur_entry != NULL) {

            char* new_name = strdup(package_name);

            boot_class_path_packages.append(new_name);

          }

        }

      }

    }

    // Hand off current packages to current lazy entry (if any)

    if ((cur_entry != NULL) &&

        (boot_class_path_packages.length() > 0)) {

      if (TraceClassLoading && Verbose) {

        print_meta_index(cur_entry, boot_class_path_packages);

      }

      MetaIndex* index = new MetaIndex(boot_class_path_packages.adr_at(0),

                                       boot_class_path_packages.length());

      cur_entry->set_meta_index(index);

    }

    fclose(file);

  }

}

void ClassLoader::setup_bootstrap_search_path() {

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

  char* sys_class_path = os::strdup(Arguments::get_sysclasspath());

  if (TraceClassLoading && Verbose) {

    tty->print_cr("[Bootstrap loader class path=%s]", sys_class_path);

  }

  int len = (int)strlen(sys_class_path);

  int end = 0;

  // Iterate over class path entries

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

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

      end++;

    }

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

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

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

    update_class_path_entry_list(path, false);

    FREE_C_HEAP_ARRAY(char, path);

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

      end++;

    }

  }

}

void ClassLoader::create_class_path_entry(char *path, struct stat st, ClassPathEntry **new_entry, bool lazy) {

  JavaThread* thread = JavaThread::current();

  if (lazy) {

    *new_entry = new LazyClassPathEntry(path, st);

    return;

  }

  if ((st.st_mode & S_IFREG) == S_IFREG) {

    // Regular file, should be a zip file

    // Canonicalized filename

    char canonical_path[JVM_MAXPATHLEN];

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

      // This matches the classic VM

      EXCEPTION_MARK;

      THROW_MSG(vmSymbols::java_io_IOException(), "Bad pathname");

    }

    char* error_msg = NULL;

    jzfile* zip;

    {

      // enable call to C land

      ThreadToNativeFromVM ttn(thread);

      HandleMark hm(thread);

      zip = (*ZipOpen)(canonical_path, &error_msg);

    }

    if (zip != NULL && error_msg == NULL) {

      *new_entry = new ClassPathZipEntry(zip, path);

      if (TraceClassLoading) {

        tty->print_cr("[Opened %s]", path);

      }

    } else {

      ResourceMark rm(thread);

      char *msg;

      if (error_msg == NULL) {

        msg = NEW_RESOURCE_ARRAY(char, strlen(path) + 128); ;

        jio_snprintf(msg, strlen(path) + 127, "error in opening JAR file %s", path);

      } else {

        int len = (int)(strlen(path) + strlen(error_msg) + 128);

        msg = NEW_RESOURCE_ARRAY(char, len); ;

        jio_snprintf(msg, len - 1, "error in opening JAR file <%s> %s", error_msg, path);

      }

      EXCEPTION_MARK;

      THROW_MSG(vmSymbols::java_lang_ClassNotFoundException(), msg);

    }

  } else {

    // Directory

    *new_entry = new ClassPathDirEntry(path);

    if (TraceClassLoading) {

      tty->print_cr("[Path %s]", path);

    }

  }

}

// Create a class path zip entry for a given path (return NULL if not found

// or zip/JAR file cannot be opened)

ClassPathZipEntry* ClassLoader::create_class_path_zip_entry(const char *path) {

  // check for a regular file

  struct stat st;

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