< prev index next >

src/hotspot/share/classfile/modules.cpp

Print this page

 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];
< prev index next >