1 /*
   2  * Copyright (c) 2016, 2017, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  *
  23  */
  24 
  25 #ifndef SHARE_VM_CLASSFILE_MODULEENTRY_HPP
  26 #define SHARE_VM_CLASSFILE_MODULEENTRY_HPP
  27 
  28 #include "classfile/classLoaderData.hpp"
  29 #include "classfile/vmSymbols.hpp"
  30 #include "oops/symbol.hpp"
  31 #include "prims/jni.h"
  32 #include "runtime/mutexLocker.hpp"
  33 #include "trace/traceMacros.hpp"
  34 #include "utilities/growableArray.hpp"
  35 #include "utilities/hashtable.hpp"
  36 #include "utilities/ostream.hpp"
  37 
  38 #define UNNAMED_MODULE "Unnamed Module"
  39 #define JAVAPKG "java"
  40 #define JAVAPKG_LEN 4
  41 #define JAVA_BASE_NAME "java.base"
  42 
  43 class ModuleClosure;
  44 
  45 // A ModuleEntry describes a module that has been defined by a call to JVM_DefineModule.
  46 // It contains:
  47 //   - Symbol* containing the module's name.
  48 //   - pointer to the java.lang.reflect.Module for this module.
  49 //   - pointer to the java.security.ProtectionDomain shared by classes defined to this module.
  50 //   - ClassLoaderData*, class loader of this module.
  51 //   - a growable array containg other module entries that this module can read.
  52 //   - a flag indicating if this module can read all unnamed modules.
  53 //
  54 // The Mutex Module_lock is shared between ModuleEntry and PackageEntry, to lock either
  55 // data structure.
  56 class ModuleEntry : public HashtableEntry<Symbol*, mtModule> {
  57 private:
  58   jobject _module;                     // java.lang.reflect.Module
  59   jobject _pd;                         // java.security.ProtectionDomain, cached
  60                                        // for shared classes from this module
  61   ClassLoaderData* _loader_data;
  62   GrowableArray<ModuleEntry*>* _reads; // list of modules that are readable by this module
  63   Symbol* _version;                    // module version number
  64   Symbol* _location;                   // module location
  65   bool _can_read_all_unnamed;
  66   bool _has_default_read_edges;        // JVMTI redefine/retransform support
  67   bool _must_walk_reads;               // walk module's reads list at GC safepoints to purge out dead modules
  68   bool _is_patched;                    // whether the module is patched via --patch-module
  69   TRACE_DEFINE_TRACE_ID_FIELD;
  70   enum {MODULE_READS_SIZE = 101};      // Initial size of list of modules that the module can read.
  71 
  72 public:
  73   void init() {
  74     _module = NULL;
  75     _loader_data = NULL;
  76     _pd = NULL;
  77     _reads = NULL;
  78     _version = NULL;
  79     _location = NULL;
  80     _can_read_all_unnamed = false;
  81     _has_default_read_edges = false;
  82     _must_walk_reads = false;
  83     _is_patched = false;
  84   }
  85 
  86   Symbol*          name() const                        { return literal(); }
  87   void             set_name(Symbol* n)                 { set_literal(n); }
  88 
  89   jobject          module() const                      { return _module; }
  90   void             set_module(jobject j)               { _module = j; }
  91 
  92   // The shared ProtectionDomain reference is set once the VM loads a shared class
  93   // originated from the current Module. The referenced ProtectionDomain object is
  94   // created by the ClassLoader when loading a class (shared or non-shared) from the
  95   // Module for the first time. This ProtectionDomain object is used for all
  96   // classes from the Module loaded by the same ClassLoader.
  97   Handle           shared_protection_domain();
  98   void             set_shared_protection_domain(ClassLoaderData *loader_data, Handle pd);
  99 
 100   ClassLoaderData* loader_data() const                 { return _loader_data; }
 101   void             set_loader_data(ClassLoaderData* l) { _loader_data = l; }
 102 
 103   Symbol*          version() const                     { return _version; }
 104   void             set_version(Symbol* version);
 105 
 106   Symbol*          location() const                    { return _location; }
 107   void             set_location(Symbol* location);
 108   bool             is_non_jdk_module();
 109 
 110   bool             can_read(ModuleEntry* m) const;
 111   bool             has_reads() const;
 112   void             add_read(ModuleEntry* m);
 113   void             set_read_walk_required(ClassLoaderData* m_loader_data);
 114 
 115   bool             is_named() const                    { return (name() != NULL); }
 116 
 117   bool can_read_all_unnamed() const {
 118     assert(is_named() || _can_read_all_unnamed == true,
 119            "unnamed modules can always read all unnamed modules");
 120     return _can_read_all_unnamed;
 121   }
 122 
 123   // Modules can only go from strict to loose.
 124   void set_can_read_all_unnamed() { _can_read_all_unnamed = true; }
 125 
 126   bool has_default_read_edges() const {
 127     return _has_default_read_edges;
 128   }
 129 
 130   // Sets true and returns the previous value.
 131   bool set_has_default_read_edges() {
 132     MutexLocker ml(Module_lock);
 133     bool prev = _has_default_read_edges;
 134     _has_default_read_edges = true;
 135     return prev;
 136   }
 137 
 138   void set_is_patched() {
 139       _is_patched = true;
 140   }
 141   bool is_patched() {
 142       return _is_patched;
 143   }
 144 
 145   ModuleEntry* next() const {
 146     return (ModuleEntry*)HashtableEntry<Symbol*, mtModule>::next();
 147   }
 148   ModuleEntry** next_addr() {
 149     return (ModuleEntry**)HashtableEntry<Symbol*, mtModule>::next_addr();
 150   }
 151 
 152   // iteration support for readability
 153   void module_reads_do(ModuleClosure* const f);
 154 
 155   TRACE_DEFINE_TRACE_ID_METHODS;
 156 
 157   // Purge dead weak references out of reads list when any given class loader is unloaded.
 158   void purge_reads();
 159   void delete_reads();
 160 
 161   void print(outputStream* st = tty);
 162   void verify();
 163 };
 164 
 165 // Iterator interface
 166 class ModuleClosure: public StackObj {
 167  public:
 168   virtual void do_module(ModuleEntry* const module) = 0;
 169 };
 170 
 171 
 172 // The ModuleEntryTable is a Hashtable containing a list of all modules defined
 173 // by a particular class loader.  Each module is represented as a ModuleEntry node.
 174 //
 175 // Each ModuleEntryTable contains a _javabase_module field which allows for the
 176 // creation of java.base's ModuleEntry very early in bootstrapping before the
 177 // corresponding JVM_DefineModule call for java.base occurs during module system
 178 // initialization.  Setting up java.base's ModuleEntry early enables classes,
 179 // loaded prior to the module system being initialized to be created with their
 180 // PackageEntry node's correctly pointing at java.base's ModuleEntry.  No class
 181 // outside of java.base is allowed to be loaded pre-module system initialization.
 182 //
 183 // The ModuleEntryTable's lookup is lock free.
 184 //
 185 class ModuleEntryTable : public Hashtable<Symbol*, mtModule> {
 186   friend class VMStructs;
 187 public:
 188   enum Constants {
 189     _moduletable_entry_size  = 109 // number of entries in module entry table
 190   };
 191 
 192 private:
 193   static ModuleEntry* _javabase_module;
 194   ModuleEntry* _unnamed_module;
 195 
 196   ModuleEntry* new_entry(unsigned int hash, Handle module_handle, Symbol* name, Symbol* version,
 197                          Symbol* location, ClassLoaderData* loader_data);
 198   void add_entry(int index, ModuleEntry* new_entry);
 199 
 200   int entry_size() const { return BasicHashtable<mtModule>::entry_size(); }
 201 
 202   ModuleEntry** bucket_addr(int i) {
 203     return (ModuleEntry**)Hashtable<Symbol*, mtModule>::bucket_addr(i);
 204   }
 205 
 206   static unsigned int compute_hash(Symbol* name) { return ((name == NULL) ? 0 : (unsigned int)(name->identity_hash())); }
 207   int index_for(Symbol* name) const              { return hash_to_index(compute_hash(name)); }
 208 
 209 public:
 210   ModuleEntryTable(int table_size);
 211   ~ModuleEntryTable();
 212 
 213   ModuleEntry* bucket(int i) {
 214     return (ModuleEntry*)Hashtable<Symbol*, mtModule>::bucket(i);
 215   }
 216 
 217   // Create module in loader's module entry table, if already exists then
 218   // return null.  Assume Module_lock has been locked by caller.
 219   ModuleEntry* locked_create_entry_or_null(Handle module_handle,
 220                                            Symbol* module_name,
 221                                            Symbol* module_version,
 222                                            Symbol* module_location,
 223                                            ClassLoaderData* loader_data);
 224 
 225   // Only lookup module within loader's module entry table.  The table read is lock-free.
 226   ModuleEntry* lookup_only(Symbol* name);
 227 
 228   // purge dead weak references out of reads list
 229   void purge_all_module_reads();
 230 
 231   // Special handling for unnamed module, one per class loader's ModuleEntryTable
 232   void create_unnamed_module(ClassLoaderData* loader_data);
 233   ModuleEntry* unnamed_module()                                { return _unnamed_module; }
 234 
 235   // Special handling for java.base
 236   static ModuleEntry* javabase_moduleEntry()                   { return _javabase_module; }
 237   static void set_javabase_moduleEntry(ModuleEntry* java_base) { _javabase_module = java_base; }
 238   static bool javabase_defined()                               { return ((_javabase_module != NULL) &&
 239                                                                          (_javabase_module->module() != NULL)); }
 240   static void finalize_javabase(Handle module_handle, Symbol* version, Symbol* location);
 241   static void patch_javabase_entries(Handle module_handle);
 242 
 243   void print(outputStream* st = tty);
 244   void verify();
 245 };
 246 
 247 #endif // SHARE_VM_CLASSFILE_MODULEENTRY_HPP