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 #include "precompiled.hpp" 26 #include "jvm.h" 27 #include "classfile/classFileParser.hpp" 28 #include "classfile/classLoader.hpp" 29 #include "classfile/classLoaderData.inline.hpp" 30 #include "classfile/classLoaderDataShared.hpp" 31 #include "classfile/javaAssertions.hpp" 32 #include "classfile/javaClasses.hpp" 33 #include "classfile/javaClasses.inline.hpp" 34 #include "classfile/moduleEntry.hpp" 35 #include "classfile/modules.hpp" 36 #include "classfile/packageEntry.hpp" 37 #include "classfile/stringTable.hpp" 38 #include "classfile/symbolTable.hpp" 39 #include "classfile/systemDictionary.hpp" 40 #include "classfile/vmSymbols.hpp" 41 #include "logging/log.hpp" 42 #include "logging/logStream.hpp" 43 #include "memory/metaspaceShared.hpp" 44 #include "memory/resourceArea.hpp" 45 #include "runtime/handles.inline.hpp" 46 #include "runtime/javaCalls.hpp" 47 #include "runtime/jniHandles.inline.hpp" 48 #include "utilities/stringUtils.hpp" 49 #include "utilities/utf8.hpp" 50 51 static bool verify_module_name(const char *module_name, int len) { 52 assert(module_name != NULL, "invariant"); 53 return (len > 0 && len <= Symbol::max_length()); 54 } 55 56 static bool verify_package_name(const char* package_name, int len) { 57 assert(package_name != NULL, "Package name derived from non-null jstring can't be NULL"); 58 return (len > 0 && len <= Symbol::max_length() && 59 ClassFileParser::verify_unqualified_name(package_name, len, 60 ClassFileParser::LegalClass)); 61 } 62 63 static char* get_module_name(oop module, int& len, TRAPS) { 64 oop name_oop = java_lang_Module::name(module); 65 if (name_oop == NULL) { 66 THROW_MSG_NULL(vmSymbols::java_lang_NullPointerException(), "Null module name"); 67 } 68 char* module_name = java_lang_String::as_utf8_string(name_oop, len); 69 if (!verify_module_name(module_name, len)) { 70 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), 71 err_msg("Invalid module name: %s", module_name)); 72 } 73 return module_name; 74 } 75 76 static Symbol* as_symbol(jstring str_object) { 77 if (str_object == NULL) { 78 return NULL; 79 } 80 int len; 81 char* str = java_lang_String::as_utf8_string(JNIHandles::resolve_non_null(str_object), len); 82 return SymbolTable::new_symbol(str, len); 83 } 84 85 ModuleEntryTable* Modules::get_module_entry_table(Handle h_loader) { 86 // This code can be called during start-up, before the classLoader's classLoader data got 87 // created. So, call register_loader() to make sure the classLoader data gets created. 88 ClassLoaderData *loader_cld = SystemDictionary::register_loader(h_loader); 89 return loader_cld->modules(); 90 } 91 92 static PackageEntryTable* get_package_entry_table(Handle h_loader) { 93 // This code can be called during start-up, before the classLoader's classLoader data got 94 // created. So, call register_loader() to make sure the classLoader data gets created. 95 ClassLoaderData *loader_cld = SystemDictionary::register_loader(h_loader); 96 return loader_cld->packages(); 97 } 98 99 static ModuleEntry* get_module_entry(jobject module, TRAPS) { 100 oop m = JNIHandles::resolve_non_null(module); 101 if (!java_lang_Module::is_instance(m)) { 102 THROW_MSG_NULL(vmSymbols::java_lang_IllegalArgumentException(), 103 "module is not an instance of type java.lang.Module"); 104 } 105 return java_lang_Module::module_entry(m); 106 } 107 108 109 static PackageEntry* get_locked_package_entry(ModuleEntry* module_entry, const char* package_name, int len, TRAPS) { 110 assert(Module_lock->owned_by_self(), "should have the Module_lock"); 111 assert(package_name != NULL, "Precondition"); 112 TempNewSymbol pkg_symbol = SymbolTable::new_symbol(package_name, len); 113 PackageEntryTable* package_entry_table = module_entry->loader_data()->packages(); 114 assert(package_entry_table != NULL, "Unexpected null package entry table"); 115 PackageEntry* package_entry = package_entry_table->locked_lookup_only(pkg_symbol); 116 assert(package_entry == NULL || package_entry->module() == module_entry, "Unexpectedly found a package linked to another module"); 117 return package_entry; 118 } 119 120 static PackageEntry* get_package_entry_by_name(Symbol* package, 121 Handle h_loader, 122 TRAPS) { 123 if (package != NULL) { 124 PackageEntryTable* const package_entry_table = 125 get_package_entry_table(h_loader); 126 assert(package_entry_table != NULL, "Unexpected null package entry table"); 127 return package_entry_table->lookup_only(package); 128 } 129 return NULL; 130 } 131 132 bool Modules::is_package_defined(Symbol* package, Handle h_loader, TRAPS) { 133 PackageEntry* res = get_package_entry_by_name(package, h_loader, CHECK_false); 134 return res != NULL; 135 } 136 137 // Converts the String oop to an internal package 138 // Will use the provided buffer if it's sufficiently large, otherwise allocates 139 // a resource array 140 // The length of the resulting string will be assigned to utf8_len 141 static const char* as_internal_package(oop package_string, char* buf, int buflen, int& utf8_len) { 142 char* package_name = java_lang_String::as_utf8_string_full(package_string, buf, buflen, utf8_len); 143 144 // Turn all '/'s into '.'s 145 for (int index = 0; index < utf8_len; index++) { 146 if (package_name[index] == JVM_SIGNATURE_DOT) { 147 package_name[index] = JVM_SIGNATURE_SLASH; 148 } 149 } 150 return package_name; 151 } 152 153 static void define_javabase_module(Handle module_handle, jstring version, jstring location, 154 objArrayHandle pkgs, int num_packages, TRAPS) { 155 ResourceMark rm(THREAD); 156 157 // Obtain java.base's module version 158 TempNewSymbol version_symbol = as_symbol(version); 159 160 // Obtain java.base's location 161 TempNewSymbol location_symbol = as_symbol(location); 162 163 // Check that the packages are syntactically ok. 164 char buf[128]; 165 GrowableArray<Symbol*>* pkg_list = new GrowableArray<Symbol*>(num_packages); 166 for (int x = 0; x < num_packages; x++) { 167 oop pkg_str = pkgs->obj_at(x); 168 169 if (pkg_str == NULL || pkg_str->klass() != SystemDictionary::String_klass()) { 170 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), 171 err_msg("Bad package name")); 172 } 173 174 int package_len; 175 const char* package_name = as_internal_package(pkg_str, buf, sizeof(buf), package_len); 176 if (!verify_package_name(package_name, package_len)) { 177 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), 178 err_msg("Invalid package name: %s for module: " JAVA_BASE_NAME, package_name)); 179 } 180 Symbol* pkg_symbol = SymbolTable::new_symbol(package_name, package_len); 181 pkg_list->append(pkg_symbol); 182 } 183 184 // Validate java_base's loader is the boot loader. 185 oop loader = java_lang_Module::loader(module_handle()); 186 if (loader != NULL) { 187 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), 188 "Class loader must be the boot class loader"); 189 } 190 Handle h_loader(THREAD, loader); 191 192 // Ensure the boot loader's PackageEntryTable has been created 193 PackageEntryTable* package_table = get_package_entry_table(h_loader); 194 assert(pkg_list->length() == 0 || package_table != NULL, "Bad package_table"); 195 196 // Ensure java.base's ModuleEntry has been created 197 assert(ModuleEntryTable::javabase_moduleEntry() != NULL, "No ModuleEntry for " JAVA_BASE_NAME); 198 199 bool duplicate_javabase = false; 200 { 201 MutexLocker m1(THREAD, Module_lock); 202 203 if (ModuleEntryTable::javabase_defined()) { 204 duplicate_javabase = true; 205 } else { 206 207 // Verify that all java.base packages created during bootstrapping are in 208 // pkg_list. If any are not in pkg_list, than a non-java.base class was 209 // loaded erroneously pre java.base module definition. 210 package_table->verify_javabase_packages(pkg_list); 211 212 // loop through and add any new packages for java.base 213 for (int x = 0; x < pkg_list->length(); x++) { 214 // Some of java.base's packages were added early in bootstrapping, ignore duplicates. 215 package_table->locked_create_entry_if_not_exist(pkg_list->at(x), 216 ModuleEntryTable::javabase_moduleEntry()); 217 assert(package_table->locked_lookup_only(pkg_list->at(x)) != NULL, 218 "Unable to create a " JAVA_BASE_NAME " package entry"); 219 // Unable to have a GrowableArray of TempNewSymbol. Must decrement the refcount of 220 // the Symbol* that was created above for each package. The refcount was incremented 221 // by SymbolTable::new_symbol and as well by the PackageEntry creation. 222 pkg_list->at(x)->decrement_refcount(); 223 } 224 225 // Finish defining java.base's ModuleEntry 226 ModuleEntryTable::finalize_javabase(module_handle, version_symbol, location_symbol); 227 } 228 } 229 if (duplicate_javabase) { 230 THROW_MSG(vmSymbols::java_lang_InternalError(), 231 "Module " JAVA_BASE_NAME " is already defined"); 232 } 233 234 // Only the thread that actually defined the base module will get here, 235 // so no locking is needed. 236 237 // Patch any previously loaded class's module field with java.base's java.lang.Module. 238 ModuleEntryTable::patch_javabase_entries(module_handle); 239 240 log_info(module, load)(JAVA_BASE_NAME " location: %s", 241 location_symbol != NULL ? location_symbol->as_C_string() : "NULL"); 242 log_debug(module)("define_javabase_module(): Definition of module: " 243 JAVA_BASE_NAME ", version: %s, location: %s, package #: %d", 244 version_symbol != NULL ? version_symbol->as_C_string() : "NULL", 245 location_symbol != NULL ? location_symbol->as_C_string() : "NULL", 246 pkg_list->length()); 247 248 // packages defined to java.base 249 if (log_is_enabled(Trace, module)) { 250 for (int x = 0; x < pkg_list->length(); x++) { 251 log_trace(module)("define_javabase_module(): creation of package %s for module " JAVA_BASE_NAME, 252 (pkg_list->at(x))->as_C_string()); 253 } 254 } 255 } 256 257 // Caller needs ResourceMark. 258 void throw_dup_pkg_exception(const char* module_name, PackageEntry* package, TRAPS) { 259 const char* package_name = package->name()->as_C_string(); 260 if (package->module()->is_named()) { 261 THROW_MSG(vmSymbols::java_lang_IllegalStateException(), 262 err_msg("Package %s for module %s is already in another module, %s, defined to the class loader", 263 package_name, module_name, package->module()->name()->as_C_string())); 264 } else { 265 THROW_MSG(vmSymbols::java_lang_IllegalStateException(), 266 err_msg("Package %s for module %s is already in the unnamed module defined to the class loader", 267 package_name, module_name)); 268 } 269 } 270 271 void Modules::define_module(jobject module, jboolean is_open, jstring version, 272 jstring location, jobjectArray packages, TRAPS) { 273 ResourceMark rm(THREAD); 274 275 if (module == NULL) { 276 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null module object"); 277 } 278 279 Handle module_handle(THREAD, JNIHandles::resolve_non_null(module)); 280 if (!java_lang_Module::is_instance(module_handle())) { 281 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), 282 "module is not an instance of type java.lang.Module"); 283 } 284 285 int module_name_len; 286 char* module_name = get_module_name(module_handle(), module_name_len, CHECK); 287 if (module_name == NULL) { 288 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), 289 "Module name cannot be null"); 290 } 291 292 // Resolve packages 293 objArrayHandle packages_h(THREAD, objArrayOop(JNIHandles::resolve(packages))); 294 int num_packages = (packages_h.is_null() ? 0 : packages_h->length()); 295 296 // Special handling of java.base definition 297 if (strcmp(module_name, JAVA_BASE_NAME) == 0) { 298 assert(is_open == JNI_FALSE, "java.base module cannot be open"); 299 define_javabase_module(module_handle, version, location, packages_h, num_packages, CHECK); 300 return; 301 } 302 303 oop loader = java_lang_Module::loader(module_handle()); 304 // Make sure loader is not the jdk.internal.reflect.DelegatingClassLoader. 305 if (loader != java_lang_ClassLoader::non_reflection_class_loader(loader)) { 306 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), 307 "Class loader is an invalid delegating class loader"); 308 } 309 Handle h_loader = Handle(THREAD, loader); 310 // define_module can be called during start-up, before the class loader's ClassLoaderData 311 // has been created. SystemDictionary::register_loader ensures creation, if needed. 312 ClassLoaderData* loader_data = SystemDictionary::register_loader(h_loader); 313 assert(loader_data != NULL, "class loader data shouldn't be null"); 314 315 // Only modules defined to either the boot or platform class loader, can define a "java/" package. 316 bool java_pkg_disallowed = !h_loader.is_null() && 317 !SystemDictionary::is_platform_class_loader(h_loader()); 318 319 // Check that the list of packages has no duplicates and that the 320 // packages are syntactically ok. 321 char buf[128]; 322 GrowableArray<Symbol*>* pkg_list = new GrowableArray<Symbol*>(num_packages); 323 for (int x = 0; x < num_packages; x++) { 324 oop pkg_str = packages_h->obj_at(x); 325 if (pkg_str == NULL || pkg_str->klass() != SystemDictionary::String_klass()) { 326 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), 327 err_msg("Bad package name")); 328 } 329 330 int package_len; 331 const char* package_name = as_internal_package(pkg_str, buf, sizeof(buf), package_len); 332 if (!verify_package_name(package_name, package_len)) { 333 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), 334 err_msg("Invalid package name: %s for module: %s", 335 package_name, module_name)); 336 } 337 338 // Only modules defined to either the boot or platform class loader, can define a "java/" package. 339 if (java_pkg_disallowed && 340 (strncmp(package_name, JAVAPKG, JAVAPKG_LEN) == 0 && 341 (package_name[JAVAPKG_LEN] == JVM_SIGNATURE_SLASH || package_name[JAVAPKG_LEN] == '\0'))) { 342 const char* class_loader_name = loader_data->loader_name_and_id(); 343 size_t pkg_len = strlen(package_name); 344 char* pkg_name = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, pkg_len + 1); 345 strncpy(pkg_name, package_name, pkg_len + 1); 346 StringUtils::replace_no_expand(pkg_name, "/", "."); 347 const char* msg_text1 = "Class loader (instance of): "; 348 const char* msg_text2 = " tried to define prohibited package name: "; 349 size_t len = strlen(msg_text1) + strlen(class_loader_name) + strlen(msg_text2) + pkg_len + 1; 350 char* message = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, len); 351 jio_snprintf(message, len, "%s%s%s%s", msg_text1, class_loader_name, msg_text2, pkg_name); 352 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), message); 353 } 354 355 Symbol* pkg_symbol = SymbolTable::new_symbol(package_name, package_len); 356 pkg_list->append(pkg_symbol); 357 } 358 359 ModuleEntryTable* module_table = get_module_entry_table(h_loader); 360 assert(module_table != NULL, "module entry table shouldn't be null"); 361 362 // Create symbol* entry for module name. 363 TempNewSymbol module_symbol = SymbolTable::new_symbol(module_name, module_name_len); 364 365 bool dupl_modules = false; 366 367 // Create symbol for module version. 368 TempNewSymbol version_symbol = as_symbol(version); 369 370 // Create symbol* entry for module location. 371 TempNewSymbol location_symbol = as_symbol(location); 372 373 PackageEntryTable* package_table = NULL; 374 PackageEntry* existing_pkg = NULL; 375 { 376 MutexLocker ml(THREAD, Module_lock); 377 378 if (num_packages > 0) { 379 package_table = get_package_entry_table(h_loader); 380 assert(package_table != NULL, "Missing package_table"); 381 382 // Check that none of the packages exist in the class loader's package table. 383 for (int x = 0; x < pkg_list->length(); x++) { 384 existing_pkg = package_table->locked_lookup_only(pkg_list->at(x)); 385 if (existing_pkg != NULL) { 386 // This could be because the module was already defined. If so, 387 // report that error instead of the package error. 388 if (module_table->lookup_only(module_symbol) != NULL) { 389 dupl_modules = true; 390 } 391 break; 392 } 393 } 394 } // if (num_packages > 0)... 395 396 // Add the module and its packages. 397 if (!dupl_modules && existing_pkg == NULL) { 398 if (module_table->lookup_only(module_symbol) == NULL) { 399 // Create the entry for this module in the class loader's module entry table. 400 ModuleEntry* module_entry = module_table->locked_create_entry(module_handle, 401 (is_open == JNI_TRUE), module_symbol, 402 version_symbol, location_symbol, loader_data); 403 assert(module_entry != NULL, "module_entry creation failed"); 404 405 // Add the packages. 406 assert(pkg_list->length() == 0 || package_table != NULL, "Bad package table"); 407 for (int y = 0; y < pkg_list->length(); y++) { 408 package_table->locked_create_entry(pkg_list->at(y), module_entry); 409 410 // Unable to have a GrowableArray of TempNewSymbol. Must decrement the refcount of 411 // the Symbol* that was created above for each package. The refcount was incremented 412 // by SymbolTable::new_symbol and as well by the PackageEntry creation. 413 pkg_list->at(y)->decrement_refcount(); 414 } 415 416 // Store pointer to ModuleEntry record in java.lang.Module object. 417 java_lang_Module::set_module_entry(module_handle(), module_entry); 418 } else { 419 dupl_modules = true; 420 } 421 } 422 } // Release the lock 423 424 // any errors ? 425 if (dupl_modules) { 426 THROW_MSG(vmSymbols::java_lang_IllegalStateException(), 427 err_msg("Module %s is already defined", module_name)); 428 } else if (existing_pkg != NULL) { 429 throw_dup_pkg_exception(module_name, existing_pkg, CHECK); 430 } 431 432 log_info(module, load)("%s location: %s", module_name, 433 location_symbol != NULL ? location_symbol->as_C_string() : "NULL"); 434 LogTarget(Debug, module) lt; 435 if (lt.is_enabled()) { 436 LogStream ls(lt); 437 ls.print("define_module(): creation of module: %s, version: %s, location: %s, ", 438 module_name, version_symbol != NULL ? version_symbol->as_C_string() : "NULL", 439 location_symbol != NULL ? location_symbol->as_C_string() : "NULL"); 440 loader_data->print_value_on(&ls); 441 ls.print_cr(", package #: %d", pkg_list->length()); 442 for (int y = 0; y < pkg_list->length(); y++) { 443 log_trace(module)("define_module(): creation of package %s for module %s", 444 (pkg_list->at(y))->as_C_string(), module_name); 445 } 446 } 447 448 // If the module is defined to the boot loader and an exploded build is being 449 // used, prepend <java.home>/modules/modules_name to the system boot class path. 450 if (h_loader.is_null() && !ClassLoader::has_jrt_entry()) { 451 ClassLoader::add_to_exploded_build_list(module_symbol, CHECK); 452 } 453 } 454 455 #if INCLUDE_CDS_JAVA_HEAP 456 void Modules::define_archived_modules(jobject platform_loader, jobject system_loader, TRAPS) { 457 if (platform_loader == NULL) { 458 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null platform loader object"); 459 } 460 461 if (system_loader == NULL) { 462 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null system loader object"); 463 } 464 465 if (UseSharedSpaces && MetaspaceShared::use_full_module_graph()) { 466 Handle h_platform_loader(THREAD, JNIHandles::resolve_non_null(platform_loader)); 467 ClassLoaderData* platform_loader_data = SystemDictionary::register_loader(h_platform_loader); 468 ClassLoaderDataShared::restore_java_platform_loader_from_archive(platform_loader_data); 469 470 Handle h_system_loader(THREAD, JNIHandles::resolve_non_null(system_loader)); 471 ClassLoaderData* system_loader_data = SystemDictionary::register_loader(h_system_loader); 472 ClassLoaderDataShared::restore_java_system_loader_from_archive(system_loader_data); 473 } 474 } 475 #endif 476 477 void Modules::set_bootloader_unnamed_module(jobject module, TRAPS) { 478 ResourceMark rm(THREAD); 479 480 if (module == NULL) { 481 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null module object"); 482 } 483 Handle module_handle(THREAD, JNIHandles::resolve(module)); 484 if (!java_lang_Module::is_instance(module_handle())) { 485 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), 486 "module is not an instance of type java.lang.Module"); 487 } 488 489 // Ensure that this is an unnamed module 490 oop name = java_lang_Module::name(module_handle()); 491 if (name != NULL) { 492 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), 493 "boot loader's unnamed module's java.lang.Module has a name"); 494 } 495 496 // Validate java_base's loader is the boot loader. 497 oop loader = java_lang_Module::loader(module_handle()); 498 if (loader != NULL) { 499 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), 500 "Class loader must be the boot class loader"); 501 } 502 503 log_debug(module)("set_bootloader_unnamed_module(): recording unnamed module for boot loader"); 504 505 // Set java.lang.Module for the boot loader's unnamed module 506 ClassLoaderData* boot_loader_data = ClassLoaderData::the_null_class_loader_data(); 507 ModuleEntry* unnamed_module = boot_loader_data->unnamed_module(); 508 assert(unnamed_module != NULL, "boot loader's unnamed ModuleEntry not defined"); 509 unnamed_module->set_module(boot_loader_data->add_handle(module_handle)); 510 // Store pointer to the ModuleEntry in the unnamed module's java.lang.Module object. 511 java_lang_Module::set_module_entry(module_handle(), unnamed_module); 512 } 513 514 void Modules::add_module_exports(jobject from_module, jstring package_name, jobject to_module, TRAPS) { 515 516 if (package_name == NULL) { 517 THROW_MSG(vmSymbols::java_lang_NullPointerException(), 518 "package is null"); 519 } 520 if (from_module == NULL) { 521 THROW_MSG(vmSymbols::java_lang_NullPointerException(), 522 "from_module is null"); 523 } 524 ModuleEntry* from_module_entry = get_module_entry(from_module, CHECK); 525 if (from_module_entry == NULL) { 526 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), 527 "from_module cannot be found"); 528 } 529 530 // All packages in unnamed and open modules are exported by default. 531 if (!from_module_entry->is_named() || from_module_entry->is_open()) return; 532 533 ModuleEntry* to_module_entry; 534 if (to_module == NULL) { 535 to_module_entry = NULL; // It's an unqualified export. 536 } else { 537 to_module_entry = get_module_entry(to_module, CHECK); 538 if (to_module_entry == NULL) { 539 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), 540 "to_module is invalid"); 541 } 542 } 543 544 PackageEntry* package_entry = NULL; 545 char buf[128]; 546 int package_len; 547 548 ResourceMark rm(THREAD); 549 const char* pkg = as_internal_package(JNIHandles::resolve_non_null(package_name), buf, sizeof(buf), package_len); 550 { 551 MutexLocker ml(THREAD, Module_lock); 552 package_entry = get_locked_package_entry(from_module_entry, pkg, package_len, CHECK); 553 // Do nothing if modules are the same 554 // If the package is not found we'll throw an exception later 555 if (from_module_entry != to_module_entry && 556 package_entry != NULL) { 557 package_entry->set_exported(to_module_entry); 558 } 559 } 560 561 // Handle errors and logging outside locked section 562 if (package_entry == NULL) { 563 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), 564 err_msg("Package %s not found in from_module %s", 565 pkg != NULL ? pkg : "", 566 from_module_entry->name()->as_C_string())); 567 } 568 569 if (log_is_enabled(Debug, module)) { 570 log_debug(module)("add_module_exports(): package %s in module %s is exported to module %s", 571 package_entry->name()->as_C_string(), 572 from_module_entry->name()->as_C_string(), 573 to_module_entry == NULL ? "NULL" : 574 to_module_entry->is_named() ? 575 to_module_entry->name()->as_C_string() : UNNAMED_MODULE); 576 } 577 } 578 579 580 void Modules::add_module_exports_qualified(jobject from_module, jstring package, 581 jobject to_module, TRAPS) { 582 if (to_module == NULL) { 583 THROW_MSG(vmSymbols::java_lang_NullPointerException(), 584 "to_module is null"); 585 } 586 add_module_exports(from_module, package, to_module, CHECK); 587 } 588 589 void Modules::add_reads_module(jobject from_module, jobject to_module, TRAPS) { 590 if (from_module == NULL) { 591 THROW_MSG(vmSymbols::java_lang_NullPointerException(), 592 "from_module is null"); 593 } 594 595 ModuleEntry* from_module_entry = get_module_entry(from_module, CHECK); 596 if (from_module_entry == NULL) { 597 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), 598 "from_module is not valid"); 599 } 600 601 ModuleEntry* to_module_entry; 602 if (to_module != NULL) { 603 to_module_entry = get_module_entry(to_module, CHECK); 604 if (to_module_entry == NULL) { 605 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), 606 "to_module is invalid"); 607 } 608 } else { 609 to_module_entry = NULL; 610 } 611 612 ResourceMark rm(THREAD); 613 log_debug(module)("add_reads_module(): Adding read from module %s to module %s", 614 from_module_entry->is_named() ? 615 from_module_entry->name()->as_C_string() : UNNAMED_MODULE, 616 to_module_entry == NULL ? "all unnamed" : 617 (to_module_entry->is_named() ? 618 to_module_entry->name()->as_C_string() : UNNAMED_MODULE)); 619 620 // if modules are the same or if from_module is unnamed then no need to add the read. 621 if (from_module_entry != to_module_entry && from_module_entry->is_named()) { 622 from_module_entry->add_read(to_module_entry); 623 } 624 } 625 626 // This method is called by JFR and JNI. 627 jobject Modules::get_module(jclass clazz, TRAPS) { 628 assert(ModuleEntryTable::javabase_defined(), 629 "Attempt to call get_module before " JAVA_BASE_NAME " is defined"); 630 631 if (clazz == NULL) { 632 THROW_MSG_(vmSymbols::java_lang_NullPointerException(), 633 "class is null", JNI_FALSE); 634 } 635 oop mirror = JNIHandles::resolve_non_null(clazz); 636 if (mirror == NULL) { 637 log_debug(module)("get_module(): no mirror, returning NULL"); 638 return NULL; 639 } 640 if (!java_lang_Class::is_instance(mirror)) { 641 THROW_MSG_(vmSymbols::java_lang_IllegalArgumentException(), 642 "Invalid class", JNI_FALSE); 643 } 644 645 oop module = java_lang_Class::module(mirror); 646 647 assert(module != NULL, "java.lang.Class module field not set"); 648 assert(java_lang_Module::is_instance(module), "module is not an instance of type java.lang.Module"); 649 650 LogTarget(Debug,module) lt; 651 if (lt.is_enabled()) { 652 ResourceMark rm(THREAD); 653 LogStream ls(lt); 654 Klass* klass = java_lang_Class::as_Klass(mirror); 655 oop module_name = java_lang_Module::name(module); 656 if (module_name != NULL) { 657 ls.print("get_module(): module "); 658 java_lang_String::print(module_name, tty); 659 } else { 660 ls.print("get_module(): Unamed Module"); 661 } 662 if (klass != NULL) { 663 ls.print_cr(" for class %s", klass->external_name()); 664 } else { 665 ls.print_cr(" for primitive class"); 666 } 667 } 668 669 return JNIHandles::make_local(THREAD, module); 670 } 671 672 jobject Modules::get_named_module(Handle h_loader, const char* package_name, TRAPS) { 673 assert(ModuleEntryTable::javabase_defined(), 674 "Attempt to call get_named_module before " JAVA_BASE_NAME " is defined"); 675 assert(h_loader.is_null() || java_lang_ClassLoader::is_subclass(h_loader->klass()), 676 "Class loader is not a subclass of java.lang.ClassLoader"); 677 assert(package_name != NULL, "the package_name should not be NULL"); 678 679 if (strlen(package_name) == 0) { 680 return NULL; 681 } 682 TempNewSymbol package_sym = SymbolTable::new_symbol(package_name); 683 const PackageEntry* const pkg_entry = 684 get_package_entry_by_name(package_sym, h_loader, THREAD); 685 const ModuleEntry* const module_entry = (pkg_entry != NULL ? pkg_entry->module() : NULL); 686 687 if (module_entry != NULL && module_entry->module() != NULL && module_entry->is_named()) { 688 return JNIHandles::make_local(THREAD, module_entry->module()); 689 } 690 return NULL; 691 } 692 693 // Export package in module to all unnamed modules. 694 void Modules::add_module_exports_to_all_unnamed(jobject module, jstring package_name, TRAPS) { 695 if (module == NULL) { 696 THROW_MSG(vmSymbols::java_lang_NullPointerException(), 697 "module is null"); 698 } 699 if (package_name == NULL) { 700 THROW_MSG(vmSymbols::java_lang_NullPointerException(), 701 "package is null"); 702 } 703 ModuleEntry* module_entry = get_module_entry(module, CHECK); 704 if (module_entry == NULL) { 705 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), 706 "module is invalid"); 707 } 708 709 // No-op for unnamed module and open modules 710 if (!module_entry->is_named() || module_entry->is_open()) 711 return; 712 713 ResourceMark rm(THREAD); 714 char buf[128]; 715 int pkg_len; 716 const char* pkg = as_internal_package(JNIHandles::resolve_non_null(package_name), buf, sizeof(buf), pkg_len); 717 PackageEntry* package_entry = NULL; 718 { 719 MutexLocker m1(THREAD, Module_lock); 720 package_entry = get_locked_package_entry(module_entry, pkg, pkg_len, CHECK); 721 722 // Mark package as exported to all unnamed modules. 723 if (package_entry != NULL) { 724 package_entry->set_is_exported_allUnnamed(); 725 } 726 } 727 728 // Handle errors and logging outside locked section 729 if (package_entry == NULL) { 730 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(), 731 err_msg("Package %s not found in module %s", 732 pkg != NULL ? pkg : "", 733 module_entry->name()->as_C_string())); 734 } 735 736 if (log_is_enabled(Debug, module)) { 737 log_debug(module)("add_module_exports_to_all_unnamed(): package %s in module" 738 " %s is exported to all unnamed modules", 739 package_entry->name()->as_C_string(), 740 module_entry->name()->as_C_string()); 741 } 742 }