< prev index next >

src/hotspot/share/classfile/modules.cpp

Print this page

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