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
731 // Patch any previously loaded class's module field with java.base's java.lang.Module.
732 ModuleEntryTable::patch_javabase_entries(current, java_base_module);
733 }
734
735 ClassLoaderDataShared::load_archived_platform_and_system_class_loaders();
736
737 ClassLoaderData* platform_loader_data = SystemDictionary::register_loader(h_platform_loader);
738 SystemDictionary::set_platform_loader(platform_loader_data);
739 ClassLoaderDataShared::restore_java_platform_loader_from_archive(platform_loader_data);
740
741 ClassLoaderData* system_loader_data = SystemDictionary::register_loader(h_system_loader);
742 SystemDictionary::set_system_loader(system_loader_data);
743 // system_loader_data here is always an instance of jdk.internal.loader.ClassLoader$AppClassLoader.
744 // However, if -Djava.system.class.loader=xxx is specified, java_platform_loader() would
745 // be an instance of a user-defined class, so make sure this never happens.
746 assert(Arguments::get_property("java.system.class.loader") == nullptr,
747 "archived full module should have been disabled if -Djava.system.class.loader is specified");
748 ClassLoaderDataShared::restore_java_system_loader_from_archive(system_loader_data);
749 }
750
751 void Modules::check_cds_restrictions(TRAPS) {
752 if (CDSConfig::is_dumping_full_module_graph() && Universe::is_module_initialized()) {
753 THROW_MSG(vmSymbols::java_lang_UnsupportedOperationException(),
754 "During -Xshare:dump, module system cannot be modified after it's initialized");
755 }
756 }
757 #endif // INCLUDE_CDS_JAVA_HEAP
758
759 void Modules::set_bootloader_unnamed_module(Handle module, TRAPS) {
760 ResourceMark rm(THREAD);
761
762 if (module.is_null()) {
763 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null module object");
764 }
765 if (!java_lang_Module::is_instance(module())) {
766 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
767 "module is not an instance of type java.lang.Module");
768 }
769
770 // Ensure that this is an unnamed module
771 oop name = java_lang_Module::name(module());
772 if (name != nullptr) {
773 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
774 "boot loader's unnamed module's java.lang.Module has a name");
775 }
776
777 // Validate java_base's loader is the boot loader.
778 oop loader = java_lang_Module::loader(module());
787 ClassLoaderData* boot_loader_data = ClassLoaderData::the_null_class_loader_data();
788 ModuleEntry* unnamed_module = boot_loader_data->unnamed_module();
789 assert(unnamed_module != nullptr, "boot loader's unnamed ModuleEntry not defined");
790
791 #if INCLUDE_CDS_JAVA_HEAP
792 if (CDSConfig::is_using_full_module_graph()) {
793 precond(unnamed_module == ClassLoaderDataShared::archived_boot_unnamed_module());
794 if (!CDSConfig::is_using_aot_linked_classes()) {
795 unnamed_module->restore_archived_oops(boot_loader_data);
796 }
797 } else
798 #endif
799 {
800 unnamed_module->set_module_handle(boot_loader_data->add_handle(module));
801 // Store pointer to the ModuleEntry in the unnamed module's java.lang.Module object.
802 java_lang_Module::set_module_entry(module(), unnamed_module);
803 }
804 }
805
806 void Modules::add_module_exports(Handle from_module, jstring package_name, Handle to_module, TRAPS) {
807 check_cds_restrictions(CHECK);
808
809 if (package_name == nullptr) {
810 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
811 "package is null");
812 }
813 if (from_module.is_null()) {
814 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
815 "from_module is null");
816 }
817 ModuleEntry* from_module_entry = get_module_entry(from_module, CHECK);
818 if (from_module_entry == nullptr) {
819 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
820 "from_module cannot be found");
821 }
822
823 // All packages in unnamed and open modules are exported by default.
824 if (!from_module_entry->is_named() || from_module_entry->is_open()) return;
825
826 ModuleEntry* to_module_entry;
827 if (to_module.is_null()) {
855 if (package_entry == nullptr) {
856 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
857 err_msg("Package %s not found in from_module %s",
858 pkg != nullptr ? pkg : "",
859 from_module_entry->name()->as_C_string()));
860 }
861
862 if (log_is_enabled(Debug, module)) {
863 log_debug(module)("add_module_exports(): package %s in module %s is exported to module %s",
864 package_entry->name()->as_C_string(),
865 from_module_entry->name()->as_C_string(),
866 to_module_entry == nullptr ? "null" :
867 to_module_entry->is_named() ?
868 to_module_entry->name()->as_C_string() : UNNAMED_MODULE);
869 }
870 }
871
872
873 void Modules::add_module_exports_qualified(Handle from_module, jstring package,
874 Handle to_module, TRAPS) {
875 check_cds_restrictions(CHECK);
876 if (to_module.is_null()) {
877 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
878 "to_module is null");
879 }
880 add_module_exports(from_module, package, to_module, CHECK);
881 }
882
883 void Modules::add_reads_module(Handle from_module, Handle to_module, TRAPS) {
884 check_cds_restrictions(CHECK);
885 if (from_module.is_null()) {
886 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
887 "from_module is null");
888 }
889
890 ModuleEntry* from_module_entry = get_module_entry(from_module, CHECK);
891 if (from_module_entry == nullptr) {
892 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
893 "from_module is not valid");
894 }
895
896 ModuleEntry* to_module_entry;
897 if (!to_module.is_null()) {
898 to_module_entry = get_module_entry(to_module, CHECK);
899 if (to_module_entry == nullptr) {
900 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
901 "to_module is invalid");
902 }
903 } else {
904 to_module_entry = nullptr;
970 assert(h_loader.is_null() || java_lang_ClassLoader::is_subclass(h_loader->klass()),
971 "Class loader is not a subclass of java.lang.ClassLoader");
972 assert(package_name != nullptr, "the package_name should not be null");
973
974 if (strlen(package_name) == 0) {
975 return nullptr;
976 }
977 TempNewSymbol package_sym = SymbolTable::new_symbol(package_name);
978 const PackageEntry* const pkg_entry =
979 get_package_entry_by_name(package_sym, h_loader);
980 const ModuleEntry* const module_entry = (pkg_entry != nullptr ? pkg_entry->module() : nullptr);
981
982 if (module_entry != nullptr && module_entry->module_oop() != nullptr && module_entry->is_named()) {
983 return module_entry->module_oop();
984 }
985 return nullptr;
986 }
987
988 // Export package in module to all unnamed modules.
989 void Modules::add_module_exports_to_all_unnamed(Handle module, jstring package_name, TRAPS) {
990 check_cds_restrictions(CHECK);
991 if (module.is_null()) {
992 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
993 "module is null");
994 }
995 if (package_name == nullptr) {
996 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
997 "package is null");
998 }
999 ModuleEntry* module_entry = get_module_entry(module, CHECK);
1000 if (module_entry == nullptr) {
1001 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
1002 "module is invalid");
1003 }
1004
1005 // No-op for unnamed module and open modules
1006 if (!module_entry->is_named() || module_entry->is_open())
1007 return;
1008
1009 ResourceMark rm(THREAD);
1010 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
733 // Patch any previously loaded class's module field with java.base's java.lang.Module.
734 ModuleEntryTable::patch_javabase_entries(current, java_base_module);
735 }
736
737 ClassLoaderDataShared::load_archived_platform_and_system_class_loaders();
738
739 ClassLoaderData* platform_loader_data = SystemDictionary::register_loader(h_platform_loader);
740 SystemDictionary::set_platform_loader(platform_loader_data);
741 ClassLoaderDataShared::restore_java_platform_loader_from_archive(platform_loader_data);
742
743 ClassLoaderData* system_loader_data = SystemDictionary::register_loader(h_system_loader);
744 SystemDictionary::set_system_loader(system_loader_data);
745 // system_loader_data here is always an instance of jdk.internal.loader.ClassLoader$AppClassLoader.
746 // However, if -Djava.system.class.loader=xxx is specified, java_platform_loader() would
747 // be an instance of a user-defined class, so make sure this never happens.
748 assert(Arguments::get_property("java.system.class.loader") == nullptr,
749 "archived full module should have been disabled if -Djava.system.class.loader is specified");
750 ClassLoaderDataShared::restore_java_system_loader_from_archive(system_loader_data);
751 }
752
753 void Modules::check_cds_restrictions(Handle module1, Handle module2, TRAPS) {
754 if (CDSConfig::is_dumping_full_module_graph() && Universe::is_module_initialized()) {
755 if (CDSConfig::is_dumping_dynamic_proxies() && (is_dynamic_proxy_module(module1) || is_dynamic_proxy_module(module2))) {
756 // The only the we allow is to add or modify the jdk.proxy?? modules that are used for dynamic proxies.
757 } else {
758 THROW_MSG(vmSymbols::java_lang_UnsupportedOperationException(),
759 "During -Xshare:dump, module system cannot be modified after it's initialized");
760 }
761 }
762 }
763
764 #endif // INCLUDE_CDS_JAVA_HEAP
765
766 bool Modules::is_dynamic_proxy_module(Handle module) {
767 if (!module.is_null()) {
768 ModuleEntry* module_entry = java_lang_Module::module_entry(module());
769 return is_dynamic_proxy_module(module_entry);
770 }
771 return false;
772 }
773
774 bool Modules::is_dynamic_proxy_module(ModuleEntry* module_entry) {
775 return (module_entry != nullptr && module_entry->is_named() && module_entry->name()->starts_with("jdk.proxy"));
776 }
777
778 void Modules::set_bootloader_unnamed_module(Handle module, TRAPS) {
779 ResourceMark rm(THREAD);
780
781 if (module.is_null()) {
782 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null module object");
783 }
784 if (!java_lang_Module::is_instance(module())) {
785 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
786 "module is not an instance of type java.lang.Module");
787 }
788
789 // Ensure that this is an unnamed module
790 oop name = java_lang_Module::name(module());
791 if (name != nullptr) {
792 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
793 "boot loader's unnamed module's java.lang.Module has a name");
794 }
795
796 // Validate java_base's loader is the boot loader.
797 oop loader = java_lang_Module::loader(module());
806 ClassLoaderData* boot_loader_data = ClassLoaderData::the_null_class_loader_data();
807 ModuleEntry* unnamed_module = boot_loader_data->unnamed_module();
808 assert(unnamed_module != nullptr, "boot loader's unnamed ModuleEntry not defined");
809
810 #if INCLUDE_CDS_JAVA_HEAP
811 if (CDSConfig::is_using_full_module_graph()) {
812 precond(unnamed_module == ClassLoaderDataShared::archived_boot_unnamed_module());
813 if (!CDSConfig::is_using_aot_linked_classes()) {
814 unnamed_module->restore_archived_oops(boot_loader_data);
815 }
816 } else
817 #endif
818 {
819 unnamed_module->set_module_handle(boot_loader_data->add_handle(module));
820 // Store pointer to the ModuleEntry in the unnamed module's java.lang.Module object.
821 java_lang_Module::set_module_entry(module(), unnamed_module);
822 }
823 }
824
825 void Modules::add_module_exports(Handle from_module, jstring package_name, Handle to_module, TRAPS) {
826 check_cds_restrictions(from_module, to_module, CHECK);
827
828 if (package_name == nullptr) {
829 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
830 "package is null");
831 }
832 if (from_module.is_null()) {
833 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
834 "from_module is null");
835 }
836 ModuleEntry* from_module_entry = get_module_entry(from_module, CHECK);
837 if (from_module_entry == nullptr) {
838 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
839 "from_module cannot be found");
840 }
841
842 // All packages in unnamed and open modules are exported by default.
843 if (!from_module_entry->is_named() || from_module_entry->is_open()) return;
844
845 ModuleEntry* to_module_entry;
846 if (to_module.is_null()) {
874 if (package_entry == nullptr) {
875 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
876 err_msg("Package %s not found in from_module %s",
877 pkg != nullptr ? pkg : "",
878 from_module_entry->name()->as_C_string()));
879 }
880
881 if (log_is_enabled(Debug, module)) {
882 log_debug(module)("add_module_exports(): package %s in module %s is exported to module %s",
883 package_entry->name()->as_C_string(),
884 from_module_entry->name()->as_C_string(),
885 to_module_entry == nullptr ? "null" :
886 to_module_entry->is_named() ?
887 to_module_entry->name()->as_C_string() : UNNAMED_MODULE);
888 }
889 }
890
891
892 void Modules::add_module_exports_qualified(Handle from_module, jstring package,
893 Handle to_module, TRAPS) {
894 check_cds_restrictions(from_module, to_module, CHECK);
895 if (to_module.is_null()) {
896 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
897 "to_module is null");
898 }
899 add_module_exports(from_module, package, to_module, CHECK);
900 }
901
902 void Modules::add_reads_module(Handle from_module, Handle to_module, TRAPS) {
903 check_cds_restrictions(from_module, to_module, CHECK);
904 if (from_module.is_null()) {
905 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
906 "from_module is null");
907 }
908
909 ModuleEntry* from_module_entry = get_module_entry(from_module, CHECK);
910 if (from_module_entry == nullptr) {
911 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
912 "from_module is not valid");
913 }
914
915 ModuleEntry* to_module_entry;
916 if (!to_module.is_null()) {
917 to_module_entry = get_module_entry(to_module, CHECK);
918 if (to_module_entry == nullptr) {
919 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
920 "to_module is invalid");
921 }
922 } else {
923 to_module_entry = nullptr;
989 assert(h_loader.is_null() || java_lang_ClassLoader::is_subclass(h_loader->klass()),
990 "Class loader is not a subclass of java.lang.ClassLoader");
991 assert(package_name != nullptr, "the package_name should not be null");
992
993 if (strlen(package_name) == 0) {
994 return nullptr;
995 }
996 TempNewSymbol package_sym = SymbolTable::new_symbol(package_name);
997 const PackageEntry* const pkg_entry =
998 get_package_entry_by_name(package_sym, h_loader);
999 const ModuleEntry* const module_entry = (pkg_entry != nullptr ? pkg_entry->module() : nullptr);
1000
1001 if (module_entry != nullptr && module_entry->module_oop() != nullptr && module_entry->is_named()) {
1002 return module_entry->module_oop();
1003 }
1004 return nullptr;
1005 }
1006
1007 // Export package in module to all unnamed modules.
1008 void Modules::add_module_exports_to_all_unnamed(Handle module, jstring package_name, TRAPS) {
1009 check_cds_restrictions(Handle(), module, CHECK);
1010 if (module.is_null()) {
1011 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
1012 "module is null");
1013 }
1014 if (package_name == nullptr) {
1015 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
1016 "package is null");
1017 }
1018 ModuleEntry* module_entry = get_module_entry(module, CHECK);
1019 if (module_entry == nullptr) {
1020 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
1021 "module is invalid");
1022 }
1023
1024 // No-op for unnamed module and open modules
1025 if (!module_entry->is_named() || module_entry->is_open())
1026 return;
1027
1028 ResourceMark rm(THREAD);
1029 char buf[128];
|