1 /*
   2  * Copyright (c) 2016, 2020, 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_CLASSFILE_MODULEENTRY_HPP
  26 #define SHARE_CLASSFILE_MODULEENTRY_HPP
  27 
  28 #include "jni.h"
  29 #include "classfile/classLoaderData.hpp"
  30 #include "classfile/vmSymbols.hpp"
  31 #include "oops/oopHandle.hpp"
  32 #include "oops/symbol.hpp"
  33 #include "runtime/jniHandles.hpp"
  34 #include "runtime/mutexLocker.hpp"
  35 #include "utilities/growableArray.hpp"
  36 #include "utilities/hashtable.hpp"
  37 #include "utilities/macros.hpp"
  38 #include "utilities/ostream.hpp"
  39 #if INCLUDE_JFR
  40 #include "jfr/support/jfrTraceIdExtension.hpp"
  41 #endif
  42 
  43 #define UNNAMED_MODULE "unnamed module"
  44 #define UNNAMED_MODULE_LEN 14
  45 #define JAVAPKG "java"
  46 #define JAVAPKG_LEN 4
  47 #define JAVA_BASE_NAME "java.base"
  48 #define JAVA_BASE_NAME_LEN 9
  49 
  50 template <class T> class Array;
  51 class ModuleClosure;
  52 
  53 // A ModuleEntry describes a module that has been defined by a call to JVM_DefineModule.
  54 // It contains:
  55 //   - Symbol* containing the module's name.
  56 //   - pointer to the java.lang.Module for this module.
  57 //   - pointer to the java.security.ProtectionDomain shared by classes defined to this module.
  58 //   - ClassLoaderData*, class loader of this module.
  59 //   - a growable array containg other module entries that this module can read.
  60 //   - a flag indicating if this module can read all unnamed modules.
  61 //
  62 // The Mutex Module_lock is shared between ModuleEntry and PackageEntry, to lock either
  63 // data structure.
  64 class ModuleEntry : public HashtableEntry<Symbol*, mtModule> {
  65 private:
  66   OopHandle _module;                   // java.lang.Module
  67   OopHandle _shared_pd;                // java.security.ProtectionDomain, cached
  68                                        // for shared classes from this module
  69   ClassLoaderData* _loader_data;
  70   GrowableArray<ModuleEntry*>* _reads; // list of modules that are readable by this module
  71   Symbol* _version;                    // module version number
  72   Symbol* _location;                   // module location
  73   CDS_ONLY(int _shared_path_index;)    // >=0 if classes in this module are in CDS archive
  74   bool _can_read_all_unnamed;
  75   bool _has_default_read_edges;        // JVMTI redefine/retransform support
  76   bool _must_walk_reads;               // walk module's reads list at GC safepoints to purge out dead modules
  77   bool _is_open;                       // whether the packages in the module are all unqualifiedly exported
  78   bool _is_patched;                    // whether the module is patched via --patch-module
  79   CDS_JAVA_HEAP_ONLY(narrowOop _archived_module_narrow_oop;)
  80 
  81   JFR_ONLY(DEFINE_TRACE_ID_FIELD;)
  82   enum {MODULE_READS_SIZE = 101};      // Initial size of list of modules that the module can read.
  83 
  84 public:
  85   void init() {
  86     _module = OopHandle();
  87     _shared_pd = OopHandle();
  88     _loader_data = NULL;
  89     _reads = NULL;
  90     _version = NULL;
  91     _location = NULL;
  92     _can_read_all_unnamed = false;
  93     _has_default_read_edges = false;
  94     _must_walk_reads = false;
  95     _is_patched = false;
  96     _is_open = false;
  97     CDS_ONLY(_shared_path_index = -1);
  98   }
  99 
 100   Symbol*          name() const                        { return literal(); }
 101   void             set_name(Symbol* n)                 { set_literal(n); }
 102 
 103   oop              module() const;
 104   OopHandle        module_handle() const               { return _module; }
 105   void             set_module(OopHandle j)             { _module = j; }
 106 
 107   // The shared ProtectionDomain reference is set once the VM loads a shared class
 108   // originated from the current Module. The referenced ProtectionDomain object is
 109   // created by the ClassLoader when loading a class (shared or non-shared) from the
 110   // Module for the first time. This ProtectionDomain object is used for all
 111   // classes from the Module loaded by the same ClassLoader.
 112   oop              shared_protection_domain();
 113   void             set_shared_protection_domain(ClassLoaderData *loader_data, Handle pd);
 114 
 115   ClassLoaderData* loader_data() const                 { return _loader_data; }
 116 
 117   void set_loader_data(ClassLoaderData* cld) {
 118     assert(!cld->has_class_mirror_holder(), "Unexpected has_class_mirror_holder cld");
 119     _loader_data = cld;
 120   }
 121 
 122   Symbol*          version() const                     { return _version; }
 123   void             set_version(Symbol* version);
 124 
 125   Symbol*          location() const                    { return _location; }
 126   void             set_location(Symbol* location);
 127   bool             should_show_version();
 128 
 129   bool             can_read(ModuleEntry* m) const;
 130   bool             has_reads_list() const;
 131   void             add_read(ModuleEntry* m);
 132   void             set_read_walk_required(ClassLoaderData* m_loader_data);
 133 
 134   bool             is_open() const                     { return _is_open; }
 135   void             set_is_open(bool is_open);
 136 
 137   bool             is_named() const                    { return (name() != NULL); }
 138 
 139   bool can_read_all_unnamed() const {
 140     assert(is_named() || _can_read_all_unnamed == true,
 141            "unnamed modules can always read all unnamed modules");
 142     return _can_read_all_unnamed;
 143   }
 144 
 145   // Modules can only go from strict to loose.
 146   void set_can_read_all_unnamed() { _can_read_all_unnamed = true; }
 147 
 148   bool has_default_read_edges() const {
 149     return _has_default_read_edges;
 150   }
 151 
 152   // Sets true and returns the previous value.
 153   bool set_has_default_read_edges() {
 154     MutexLocker ml(Module_lock);
 155     bool prev = _has_default_read_edges;
 156     _has_default_read_edges = true;
 157     return prev;
 158   }
 159 
 160   void set_is_patched() {
 161       _is_patched = true;
 162       CDS_ONLY(_shared_path_index = -1); // Mark all shared classes in this module invisible.
 163   }
 164   bool is_patched() {
 165       return _is_patched;
 166   }
 167 
 168   ModuleEntry* next() const {
 169     return (ModuleEntry*)HashtableEntry<Symbol*, mtModule>::next();
 170   }
 171   ModuleEntry** next_addr() {
 172     return (ModuleEntry**)HashtableEntry<Symbol*, mtModule>::next_addr();
 173   }
 174 
 175   // iteration support for readability
 176   void module_reads_do(ModuleClosure* const f);
 177 
 178   // Purge dead weak references out of reads list when any given class loader is unloaded.
 179   void purge_reads();
 180   void delete_reads();
 181 
 182   // Special handling for unnamed module, one per class loader
 183   static ModuleEntry* create_unnamed_module(ClassLoaderData* cld);
 184   static ModuleEntry* create_boot_unnamed_module(ClassLoaderData* cld);
 185   static ModuleEntry* new_unnamed_module_entry(Handle module_handle, ClassLoaderData* cld);
 186   void delete_unnamed_module();
 187 
 188   void print(outputStream* st = tty);
 189   void verify();
 190 
 191   CDS_ONLY(int shared_path_index() { return _shared_path_index;})
 192 
 193   JFR_ONLY(DEFINE_TRACE_ID_METHODS;)
 194 
 195 #if INCLUDE_CDS_JAVA_HEAP
 196   ModuleEntry* allocate_archived_entry() const;
 197   void init_as_archived_entry();
 198   void init_archived_oops();
 199   static ModuleEntry* get_archived_entry(ModuleEntry* orig_entry);
 200   static Array<ModuleEntry*>* write_archived_entry_array(GrowableArray<ModuleEntry*>* array);
 201   static GrowableArray<ModuleEntry*>* read_archived_entry_array(Array<ModuleEntry*>* archived_array);
 202   void load_from_archive(ClassLoaderData* loader_data);
 203   void restore_archive_oops(ClassLoaderData* loader_data);
 204 #endif
 205 };
 206 
 207 // Iterator interface
 208 class ModuleClosure: public StackObj {
 209  public:
 210   virtual void do_module(ModuleEntry* module) = 0;
 211 };
 212 
 213 
 214 // The ModuleEntryTable is a Hashtable containing a list of all modules defined
 215 // by a particular class loader.  Each module is represented as a ModuleEntry node.
 216 //
 217 // Each ModuleEntryTable contains a _javabase_module field which allows for the
 218 // creation of java.base's ModuleEntry very early in bootstrapping before the
 219 // corresponding JVM_DefineModule call for java.base occurs during module system
 220 // initialization.  Setting up java.base's ModuleEntry early enables classes,
 221 // loaded prior to the module system being initialized to be created with their
 222 // PackageEntry node's correctly pointing at java.base's ModuleEntry.  No class
 223 // outside of java.base is allowed to be loaded pre-module system initialization.
 224 //
 225 // The ModuleEntryTable's lookup is lock free.
 226 //
 227 class ModuleEntryTable : public Hashtable<Symbol*, mtModule> {
 228   friend class VMStructs;
 229 public:
 230   enum Constants {
 231     _moduletable_entry_size  = 109 // number of entries in module entry table
 232   };
 233 
 234 private:
 235   static ModuleEntry* _javabase_module;
 236 
 237   ModuleEntry* new_entry(unsigned int hash, Handle module_handle, bool is_open,
 238                          Symbol* name, Symbol* version, Symbol* location, ClassLoaderData* loader_data);
 239   void add_entry(int index, ModuleEntry* new_entry);
 240 
 241   int entry_size() const { return BasicHashtable<mtModule>::entry_size(); }
 242 
 243   ModuleEntry** bucket_addr(int i) {
 244     return (ModuleEntry**)Hashtable<Symbol*, mtModule>::bucket_addr(i);
 245   }
 246 
 247   static unsigned int compute_hash(Symbol* name) { return ((name == NULL) ? 0 : (unsigned int)(name->identity_hash())); }
 248   int index_for(Symbol* name) const              { return hash_to_index(compute_hash(name)); }
 249 
 250 public:
 251   ModuleEntryTable(int table_size);
 252   ~ModuleEntryTable();
 253 
 254   ModuleEntry* bucket(int i) {
 255     return (ModuleEntry*)Hashtable<Symbol*, mtModule>::bucket(i);
 256   }
 257 
 258   // Create module in loader's module entry table.  Assume Module_lock
 259   // has been locked by caller.
 260   ModuleEntry* locked_create_entry(Handle module_handle,
 261                                    bool is_open,
 262                                    Symbol* module_name,
 263                                    Symbol* module_version,
 264                                    Symbol* module_location,
 265                                    ClassLoaderData* loader_data);
 266 
 267   // Only lookup module within loader's module entry table.  The table read is lock-free.
 268   ModuleEntry* lookup_only(Symbol* name);
 269 
 270   // purge dead weak references out of reads list
 271   void purge_all_module_reads();
 272 
 273   // Special handling for java.base
 274   static ModuleEntry* javabase_moduleEntry()                   { return _javabase_module; }
 275   static void set_javabase_moduleEntry(ModuleEntry* java_base) {
 276     assert(_javabase_module == NULL, "_javabase_module is already defined");
 277     _javabase_module = java_base;
 278   }
 279 
 280   static bool javabase_defined() { return ((_javabase_module != NULL) &&
 281                                            (_javabase_module->module() != NULL)); }
 282   static void finalize_javabase(Handle module_handle, Symbol* version, Symbol* location);
 283   static void patch_javabase_entries(Handle module_handle);
 284 
 285   void print(outputStream* st = tty);
 286   void verify();
 287 
 288 #if INCLUDE_CDS_JAVA_HEAP
 289   Array<ModuleEntry*>* allocate_archived_entries();
 290   void init_archived_entries(Array<ModuleEntry*>* archived_modules);
 291   void init_archived_oops(Array<ModuleEntry*>* archived_modules);
 292   void load_archived_entries(ClassLoaderData* loader_data,
 293                              Array<ModuleEntry*>* archived_modules);
 294   void restore_archived_oops(ClassLoaderData* loader_data,
 295                              Array<ModuleEntry*>* archived_modules);
 296 #endif
 297 };
 298 
 299 #endif // SHARE_CLASSFILE_MODULEENTRY_HPP