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