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