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
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(TRAPS) {
740 if (CDSConfig::is_dumping_full_module_graph() && Universe::is_module_initialized()) {
741 THROW_MSG(vmSymbols::java_lang_UnsupportedOperationException(),
742 "During -Xshare:dump, module system cannot be modified after it's initialized");
743 }
744 }
745 #endif // INCLUDE_CDS_JAVA_HEAP
746
747 void Modules::set_bootloader_unnamed_module(Handle module, TRAPS) {
748 ResourceMark rm(THREAD);
749
750 if (module.is_null()) {
751 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null module object");
752 }
753 if (!java_lang_Module::is_instance(module())) {
754 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
755 "module is not an instance of type java.lang.Module");
756 }
757
758 // Ensure that this is an unnamed module
759 oop name = java_lang_Module::name(module());
760 if (name != nullptr) {
761 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
762 "boot loader's unnamed module's java.lang.Module has a name");
763 }
764
765 // Validate java_base's loader is the boot loader.
766 oop loader = java_lang_Module::loader(module());
767 if (loader != nullptr) {
768 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
769 "Class loader must be the boot class loader");
770 }
771
772 log_debug(module)("set_bootloader_unnamed_module(): recording unnamed module for boot loader");
773
774 // Set java.lang.Module for the boot loader's unnamed module
775 ClassLoaderData* boot_loader_data = ClassLoaderData::the_null_class_loader_data();
776 ModuleEntry* unnamed_module = boot_loader_data->unnamed_module();
777 assert(unnamed_module != nullptr, "boot loader's unnamed ModuleEntry not defined");
778 unnamed_module->set_module(boot_loader_data->add_handle(module));
779 // Store pointer to the ModuleEntry in the unnamed module's java.lang.Module object.
780 java_lang_Module::set_module_entry(module(), unnamed_module);
781 }
782
783 void Modules::add_module_exports(Handle from_module, jstring package_name, Handle to_module, TRAPS) {
784 check_cds_restrictions(CHECK);
785
786 if (package_name == nullptr) {
787 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
788 "package is null");
789 }
790 if (from_module.is_null()) {
791 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
792 "from_module is null");
793 }
794 ModuleEntry* from_module_entry = get_module_entry(from_module, CHECK);
795 if (from_module_entry == nullptr) {
796 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
797 "from_module cannot be found");
798 }
799
800 // All packages in unnamed and open modules are exported by default.
801 if (!from_module_entry->is_named() || from_module_entry->is_open()) return;
802
803 ModuleEntry* to_module_entry;
804 if (to_module.is_null()) {
832 if (package_entry == nullptr) {
833 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
834 err_msg("Package %s not found in from_module %s",
835 pkg != nullptr ? pkg : "",
836 from_module_entry->name()->as_C_string()));
837 }
838
839 if (log_is_enabled(Debug, module)) {
840 log_debug(module)("add_module_exports(): package %s in module %s is exported to module %s",
841 package_entry->name()->as_C_string(),
842 from_module_entry->name()->as_C_string(),
843 to_module_entry == nullptr ? "null" :
844 to_module_entry->is_named() ?
845 to_module_entry->name()->as_C_string() : UNNAMED_MODULE);
846 }
847 }
848
849
850 void Modules::add_module_exports_qualified(Handle from_module, jstring package,
851 Handle to_module, TRAPS) {
852 check_cds_restrictions(CHECK);
853 if (to_module.is_null()) {
854 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
855 "to_module is null");
856 }
857 add_module_exports(from_module, package, to_module, CHECK);
858 }
859
860 void Modules::add_reads_module(Handle from_module, Handle to_module, TRAPS) {
861 check_cds_restrictions(CHECK);
862 if (from_module.is_null()) {
863 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
864 "from_module is null");
865 }
866
867 ModuleEntry* from_module_entry = get_module_entry(from_module, CHECK);
868 if (from_module_entry == nullptr) {
869 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
870 "from_module is not valid");
871 }
872
873 ModuleEntry* to_module_entry;
874 if (!to_module.is_null()) {
875 to_module_entry = get_module_entry(to_module, CHECK);
876 if (to_module_entry == nullptr) {
877 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
878 "to_module is invalid");
879 }
880 } else {
881 to_module_entry = nullptr;
947 assert(h_loader.is_null() || java_lang_ClassLoader::is_subclass(h_loader->klass()),
948 "Class loader is not a subclass of java.lang.ClassLoader");
949 assert(package_name != nullptr, "the package_name should not be null");
950
951 if (strlen(package_name) == 0) {
952 return nullptr;
953 }
954 TempNewSymbol package_sym = SymbolTable::new_symbol(package_name);
955 const PackageEntry* const pkg_entry =
956 get_package_entry_by_name(package_sym, h_loader);
957 const ModuleEntry* const module_entry = (pkg_entry != nullptr ? pkg_entry->module() : nullptr);
958
959 if (module_entry != nullptr && module_entry->module() != nullptr && module_entry->is_named()) {
960 return module_entry->module();
961 }
962 return nullptr;
963 }
964
965 // Export package in module to all unnamed modules.
966 void Modules::add_module_exports_to_all_unnamed(Handle module, jstring package_name, TRAPS) {
967 check_cds_restrictions(CHECK);
968 if (module.is_null()) {
969 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
970 "module is null");
971 }
972 if (package_name == nullptr) {
973 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
974 "package is null");
975 }
976 ModuleEntry* module_entry = get_module_entry(module, CHECK);
977 if (module_entry == nullptr) {
978 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
979 "module is invalid");
980 }
981
982 // No-op for unnamed module and open modules
983 if (!module_entry->is_named() || module_entry->is_open())
984 return;
985
986 ResourceMark rm(THREAD);
987 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
721 }
722
723 if (h_system_loader.is_null()) {
724 THROW_MSG(vmSymbols::java_lang_NullPointerException(), "Null system loader object");
725 }
726
727 ClassLoaderData* platform_loader_data = SystemDictionary::register_loader(h_platform_loader);
728 SystemDictionary::set_platform_loader(platform_loader_data);
729 ClassLoaderDataShared::restore_java_platform_loader_from_archive(platform_loader_data);
730
731 ClassLoaderData* system_loader_data = SystemDictionary::register_loader(h_system_loader);
732 SystemDictionary::set_system_loader(system_loader_data);
733 // system_loader_data here is always an instance of jdk.internal.loader.ClassLoader$AppClassLoader.
734 // However, if -Djava.system.class.loader=xxx is specified, java_platform_loader() would
735 // be an instance of a user-defined class, so make sure this never happens.
736 assert(Arguments::get_property("java.system.class.loader") == nullptr,
737 "archived full module should have been disabled if -Djava.system.class.loader is specified");
738 ClassLoaderDataShared::restore_java_system_loader_from_archive(system_loader_data);
739 }
740
741 void Modules::check_cds_restrictions(Handle module1, Handle module2, TRAPS) {
742 if (CDSConfig::is_dumping_full_module_graph() && Universe::is_module_initialized()) {
743 if (CDSConfig::is_dumping_dynamic_proxies() && (is_dynamic_proxy_module(module1) || is_dynamic_proxy_module(module2))) {
744 // The only the we allow is to add or modify the jdk.proxy?? modules that are used for dynamic proxies.
745 } else {
746 THROW_MSG(vmSymbols::java_lang_UnsupportedOperationException(),
747 "During -Xshare:dump, module system cannot be modified after it's initialized");
748 }
749 }
750 }
751
752 #endif // INCLUDE_CDS_JAVA_HEAP
753
754 bool Modules::is_dynamic_proxy_module(Handle module) {
755 if (!module.is_null()) {
756 ModuleEntry* module_entry = java_lang_Module::module_entry(module());
757 return is_dynamic_proxy_module(module_entry);
758 }
759 return false;
760 }
761
762 bool Modules::is_dynamic_proxy_module(ModuleEntry* module_entry) {
763 return (module_entry != nullptr && module_entry->is_named() && module_entry->name()->starts_with("jdk.proxy"));
764 }
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());
786 if (loader != nullptr) {
787 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
788 "Class loader must be the boot class loader");
789 }
790
791 log_debug(module)("set_bootloader_unnamed_module(): recording unnamed module for boot loader");
792
793 // Set java.lang.Module for the boot loader's unnamed 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 unnamed_module->set_module(boot_loader_data->add_handle(module));
798 // Store pointer to the ModuleEntry in the unnamed module's java.lang.Module object.
799 java_lang_Module::set_module_entry(module(), unnamed_module);
800 }
801
802 void Modules::add_module_exports(Handle from_module, jstring package_name, Handle to_module, TRAPS) {
803 check_cds_restrictions(from_module, to_module, CHECK);
804
805 if (package_name == nullptr) {
806 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
807 "package is null");
808 }
809 if (from_module.is_null()) {
810 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
811 "from_module is null");
812 }
813 ModuleEntry* from_module_entry = get_module_entry(from_module, CHECK);
814 if (from_module_entry == nullptr) {
815 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
816 "from_module cannot be found");
817 }
818
819 // All packages in unnamed and open modules are exported by default.
820 if (!from_module_entry->is_named() || from_module_entry->is_open()) return;
821
822 ModuleEntry* to_module_entry;
823 if (to_module.is_null()) {
851 if (package_entry == nullptr) {
852 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
853 err_msg("Package %s not found in from_module %s",
854 pkg != nullptr ? pkg : "",
855 from_module_entry->name()->as_C_string()));
856 }
857
858 if (log_is_enabled(Debug, module)) {
859 log_debug(module)("add_module_exports(): package %s in module %s is exported to module %s",
860 package_entry->name()->as_C_string(),
861 from_module_entry->name()->as_C_string(),
862 to_module_entry == nullptr ? "null" :
863 to_module_entry->is_named() ?
864 to_module_entry->name()->as_C_string() : UNNAMED_MODULE);
865 }
866 }
867
868
869 void Modules::add_module_exports_qualified(Handle from_module, jstring package,
870 Handle to_module, TRAPS) {
871 check_cds_restrictions(from_module, to_module, CHECK);
872 if (to_module.is_null()) {
873 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
874 "to_module is null");
875 }
876 add_module_exports(from_module, package, to_module, CHECK);
877 }
878
879 void Modules::add_reads_module(Handle from_module, Handle to_module, TRAPS) {
880 check_cds_restrictions(from_module, to_module, CHECK);
881 if (from_module.is_null()) {
882 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
883 "from_module is null");
884 }
885
886 ModuleEntry* from_module_entry = get_module_entry(from_module, CHECK);
887 if (from_module_entry == nullptr) {
888 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
889 "from_module is not valid");
890 }
891
892 ModuleEntry* to_module_entry;
893 if (!to_module.is_null()) {
894 to_module_entry = get_module_entry(to_module, CHECK);
895 if (to_module_entry == nullptr) {
896 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
897 "to_module is invalid");
898 }
899 } else {
900 to_module_entry = nullptr;
966 assert(h_loader.is_null() || java_lang_ClassLoader::is_subclass(h_loader->klass()),
967 "Class loader is not a subclass of java.lang.ClassLoader");
968 assert(package_name != nullptr, "the package_name should not be null");
969
970 if (strlen(package_name) == 0) {
971 return nullptr;
972 }
973 TempNewSymbol package_sym = SymbolTable::new_symbol(package_name);
974 const PackageEntry* const pkg_entry =
975 get_package_entry_by_name(package_sym, h_loader);
976 const ModuleEntry* const module_entry = (pkg_entry != nullptr ? pkg_entry->module() : nullptr);
977
978 if (module_entry != nullptr && module_entry->module() != nullptr && module_entry->is_named()) {
979 return module_entry->module();
980 }
981 return nullptr;
982 }
983
984 // Export package in module to all unnamed modules.
985 void Modules::add_module_exports_to_all_unnamed(Handle module, jstring package_name, TRAPS) {
986 check_cds_restrictions(Handle(), module, CHECK);
987 if (module.is_null()) {
988 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
989 "module is null");
990 }
991 if (package_name == nullptr) {
992 THROW_MSG(vmSymbols::java_lang_NullPointerException(),
993 "package is null");
994 }
995 ModuleEntry* module_entry = get_module_entry(module, CHECK);
996 if (module_entry == nullptr) {
997 THROW_MSG(vmSymbols::java_lang_IllegalArgumentException(),
998 "module is invalid");
999 }
1000
1001 // No-op for unnamed module and open modules
1002 if (!module_entry->is_named() || module_entry->is_open())
1003 return;
1004
1005 ResourceMark rm(THREAD);
1006 char buf[128];
|