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 #include "precompiled.hpp"

    26 #include "classfile/classLoaderData.hpp"

    27 #include "classfile/javaClasses.hpp"

    28 #include "classfile/moduleEntry.hpp"

    29 #include "logging/log.hpp"

    30 #include "memory/resourceArea.hpp"

    31 #include "oops/symbol.hpp"

    32 #include "prims/jni.h"

    33 #include "runtime/handles.inline.hpp"

    34 #include "runtime/safepoint.hpp"

    35 #include "trace/traceMacros.hpp"

    36 #include "utilities/events.hpp"

    37 #include "utilities/growableArray.hpp"

    38 #include "utilities/hashtable.inline.hpp"

    39 #include "utilities/ostream.hpp"

    40 

    41 ModuleEntry* ModuleEntryTable::_javabase_module = NULL;

    42 

    43 void ModuleEntry::set_location(Symbol* location) {

    44   if (_location != NULL) {

    45     // _location symbol's refcounts are managed by ModuleEntry,

    46     // must decrement the old one before updating.

    47     _location->decrement_refcount();

    48   }

    49 

    50   _location = location;

    51 

    52   if (location != NULL) {

    53     location->increment_refcount();

    54   }

    55 }

    56 

    57 bool ModuleEntry::is_non_jdk_module() {

    58   ResourceMark rm;

    59   if (location() != NULL) {

    60     const char* loc = location()->as_C_string();

    61     if (strncmp(loc, "jrt:/java.", 10) != 0 && strncmp(loc, "jrt:/jdk.", 9) != 0) {

    62       return true;

    63     }

    64   }

    65   return false;

    66 }

    67 

    68 void ModuleEntry::set_version(Symbol* version) {

    69   if (_version != NULL) {

    70     // _version symbol's refcounts are managed by ModuleEntry,

    71     // must decrement the old one before updating.

    72     _version->decrement_refcount();

    73   }

    74 

    75   _version = version;

    76 

    77   if (version != NULL) {

    78     version->increment_refcount();

    79   }

    80 }

    81 

    82 // Returns the shared ProtectionDomain

    83 oop ModuleEntry::shared_protection_domain() {

    84   return _pd.resolve();

    85 }

    86 

    87 // Set the shared ProtectionDomain atomically

    88 void ModuleEntry::set_shared_protection_domain(ClassLoaderData *loader_data,

    89                                                Handle pd_h) {

    90   // Create a handle for the shared ProtectionDomain and save it atomically.

    91   // init_handle_locked checks if someone beats us setting the _pd cache.

    92   loader_data->init_handle_locked(_pd, pd_h);

    93 }

    94 

    95 // Returns true if this module can read module m

    96 bool ModuleEntry::can_read(ModuleEntry* m) const {

    97   assert(m != NULL, "No module to lookup in this module's reads list");

    98 

    99   // Unnamed modules read everyone and all modules

   100   // read java.base.  If either of these conditions

   101   // hold, readability has been established.

   102   if (!this->is_named() ||

   103       (m == ModuleEntryTable::javabase_moduleEntry())) {

   104     return true;

   105   }

   106 

   107   MutexLocker m1(Module_lock);

   108   // This is a guard against possible race between agent threads that redefine

   109   // or retransform classes in this module. Only one of them is adding the

   110   // default read edges to the unnamed modules of the boot and app class loaders

   111   // with an upcall to jdk.internal.module.Modules.transformedByAgent.

   112   // At the same time, another thread can instrument the module classes by

   113   // injecting dependencies that require the default read edges for resolution.

   114   if (this->has_default_read_edges() && !m->is_named()) {

   115     ClassLoaderData* cld = m->loader_data();

   116     if (cld->is_the_null_class_loader_data() || cld->is_system_class_loader_data()) {

   117       return true; // default read edge

   118     }

   119   }

   120   if (!has_reads_list()) {

   121     return false;

   122   } else {

   123     return _reads->contains(m);

   124   }

   125 }

   126 

   127 // Add a new module to this module's reads list

   128 void ModuleEntry::add_read(ModuleEntry* m) {

   129   // Unnamed module is special cased and can read all modules

   130   if (!is_named()) {

   131     return;

   132   }

   133 

   134   MutexLocker m1(Module_lock);

   135   if (m == NULL) {

   136     set_can_read_all_unnamed();

   137   } else {

   138     if (_reads == NULL) {

   139       // Lazily create a module's reads list

   140       _reads = new (ResourceObj::C_HEAP, mtModule)GrowableArray<ModuleEntry*>(MODULE_READS_SIZE, true);

   141     }

   142 

   143     // Determine, based on this newly established read edge to module m,

   144     // if this module's read list should be walked at a GC safepoint.

   145     set_read_walk_required(m->loader_data());

   146 

   147     // Establish readability to module m

   148     _reads->append_if_missing(m);

   149   }

   150 }

   151 

   152 // If the module's loader, that a read edge is being established to, is

   153 // not the same loader as this module's and is not one of the 3 builtin

   154 // class loaders, then this module's reads list must be walked at GC

   155 // safepoint. Modules have the same life cycle as their defining class

   156 // loaders and should be removed if dead.

   157 void ModuleEntry::set_read_walk_required(ClassLoaderData* m_loader_data) {

   158   assert(is_named(), "Cannot call set_read_walk_required on unnamed module");

   159   assert_locked_or_safepoint(Module_lock);

   160   if (!_must_walk_reads &&

   161       loader_data() != m_loader_data &&

   162       !m_loader_data->is_builtin_class_loader_data()) {

   163     _must_walk_reads = true;

   164     if (log_is_enabled(Trace, module)) {

   165       ResourceMark rm;

   166       log_trace(module)("ModuleEntry::set_read_walk_required(): module %s reads list must be walked",

   167                         (name() != NULL) ? name()->as_C_string() : UNNAMED_MODULE);

   168     }

   169   }

   170 }

   171 

   172 // Set whether the module is open, i.e. all its packages are unqualifiedly exported

   173 void ModuleEntry::set_is_open(bool is_open) {

   174   assert_lock_strong(Module_lock);

   175   _is_open = is_open;

   176 }

   177 

   178 // Returns true if the module has a non-empty reads list. As such, the unnamed

   179 // module will return false.

   180 bool ModuleEntry::has_reads_list() const {

   181   assert_locked_or_safepoint(Module_lock);

   182   return ((_reads != NULL) && !_reads->is_empty());

   183 }

   184 

   185 // Purge dead module entries out of reads list.

   186 void ModuleEntry::purge_reads() {

   187   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");

   188 

   189   if (_must_walk_reads && has_reads_list()) {

   190     // This module's _must_walk_reads flag will be reset based

   191     // on the remaining live modules on the reads list.

   192     _must_walk_reads = false;

   193 

   194     if (log_is_enabled(Trace, module)) {

   195       ResourceMark rm;

   196       log_trace(module)("ModuleEntry::purge_reads(): module %s reads list being walked",

   197                         (name() != NULL) ? name()->as_C_string() : UNNAMED_MODULE);

   198     }

   199 

   200     // Go backwards because this removes entries that are dead.

   201     int len = _reads->length();

   202     for (int idx = len - 1; idx >= 0; idx--) {

   203       ModuleEntry* module_idx = _reads->at(idx);

   204       ClassLoaderData* cld_idx = module_idx->loader_data();

   205       if (cld_idx->is_unloading()) {

   206         _reads->delete_at(idx);

   207       } else {

   208         // Update the need to walk this module's reads based on live modules

   209         set_read_walk_required(cld_idx);

   210       }

   211     }

   212   }

   213 }

   214 

   215 void ModuleEntry::module_reads_do(ModuleClosure* const f) {

   216   assert_locked_or_safepoint(Module_lock);

   217   assert(f != NULL, "invariant");

   218 

   219   if (has_reads_list()) {

   220     int reads_len = _reads->length();

   221     for (int i = 0; i < reads_len; ++i) {

   222       f->do_module(_reads->at(i));

   223     }

   224   }

   225 }

   226 

   227 void ModuleEntry::delete_reads() {

   228   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");

   229   delete _reads;

   230   _reads = NULL;

   231 }

   232 

   233 ModuleEntry* ModuleEntry::create_unnamed_module(ClassLoaderData* cld) {

   234   // The java.lang.Module for this loader's

   235   // corresponding unnamed module can be found in the java.lang.ClassLoader object.

   236   oop module = java_lang_ClassLoader::unnamedModule(cld->class_loader());

   237   ModuleEntry* unnamed_module = new_unnamed_module_entry(Handle(Thread::current(), module), cld);

   238 

   239   // Store pointer to the ModuleEntry in the unnamed module's java.lang.Module

   240   // object.

   241   java_lang_Module::set_module_entry(module, unnamed_module);

   242 

   243   return unnamed_module;

   244 }

   245 

   246 ModuleEntry* ModuleEntry::create_boot_unnamed_module(ClassLoaderData* cld) {

   247   // For the boot loader, the java.lang.Module for the unnamed module

   248   // is not known until a call to JVM_SetBootLoaderUnnamedModule is made. At

   249   // this point initially create the ModuleEntry for the unnamed module.

   250   ModuleEntry* unnamed_module = new_unnamed_module_entry(Handle(), cld);

   251   assert(unnamed_module != NULL, "boot loader unnamed module should not be null");

   252   return unnamed_module;

   253 }

   254 

   255 // When creating an unnamed module, this is called without holding the Module_lock.

   256 // This is okay because the unnamed module gets created before the ClassLoaderData

   257 // is available to other threads.

   258 ModuleEntry* ModuleEntry::new_unnamed_module_entry(Handle module_handle, ClassLoaderData* cld) {

   259   ModuleEntry* entry = (ModuleEntry*) NEW_C_HEAP_ARRAY(char, sizeof(ModuleEntry), mtModule);

   260 

   261   // Initialize everything BasicHashtable would

   262   entry->set_next(NULL);

   263   entry->set_hash(0);

   264   entry->set_literal(NULL);

   265 

   266   // Initialize fields specific to a ModuleEntry

   267   entry->init();

   268 

   269   // Unnamed modules can read all other unnamed modules.

   270   entry->set_can_read_all_unnamed();

   271 

   272   if (!module_handle.is_null()) {

   273     entry->set_module(cld->add_handle(module_handle));

   274   }

   275 

   276   entry->set_loader_data(cld);

   277   entry->_is_open = true;

   278 

   279   TRACE_INIT_ID(entry);

   280 

   281   return entry;

   282 }

   283 

   284 void ModuleEntry::delete_unnamed_module() {

   285   // Do not need unlink_entry() since the unnamed module is not in the hashtable

   286   FREE_C_HEAP_ARRAY(char, this);

   287 }

   288 

   289 ModuleEntryTable::ModuleEntryTable(int table_size)

   290   : Hashtable<Symbol*, mtModule>(table_size, sizeof(ModuleEntry))

   291 {

   292 }

   293 

   294 ModuleEntryTable::~ModuleEntryTable() {

   295   assert_locked_or_safepoint(Module_lock);

   296 

   297   // Walk through all buckets and all entries in each bucket,

   298   // freeing each entry.

   299   for (int i = 0; i < table_size(); ++i) {

   300     for (ModuleEntry* m = bucket(i); m != NULL;) {

   301       ModuleEntry* to_remove = m;

   302       // read next before freeing.

   303       m = m->next();

   304 

   305       ResourceMark rm;

   306       if (to_remove->name() != NULL) {

   307         log_info(module, unload)("unloading module %s", to_remove->name()->as_C_string());

   308       }

   309       log_debug(module)("ModuleEntryTable: deleting module: %s", to_remove->name() != NULL ?

   310                         to_remove->name()->as_C_string() : UNNAMED_MODULE);

   311 

   312       // Clean out the C heap allocated reads list first before freeing the entry

   313       to_remove->delete_reads();

   314       if (to_remove->name() != NULL) {

   315         to_remove->name()->decrement_refcount();

   316       }

   317       if (to_remove->version() != NULL) {

   318         to_remove->version()->decrement_refcount();

   319       }

   320       if (to_remove->location() != NULL) {

   321         to_remove->location()->decrement_refcount();

   322       }

   323 

   324       // Unlink from the Hashtable prior to freeing

   325       unlink_entry(to_remove);

   326       FREE_C_HEAP_ARRAY(char, to_remove);

   327     }

   328   }

   329   assert(number_of_entries() == 0, "should have removed all entries");

   330   assert(new_entry_free_list() == NULL, "entry present on ModuleEntryTable's free list");

   331   free_buckets();

   332 }

   333 

   334 ModuleEntry* ModuleEntryTable::new_entry(unsigned int hash, Handle module_handle,

   335                                          bool is_open, Symbol* name,

   336                                          Symbol* version, Symbol* location,

   337                                          ClassLoaderData* loader_data) {

   338   assert(Module_lock->owned_by_self(), "should have the Module_lock");

   339   ModuleEntry* entry = (ModuleEntry*)Hashtable<Symbol*, mtModule>::allocate_new_entry(hash, name);

   340 

   341   // Initialize fields specific to a ModuleEntry

   342   entry->init();

   343   if (name != NULL) {

   344     name->increment_refcount();

   345   } else {

   346     // Unnamed modules can read all other unnamed modules.

   347     entry->set_can_read_all_unnamed();

   348   }

   349 

   350   if (!module_handle.is_null()) {

   351     entry->set_module(loader_data->add_handle(module_handle));

   352   }

   353 

   354   entry->set_loader_data(loader_data);

   355   entry->set_version(version);

   356   entry->set_location(location);

   357   entry->set_is_open(is_open);

   358 

   359   if (ClassLoader::is_in_patch_mod_entries(name)) {

   360     entry->set_is_patched();

   361     if (log_is_enabled(Trace, module, patch)) {

   362       ResourceMark rm;

   363       log_trace(module, patch)("Marked module %s as patched from --patch-module", name->as_C_string());

   364     }

   365   }

   366 

   367   TRACE_INIT_ID(entry);

   368 

   369   return entry;

   370 }

   371 

   372 void ModuleEntryTable::add_entry(int index, ModuleEntry* new_entry) {

   373   assert(Module_lock->owned_by_self(), "should have the Module_lock");

   374   Hashtable<Symbol*, mtModule>::add_entry(index, (HashtableEntry<Symbol*, mtModule>*)new_entry);

   375 }

   376 

   377 ModuleEntry* ModuleEntryTable::locked_create_entry_or_null(Handle module_handle,

   378                                                            bool is_open,

   379                                                            Symbol* module_name,

   380                                                            Symbol* module_version,

   381                                                            Symbol* module_location,

   382                                                            ClassLoaderData* loader_data) {

   383   assert(module_name != NULL, "ModuleEntryTable locked_create_entry_or_null should never be called for unnamed module.");

   384   assert(Module_lock->owned_by_self(), "should have the Module_lock");

   385   // Check if module already exists.

   386   if (lookup_only(module_name) != NULL) {

   387     return NULL;

   388   } else {

   389     ModuleEntry* entry = new_entry(compute_hash(module_name), module_handle, is_open, module_name,

   390                                    module_version, module_location, loader_data);

   391     add_entry(index_for(module_name), entry);

   392     return entry;

   393   }

   394 }

   395 

   396 // lookup_only by Symbol* to find a ModuleEntry.

   397 ModuleEntry* ModuleEntryTable::lookup_only(Symbol* name) {

   398   assert(name != NULL, "name cannot be NULL");

   399   int index = index_for(name);

   400   for (ModuleEntry* m = bucket(index); m != NULL; m = m->next()) {

   401     if (m->name()->fast_compare(name) == 0) {

   402       return m;

   403     }

   404   }

   405   return NULL;

   406 }

   407 

   408 // Remove dead modules from all other alive modules' reads list.

   409 // This should only occur at class unloading.

   410 void ModuleEntryTable::purge_all_module_reads() {

   411   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");

   412   for (int i = 0; i < table_size(); i++) {

   413     for (ModuleEntry* entry = bucket(i);

   414                       entry != NULL;

   415                       entry = entry->next()) {

   416       entry->purge_reads();

   417     }

   418   }

   419 }

   420 

   421 void ModuleEntryTable::finalize_javabase(Handle module_handle, Symbol* version, Symbol* location) {

   422   assert(Module_lock->owned_by_self(), "should have the Module_lock");

   423   ClassLoaderData* boot_loader_data = ClassLoaderData::the_null_class_loader_data();

   424   ModuleEntryTable* module_table = boot_loader_data->modules();

   425 

   426   assert(module_table != NULL, "boot loader's ModuleEntryTable not defined");

   427 

   428   if (module_handle.is_null()) {

   429     fatal("Unable to finalize module definition for " JAVA_BASE_NAME);

   430   }

   431 

   432   // Set java.lang.Module, version and location for java.base

   433   ModuleEntry* jb_module = javabase_moduleEntry();

   434   assert(jb_module != NULL, JAVA_BASE_NAME " ModuleEntry not defined");

   435   jb_module->set_version(version);

   436   jb_module->set_location(location);

   437   // Once java.base's ModuleEntry _module field is set with the known

   438   // java.lang.Module, java.base is considered "defined" to the VM.

   439   jb_module->set_module(boot_loader_data->add_handle(module_handle));

   440 

   441   // Store pointer to the ModuleEntry for java.base in the java.lang.Module object.

   442   java_lang_Module::set_module_entry(module_handle(), jb_module);

   443 }

   444 

   445 // Within java.lang.Class instances there is a java.lang.Module field that must

   446 // be set with the defining module.  During startup, prior to java.base's definition,

   447 // classes needing their module field set are added to the fixup_module_list.

   448 // Their module field is set once java.base's java.lang.Module is known to the VM.

   449 void ModuleEntryTable::patch_javabase_entries(Handle module_handle) {

   450   if (module_handle.is_null()) {

   451     fatal("Unable to patch the module field of classes loaded prior to "

   452           JAVA_BASE_NAME "'s definition, invalid java.lang.Module");

   453   }

   454 

   455   // Do the fixups for the basic primitive types

   456   java_lang_Class::set_module(Universe::int_mirror(), module_handle());

   457   java_lang_Class::set_module(Universe::float_mirror(), module_handle());

   458   java_lang_Class::set_module(Universe::double_mirror(), module_handle());

   459   java_lang_Class::set_module(Universe::byte_mirror(), module_handle());

   460   java_lang_Class::set_module(Universe::bool_mirror(), module_handle());

   461   java_lang_Class::set_module(Universe::char_mirror(), module_handle());

   462   java_lang_Class::set_module(Universe::long_mirror(), module_handle());

   463   java_lang_Class::set_module(Universe::short_mirror(), module_handle());

   464   java_lang_Class::set_module(Universe::void_mirror(), module_handle());

   465 

   466   // Do the fixups for classes that have already been created.

   467   GrowableArray <Klass*>* list = java_lang_Class::fixup_module_field_list();

   468   int list_length = list->length();

   469   for (int i = 0; i < list_length; i++) {

   470     Klass* k = list->at(i);

   471     assert(k->is_klass(), "List should only hold classes");

   472     java_lang_Class::fixup_module_field(k, module_handle);

   473     k->class_loader_data()->dec_keep_alive();

   474   }

   475 

   476   delete java_lang_Class::fixup_module_field_list();

   477   java_lang_Class::set_fixup_module_field_list(NULL);

   478 }

   479 

   480 void ModuleEntryTable::print(outputStream* st) {

   481   st->print_cr("Module Entry Table (table_size=%d, entries=%d)",

   482                table_size(), number_of_entries());

   483   for (int i = 0; i < table_size(); i++) {

   484     for (ModuleEntry* probe = bucket(i);

   485                               probe != NULL;

   486                               probe = probe->next()) {

   487       probe->print(st);

   488     }

   489   }

   490 }

   491 

   492 void ModuleEntry::print(outputStream* st) {

   493   ResourceMark rm;

   494   st->print_cr("entry " PTR_FORMAT " name %s module " PTR_FORMAT " loader %s version %s location %s strict %s next " PTR_FORMAT,

   495                p2i(this),

   496                name() == NULL ? UNNAMED_MODULE : name()->as_C_string(),

   497                p2i(module()),

   498                loader_data()->loader_name(),

   499                version() != NULL ? version()->as_C_string() : "NULL",

   500                location() != NULL ? location()->as_C_string() : "NULL",

   501                BOOL_TO_STR(!can_read_all_unnamed()), p2i(next()));

   502 }

   503 

   504 void ModuleEntryTable::verify() {

   505   verify_table<ModuleEntry>("Module Entry Table");

   506 }

   507 

   508 void ModuleEntry::verify() {

   509   guarantee(loader_data() != NULL, "A module entry must be associated with a loader.");

   510 }