257 }
258 }
259 }
260
261 // Caller needs ResourceMark.
262 static void throw_dup_pkg_exception(const char* module_name, PackageEntry* package, TRAPS) {
263 const char* package_name = package->name()->as_C_string();
264 if (package->module()->is_named()) {
265 THROW_MSG(vmSymbols::java_lang_IllegalStateException(),
266 err_msg("Package %s for module %s is already in another module, %s, defined to the class loader",
267 package_name, module_name, package->module()->name()->as_C_string()));
268 } else {
269 THROW_MSG(vmSymbols::java_lang_IllegalStateException(),
270 err_msg("Package %s for module %s is already in the unnamed module defined to the class loader",
271 package_name, module_name));
272 }
273 }
274
275 void Modules::define_module(Handle module, jboolean is_open, jstring version,
276 jstring location, jobjectArray packages, TRAPS) {
277 check_cds_restrictions(CHECK);
278 ResourceMark rm(THREAD);
279
280 if (module.is_null()) {
281 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null module object");
282 }
283
284 if (!java_lang_Module::is_instance(module())) {
285 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
286 "module is not an instance of type java.lang.Module");
287 }
288
289 int module_name_len;
290 char* module_name = get_module_name(module(), module_name_len, CHECK);
291 if (module_name == nullptr) {
292 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
293 "Module name cannot be null");
294 }
295
296 // Resolve packages
297 objArrayHandle packages_h(THREAD, objArrayOop(JNIHandles::resolve(packages)));
298 int num_packages = (packages_h.is_null() ? 0 : packages_h->length());
299
300 // Special handling of java.base definition
301 if (strcmp(module_name, JAVA_BASE_NAME) == 0) {
302 assert(is_open == JNI_FALSE, "java.base module cannot be open");
303 define_javabase_module(module, version, location, packages_h, num_packages, CHECK);
304 return;
305 }
306
307 oop loader = java_lang_Module::loader(module());
308 // Make sure loader is not the jdk.internal.reflect.DelegatingClassLoader.
309 if (loader != java_lang_ClassLoader::non_reflection_class_loader(loader)) {
310 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
311 "Class loader is an invalid delegating class loader");
312 }
313 Handle h_loader = Handle(THREAD, loader);
314 // define_module can be called during start-up, before the class loader's ClassLoaderData
315 // has been created. SystemDictionary::register_loader ensures creation, if needed.
316 ClassLoaderData* loader_data = SystemDictionary::register_loader(h_loader);
317 assert(loader_data != nullptr, "class loader data shouldn't be null");
318
620 }
621
622 if (h_system_loader.is_null()) {
623 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null system loader object");
624 }
625
626 ClassLoaderData* platform_loader_data = SystemDictionary::register_loader(h_platform_loader);
627 SystemDictionary::set_platform_loader(platform_loader_data);
628 ClassLoaderDataShared::restore_java_platform_loader_from_archive(platform_loader_data);
629
630 ClassLoaderData* system_loader_data = SystemDictionary::register_loader(h_system_loader);
631 SystemDictionary::set_system_loader(system_loader_data);
632 // system_loader_data here is always an instance of jdk.internal.loader.ClassLoader$AppClassLoader.
633 // However, if -Djava.system.class.loader=xxx is specified, java_platform_loader() would
634 // be an instance of a user-defined class, so make sure this never happens.
635 assert(Arguments::get_property("java.system.class.loader") == nullptr,
636 "archived full module should have been disabled if -Djava.system.class.loader is specified");
637 ClassLoaderDataShared::restore_java_system_loader_from_archive(system_loader_data);
638 }
639
640 void Modules::check_cds_restrictions(TRAPS) {
641 if (CDSConfig::is_dumping_full_module_graph() && Universe::is_module_initialized()) {
642 THROW_MSG(vmSymbols::java_lang_UnsupportedOperationException(),
643 "During -Xshare:dump, module system cannot be modified after it's initialized");
644 }
645 }
646 #endif // INCLUDE_CDS_JAVA_HEAP
647
648 void Modules::set_bootloader_unnamed_module(Handle module, TRAPS) {
649 ResourceMark rm(THREAD);
650
651 if (module.is_null()) {
652 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null module object");
653 }
654 if (!java_lang_Module::is_instance(module())) {
655 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
656 "module is not an instance of type java.lang.Module");
657 }
658
659 // Ensure that this is an unnamed module
660 oop name = java_lang_Module::name(module());
661 if (name != nullptr) {
662 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
663 "boot loader's unnamed module's java.lang.Module has a name");
664 }
665
666 // Validate java_base's loader is the boot loader.
667 oop loader = java_lang_Module::loader(module());
668 if (loader != nullptr) {
669 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
670 "Class loader must be the boot class loader");
671 }
672
673 log_debug(module)("set_bootloader_unnamed_module(): recording unnamed module for boot loader");
674
675 // Set java.lang.Module for the boot loader's unnamed module
676 ClassLoaderData* boot_loader_data = ClassLoaderData::the_null_class_loader_data();
677 ModuleEntry* unnamed_module = boot_loader_data->unnamed_module();
678 assert(unnamed_module != nullptr, "boot loader's unnamed ModuleEntry not defined");
679 unnamed_module->set_module(boot_loader_data->add_handle(module));
680 // Store pointer to the ModuleEntry in the unnamed module's java.lang.Module object.
681 java_lang_Module::set_module_entry(module(), unnamed_module);
682 }
683
684 void Modules::add_module_exports(Handle from_module, jstring package_name, Handle to_module, TRAPS) {
685 check_cds_restrictions(CHECK);
686
687 if (package_name == nullptr) {
688 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
689 "package is null");
690 }
691 if (from_module.is_null()) {
692 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
693 "from_module is null");
694 }
695 ModuleEntry* from_module_entry = get_module_entry(from_module, CHECK);
696 if (from_module_entry == nullptr) {
697 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
698 "from_module cannot be found");
699 }
700
701 // All packages in unnamed and open modules are exported by default.
702 if (!from_module_entry->is_named() || from_module_entry->is_open()) return;
703
704 ModuleEntry* to_module_entry;
705 if (to_module.is_null()) {
733 if (package_entry == nullptr) {
734 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
735 err_msg("Package %s not found in from_module %s",
736 pkg != nullptr ? pkg : "",
737 from_module_entry->name()->as_C_string()));
738 }
739
740 if (log_is_enabled(Debug, module)) {
741 log_debug(module)("add_module_exports(): package %s in module %s is exported to module %s",
742 package_entry->name()->as_C_string(),
743 from_module_entry->name()->as_C_string(),
744 to_module_entry == nullptr ? "null" :
745 to_module_entry->is_named() ?
746 to_module_entry->name()->as_C_string() : UNNAMED_MODULE);
747 }
748 }
749
750
751 void Modules::add_module_exports_qualified(Handle from_module, jstring package,
752 Handle to_module, TRAPS) {
753 check_cds_restrictions(CHECK);
754 if (to_module.is_null()) {
755 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
756 "to_module is null");
757 }
758 add_module_exports(from_module, package, to_module, CHECK);
759 }
760
761 void Modules::add_reads_module(Handle from_module, Handle to_module, TRAPS) {
762 check_cds_restrictions(CHECK);
763 if (from_module.is_null()) {
764 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
765 "from_module is null");
766 }
767
768 ModuleEntry* from_module_entry = get_module_entry(from_module, CHECK);
769 if (from_module_entry == nullptr) {
770 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
771 "from_module is not valid");
772 }
773
774 ModuleEntry* to_module_entry;
775 if (!to_module.is_null()) {
776 to_module_entry = get_module_entry(to_module, CHECK);
777 if (to_module_entry == nullptr) {
778 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
779 "to_module is invalid");
780 }
781 } else {
782 to_module_entry = nullptr;
848 assert(h_loader.is_null() || java_lang_ClassLoader::is_subclass(h_loader->klass()),
849 "Class loader is not a subclass of java.lang.ClassLoader");
850 assert(package_name != nullptr, "the package_name should not be null");
851
852 if (strlen(package_name) == 0) {
853 return nullptr;
854 }
855 TempNewSymbol package_sym = SymbolTable::new_symbol(package_name);
856 const PackageEntry* const pkg_entry =
857 get_package_entry_by_name(package_sym, h_loader);
858 const ModuleEntry* const module_entry = (pkg_entry != nullptr ? pkg_entry->module() : nullptr);
859
860 if (module_entry != nullptr && module_entry->module() != nullptr && module_entry->is_named()) {
861 return module_entry->module();
862 }
863 return nullptr;
864 }
865
866 // Export package in module to all unnamed modules.
867 void Modules::add_module_exports_to_all_unnamed(Handle module, jstring package_name, TRAPS) {
868 check_cds_restrictions(CHECK);
869 if (module.is_null()) {
870 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
871 "module is null");
872 }
873 if (package_name == nullptr) {
874 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
875 "package is null");
876 }
877 ModuleEntry* module_entry = get_module_entry(module, CHECK);
878 if (module_entry == nullptr) {
879 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
880 "module is invalid");
881 }
882
883 // No-op for unnamed module and open modules
884 if (!module_entry->is_named() || module_entry->is_open())
885 return;
886
887 ResourceMark rm(THREAD);
888 char buf[128];
|
257 }
258 }
259 }
260
261 // Caller needs ResourceMark.
262 static void throw_dup_pkg_exception(const char* module_name, PackageEntry* package, TRAPS) {
263 const char* package_name = package->name()->as_C_string();
264 if (package->module()->is_named()) {
265 THROW_MSG(vmSymbols::java_lang_IllegalStateException(),
266 err_msg("Package %s for module %s is already in another module, %s, defined to the class loader",
267 package_name, module_name, package->module()->name()->as_C_string()));
268 } else {
269 THROW_MSG(vmSymbols::java_lang_IllegalStateException(),
270 err_msg("Package %s for module %s is already in the unnamed module defined to the class loader",
271 package_name, module_name));
272 }
273 }
274
275 void Modules::define_module(Handle module, jboolean is_open, jstring version,
276 jstring location, jobjectArray packages, TRAPS) {
277 ResourceMark rm(THREAD);
278
279 if (module.is_null()) {
280 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null module object");
281 }
282
283 if (!java_lang_Module::is_instance(module())) {
284 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
285 "module is not an instance of type java.lang.Module");
286 }
287
288 int module_name_len;
289 char* module_name = get_module_name(module(), module_name_len, CHECK);
290 if (module_name == nullptr) {
291 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
292 "Module name cannot be null");
293 }
294
295 // Resolve packages
296 objArrayHandle packages_h(THREAD, objArrayOop(JNIHandles::resolve(packages)));
297 int num_packages = (packages_h.is_null() ? 0 : packages_h->length());
298 if (strncmp(module_name, "jdk.proxy", 9) != 0) {
299 check_cds_restrictions(Handle(), Handle(), CHECK);
300 }
301
302 // Special handling of java.base definition
303 if (strcmp(module_name, JAVA_BASE_NAME) == 0) {
304 assert(is_open == JNI_FALSE, "java.base module cannot be open");
305 define_javabase_module(module, version, location, packages_h, num_packages, CHECK);
306 return;
307 }
308
309 oop loader = java_lang_Module::loader(module());
310 // Make sure loader is not the jdk.internal.reflect.DelegatingClassLoader.
311 if (loader != java_lang_ClassLoader::non_reflection_class_loader(loader)) {
312 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
313 "Class loader is an invalid delegating class loader");
314 }
315 Handle h_loader = Handle(THREAD, loader);
316 // define_module can be called during start-up, before the class loader's ClassLoaderData
317 // has been created. SystemDictionary::register_loader ensures creation, if needed.
318 ClassLoaderData* loader_data = SystemDictionary::register_loader(h_loader);
319 assert(loader_data != nullptr, "class loader data shouldn't be null");
320
622 }
623
624 if (h_system_loader.is_null()) {
625 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null system loader object");
626 }
627
628 ClassLoaderData* platform_loader_data = SystemDictionary::register_loader(h_platform_loader);
629 SystemDictionary::set_platform_loader(platform_loader_data);
630 ClassLoaderDataShared::restore_java_platform_loader_from_archive(platform_loader_data);
631
632 ClassLoaderData* system_loader_data = SystemDictionary::register_loader(h_system_loader);
633 SystemDictionary::set_system_loader(system_loader_data);
634 // system_loader_data here is always an instance of jdk.internal.loader.ClassLoader$AppClassLoader.
635 // However, if -Djava.system.class.loader=xxx is specified, java_platform_loader() would
636 // be an instance of a user-defined class, so make sure this never happens.
637 assert(Arguments::get_property("java.system.class.loader") == nullptr,
638 "archived full module should have been disabled if -Djava.system.class.loader is specified");
639 ClassLoaderDataShared::restore_java_system_loader_from_archive(system_loader_data);
640 }
641
642 void Modules::check_cds_restrictions(Handle module1, Handle module2, TRAPS) {
643 if (CDSConfig::is_dumping_full_module_graph() && Universe::is_module_initialized()) {
644 if (ArchiveDynamicProxies && (is_dynamic_proxy_module(module1) || is_dynamic_proxy_module(module2))) {
645 // The only the we allow is to add or modify the jdk.proxy?? modules that are used for dynamic proxies.
646 } else {
647 THROW_MSG(vmSymbols::java_lang_UnsupportedOperationException(),
648 "During -Xshare:dump, module system cannot be modified after it's initialized");
649 }
650 }
651 }
652
653 #endif // INCLUDE_CDS_JAVA_HEAP
654
655 bool Modules::is_dynamic_proxy_module(Handle module) {
656 if (!module.is_null()) {
657 ModuleEntry* module_entry = java_lang_Module::module_entry(module());
658 return is_dynamic_proxy_module(module_entry);
659 }
660 return false;
661 }
662
663 bool Modules::is_dynamic_proxy_module(ModuleEntry* module_entry) {
664 return (module_entry != nullptr && module_entry->is_named() && module_entry->name()->starts_with("jdk.proxy"));
665 }
666
667 void Modules::set_bootloader_unnamed_module(Handle module, TRAPS) {
668 ResourceMark rm(THREAD);
669
670 if (module.is_null()) {
671 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null module object");
672 }
673 if (!java_lang_Module::is_instance(module())) {
674 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
675 "module is not an instance of type java.lang.Module");
676 }
677
678 // Ensure that this is an unnamed module
679 oop name = java_lang_Module::name(module());
680 if (name != nullptr) {
681 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
682 "boot loader's unnamed module's java.lang.Module has a name");
683 }
684
685 // Validate java_base's loader is the boot loader.
686 oop loader = java_lang_Module::loader(module());
687 if (loader != nullptr) {
688 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
689 "Class loader must be the boot class loader");
690 }
691
692 log_debug(module)("set_bootloader_unnamed_module(): recording unnamed module for boot loader");
693
694 // Set java.lang.Module for the boot loader's unnamed module
695 ClassLoaderData* boot_loader_data = ClassLoaderData::the_null_class_loader_data();
696 ModuleEntry* unnamed_module = boot_loader_data->unnamed_module();
697 assert(unnamed_module != nullptr, "boot loader's unnamed ModuleEntry not defined");
698 unnamed_module->set_module(boot_loader_data->add_handle(module));
699 // Store pointer to the ModuleEntry in the unnamed module's java.lang.Module object.
700 java_lang_Module::set_module_entry(module(), unnamed_module);
701 }
702
703 void Modules::add_module_exports(Handle from_module, jstring package_name, Handle to_module, TRAPS) {
704 check_cds_restrictions(from_module, to_module, CHECK);
705
706 if (package_name == nullptr) {
707 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
708 "package is null");
709 }
710 if (from_module.is_null()) {
711 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
712 "from_module is null");
713 }
714 ModuleEntry* from_module_entry = get_module_entry(from_module, CHECK);
715 if (from_module_entry == nullptr) {
716 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
717 "from_module cannot be found");
718 }
719
720 // All packages in unnamed and open modules are exported by default.
721 if (!from_module_entry->is_named() || from_module_entry->is_open()) return;
722
723 ModuleEntry* to_module_entry;
724 if (to_module.is_null()) {
752 if (package_entry == nullptr) {
753 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
754 err_msg("Package %s not found in from_module %s",
755 pkg != nullptr ? pkg : "",
756 from_module_entry->name()->as_C_string()));
757 }
758
759 if (log_is_enabled(Debug, module)) {
760 log_debug(module)("add_module_exports(): package %s in module %s is exported to module %s",
761 package_entry->name()->as_C_string(),
762 from_module_entry->name()->as_C_string(),
763 to_module_entry == nullptr ? "null" :
764 to_module_entry->is_named() ?
765 to_module_entry->name()->as_C_string() : UNNAMED_MODULE);
766 }
767 }
768
769
770 void Modules::add_module_exports_qualified(Handle from_module, jstring package,
771 Handle to_module, TRAPS) {
772 check_cds_restrictions(from_module, to_module, CHECK);
773 if (to_module.is_null()) {
774 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
775 "to_module is null");
776 }
777 add_module_exports(from_module, package, to_module, CHECK);
778 }
779
780 void Modules::add_reads_module(Handle from_module, Handle to_module, TRAPS) {
781 check_cds_restrictions(from_module, to_module, CHECK);
782 if (from_module.is_null()) {
783 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
784 "from_module is null");
785 }
786
787 ModuleEntry* from_module_entry = get_module_entry(from_module, CHECK);
788 if (from_module_entry == nullptr) {
789 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
790 "from_module is not valid");
791 }
792
793 ModuleEntry* to_module_entry;
794 if (!to_module.is_null()) {
795 to_module_entry = get_module_entry(to_module, CHECK);
796 if (to_module_entry == nullptr) {
797 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
798 "to_module is invalid");
799 }
800 } else {
801 to_module_entry = nullptr;
867 assert(h_loader.is_null() || java_lang_ClassLoader::is_subclass(h_loader->klass()),
868 "Class loader is not a subclass of java.lang.ClassLoader");
869 assert(package_name != nullptr, "the package_name should not be null");
870
871 if (strlen(package_name) == 0) {
872 return nullptr;
873 }
874 TempNewSymbol package_sym = SymbolTable::new_symbol(package_name);
875 const PackageEntry* const pkg_entry =
876 get_package_entry_by_name(package_sym, h_loader);
877 const ModuleEntry* const module_entry = (pkg_entry != nullptr ? pkg_entry->module() : nullptr);
878
879 if (module_entry != nullptr && module_entry->module() != nullptr && module_entry->is_named()) {
880 return module_entry->module();
881 }
882 return nullptr;
883 }
884
885 // Export package in module to all unnamed modules.
886 void Modules::add_module_exports_to_all_unnamed(Handle module, jstring package_name, TRAPS) {
887 check_cds_restrictions(Handle(), module, CHECK);
888 if (module.is_null()) {
889 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
890 "module is null");
891 }
892 if (package_name == nullptr) {
893 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
894 "package is null");
895 }
896 ModuleEntry* module_entry = get_module_entry(module, CHECK);
897 if (module_entry == nullptr) {
898 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
899 "module is invalid");
900 }
901
902 // No-op for unnamed module and open modules
903 if (!module_entry->is_named() || module_entry->is_open())
904 return;
905
906 ResourceMark rm(THREAD);
907 char buf[128];
|