/*

 * Copyright (c) 2014, 2019, 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/classFileStream.hpp"

#include "classfile/classListParser.hpp"

#include "classfile/classLoader.hpp"

#include "classfile/classLoaderData.inline.hpp"

#include "classfile/classLoaderDataGraph.hpp"

#include "classfile/classLoaderExt.hpp"

#include "classfile/dictionary.hpp"

#include "classfile/javaClasses.hpp"

#include "classfile/symbolTable.hpp"

#include "classfile/systemDictionary.hpp"

#include "classfile/systemDictionaryShared.hpp"

#include "classfile/verificationType.hpp"

#include "classfile/vmSymbols.hpp"

#include "logging/log.hpp"

#include "memory/allocation.hpp"

#include "memory/filemap.hpp"

#include "memory/metadataFactory.hpp"

#include "memory/metaspaceClosure.hpp"

#include "memory/oopFactory.hpp"

#include "memory/resourceArea.hpp"

#include "memory/universe.hpp"

#include "memory/dynamicArchive.hpp"

#include "oops/instanceKlass.hpp"

#include "oops/klass.inline.hpp"

#include "oops/objArrayOop.inline.hpp"

#include "oops/oop.inline.hpp"

#include "oops/typeArrayOop.inline.hpp"

#include "runtime/handles.inline.hpp"

#include "runtime/java.hpp"

#include "runtime/javaCalls.hpp"

#include "runtime/mutexLocker.hpp"

#include "utilities/hashtable.inline.hpp"

#include "utilities/resourceHash.hpp"

#include "utilities/stringUtils.hpp"

objArrayOop SystemDictionaryShared::_shared_protection_domains  =  NULL;

objArrayOop SystemDictionaryShared::_shared_jar_urls            =  NULL;

objArrayOop SystemDictionaryShared::_shared_jar_manifests       =  NULL;

DEBUG_ONLY(bool SystemDictionaryShared::_no_class_loading_should_happen = false;)

class DumpTimeSharedClassInfo: public CHeapObj<mtClass> {

  bool                         _excluded;

public:

  struct DTConstraint {

    Symbol* _name;

    Symbol* _from_name;

    DTConstraint() : _name(NULL), _from_name(NULL) {}

    DTConstraint(Symbol* n, Symbol* fn) : _name(n), _from_name(fn) {}

  };

  InstanceKlass*               _klass;

  int                          _id;

  int                          _clsfile_size;

  int                          _clsfile_crc32;

  GrowableArray<DTConstraint>* _verifier_constraints;

  GrowableArray<char>*         _verifier_constraint_flags;

  DumpTimeSharedClassInfo() {

    _klass = NULL;

    _id = -1;

    _clsfile_size = -1;

    _clsfile_crc32 = -1;

    _excluded = false;

    _verifier_constraints = NULL;

    _verifier_constraint_flags = NULL;

  }

  void add_verification_constraint(InstanceKlass* k, Symbol* name,

         Symbol* from_name, bool from_field_is_protected, bool from_is_array, bool from_is_object);

  bool is_builtin() {

    return SystemDictionaryShared::is_builtin(_klass);

  }

  int num_constraints() {

    if (_verifier_constraint_flags != NULL) {

      return _verifier_constraint_flags->length();

    } else {

      return 0;

    }

  }

  void metaspace_pointers_do(MetaspaceClosure* it) {

    it->push(&_klass);

    if (_verifier_constraints != NULL) {

      for (int i = 0; i < _verifier_constraints->length(); i++) {

        DTConstraint* cons = _verifier_constraints->adr_at(i);

        it->push(&cons->_name);

        it->push(&cons->_from_name);

      }

    }

  }

  void set_excluded() {

    _excluded = true;

  }

  bool is_excluded() {

    // _klass may become NULL due to DynamicArchiveBuilder::set_to_null

    return _excluded || _klass == NULL;

  }

};

class DumpTimeSharedClassTable: public ResourceHashtable<

  InstanceKlass*,

  DumpTimeSharedClassInfo,

  primitive_hash<InstanceKlass*>,

  primitive_equals<InstanceKlass*>,

  15889, // prime number

  ResourceObj::C_HEAP>

{

  int _builtin_count;

  int _unregistered_count;

public:

  DumpTimeSharedClassInfo* find_or_allocate_info_for(InstanceKlass* k) {

    DumpTimeSharedClassInfo* p = get(k);

    if (p == NULL) {

      assert(!SystemDictionaryShared::no_class_loading_should_happen(),

             "no new classes can be loaded while dumping archive");

      put(k, DumpTimeSharedClassInfo());

      p = get(k);

      assert(p != NULL, "sanity");

      p->_klass = k;

    }

    return p;

  }

  class CountClassByCategory : StackObj {

    DumpTimeSharedClassTable* _table;

  public:

    CountClassByCategory(DumpTimeSharedClassTable* table) : _table(table) {}

    bool do_entry(InstanceKlass* k, DumpTimeSharedClassInfo& info) {

      if (!info.is_excluded()) {

        if (info.is_builtin()) {

          ++ _table->_builtin_count;

        } else {

          ++ _table->_unregistered_count;

        }

      }

      return true; // keep on iterating

    }

  };

  void update_counts() {

    _builtin_count = 0;

    _unregistered_count = 0;

    CountClassByCategory counter(this);

    iterate(&counter);

  }

  int count_of(bool is_builtin) const {

    if (is_builtin) {

      return _builtin_count;

    } else {

      return _unregistered_count;

    }

  }

};

class RunTimeSharedClassInfo {

public:

  struct CrcInfo {

    int _clsfile_size;

    int _clsfile_crc32;

  };

  // This is different than  DumpTimeSharedClassInfo::DTConstraint. We use

  // u4 instead of Symbol* to save space on 64-bit CPU.

  struct RTConstraint {

    u4 _name;

    u4 _from_name;

  };

  InstanceKlass* _klass;

  int _num_constraints;

  // optional CrcInfo      _crc;  (only for UNREGISTERED classes)

  // optional RTConstraint _verifier_constraints[_num_constraints]

  // optional char         _verifier_constraint_flags[_num_constraints]

private:

  static size_t header_size_size() {

    return sizeof(RunTimeSharedClassInfo);

  }

  static size_t crc_size(InstanceKlass* klass) {

    if (!SystemDictionaryShared::is_builtin(klass)) {

      return sizeof(CrcInfo);

    } else {

      return 0;

    }

  }

  static size_t verifier_constraints_size(int num_constraints) {

    return sizeof(RTConstraint) * num_constraints;

  }

  static size_t verifier_constraint_flags_size(int num_constraints) {

    return sizeof(char) * num_constraints;

  }

public:

  static size_t byte_size(InstanceKlass* klass, int num_constraints) {

    return header_size_size() +

           crc_size(klass) +

           verifier_constraints_size(num_constraints) +

           verifier_constraint_flags_size(num_constraints);

  }

private:

  size_t crc_offset() const {

    return header_size_size();

  }

  size_t verifier_constraints_offset() const {

    return crc_offset() + crc_size(_klass);

  }

  size_t verifier_constraint_flags_offset() const {

    return verifier_constraints_offset() + verifier_constraints_size(_num_constraints);

  }

  void check_constraint_offset(int i) const {

    assert(0 <= i && i < _num_constraints, "sanity");

  }

public:

  CrcInfo* crc() const {

    assert(crc_size(_klass) > 0, "must be");

    return (CrcInfo*)(address(this) + crc_offset());

  }

  RTConstraint* verifier_constraints() {

    assert(_num_constraints > 0, "sanity");

    return (RTConstraint*)(address(this) + verifier_constraints_offset());

  }

  RTConstraint* verifier_constraint_at(int i) {

    check_constraint_offset(i);

    return verifier_constraints() + i;

  }

  char* verifier_constraint_flags() {

    assert(_num_constraints > 0, "sanity");

    return (char*)(address(this) + verifier_constraint_flags_offset());

  }

  static u4 object_delta_u4(Symbol* sym) {

    if (DynamicDumpSharedSpaces) {

      sym = DynamicArchive::original_to_target(sym);

    }

    return MetaspaceShared::object_delta_u4(sym);

  }

  void init(DumpTimeSharedClassInfo& info) {

    _klass = info._klass;

    if (!SystemDictionaryShared::is_builtin(_klass)) {

      CrcInfo* c = crc();

      c->_clsfile_size = info._clsfile_size;

      c->_clsfile_crc32 = info._clsfile_crc32;

    }

    _num_constraints = info.num_constraints();

    if (_num_constraints > 0) {

      RTConstraint* constraints = verifier_constraints();

      char* flags = verifier_constraint_flags();

      int i;

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

        constraints[i]._name      = object_delta_u4(info._verifier_constraints->at(i)._name);

        constraints[i]._from_name = object_delta_u4(info._verifier_constraints->at(i)._from_name);

      }

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

        flags[i] = info._verifier_constraint_flags->at(i);

      }

    }

    if (DynamicDumpSharedSpaces) {

      _klass = DynamicArchive::original_to_target(info._klass);

    }

  }

  bool matches(int clsfile_size, int clsfile_crc32) const {

    return crc()->_clsfile_size  == clsfile_size &&

           crc()->_clsfile_crc32 == clsfile_crc32;

  }

  Symbol* get_constraint_name(int i) {

    return (Symbol*)(SharedBaseAddress + verifier_constraint_at(i)->_name);

  }

  Symbol* get_constraint_from_name(int i) {

    return (Symbol*)(SharedBaseAddress + verifier_constraint_at(i)->_from_name);

  }

  char get_constraint_flag(int i) {

    check_constraint_offset(i);

    return verifier_constraint_flags()[i];

  }

private:

  // ArchiveCompactor::allocate() has reserved a pointer immediately before

  // archived InstanceKlasses. We can use this slot to do a quick

  // lookup of InstanceKlass* -> RunTimeSharedClassInfo* without

  // building a new hashtable.

  //

  //  info_pointer_addr(klass) --> 0x0100   RunTimeSharedClassInfo*

  //  InstanceKlass* klass     --> 0x0108   <C++ vtbl>

  //                               0x0110   fields from Klass ...

  static RunTimeSharedClassInfo** info_pointer_addr(InstanceKlass* klass) {

    return &((RunTimeSharedClassInfo**)klass)[-1];

  }

public:

  static RunTimeSharedClassInfo* get_for(InstanceKlass* klass) {

    return *info_pointer_addr(klass);

  }

  static void set_for(InstanceKlass* klass, RunTimeSharedClassInfo* record) {

    if (DynamicDumpSharedSpaces) {

      klass = DynamicArchive::original_to_buffer(klass);

      *info_pointer_addr(klass) = DynamicArchive::buffer_to_target(record);

    } else {

      *info_pointer_addr(klass) = record;

    }

  }

  // Used by RunTimeSharedDictionary to implement OffsetCompactHashtable::EQUALS

  static inline bool EQUALS(

       const RunTimeSharedClassInfo* value, Symbol* key, int len_unused) {

    return (value->_klass->name() == key);

  }

};

class RunTimeSharedDictionary : public OffsetCompactHashtable<

  Symbol*,

  const RunTimeSharedClassInfo*,

  RunTimeSharedClassInfo::EQUALS> {};

static DumpTimeSharedClassTable* _dumptime_table = NULL;

// SystemDictionaries in the base layer static archive

static RunTimeSharedDictionary _builtin_dictionary;

static RunTimeSharedDictionary _unregistered_dictionary;

// SystemDictionaries in the top layer dynamic archive

static RunTimeSharedDictionary _dynamic_builtin_dictionary;

static RunTimeSharedDictionary _dynamic_unregistered_dictionary;

oop SystemDictionaryShared::shared_protection_domain(int index) {

  return _shared_protection_domains->obj_at(index);

}

oop SystemDictionaryShared::shared_jar_url(int index) {

  return _shared_jar_urls->obj_at(index);

}

oop SystemDictionaryShared::shared_jar_manifest(int index) {

  return _shared_jar_manifests->obj_at(index);

}

Handle SystemDictionaryShared::get_shared_jar_manifest(int shared_path_index, TRAPS) {

  Handle manifest ;

  if (shared_jar_manifest(shared_path_index) == NULL) {

    SharedClassPathEntry* ent = FileMapInfo::shared_path(shared_path_index);

    long size = ent->manifest_size();

    if (size <= 0) {

      return Handle();

    }

    // ByteArrayInputStream bais = new ByteArrayInputStream(buf);

    const char* src = ent->manifest();

    assert(src != NULL, "No Manifest data");

    typeArrayOop buf = oopFactory::new_byteArray(size, CHECK_NH);

    typeArrayHandle bufhandle(THREAD, buf);

    ArrayAccess<>::arraycopy_from_native(reinterpret_cast<const jbyte*>(src),

                                         buf, typeArrayOopDesc::element_offset<jbyte>(0), size);

    Handle bais = JavaCalls::construct_new_instance(SystemDictionary::ByteArrayInputStream_klass(),

                      vmSymbols::byte_array_void_signature(),

                      bufhandle, CHECK_NH);

    // manifest = new Manifest(bais)

    manifest = JavaCalls::construct_new_instance(SystemDictionary::Jar_Manifest_klass(),

                      vmSymbols::input_stream_void_signature(),

                      bais, CHECK_NH);

    atomic_set_shared_jar_manifest(shared_path_index, manifest());

  }

  manifest = Handle(THREAD, shared_jar_manifest(shared_path_index));

  assert(manifest.not_null(), "sanity");

  return manifest;

}

Handle SystemDictionaryShared::get_shared_jar_url(int shared_path_index, TRAPS) {

  Handle url_h;

  if (shared_jar_url(shared_path_index) == NULL) {

    JavaValue result(T_OBJECT);

    const char* path = FileMapInfo::shared_path_name(shared_path_index);

    Handle path_string = java_lang_String::create_from_str(path, CHECK_(url_h));

    Klass* classLoaders_klass =

        SystemDictionary::jdk_internal_loader_ClassLoaders_klass();

    JavaCalls::call_static(&result, classLoaders_klass,

                           vmSymbols::toFileURL_name(),

                           vmSymbols::toFileURL_signature(),

                           path_string, CHECK_(url_h));

    atomic_set_shared_jar_url(shared_path_index, (oop)result.get_jobject());

  }

  url_h = Handle(THREAD, shared_jar_url(shared_path_index));

  assert(url_h.not_null(), "sanity");

  return url_h;

}

Handle SystemDictionaryShared::get_package_name(Symbol* class_name, TRAPS) {

  ResourceMark rm(THREAD);

  Handle pkgname_string;

  char* pkgname = (char*) ClassLoader::package_from_name((const char*) class_name->as_C_string());

  if (pkgname != NULL) { // Package prefix found

    StringUtils::replace_no_expand(pkgname, "/", ".");

    pkgname_string = java_lang_String::create_from_str(pkgname,

                                                       CHECK_(pkgname_string));

  }

  return pkgname_string;

}

// Define Package for shared app classes from JAR file and also checks for

// package sealing (all done in Java code)

// See http://docs.oracle.com/javase/tutorial/deployment/jar/sealman.html

void SystemDictionaryShared::define_shared_package(Symbol*  class_name,

                                                   Handle class_loader,

                                                   Handle manifest,

                                                   Handle url,

                                                   TRAPS) {

  assert(SystemDictionary::is_system_class_loader(class_loader()), "unexpected class loader");

  // get_package_name() returns a NULL handle if the class is in unnamed package

  Handle pkgname_string = get_package_name(class_name, CHECK);

  if (pkgname_string.not_null()) {

    Klass* app_classLoader_klass = SystemDictionary::jdk_internal_loader_ClassLoaders_AppClassLoader_klass();

    JavaValue result(T_OBJECT);

    JavaCallArguments args(3);

    args.set_receiver(class_loader);

    args.push_oop(pkgname_string);

    args.push_oop(manifest);

    args.push_oop(url);

    JavaCalls::call_virtual(&result, app_classLoader_klass,

                            vmSymbols::defineOrCheckPackage_name(),

                            vmSymbols::defineOrCheckPackage_signature(),

                            &args,

                            CHECK);

  }

}

// Define Package for shared app/platform classes from named module

void SystemDictionaryShared::define_shared_package(Symbol* class_name,

                                                   Handle class_loader,

                                                   ModuleEntry* mod_entry,

                                                   TRAPS) {

  assert(mod_entry != NULL, "module_entry should not be NULL");

  Handle module_handle(THREAD, mod_entry->module());

  Handle pkg_name = get_package_name(class_name, CHECK);

  assert(pkg_name.not_null(), "Package should not be null for class in named module");

  Klass* classLoader_klass;

  if (SystemDictionary::is_system_class_loader(class_loader())) {

    classLoader_klass = SystemDictionary::jdk_internal_loader_ClassLoaders_AppClassLoader_klass();

  } else {

    assert(SystemDictionary::is_platform_class_loader(class_loader()), "unexpected classloader");

    classLoader_klass = SystemDictionary::jdk_internal_loader_ClassLoaders_PlatformClassLoader_klass();

  }

  JavaValue result(T_OBJECT);

  JavaCallArguments args(2);

  args.set_receiver(class_loader);

  args.push_oop(pkg_name);

  args.push_oop(module_handle);

  JavaCalls::call_virtual(&result, classLoader_klass,

                          vmSymbols::definePackage_name(),

                          vmSymbols::definePackage_signature(),

                          &args,

                          CHECK);

}

// Get the ProtectionDomain associated with the CodeSource from the classloader.