moduleEntry.hpp revision 12735:afedee84773e 
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
43class 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.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.
56class ModuleEntry : public HashtableEntry<Symbol*, mtModule> {
57private:
58  jobject _module;                     // java.lang.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
72public:
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
166class 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//
185class ModuleEntryTable : public Hashtable<Symbol*, mtModule> {
186  friend class VMStructs;
187public:
188  enum Constants {
189    _moduletable_entry_size  = 109 // number of entries in module entry table
190  };
191
192private:
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
209public:
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
248