1 /*
   2  * Copyright (c) 2016, 2019, 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 "jni.h"
  27 #include "classfile/classLoader.hpp"
  28 #include "classfile/classLoaderData.inline.hpp"
  29 #include "classfile/javaClasses.inline.hpp"
  30 #include "classfile/moduleEntry.hpp"
  31 #include "logging/log.hpp"
  32 #include "memory/resourceArea.hpp"
  33 #include "memory/universe.hpp"
  34 #include "oops/oopHandle.inline.hpp"
  35 #include "oops/symbol.hpp"
  36 #include "runtime/handles.inline.hpp"
  37 #include "runtime/safepoint.hpp"
  38 #include "utilities/events.hpp"
  39 #include "utilities/growableArray.hpp"
  40 #include "utilities/hashtable.inline.hpp"
  41 #include "utilities/ostream.hpp"
  42 
  43 ModuleEntry* ModuleEntryTable::_javabase_module = NULL;
  44 
  45 oop ModuleEntry::module() const { return _module.resolve(); }
  46 
  47 void ModuleEntry::set_location(Symbol* location) {
  48   if (_location != NULL) {
  49     // _location symbol's refcounts are managed by ModuleEntry,
  50     // must decrement the old one before updating.
  51     _location->decrement_refcount();
  52   }
  53 
  54   _location = location;
  55 
  56   if (location != NULL) {
  57     location->increment_refcount();
  58   }
  59 }
  60 
  61 // Return true if the module's version should be displayed in error messages,
  62 // logging, etc.
  63 // Return false if the module's version is null, if it is unnamed, or if the
  64 // module is not an upgradeable module.
  65 // Detect if the module is not upgradeable by checking:
  66 //     1. Module location is "jrt:/java." and its loader is boot or platform
  67 //     2. Module location is "jrt:/jdk.", its loader is one of the builtin loaders
  68 //        and its version is the same as module java.base's version
  69 // The above check is imprecise but should work in almost all cases.
  70 bool ModuleEntry::should_show_version() {
  71   if (version() == NULL || !is_named()) return false;
  72 
  73   if (location() != NULL) {
  74     ResourceMark rm;
  75     const char* loc = location()->as_C_string();
  76     ClassLoaderData* cld = loader_data();
  77 
  78     if ((cld->is_the_null_class_loader_data() || cld->is_platform_class_loader_data()) &&
  79         (strncmp(loc, "jrt:/java.", 10) == 0)) {
  80       return false;
  81     }
  82     if ((ModuleEntryTable::javabase_moduleEntry()->version()->fast_compare(version()) == 0) &&
  83         cld->is_permanent_class_loader_data() && (strncmp(loc, "jrt:/jdk.", 9) == 0)) {
  84       return false;
  85     }
  86   }
  87   return true;
  88 }
  89 
  90 void ModuleEntry::set_version(Symbol* version) {
  91   if (_version != NULL) {
  92     // _version symbol's refcounts are managed by ModuleEntry,
  93     // must decrement the old one before updating.
  94     _version->decrement_refcount();
  95   }
  96 
  97   _version = version;
  98 
  99   if (version != NULL) {
 100     version->increment_refcount();
 101   }
 102 }
 103 
 104 // Returns the shared ProtectionDomain
 105 oop ModuleEntry::shared_protection_domain() {
 106   return _pd.resolve();
 107 }
 108 
 109 // Set the shared ProtectionDomain atomically
 110 void ModuleEntry::set_shared_protection_domain(ClassLoaderData *loader_data,
 111                                                Handle pd_h) {
 112   // Create a handle for the shared ProtectionDomain and save it atomically.
 113   // init_handle_locked checks if someone beats us setting the _pd cache.
 114   loader_data->init_handle_locked(_pd, pd_h);
 115 }
 116 
 117 // Returns true if this module can read module m
 118 bool ModuleEntry::can_read(ModuleEntry* m) const {
 119   assert(m != NULL, "No module to lookup in this module's reads list");
 120 
 121   // Unnamed modules read everyone and all modules
 122   // read java.base.  If either of these conditions
 123   // hold, readability has been established.
 124   if (!this->is_named() ||
 125       (m == ModuleEntryTable::javabase_moduleEntry())) {
 126     return true;
 127   }
 128 
 129   MutexLocker m1(Module_lock);
 130   // This is a guard against possible race between agent threads that redefine
 131   // or retransform classes in this module. Only one of them is adding the
 132   // default read edges to the unnamed modules of the boot and app class loaders
 133   // with an upcall to jdk.internal.module.Modules.transformedByAgent.
 134   // At the same time, another thread can instrument the module classes by
 135   // injecting dependencies that require the default read edges for resolution.
 136   if (this->has_default_read_edges() && !m->is_named()) {
 137     ClassLoaderData* cld = m->loader_data();
 138     if (cld->is_the_null_class_loader_data() || cld->is_system_class_loader_data()) {
 139       return true; // default read edge
 140     }
 141   }
 142   if (!has_reads_list()) {
 143     return false;
 144   } else {
 145     return _reads->contains(m);
 146   }
 147 }
 148 
 149 // Add a new module to this module's reads list
 150 void ModuleEntry::add_read(ModuleEntry* m) {
 151   // Unnamed module is special cased and can read all modules
 152   if (!is_named()) {
 153     return;
 154   }
 155 
 156   MutexLocker m1(Module_lock);
 157   if (m == NULL) {
 158     set_can_read_all_unnamed();
 159   } else {
 160     if (_reads == NULL) {
 161       // Lazily create a module's reads list
 162       _reads = new (ResourceObj::C_HEAP, mtModule)GrowableArray<ModuleEntry*>(MODULE_READS_SIZE, true);
 163     }
 164 
 165     // Determine, based on this newly established read edge to module m,
 166     // if this module's read list should be walked at a GC safepoint.
 167     set_read_walk_required(m->loader_data());
 168 
 169     // Establish readability to module m
 170     _reads->append_if_missing(m);
 171   }
 172 }
 173 
 174 // If the module's loader, that a read edge is being established to, is
 175 // not the same loader as this module's and is not one of the 3 builtin
 176 // class loaders, then this module's reads list must be walked at GC
 177 // safepoint. Modules have the same life cycle as their defining class
 178 // loaders and should be removed if dead.
 179 void ModuleEntry::set_read_walk_required(ClassLoaderData* m_loader_data) {
 180   assert(is_named(), "Cannot call set_read_walk_required on unnamed module");
 181   assert_locked_or_safepoint(Module_lock);
 182   if (!_must_walk_reads &&
 183       loader_data() != m_loader_data &&
 184       !m_loader_data->is_builtin_class_loader_data()) {
 185     _must_walk_reads = true;
 186     if (log_is_enabled(Trace, module)) {
 187       ResourceMark rm;
 188       log_trace(module)("ModuleEntry::set_read_walk_required(): module %s reads list must be walked",
 189                         (name() != NULL) ? name()->as_C_string() : UNNAMED_MODULE);
 190     }
 191   }
 192 }
 193 
 194 // Set whether the module is open, i.e. all its packages are unqualifiedly exported
 195 void ModuleEntry::set_is_open(bool is_open) {
 196   assert_lock_strong(Module_lock);
 197   _is_open = is_open;
 198 }
 199 
 200 // Returns true if the module has a non-empty reads list. As such, the unnamed
 201 // module will return false.
 202 bool ModuleEntry::has_reads_list() const {
 203   assert_locked_or_safepoint(Module_lock);
 204   return ((_reads != NULL) && !_reads->is_empty());
 205 }
 206 
 207 // Purge dead module entries out of reads list.
 208 void ModuleEntry::purge_reads() {
 209   assert_locked_or_safepoint(Module_lock);
 210 
 211   if (_must_walk_reads && has_reads_list()) {
 212     // This module's _must_walk_reads flag will be reset based
 213     // on the remaining live modules on the reads list.
 214     _must_walk_reads = false;
 215 
 216     if (log_is_enabled(Trace, module)) {
 217       ResourceMark rm;
 218       log_trace(module)("ModuleEntry::purge_reads(): module %s reads list being walked",
 219                         (name() != NULL) ? name()->as_C_string() : UNNAMED_MODULE);
 220     }
 221 
 222     // Go backwards because this removes entries that are dead.
 223     int len = _reads->length();
 224     for (int idx = len - 1; idx >= 0; idx--) {
 225       ModuleEntry* module_idx = _reads->at(idx);
 226       ClassLoaderData* cld_idx = module_idx->loader_data();
 227       if (cld_idx->is_unloading()) {
 228         _reads->delete_at(idx);
 229       } else {
 230         // Update the need to walk this module's reads based on live modules
 231         set_read_walk_required(cld_idx);
 232       }
 233     }
 234   }
 235 }
 236 
 237 void ModuleEntry::module_reads_do(ModuleClosure* f) {
 238   assert_locked_or_safepoint(Module_lock);
 239   assert(f != NULL, "invariant");
 240 
 241   if (has_reads_list()) {
 242     int reads_len = _reads->length();
 243     for (int i = 0; i < reads_len; ++i) {
 244       f->do_module(_reads->at(i));
 245     }
 246   }
 247 }
 248 
 249 void ModuleEntry::delete_reads() {
 250   delete _reads;
 251   _reads = NULL;
 252 }
 253 
 254 ModuleEntry* ModuleEntry::create_unnamed_module(ClassLoaderData* cld) {
 255   // The java.lang.Module for this loader's
 256   // corresponding unnamed module can be found in the java.lang.ClassLoader object.
 257   oop module = java_lang_ClassLoader::unnamedModule(cld->class_loader());
 258 
 259   // Ensure that the unnamed module was correctly set when the class loader was constructed.
 260   // Guarantee will cause a recognizable crash if the user code has circumvented calling the ClassLoader constructor.
 261   ResourceMark rm;
 262   guarantee(java_lang_Module::is_instance(module),
 263             "The unnamed module for ClassLoader %s, is null or not an instance of java.lang.Module. The class loader has not been initialized correctly.",
 264             cld->loader_name_and_id());
 265 
 266   ModuleEntry* unnamed_module = new_unnamed_module_entry(Handle(Thread::current(), module), cld);
 267 
 268   // Store pointer to the ModuleEntry in the unnamed module's java.lang.Module object.
 269   java_lang_Module::set_module_entry(module, unnamed_module);
 270 
 271   return unnamed_module;
 272 }
 273 
 274 ModuleEntry* ModuleEntry::create_boot_unnamed_module(ClassLoaderData* cld) {
 275   // For the boot loader, the java.lang.Module for the unnamed module
 276   // is not known until a call to JVM_SetBootLoaderUnnamedModule is made. At
 277   // this point initially create the ModuleEntry for the unnamed module.
 278   ModuleEntry* unnamed_module = new_unnamed_module_entry(Handle(), cld);
 279   assert(unnamed_module != NULL, "boot loader unnamed module should not be null");
 280   return unnamed_module;
 281 }
 282 
 283 // When creating an unnamed module, this is called without holding the Module_lock.
 284 // This is okay because the unnamed module gets created before the ClassLoaderData
 285 // is available to other threads.
 286 ModuleEntry* ModuleEntry::new_unnamed_module_entry(Handle module_handle, ClassLoaderData* cld) {
 287   ModuleEntry* entry = NEW_C_HEAP_OBJ(ModuleEntry, mtModule);
 288 
 289   // Initialize everything BasicHashtable would
 290   entry->set_next(NULL);
 291   entry->set_hash(0);
 292   entry->set_literal(NULL);
 293 
 294   // Initialize fields specific to a ModuleEntry
 295   entry->init();
 296 
 297   // Unnamed modules can read all other unnamed modules.
 298   entry->set_can_read_all_unnamed();
 299 
 300   if (!module_handle.is_null()) {
 301     entry->set_module(cld->add_handle(module_handle));
 302   }
 303 
 304   entry->set_loader_data(cld);
 305   entry->_is_open = true;
 306 
 307   JFR_ONLY(INIT_ID(entry);)
 308 
 309   return entry;
 310 }
 311 
 312 void ModuleEntry::delete_unnamed_module() {
 313   // Do not need unlink_entry() since the unnamed module is not in the hashtable
 314   FREE_C_HEAP_OBJ(this);
 315 }
 316 
 317 ModuleEntryTable::ModuleEntryTable(int table_size)
 318   : Hashtable<Symbol*, mtModule>(table_size, sizeof(ModuleEntry))
 319 {
 320 }
 321 
 322 ModuleEntryTable::~ModuleEntryTable() {
 323   // Walk through all buckets and all entries in each bucket,
 324   // freeing each entry.
 325   for (int i = 0; i < table_size(); ++i) {
 326     for (ModuleEntry* m = bucket(i); m != NULL;) {
 327       ModuleEntry* to_remove = m;
 328       // read next before freeing.
 329       m = m->next();
 330 
 331       ResourceMark rm;
 332       if (to_remove->name() != NULL) {
 333         log_info(module, unload)("unloading module %s", to_remove->name()->as_C_string());
 334       }
 335       log_debug(module)("ModuleEntryTable: deleting module: %s", to_remove->name() != NULL ?
 336                         to_remove->name()->as_C_string() : UNNAMED_MODULE);
 337 
 338       // Clean out the C heap allocated reads list first before freeing the entry
 339       to_remove->delete_reads();
 340       if (to_remove->name() != NULL) {
 341         to_remove->name()->decrement_refcount();
 342       }
 343       if (to_remove->version() != NULL) {
 344         to_remove->version()->decrement_refcount();
 345       }
 346       if (to_remove->location() != NULL) {
 347         to_remove->location()->decrement_refcount();
 348       }
 349 
 350       // Unlink from the Hashtable prior to freeing
 351       unlink_entry(to_remove);
 352       FREE_C_HEAP_ARRAY(char, to_remove);
 353     }
 354   }
 355   assert(number_of_entries() == 0, "should have removed all entries");
 356   assert(new_entry_free_list() == NULL, "entry present on ModuleEntryTable's free list");
 357 }
 358 
 359 ModuleEntry* ModuleEntryTable::new_entry(unsigned int hash, Handle module_handle,
 360                                          bool is_open, Symbol* name,
 361                                          Symbol* version, Symbol* location,
 362                                          ClassLoaderData* loader_data) {
 363   assert(Module_lock->owned_by_self(), "should have the Module_lock");
 364   ModuleEntry* entry = (ModuleEntry*)Hashtable<Symbol*, mtModule>::allocate_new_entry(hash, name);
 365 
 366   // Initialize fields specific to a ModuleEntry
 367   entry->init();
 368   if (name != NULL) {
 369     name->increment_refcount();
 370   } else {
 371     // Unnamed modules can read all other unnamed modules.
 372     entry->set_can_read_all_unnamed();
 373   }
 374 
 375   if (!module_handle.is_null()) {
 376     entry->set_module(loader_data->add_handle(module_handle));
 377   }
 378 
 379   entry->set_loader_data(loader_data);
 380   entry->set_version(version);
 381   entry->set_location(location);
 382   entry->set_is_open(is_open);
 383 
 384   if (ClassLoader::is_in_patch_mod_entries(name)) {
 385     entry->set_is_patched();
 386     if (log_is_enabled(Trace, module, patch)) {
 387       ResourceMark rm;
 388       log_trace(module, patch)("Marked module %s as patched from --patch-module",
 389                                name != NULL ? name->as_C_string() : UNNAMED_MODULE);
 390     }
 391   }
 392 
 393   JFR_ONLY(INIT_ID(entry);)
 394 
 395   return entry;
 396 }
 397 
 398 void ModuleEntryTable::add_entry(int index, ModuleEntry* new_entry) {
 399   assert(Module_lock->owned_by_self(), "should have the Module_lock");
 400   Hashtable<Symbol*, mtModule>::add_entry(index, (HashtableEntry<Symbol*, mtModule>*)new_entry);
 401 }
 402 
 403 // Create an entry in the class loader's module_entry_table.  It is the
 404 // caller's responsibility to ensure that the entry has not already been
 405 // created.
 406 ModuleEntry* ModuleEntryTable::locked_create_entry(Handle module_handle,
 407                                                    bool is_open,
 408                                                    Symbol* module_name,
 409                                                    Symbol* module_version,
 410                                                    Symbol* module_location,
 411                                                    ClassLoaderData* loader_data) {
 412   assert(module_name != NULL, "ModuleEntryTable locked_create_entry should never be called for unnamed module.");
 413   assert(Module_lock->owned_by_self(), "should have the Module_lock");
 414   assert(lookup_only(module_name) == NULL, "Module already exists");
 415   ModuleEntry* entry = new_entry(compute_hash(module_name), module_handle, is_open, module_name,
 416                                  module_version, module_location, loader_data);
 417   add_entry(index_for(module_name), entry);
 418   return entry;
 419 }
 420 
 421 // lookup_only by Symbol* to find a ModuleEntry.
 422 ModuleEntry* ModuleEntryTable::lookup_only(Symbol* name) {
 423   assert(name != NULL, "name cannot be NULL");
 424   int index = index_for(name);
 425   for (ModuleEntry* m = bucket(index); m != NULL; m = m->next()) {
 426     if (m->name()->fast_compare(name) == 0) {
 427       return m;
 428     }
 429   }
 430   return NULL;
 431 }
 432 
 433 // Remove dead modules from all other alive modules' reads list.
 434 // This should only occur at class unloading.
 435 void ModuleEntryTable::purge_all_module_reads() {
 436   assert_locked_or_safepoint(Module_lock);
 437   for (int i = 0; i < table_size(); i++) {
 438     for (ModuleEntry* entry = bucket(i);
 439                       entry != NULL;
 440                       entry = entry->next()) {
 441       entry->purge_reads();
 442     }
 443   }
 444 }
 445 
 446 void ModuleEntryTable::finalize_javabase(Handle module_handle, Symbol* version, Symbol* location) {
 447   assert(Module_lock->owned_by_self(), "should have the Module_lock");
 448   ClassLoaderData* boot_loader_data = ClassLoaderData::the_null_class_loader_data();
 449   ModuleEntryTable* module_table = boot_loader_data->modules();
 450 
 451   assert(module_table != NULL, "boot loader's ModuleEntryTable not defined");
 452 
 453   if (module_handle.is_null()) {
 454     fatal("Unable to finalize module definition for " JAVA_BASE_NAME);
 455   }
 456 
 457   // Set java.lang.Module, version and location for java.base
 458   ModuleEntry* jb_module = javabase_moduleEntry();
 459   assert(jb_module != NULL, JAVA_BASE_NAME " ModuleEntry not defined");
 460   jb_module->set_version(version);
 461   jb_module->set_location(location);
 462   // Once java.base's ModuleEntry _module field is set with the known
 463   // java.lang.Module, java.base is considered "defined" to the VM.
 464   jb_module->set_module(boot_loader_data->add_handle(module_handle));
 465 
 466   // Store pointer to the ModuleEntry for java.base in the java.lang.Module object.
 467   java_lang_Module::set_module_entry(module_handle(), jb_module);
 468 }
 469 
 470 // Within java.lang.Class instances there is a java.lang.Module field that must
 471 // be set with the defining module.  During startup, prior to java.base's definition,
 472 // classes needing their module field set are added to the fixup_module_list.
 473 // Their module field is set once java.base's java.lang.Module is known to the VM.
 474 void ModuleEntryTable::patch_javabase_entries(Handle module_handle) {
 475   if (module_handle.is_null()) {
 476     fatal("Unable to patch the module field of classes loaded prior to "
 477           JAVA_BASE_NAME "'s definition, invalid java.lang.Module");
 478   }
 479 
 480   // Do the fixups for the basic primitive types
 481   java_lang_Class::set_module(Universe::int_mirror(), module_handle());
 482   java_lang_Class::set_module(Universe::float_mirror(), module_handle());
 483   java_lang_Class::set_module(Universe::double_mirror(), module_handle());
 484   java_lang_Class::set_module(Universe::byte_mirror(), module_handle());
 485   java_lang_Class::set_module(Universe::bool_mirror(), module_handle());
 486   java_lang_Class::set_module(Universe::char_mirror(), module_handle());
 487   java_lang_Class::set_module(Universe::long_mirror(), module_handle());
 488   java_lang_Class::set_module(Universe::short_mirror(), module_handle());
 489   java_lang_Class::set_module(Universe::void_mirror(), module_handle());
 490 
 491   // Do the fixups for classes that have already been created.
 492   GrowableArray <Klass*>* list = java_lang_Class::fixup_module_field_list();
 493   int list_length = list->length();
 494   for (int i = 0; i < list_length; i++) {
 495     Klass* k = list->at(i);
 496     assert(k->is_klass(), "List should only hold classes");
 497     java_lang_Class::fixup_module_field(k, module_handle);
 498     k->class_loader_data()->dec_keep_alive();
 499   }
 500 
 501   delete java_lang_Class::fixup_module_field_list();
 502   java_lang_Class::set_fixup_module_field_list(NULL);
 503 }
 504 
 505 void ModuleEntryTable::print(outputStream* st) {
 506   st->print_cr("Module Entry Table (table_size=%d, entries=%d)",
 507                table_size(), number_of_entries());
 508   for (int i = 0; i < table_size(); i++) {
 509     for (ModuleEntry* probe = bucket(i);
 510                               probe != NULL;
 511                               probe = probe->next()) {
 512       probe->print(st);
 513     }
 514   }
 515 }
 516 
 517 void ModuleEntry::print(outputStream* st) {
 518   ResourceMark rm;
 519   st->print_cr("entry " PTR_FORMAT " name %s module " PTR_FORMAT " loader %s version %s location %s strict %s next " PTR_FORMAT,
 520                p2i(this),
 521                name() == NULL ? UNNAMED_MODULE : name()->as_C_string(),
 522                p2i(module()),
 523                loader_data()->loader_name_and_id(),
 524                version() != NULL ? version()->as_C_string() : "NULL",
 525                location() != NULL ? location()->as_C_string() : "NULL",
 526                BOOL_TO_STR(!can_read_all_unnamed()), p2i(next()));
 527 }
 528 
 529 void ModuleEntryTable::verify() {
 530   verify_table<ModuleEntry>("Module Entry Table");
 531 }
 532 
 533 void ModuleEntry::verify() {
 534   guarantee(loader_data() != NULL, "A module entry must be associated with a loader.");
 535 }