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