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);
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
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(),
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) {
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;
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];
|
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 "prims/jvmtiExport.hpp"
46 #include "runtime/handles.inline.hpp"
47 #include "runtime/javaCalls.hpp"
48 #include "runtime/jniHandles.inline.hpp"
49 #include "utilities/stringUtils.hpp"
50 #include "utilities/utf8.hpp"
51
52 static bool verify_module_name(const char *module_name, int len) {
53 assert(module_name != NULL, "invariant");
54 return (len > 0 && len <= Symbol::max_length());
55 }
56
57 static bool verify_package_name(const char* package_name, int len) {
58 assert(package_name != NULL, "Package name derived from non-null jstring can't be NULL");
59 return (len > 0 && len <= Symbol::max_length() &&
60 ClassFileParser::verify_unqualified_name(package_name, len,
61 ClassFileParser::LegalClass));
62 }
63
64 static char* get_module_name(oop module, int& len, TRAPS) {
65 oop name_oop = java_lang_Module::name(module);
254 }
255 }
256 }
257
258 // Caller needs ResourceMark.
259 void throw_dup_pkg_exception(const char* module_name, PackageEntry* package, TRAPS) {
260 const char* package_name = package->name()->as_C_string();
261 if (package->module()->is_named()) {
262 THROW_MSG(vmSymbols::java_lang_IllegalStateException(),
263 err_msg("Package %s for module %s is already in another module, %s, defined to the class loader",
264 package_name, module_name, package->module()->name()->as_C_string()));
265 } else {
266 THROW_MSG(vmSymbols::java_lang_IllegalStateException(),
267 err_msg("Package %s for module %s is already in the unnamed module defined to the class loader",
268 package_name, module_name));
269 }
270 }
271
272 void Modules::define_module(jobject module, jboolean is_open, jstring version,
273 jstring location, jobjectArray packages, TRAPS) {
274 check_cds_restrictions(CHECK);
275 ResourceMark rm(THREAD);
276
277 if (module == NULL) {
278 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null module object");
279 }
280
281 Handle module_handle(THREAD, JNIHandles::resolve_non_null(module));
282 if (!java_lang_Module::is_instance(module_handle())) {
283 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
284 "module is not an instance of type java.lang.Module");
285 }
286
287 int module_name_len;
288 char* module_name = get_module_name(module_handle(), module_name_len, CHECK);
289 if (module_name == NULL) {
290 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
291 "Module name cannot be null");
292 }
293
294 // Resolve packages
439 ls.print("define_module(): creation of module: %s, version: %s, location: %s, ",
440 module_name, version_symbol != NULL ? version_symbol->as_C_string() : "NULL",
441 location_symbol != NULL ? location_symbol->as_C_string() : "NULL");
442 loader_data->print_value_on(&ls);
443 ls.print_cr(", package #: %d", pkg_list->length());
444 for (int y = 0; y < pkg_list->length(); y++) {
445 log_trace(module)("define_module(): creation of package %s for module %s",
446 (pkg_list->at(y))->as_C_string(), module_name);
447 }
448 }
449
450 // If the module is defined to the boot loader and an exploded build is being
451 // used, prepend <java.home>/modules/modules_name to the system boot class path.
452 if (h_loader.is_null() && !ClassLoader::has_jrt_entry()) {
453 ClassLoader::add_to_exploded_build_list(module_symbol, CHECK);
454 }
455 }
456
457 #if INCLUDE_CDS_JAVA_HEAP
458 void Modules::define_archived_modules(jobject platform_loader, jobject system_loader, TRAPS) {
459 assert(UseSharedSpaces && MetaspaceShared::use_full_module_graph(), "must be");
460
461 // We don't want the classes used by the archived full module graph to be redefined by JVMTI.
462 // Luckily, such classes are loaded in the JVMTI "early" phase, and CDS is disable if a JVMTI
463 // agent wants to redefine classes in this phase.
464 JVMTI_ONLY(assert(JvmtiExport::is_early_phase(), "must be"));
465 assert(!(JvmtiExport::should_post_class_file_load_hook() && JvmtiExport::has_early_class_hook_env()),
466 "CDS should be disabled if early class hooks are enabled");
467
468 Handle java_base_module(THREAD, ClassLoaderDataShared::restore_archived_oops_for_null_class_loader_data());
469 // Patch any previously loaded class's module field with java.base's java.lang.Module.
470 ModuleEntryTable::patch_javabase_entries(java_base_module);
471
472 if (platform_loader == NULL) {
473 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null platform loader object");
474 }
475
476 if (system_loader == NULL) {
477 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null system loader object");
478 }
479
480 Handle h_platform_loader(THREAD, JNIHandles::resolve_non_null(platform_loader));
481 ClassLoaderData* platform_loader_data = SystemDictionary::register_loader(h_platform_loader);
482 ClassLoaderDataShared::restore_java_platform_loader_from_archive(platform_loader_data);
483
484 Handle h_system_loader(THREAD, JNIHandles::resolve_non_null(system_loader));
485 ClassLoaderData* system_loader_data = SystemDictionary::register_loader(h_system_loader);
486 ClassLoaderDataShared::restore_java_system_loader_from_archive(system_loader_data);
487 }
488
489 void Modules::check_cds_restrictions(TRAPS) {
490 if (DumpSharedSpaces && Universe::is_module_initialized() && MetaspaceShared::use_full_module_graph()) {
491 THROW_MSG(vmSymbols::java_lang_UnsupportedOperationException(),
492 "During -Xshare:dump, module system cannot be modified after it's initialized");
493 }
494 }
495 #endif
496
497 void Modules::set_bootloader_unnamed_module(jobject module, TRAPS) {
498 ResourceMark rm(THREAD);
499
500 if (module == NULL) {
501 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null module object");
502 }
503 Handle module_handle(THREAD, JNIHandles::resolve(module));
504 if (!java_lang_Module::is_instance(module_handle())) {
505 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
506 "module is not an instance of type java.lang.Module");
507 }
508
509 // Ensure that this is an unnamed module
510 oop name = java_lang_Module::name(module_handle());
511 if (name != NULL) {
512 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
515
516 // Validate java_base's loader is the boot loader.
517 oop loader = java_lang_Module::loader(module_handle());
518 if (loader != NULL) {
519 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
520 "Class loader must be the boot class loader");
521 }
522
523 log_debug(module)("set_bootloader_unnamed_module(): recording unnamed module for boot loader");
524
525 // Set java.lang.Module for the boot loader's unnamed module
526 ClassLoaderData* boot_loader_data = ClassLoaderData::the_null_class_loader_data();
527 ModuleEntry* unnamed_module = boot_loader_data->unnamed_module();
528 assert(unnamed_module != NULL, "boot loader's unnamed ModuleEntry not defined");
529 unnamed_module->set_module(boot_loader_data->add_handle(module_handle));
530 // Store pointer to the ModuleEntry in the unnamed module's java.lang.Module object.
531 java_lang_Module::set_module_entry(module_handle(), unnamed_module);
532 }
533
534 void Modules::add_module_exports(jobject from_module, jstring package_name, jobject to_module, TRAPS) {
535 check_cds_restrictions(CHECK);
536
537 if (package_name == NULL) {
538 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
539 "package is null");
540 }
541 if (from_module == NULL) {
542 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
543 "from_module is null");
544 }
545 ModuleEntry* from_module_entry = get_module_entry(from_module, CHECK);
546 if (from_module_entry == NULL) {
547 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
548 "from_module cannot be found");
549 }
550
551 // All packages in unnamed and open modules are exported by default.
552 if (!from_module_entry->is_named() || from_module_entry->is_open()) return;
553
554 ModuleEntry* to_module_entry;
555 if (to_module == NULL) {
583 if (package_entry == NULL) {
584 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
585 err_msg("Package %s not found in from_module %s",
586 pkg != NULL ? pkg : "",
587 from_module_entry->name()->as_C_string()));
588 }
589
590 if (log_is_enabled(Debug, module)) {
591 log_debug(module)("add_module_exports(): package %s in module %s is exported to module %s",
592 package_entry->name()->as_C_string(),
593 from_module_entry->name()->as_C_string(),
594 to_module_entry == NULL ? "NULL" :
595 to_module_entry->is_named() ?
596 to_module_entry->name()->as_C_string() : UNNAMED_MODULE);
597 }
598 }
599
600
601 void Modules::add_module_exports_qualified(jobject from_module, jstring package,
602 jobject to_module, TRAPS) {
603 check_cds_restrictions(CHECK);
604 if (to_module == NULL) {
605 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
606 "to_module is null");
607 }
608 add_module_exports(from_module, package, to_module, CHECK);
609 }
610
611 void Modules::add_reads_module(jobject from_module, jobject to_module, TRAPS) {
612 check_cds_restrictions(CHECK);
613 if (from_module == NULL) {
614 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
615 "from_module is null");
616 }
617
618 ModuleEntry* from_module_entry = get_module_entry(from_module, CHECK);
619 if (from_module_entry == NULL) {
620 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
621 "from_module is not valid");
622 }
623
624 ModuleEntry* to_module_entry;
625 if (to_module != NULL) {
626 to_module_entry = get_module_entry(to_module, CHECK);
627 if (to_module_entry == NULL) {
628 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
629 "to_module is invalid");
630 }
631 } else {
632 to_module_entry = NULL;
698 assert(h_loader.is_null() || java_lang_ClassLoader::is_subclass(h_loader->klass()),
699 "Class loader is not a subclass of java.lang.ClassLoader");
700 assert(package_name != NULL, "the package_name should not be NULL");
701
702 if (strlen(package_name) == 0) {
703 return NULL;
704 }
705 TempNewSymbol package_sym = SymbolTable::new_symbol(package_name);
706 const PackageEntry* const pkg_entry =
707 get_package_entry_by_name(package_sym, h_loader, THREAD);
708 const ModuleEntry* const module_entry = (pkg_entry != NULL ? pkg_entry->module() : NULL);
709
710 if (module_entry != NULL && module_entry->module() != NULL && module_entry->is_named()) {
711 return JNIHandles::make_local(THREAD, module_entry->module());
712 }
713 return NULL;
714 }
715
716 // Export package in module to all unnamed modules.
717 void Modules::add_module_exports_to_all_unnamed(jobject module, jstring package_name, TRAPS) {
718 check_cds_restrictions(CHECK);
719 if (module == NULL) {
720 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
721 "module is null");
722 }
723 if (package_name == NULL) {
724 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
725 "package is null");
726 }
727 ModuleEntry* module_entry = get_module_entry(module, CHECK);
728 if (module_entry == NULL) {
729 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
730 "module is invalid");
731 }
732
733 // No-op for unnamed module and open modules
734 if (!module_entry->is_named() || module_entry->is_open())
735 return;
736
737 ResourceMark rm(THREAD);
738 char buf[128];
|