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