260 }
261 }
262 }
263
264 // Caller needs ResourceMark.
265 static void throw_dup_pkg_exception(const char* module_name, PackageEntry* package, TRAPS) {
266 const char* package_name = package->name()->as_C_string();
267 if (package->module()->is_named()) {
268 THROW_MSG(vmSymbols::java_lang_IllegalStateException(),
269 err_msg("Package %s for module %s is already in another module, %s, defined to the class loader",
270 package_name, module_name, package->module()->name()->as_C_string()));
271 } else {
272 THROW_MSG(vmSymbols::java_lang_IllegalStateException(),
273 err_msg("Package %s for module %s is already in the unnamed module defined to the class loader",
274 package_name, module_name));
275 }
276 }
277
278 void Modules::define_module(Handle module, jboolean is_open, jstring version,
279 jstring location, jobjectArray packages, TRAPS) {
280 check_cds_restrictions(CHECK);
281 ResourceMark rm(THREAD);
282
283 if (module.is_null()) {
284 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null module object");
285 }
286
287 if (!java_lang_Module::is_instance(module())) {
288 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
289 "module is not an instance of type java.lang.Module");
290 }
291
292 int module_name_len;
293 char* module_name = get_module_name(module(), module_name_len, CHECK);
294 if (module_name == nullptr) {
295 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
296 "Module name cannot be null");
297 }
298
299 // Resolve packages
300 objArrayHandle packages_h(THREAD, objArrayOop(JNIHandles::resolve(packages)));
301 int num_packages = (packages_h.is_null() ? 0 : packages_h->length());
302
303 // Special handling of java.base definition
304 if (strcmp(module_name, JAVA_BASE_NAME) == 0) {
305 assert(is_open == JNI_FALSE, "java.base module cannot be open");
306 define_javabase_module(module, version, location, packages_h, num_packages, CHECK);
307 return;
308 }
309
310 oop loader = java_lang_Module::loader(module());
311 Handle h_loader = Handle(THREAD, loader);
312 // define_module can be called during start-up, before the class loader's ClassLoaderData
313 // has been created. SystemDictionary::register_loader ensures creation, if needed.
314 ClassLoaderData* loader_data = SystemDictionary::register_loader(h_loader);
315 assert(loader_data != nullptr, "class loader data shouldn't be null");
316
317 // Only modules defined to either the boot or platform class loader, can define a "java/" package.
318 bool java_pkg_disallowed = !h_loader.is_null() &&
319 !SystemDictionary::is_platform_class_loader(h_loader());
320
321 // Check that the list of packages has no duplicates and that the
717 }
718
719 if (h_system_loader.is_null()) {
720 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null system loader object");
721 }
722
723 ClassLoaderData* platform_loader_data = SystemDictionary::register_loader(h_platform_loader);
724 SystemDictionary::set_platform_loader(platform_loader_data);
725 ClassLoaderDataShared::restore_java_platform_loader_from_archive(platform_loader_data);
726
727 ClassLoaderData* system_loader_data = SystemDictionary::register_loader(h_system_loader);
728 SystemDictionary::set_system_loader(system_loader_data);
729 // system_loader_data here is always an instance of jdk.internal.loader.ClassLoader$AppClassLoader.
730 // However, if -Djava.system.class.loader=xxx is specified, java_platform_loader() would
731 // be an instance of a user-defined class, so make sure this never happens.
732 assert(Arguments::get_property("java.system.class.loader") == nullptr,
733 "archived full module should have been disabled if -Djava.system.class.loader is specified");
734 ClassLoaderDataShared::restore_java_system_loader_from_archive(system_loader_data);
735 }
736
737 void Modules::check_cds_restrictions(TRAPS) {
738 if (CDSConfig::is_dumping_full_module_graph() && Universe::is_module_initialized()) {
739 THROW_MSG(vmSymbols::java_lang_UnsupportedOperationException(),
740 "During -Xshare:dump, module system cannot be modified after it's initialized");
741 }
742 }
743 #endif // INCLUDE_CDS_JAVA_HEAP
744
745 void Modules::set_bootloader_unnamed_module(Handle module, TRAPS) {
746 ResourceMark rm(THREAD);
747
748 if (module.is_null()) {
749 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null module object");
750 }
751 if (!java_lang_Module::is_instance(module())) {
752 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
753 "module is not an instance of type java.lang.Module");
754 }
755
756 // Ensure that this is an unnamed module
757 oop name = java_lang_Module::name(module());
758 if (name != nullptr) {
759 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
760 "boot loader's unnamed module's java.lang.Module has a name");
761 }
762
763 // Validate java_base's loader is the boot loader.
764 oop loader = java_lang_Module::loader(module());
771
772 // Set java.lang.Module for the boot loader's unnamed module
773 ClassLoaderData* boot_loader_data = ClassLoaderData::the_null_class_loader_data();
774 ModuleEntry* unnamed_module = boot_loader_data->unnamed_module();
775 assert(unnamed_module != nullptr, "boot loader's unnamed ModuleEntry not defined");
776
777 #if INCLUDE_CDS_JAVA_HEAP
778 if (CDSConfig::is_using_full_module_graph()) {
779 precond(unnamed_module == ClassLoaderDataShared::archived_boot_unnamed_module());
780 unnamed_module->restore_archived_oops(boot_loader_data);
781 } else
782 #endif
783 {
784 unnamed_module->set_module_handle(boot_loader_data->add_handle(module));
785 // Store pointer to the ModuleEntry in the unnamed module's java.lang.Module object.
786 java_lang_Module::set_module_entry(module(), unnamed_module);
787 }
788 }
789
790 void Modules::add_module_exports(Handle from_module, jstring package_name, Handle to_module, TRAPS) {
791 check_cds_restrictions(CHECK);
792
793 if (package_name == nullptr) {
794 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
795 "package is null");
796 }
797 if (from_module.is_null()) {
798 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
799 "from_module is null");
800 }
801 ModuleEntry* from_module_entry = get_module_entry(from_module, CHECK);
802 if (from_module_entry == nullptr) {
803 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
804 "from_module cannot be found");
805 }
806
807 // All packages in unnamed and open modules are exported by default.
808 if (!from_module_entry->is_named() || from_module_entry->is_open()) return;
809
810 ModuleEntry* to_module_entry;
811 if (to_module.is_null()) {
839 if (package_entry == nullptr) {
840 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
841 err_msg("Package %s not found in from_module %s",
842 pkg != nullptr ? pkg : "",
843 from_module_entry->name()->as_C_string()));
844 }
845
846 if (log_is_enabled(Debug, module)) {
847 log_debug(module)("add_module_exports(): package %s in module %s is exported to module %s",
848 package_entry->name()->as_C_string(),
849 from_module_entry->name()->as_C_string(),
850 to_module_entry == nullptr ? "null" :
851 to_module_entry->is_named() ?
852 to_module_entry->name()->as_C_string() : UNNAMED_MODULE);
853 }
854 }
855
856
857 void Modules::add_module_exports_qualified(Handle from_module, jstring package,
858 Handle to_module, TRAPS) {
859 check_cds_restrictions(CHECK);
860 if (to_module.is_null()) {
861 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
862 "to_module is null");
863 }
864 add_module_exports(from_module, package, to_module, CHECK);
865 }
866
867 void Modules::add_reads_module(Handle from_module, Handle to_module, TRAPS) {
868 check_cds_restrictions(CHECK);
869 if (from_module.is_null()) {
870 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
871 "from_module is null");
872 }
873
874 ModuleEntry* from_module_entry = get_module_entry(from_module, CHECK);
875 if (from_module_entry == nullptr) {
876 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
877 "from_module is not valid");
878 }
879
880 ModuleEntry* to_module_entry;
881 if (!to_module.is_null()) {
882 to_module_entry = get_module_entry(to_module, CHECK);
883 if (to_module_entry == nullptr) {
884 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
885 "to_module is invalid");
886 }
887 } else {
888 to_module_entry = nullptr;
954 assert(h_loader.is_null() || java_lang_ClassLoader::is_subclass(h_loader->klass()),
955 "Class loader is not a subclass of java.lang.ClassLoader");
956 assert(package_name != nullptr, "the package_name should not be null");
957
958 if (strlen(package_name) == 0) {
959 return nullptr;
960 }
961 TempNewSymbol package_sym = SymbolTable::new_symbol(package_name);
962 const PackageEntry* const pkg_entry =
963 get_package_entry_by_name(package_sym, h_loader);
964 const ModuleEntry* const module_entry = (pkg_entry != nullptr ? pkg_entry->module() : nullptr);
965
966 if (module_entry != nullptr && module_entry->module_oop() != nullptr && module_entry->is_named()) {
967 return module_entry->module_oop();
968 }
969 return nullptr;
970 }
971
972 // Export package in module to all unnamed modules.
973 void Modules::add_module_exports_to_all_unnamed(Handle module, jstring package_name, TRAPS) {
974 check_cds_restrictions(CHECK);
975 if (module.is_null()) {
976 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
977 "module is null");
978 }
979 if (package_name == nullptr) {
980 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
981 "package is null");
982 }
983 ModuleEntry* module_entry = get_module_entry(module, CHECK);
984 if (module_entry == nullptr) {
985 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
986 "module is invalid");
987 }
988
989 // No-op for unnamed module and open modules
990 if (!module_entry->is_named() || module_entry->is_open())
991 return;
992
993 ResourceMark rm(THREAD);
994 char buf[128];
|
260 }
261 }
262 }
263
264 // Caller needs ResourceMark.
265 static void throw_dup_pkg_exception(const char* module_name, PackageEntry* package, TRAPS) {
266 const char* package_name = package->name()->as_C_string();
267 if (package->module()->is_named()) {
268 THROW_MSG(vmSymbols::java_lang_IllegalStateException(),
269 err_msg("Package %s for module %s is already in another module, %s, defined to the class loader",
270 package_name, module_name, package->module()->name()->as_C_string()));
271 } else {
272 THROW_MSG(vmSymbols::java_lang_IllegalStateException(),
273 err_msg("Package %s for module %s is already in the unnamed module defined to the class loader",
274 package_name, module_name));
275 }
276 }
277
278 void Modules::define_module(Handle module, jboolean is_open, jstring version,
279 jstring location, jobjectArray packages, TRAPS) {
280 ResourceMark rm(THREAD);
281
282 if (module.is_null()) {
283 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null module object");
284 }
285
286 if (!java_lang_Module::is_instance(module())) {
287 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
288 "module is not an instance of type java.lang.Module");
289 }
290
291 int module_name_len;
292 char* module_name = get_module_name(module(), module_name_len, CHECK);
293 if (module_name == nullptr) {
294 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
295 "Module name cannot be null");
296 }
297
298 // Resolve packages
299 objArrayHandle packages_h(THREAD, objArrayOop(JNIHandles::resolve(packages)));
300 int num_packages = (packages_h.is_null() ? 0 : packages_h->length());
301 if (strncmp(module_name, "jdk.proxy", 9) != 0) {
302 check_cds_restrictions(Handle(), Handle(), CHECK);
303 }
304
305 // Special handling of java.base definition
306 if (strcmp(module_name, JAVA_BASE_NAME) == 0) {
307 assert(is_open == JNI_FALSE, "java.base module cannot be open");
308 define_javabase_module(module, version, location, packages_h, num_packages, CHECK);
309 return;
310 }
311
312 oop loader = java_lang_Module::loader(module());
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
319 // Only modules defined to either the boot or platform class loader, can define a "java/" package.
320 bool java_pkg_disallowed = !h_loader.is_null() &&
321 !SystemDictionary::is_platform_class_loader(h_loader());
322
323 // Check that the list of packages has no duplicates and that the
719 }
720
721 if (h_system_loader.is_null()) {
722 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null system loader object");
723 }
724
725 ClassLoaderData* platform_loader_data = SystemDictionary::register_loader(h_platform_loader);
726 SystemDictionary::set_platform_loader(platform_loader_data);
727 ClassLoaderDataShared::restore_java_platform_loader_from_archive(platform_loader_data);
728
729 ClassLoaderData* system_loader_data = SystemDictionary::register_loader(h_system_loader);
730 SystemDictionary::set_system_loader(system_loader_data);
731 // system_loader_data here is always an instance of jdk.internal.loader.ClassLoader$AppClassLoader.
732 // However, if -Djava.system.class.loader=xxx is specified, java_platform_loader() would
733 // be an instance of a user-defined class, so make sure this never happens.
734 assert(Arguments::get_property("java.system.class.loader") == nullptr,
735 "archived full module should have been disabled if -Djava.system.class.loader is specified");
736 ClassLoaderDataShared::restore_java_system_loader_from_archive(system_loader_data);
737 }
738
739 void Modules::check_cds_restrictions(Handle module1, Handle module2, TRAPS) {
740 if (CDSConfig::is_dumping_full_module_graph() && Universe::is_module_initialized()) {
741 if (CDSConfig::is_dumping_dynamic_proxies() && (is_dynamic_proxy_module(module1) || is_dynamic_proxy_module(module2))) {
742 // The only the we allow is to add or modify the jdk.proxy?? modules that are used for dynamic proxies.
743 } else {
744 THROW_MSG(vmSymbols::java_lang_UnsupportedOperationException(),
745 "During -Xshare:dump, module system cannot be modified after it's initialized");
746 }
747 }
748 }
749
750 #endif // INCLUDE_CDS_JAVA_HEAP
751
752 bool Modules::is_dynamic_proxy_module(Handle module) {
753 if (!module.is_null()) {
754 ModuleEntry* module_entry = java_lang_Module::module_entry(module());
755 return is_dynamic_proxy_module(module_entry);
756 }
757 return false;
758 }
759
760 bool Modules::is_dynamic_proxy_module(ModuleEntry* module_entry) {
761 return (module_entry != nullptr && module_entry->is_named() && module_entry->name()->starts_with("jdk.proxy"));
762 }
763
764 void Modules::set_bootloader_unnamed_module(Handle module, TRAPS) {
765 ResourceMark rm(THREAD);
766
767 if (module.is_null()) {
768 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null module object");
769 }
770 if (!java_lang_Module::is_instance(module())) {
771 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
772 "module is not an instance of type java.lang.Module");
773 }
774
775 // Ensure that this is an unnamed module
776 oop name = java_lang_Module::name(module());
777 if (name != nullptr) {
778 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
779 "boot loader's unnamed module's java.lang.Module has a name");
780 }
781
782 // Validate java_base's loader is the boot loader.
783 oop loader = java_lang_Module::loader(module());
790
791 // Set java.lang.Module for the boot loader's unnamed module
792 ClassLoaderData* boot_loader_data = ClassLoaderData::the_null_class_loader_data();
793 ModuleEntry* unnamed_module = boot_loader_data->unnamed_module();
794 assert(unnamed_module != nullptr, "boot loader's unnamed ModuleEntry not defined");
795
796 #if INCLUDE_CDS_JAVA_HEAP
797 if (CDSConfig::is_using_full_module_graph()) {
798 precond(unnamed_module == ClassLoaderDataShared::archived_boot_unnamed_module());
799 unnamed_module->restore_archived_oops(boot_loader_data);
800 } else
801 #endif
802 {
803 unnamed_module->set_module_handle(boot_loader_data->add_handle(module));
804 // Store pointer to the ModuleEntry in the unnamed module's java.lang.Module object.
805 java_lang_Module::set_module_entry(module(), unnamed_module);
806 }
807 }
808
809 void Modules::add_module_exports(Handle from_module, jstring package_name, Handle to_module, TRAPS) {
810 check_cds_restrictions(from_module, to_module, CHECK);
811
812 if (package_name == nullptr) {
813 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
814 "package is null");
815 }
816 if (from_module.is_null()) {
817 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
818 "from_module is null");
819 }
820 ModuleEntry* from_module_entry = get_module_entry(from_module, CHECK);
821 if (from_module_entry == nullptr) {
822 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
823 "from_module cannot be found");
824 }
825
826 // All packages in unnamed and open modules are exported by default.
827 if (!from_module_entry->is_named() || from_module_entry->is_open()) return;
828
829 ModuleEntry* to_module_entry;
830 if (to_module.is_null()) {
858 if (package_entry == nullptr) {
859 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
860 err_msg("Package %s not found in from_module %s",
861 pkg != nullptr ? pkg : "",
862 from_module_entry->name()->as_C_string()));
863 }
864
865 if (log_is_enabled(Debug, module)) {
866 log_debug(module)("add_module_exports(): package %s in module %s is exported to module %s",
867 package_entry->name()->as_C_string(),
868 from_module_entry->name()->as_C_string(),
869 to_module_entry == nullptr ? "null" :
870 to_module_entry->is_named() ?
871 to_module_entry->name()->as_C_string() : UNNAMED_MODULE);
872 }
873 }
874
875
876 void Modules::add_module_exports_qualified(Handle from_module, jstring package,
877 Handle to_module, TRAPS) {
878 check_cds_restrictions(from_module, to_module, CHECK);
879 if (to_module.is_null()) {
880 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
881 "to_module is null");
882 }
883 add_module_exports(from_module, package, to_module, CHECK);
884 }
885
886 void Modules::add_reads_module(Handle from_module, Handle to_module, TRAPS) {
887 check_cds_restrictions(from_module, to_module, CHECK);
888 if (from_module.is_null()) {
889 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
890 "from_module is null");
891 }
892
893 ModuleEntry* from_module_entry = get_module_entry(from_module, CHECK);
894 if (from_module_entry == nullptr) {
895 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
896 "from_module is not valid");
897 }
898
899 ModuleEntry* to_module_entry;
900 if (!to_module.is_null()) {
901 to_module_entry = get_module_entry(to_module, CHECK);
902 if (to_module_entry == nullptr) {
903 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
904 "to_module is invalid");
905 }
906 } else {
907 to_module_entry = nullptr;
973 assert(h_loader.is_null() || java_lang_ClassLoader::is_subclass(h_loader->klass()),
974 "Class loader is not a subclass of java.lang.ClassLoader");
975 assert(package_name != nullptr, "the package_name should not be null");
976
977 if (strlen(package_name) == 0) {
978 return nullptr;
979 }
980 TempNewSymbol package_sym = SymbolTable::new_symbol(package_name);
981 const PackageEntry* const pkg_entry =
982 get_package_entry_by_name(package_sym, h_loader);
983 const ModuleEntry* const module_entry = (pkg_entry != nullptr ? pkg_entry->module() : nullptr);
984
985 if (module_entry != nullptr && module_entry->module_oop() != nullptr && module_entry->is_named()) {
986 return module_entry->module_oop();
987 }
988 return nullptr;
989 }
990
991 // Export package in module to all unnamed modules.
992 void Modules::add_module_exports_to_all_unnamed(Handle module, jstring package_name, TRAPS) {
993 check_cds_restrictions(Handle(), module, CHECK);
994 if (module.is_null()) {
995 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
996 "module is null");
997 }
998 if (package_name == nullptr) {
999 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
1000 "package is null");
1001 }
1002 ModuleEntry* module_entry = get_module_entry(module, CHECK);
1003 if (module_entry == nullptr) {
1004 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
1005 "module is invalid");
1006 }
1007
1008 // No-op for unnamed module and open modules
1009 if (!module_entry->is_named() || module_entry->is_open())
1010 return;
1011
1012 ResourceMark rm(THREAD);
1013 char buf[128];
|