1 /* 2 * Copyright (c) 2014, 2018, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 * 23 */ 24 25 #include "precompiled.hpp" 26 #include "classfile/classFileStream.hpp" 27 #include "classfile/classListParser.hpp" 28 #include "classfile/classLoader.hpp" 29 #include "classfile/classLoaderData.inline.hpp" 30 #include "classfile/classLoaderExt.hpp" 31 #include "classfile/compactHashtable.inline.hpp" 32 #include "classfile/dictionary.hpp" 33 #include "classfile/javaClasses.hpp" 34 #include "classfile/sharedClassUtil.hpp" 35 #include "classfile/symbolTable.hpp" 36 #include "classfile/systemDictionary.hpp" 37 #include "classfile/systemDictionaryShared.hpp" 38 #include "classfile/verificationType.hpp" 39 #include "classfile/vmSymbols.hpp" 40 #include "logging/log.hpp" 41 #include "memory/allocation.hpp" 42 #include "memory/filemap.hpp" 43 #include "memory/metadataFactory.hpp" 44 #include "memory/metaspaceClosure.hpp" 45 #include "memory/oopFactory.hpp" 46 #include "memory/resourceArea.hpp" 47 #include "oops/instanceKlass.hpp" 48 #include "oops/klass.inline.hpp" 49 #include "oops/objArrayOop.inline.hpp" 50 #include "oops/oop.inline.hpp" 51 #include "oops/typeArrayOop.inline.hpp" 52 #include "runtime/java.hpp" 53 #include "runtime/javaCalls.hpp" 54 #include "runtime/mutexLocker.hpp" 55 #include "utilities/hashtable.inline.hpp" 56 #include "utilities/stringUtils.hpp" 57 58 59 objArrayOop SystemDictionaryShared::_shared_protection_domains = NULL; 60 objArrayOop SystemDictionaryShared::_shared_jar_urls = NULL; 61 objArrayOop SystemDictionaryShared::_shared_jar_manifests = NULL; 62 63 static Mutex* SharedDictionary_lock = NULL; 64 65 void SystemDictionaryShared::initialize(TRAPS) { 66 if (_java_system_loader != NULL) { 67 SharedDictionary_lock = new Mutex(Mutex::leaf, "SharedDictionary_lock", true); 68 69 // These classes need to be initialized before calling get_shared_jar_manifest(), etc. 70 SystemDictionary::ByteArrayInputStream_klass()->initialize(CHECK); 71 SystemDictionary::File_klass()->initialize(CHECK); 72 SystemDictionary::Jar_Manifest_klass()->initialize(CHECK); 73 SystemDictionary::CodeSource_klass()->initialize(CHECK); 74 } 75 } 76 77 oop SystemDictionaryShared::shared_protection_domain(int index) { 78 return _shared_protection_domains->obj_at(index); 79 } 80 81 oop SystemDictionaryShared::shared_jar_url(int index) { 82 return _shared_jar_urls->obj_at(index); 83 } 84 85 oop SystemDictionaryShared::shared_jar_manifest(int index) { 86 return _shared_jar_manifests->obj_at(index); 87 } 88 89 90 Handle SystemDictionaryShared::get_shared_jar_manifest(int shared_path_index, TRAPS) { 91 Handle empty; 92 Handle manifest ; 93 if (shared_jar_manifest(shared_path_index) == NULL) { 94 SharedClassPathEntryExt* ent = (SharedClassPathEntryExt*)FileMapInfo::shared_classpath(shared_path_index); 95 long size = ent->manifest_size(); 96 if (size <= 0) { 97 return empty; // No manifest - return NULL handle 98 } 99 100 // ByteArrayInputStream bais = new ByteArrayInputStream(buf); 101 InstanceKlass* bais_klass = SystemDictionary::ByteArrayInputStream_klass(); 102 Handle bais = bais_klass->allocate_instance_handle(CHECK_(empty)); 103 { 104 const char* src = ent->manifest(); 105 assert(src != NULL, "No Manifest data"); 106 typeArrayOop buf = oopFactory::new_byteArray(size, CHECK_(empty)); 107 typeArrayHandle bufhandle(THREAD, buf); 108 char* dst = (char*)(buf->byte_at_addr(0)); 109 memcpy(dst, src, (size_t)size); 110 111 JavaValue result(T_VOID); 112 JavaCalls::call_special(&result, bais, bais_klass, 113 vmSymbols::object_initializer_name(), 114 vmSymbols::byte_array_void_signature(), 115 bufhandle, CHECK_(empty)); 116 } 117 118 // manifest = new Manifest(bais) 119 InstanceKlass* manifest_klass = SystemDictionary::Jar_Manifest_klass(); 120 manifest = manifest_klass->allocate_instance_handle(CHECK_(empty)); 121 { 122 JavaValue result(T_VOID); 123 JavaCalls::call_special(&result, manifest, manifest_klass, 124 vmSymbols::object_initializer_name(), 125 vmSymbols::input_stream_void_signature(), 126 bais, CHECK_(empty)); 127 } 128 atomic_set_shared_jar_manifest(shared_path_index, manifest()); 129 } 130 131 manifest = Handle(THREAD, shared_jar_manifest(shared_path_index)); 132 assert(manifest.not_null(), "sanity"); 133 return manifest; 134 } 135 136 Handle SystemDictionaryShared::get_shared_jar_url(int shared_path_index, TRAPS) { 137 Handle url_h; 138 if (shared_jar_url(shared_path_index) == NULL) { 139 JavaValue result(T_OBJECT); 140 const char* path = FileMapInfo::shared_classpath_name(shared_path_index); 141 Handle path_string = java_lang_String::create_from_str(path, CHECK_(url_h)); 142 Klass* classLoaders_klass = 143 SystemDictionary::jdk_internal_loader_ClassLoaders_klass(); 144 JavaCalls::call_static(&result, classLoaders_klass, 145 vmSymbols::toFileURL_name(), 146 vmSymbols::toFileURL_signature(), 147 path_string, CHECK_(url_h)); 148 149 atomic_set_shared_jar_url(shared_path_index, (oop)result.get_jobject()); 150 } 151 152 url_h = Handle(THREAD, shared_jar_url(shared_path_index)); 153 assert(url_h.not_null(), "sanity"); 154 return url_h; 155 } 156 157 Handle SystemDictionaryShared::get_package_name(Symbol* class_name, TRAPS) { 158 ResourceMark rm(THREAD); 159 Handle pkgname_string; 160 char* pkgname = (char*) ClassLoader::package_from_name((const char*) class_name->as_C_string()); 161 if (pkgname != NULL) { // Package prefix found 162 StringUtils::replace_no_expand(pkgname, "/", "."); 163 pkgname_string = java_lang_String::create_from_str(pkgname, 164 CHECK_(pkgname_string)); 165 } 166 return pkgname_string; 167 } 168 169 // Define Package for shared app classes from JAR file and also checks for 170 // package sealing (all done in Java code) 171 // See http://docs.oracle.com/javase/tutorial/deployment/jar/sealman.html 172 void SystemDictionaryShared::define_shared_package(Symbol* class_name, 173 Handle class_loader, 174 Handle manifest, 175 Handle url, 176 TRAPS) { 177 assert(class_loader == _java_system_loader, "unexpected class loader"); 178 // get_package_name() returns a NULL handle if the class is in unnamed package 179 Handle pkgname_string = get_package_name(class_name, CHECK); 180 if (pkgname_string.not_null()) { 181 Klass* app_classLoader_klass = SystemDictionary::jdk_internal_loader_ClassLoaders_AppClassLoader_klass(); 182 JavaValue result(T_OBJECT); 183 JavaCallArguments args(3); 184 args.set_receiver(class_loader); 185 args.push_oop(pkgname_string); 186 args.push_oop(manifest); 187 args.push_oop(url); 188 JavaCalls::call_virtual(&result, app_classLoader_klass, 189 vmSymbols::defineOrCheckPackage_name(), 190 vmSymbols::defineOrCheckPackage_signature(), 191 &args, 192 CHECK); 193 } 194 } 195 196 // Define Package for shared app/platform classes from named module 197 void SystemDictionaryShared::define_shared_package(Symbol* class_name, 198 Handle class_loader, 199 ModuleEntry* mod_entry, 200 TRAPS) { 201 assert(mod_entry != NULL, "module_entry should not be NULL"); 202 Handle module_handle(THREAD, mod_entry->module()); 203 204 Handle pkg_name = get_package_name(class_name, CHECK); 205 assert(pkg_name.not_null(), "Package should not be null for class in named module"); 206 207 Klass* classLoader_klass; 208 if (SystemDictionary::is_system_class_loader(class_loader())) { 209 classLoader_klass = SystemDictionary::jdk_internal_loader_ClassLoaders_AppClassLoader_klass(); 210 } else { 211 assert(SystemDictionary::is_platform_class_loader(class_loader()), "unexpected classloader"); 212 classLoader_klass = SystemDictionary::jdk_internal_loader_ClassLoaders_PlatformClassLoader_klass(); 213 } 214 215 JavaValue result(T_OBJECT); 216 JavaCallArguments args(2); 217 args.set_receiver(class_loader); 218 args.push_oop(pkg_name); 219 args.push_oop(module_handle); 220 JavaCalls::call_virtual(&result, classLoader_klass, 221 vmSymbols::definePackage_name(), 222 vmSymbols::definePackage_signature(), 223 &args, 224 CHECK); 225 } 226 227 // Get the ProtectionDomain associated with the CodeSource from the classloader. 228 Handle SystemDictionaryShared::get_protection_domain_from_classloader(Handle class_loader, 229 Handle url, TRAPS) { 230 // CodeSource cs = new CodeSource(url, null); 231 InstanceKlass* cs_klass = SystemDictionary::CodeSource_klass(); 232 Handle cs = cs_klass->allocate_instance_handle(CHECK_NH); 233 JavaValue void_result(T_VOID); 234 JavaCalls::call_special(&void_result, cs, cs_klass, 235 vmSymbols::object_initializer_name(), 236 vmSymbols::url_code_signer_array_void_signature(), 237 url, Handle(), CHECK_NH); 238 239 // protection_domain = SecureClassLoader.getProtectionDomain(cs); 240 Klass* secureClassLoader_klass = SystemDictionary::SecureClassLoader_klass(); 241 JavaValue obj_result(T_OBJECT); 242 JavaCalls::call_virtual(&obj_result, class_loader, secureClassLoader_klass, 243 vmSymbols::getProtectionDomain_name(), 244 vmSymbols::getProtectionDomain_signature(), 245 cs, CHECK_NH); 246 return Handle(THREAD, (oop)obj_result.get_jobject()); 247 } 248 249 // Returns the ProtectionDomain associated with the JAR file identified by the url. 250 Handle SystemDictionaryShared::get_shared_protection_domain(Handle class_loader, 251 int shared_path_index, 252 Handle url, 253 TRAPS) { 254 Handle protection_domain; 255 if (shared_protection_domain(shared_path_index) == NULL) { 256 Handle pd = get_protection_domain_from_classloader(class_loader, url, THREAD); 257 atomic_set_shared_protection_domain(shared_path_index, pd()); 258 } 259 260 // Acquire from the cache because if another thread beats the current one to 261 // set the shared protection_domain and the atomic_set fails, the current thread 262 // needs to get the updated protection_domain from the cache. 263 protection_domain = Handle(THREAD, shared_protection_domain(shared_path_index)); 264 assert(protection_domain.not_null(), "sanity"); 265 return protection_domain; 266 } 267 268 // Returns the ProtectionDomain associated with the moduleEntry. 269 Handle SystemDictionaryShared::get_shared_protection_domain(Handle class_loader, 270 ModuleEntry* mod, TRAPS) { 271 ClassLoaderData *loader_data = mod->loader_data(); 272 Handle protection_domain; 273 if (mod->shared_protection_domain() == NULL) { 274 Symbol* location = mod->location(); 275 if (location != NULL) { 276 Handle url_string = java_lang_String::create_from_symbol( 277 location, CHECK_(protection_domain)); 278 JavaValue result(T_OBJECT); 279 Klass* classLoaders_klass = 280 SystemDictionary::jdk_internal_loader_ClassLoaders_klass(); 281 JavaCalls::call_static(&result, classLoaders_klass, vmSymbols::toFileURL_name(), 282 vmSymbols::toFileURL_signature(), 283 url_string, CHECK_(protection_domain)); 284 Handle url = Handle(THREAD, (oop)result.get_jobject()); 285 286 Handle pd = get_protection_domain_from_classloader(class_loader, url, THREAD); 287 mod->set_shared_protection_domain(loader_data, pd); 288 } 289 } 290 291 protection_domain = Handle(THREAD, mod->shared_protection_domain()); 292 assert(protection_domain.not_null(), "sanity"); 293 return protection_domain; 294 } 295 296 // Initializes the java.lang.Package and java.security.ProtectionDomain objects associated with 297 // the given InstanceKlass. 298 // Returns the ProtectionDomain for the InstanceKlass. 299 Handle SystemDictionaryShared::init_security_info(Handle class_loader, InstanceKlass* ik, TRAPS) { 300 Handle pd; 301 302 if (ik != NULL) { 303 int index = ik->shared_classpath_index(); 304 assert(index >= 0, "Sanity"); 305 SharedClassPathEntryExt* ent = 306 (SharedClassPathEntryExt*)FileMapInfo::shared_classpath(index); 307 Symbol* class_name = ik->name(); 308 309 if (ent->is_modules_image()) { 310 // For shared app/platform classes originated from the run-time image: 311 // The ProtectionDomains are cached in the corresponding ModuleEntries 312 // for fast access by the VM. 313 ResourceMark rm; 314 ClassLoaderData *loader_data = 315 ClassLoaderData::class_loader_data(class_loader()); 316 PackageEntryTable* pkgEntryTable = loader_data->packages(); 317 TempNewSymbol pkg_name = InstanceKlass::package_from_name(class_name, CHECK_(pd)); 318 if (pkg_name != NULL) { 319 PackageEntry* pkg_entry = pkgEntryTable->lookup_only(pkg_name); 320 if (pkg_entry != NULL) { 321 ModuleEntry* mod_entry = pkg_entry->module(); 322 pd = get_shared_protection_domain(class_loader, mod_entry, THREAD); 323 define_shared_package(class_name, class_loader, mod_entry, CHECK_(pd)); 324 } 325 } 326 } else { 327 // For shared app/platform classes originated from JAR files on the class path: 328 // Each of the 3 SystemDictionaryShared::_shared_xxx arrays has the same length 329 // as the shared classpath table in the shared archive (see 330 // FileMap::_classpath_entry_table in filemap.hpp for details). 331 // 332 // If a shared InstanceKlass k is loaded from the class path, let 333 // 334 // index = k->shared_classpath_index(): 335 // 336 // FileMap::_classpath_entry_table[index] identifies the JAR file that contains k. 337 // 338 // k's protection domain is: 339 // 340 // ProtectionDomain pd = _shared_protection_domains[index]; 341 // 342 // and k's Package is initialized using 343 // 344 // manifest = _shared_jar_manifests[index]; 345 // url = _shared_jar_urls[index]; 346 // define_shared_package(class_name, class_loader, manifest, url, CHECK_(pd)); 347 // 348 // Note that if an element of these 3 _shared_xxx arrays is NULL, it will be initialized by 349 // the corresponding SystemDictionaryShared::get_shared_xxx() function. 350 Handle manifest = get_shared_jar_manifest(index, CHECK_(pd)); 351 Handle url = get_shared_jar_url(index, CHECK_(pd)); 352 define_shared_package(class_name, class_loader, manifest, url, CHECK_(pd)); 353 pd = get_shared_protection_domain(class_loader, index, url, CHECK_(pd)); 354 } 355 } 356 return pd; 357 } 358 359 // Currently AppCDS only archives classes from the run-time image, the 360 // -Xbootclasspath/a path, and the class path. The following rules need to be 361 // revised when AppCDS is changed to archive classes from other code sources 362 // in the future, for example the module path (specified by -p). 363 // 364 // Check if a shared class can be loaded by the specific classloader. Following 365 // are the "visible" archived classes for different classloaders. 366 // 367 // NULL classloader: 368 // - see SystemDictionary::is_shared_class_visible() 369 // Platform classloader: 370 // - Module class from "modules" jimage. ModuleEntry must be defined in the 371 // classloader. 372 // App Classloader: 373 // - Module class from "modules" jimage. ModuleEntry must be defined in the 374 // classloader. 375 // - Class from -cp. The class must have no PackageEntry defined in any of the 376 // boot/platform/app classloader, or must be in the unnamed module defined in the 377 // AppClassLoader. 378 bool SystemDictionaryShared::is_shared_class_visible_for_classloader( 379 InstanceKlass* ik, 380 Handle class_loader, 381 const char* pkg_string, 382 Symbol* pkg_name, 383 PackageEntry* pkg_entry, 384 ModuleEntry* mod_entry, 385 TRAPS) { 386 assert(class_loader.not_null(), "Class loader should not be NULL"); 387 assert(Universe::is_module_initialized(), "Module system is not initialized"); 388 389 int path_index = ik->shared_classpath_index(); 390 SharedClassPathEntry* ent = 391 (SharedClassPathEntry*)FileMapInfo::shared_classpath(path_index); 392 393 if (SystemDictionary::is_platform_class_loader(class_loader())) { 394 assert(ent != NULL, "shared class for PlatformClassLoader should have valid SharedClassPathEntry"); 395 // The PlatformClassLoader can only load archived class originated from the 396 // run-time image. The class' PackageEntry/ModuleEntry must be 397 // defined by the PlatformClassLoader. 398 if (mod_entry != NULL) { 399 // PackageEntry/ModuleEntry is found in the classloader. Check if the 400 // ModuleEntry's location agrees with the archived class' origination. 401 if (ent->is_modules_image() && mod_entry->location()->starts_with("jrt:")) { 402 return true; // Module class from the "modules" jimage 403 } 404 } 405 } else if (SystemDictionary::is_system_class_loader(class_loader())) { 406 assert(ent != NULL, "shared class for system loader should have valid SharedClassPathEntry"); 407 if (pkg_string == NULL) { 408 // The archived class is in the unnamed package. Currently, the boot image 409 // does not contain any class in the unnamed package. 410 assert(!ent->is_modules_image(), "Class in the unnamed package must be from the classpath"); 411 if (path_index >= ClassLoaderExt::app_paths_start_index()) { 412 return true; 413 } 414 } else { 415 // Check if this is from a PackageEntry/ModuleEntry defined in the AppClassloader. 416 if (pkg_entry == NULL) { 417 // It's not guaranteed that the class is from the classpath if the 418 // PackageEntry cannot be found from the AppClassloader. Need to check 419 // the boot and platform classloader as well. 420 if (get_package_entry(pkg_name, ClassLoaderData::class_loader_data_or_null(SystemDictionary::java_platform_loader())) == NULL && 421 get_package_entry(pkg_name, ClassLoaderData::the_null_class_loader_data()) == NULL) { 422 // The PackageEntry is not defined in any of the boot/platform/app classloaders. 423 // The archived class must from -cp path and not from the run-time image. 424 if (!ent->is_modules_image() && path_index >= ClassLoaderExt::app_paths_start_index()) { 425 return true; 426 } 427 } 428 } else if (mod_entry != NULL) { 429 // The package/module is defined in the AppClassLoader. Currently we only 430 // support archiving application module class from the run-time image. 431 // Packages from the -cp path are in the unnamed_module. 432 if ((ent->is_modules_image() && mod_entry->location()->starts_with("jrt:")) || 433 (pkg_entry->in_unnamed_module() && path_index >= ClassLoaderExt::app_paths_start_index())) { 434 DEBUG_ONLY( \ 435 ClassLoaderData* loader_data = class_loader_data(class_loader); \ 436 if (pkg_entry->in_unnamed_module()) \ 437 assert(mod_entry == loader_data->unnamed_module(), "the unnamed module is not defined in the classloader");) 438 439 return true; 440 } 441 } 442 } 443 } else { 444 // TEMP: if a shared class can be found by a custom loader, consider it visible now. 445 // FIXME: is this actually correct? 446 return true; 447 } 448 return false; 449 } 450 451 // The following stack shows how this code is reached: 452 // 453 // [0] SystemDictionaryShared::find_or_load_shared_class() 454 // [1] JVM_FindLoadedClass 455 // [2] java.lang.ClassLoader.findLoadedClass0() 456 // [3] java.lang.ClassLoader.findLoadedClass() 457 // [4] java.lang.ClassLoader.loadClass() 458 // [5] jdk.internal.loader.ClassLoaders$AppClassLoader_klass.loadClass() 459 // 460 // Because AppCDS supports only the PlatformClassLoader and AppClassLoader, we make the following 461 // assumptions (based on the JDK 8.0 source code): 462 // 463 // [a] these two loaders use the default implementation of 464 // ClassLoader.loadClass(String name, boolean resolve), which 465 // [b] calls findLoadedClass(name), immediately followed by parent.loadClass(), 466 // immediately followed by findClass(name). 467 // [c] If the requested class is a shared class of the current class loader, parent.loadClass() 468 // always returns null, and 469 // [d] if AppCDS is not enabled, the class would be loaded by findClass() by decoding it from a 470 // JAR file and then parsed. 471 // 472 // Given these assumptions, we intercept the findLoadedClass() call to invoke 473 // SystemDictionaryShared::find_or_load_shared_class() to load the shared class from 474 // the archive. The reasons are: 475 // 476 // + Because AppCDS is a commercial feature, we want to hide the implementation. There 477 // is currently no easy way to hide Java code, so we did it with native code. 478 // + Start-up is improved because we avoid decoding the JAR file, and avoid delegating 479 // to the parent (since we know the parent will not find this class). 480 // 481 // NOTE: there's a lot of assumption about the Java code. If any of that change, this 482 // needs to be redesigned. 483 // 484 // An alternative is to modify the Java code of AppClassLoader.loadClass(). 485 // 486 InstanceKlass* SystemDictionaryShared::find_or_load_shared_class( 487 Symbol* name, Handle class_loader, TRAPS) { 488 if (DumpSharedSpaces) { 489 return NULL; 490 } 491 492 InstanceKlass* k = NULL; 493 if (shared_dictionary() != NULL && 494 UseAppCDS && (SystemDictionary::is_system_class_loader(class_loader()) || 495 SystemDictionary::is_platform_class_loader(class_loader()))) { 496 497 // Fix for 4474172; see evaluation for more details 498 class_loader = Handle( 499 THREAD, java_lang_ClassLoader::non_reflection_class_loader(class_loader())); 500 ClassLoaderData *loader_data = register_loader(class_loader); 501 Dictionary* dictionary = loader_data->dictionary(); 502 503 unsigned int d_hash = dictionary->compute_hash(name); 504 505 bool DoObjectLock = true; 506 if (is_parallelCapable(class_loader)) { 507 DoObjectLock = false; 508 } 509 510 // Make sure we are synchronized on the class loader before we proceed 511 // 512 // Note: currently, find_or_load_shared_class is called only from 513 // JVM_FindLoadedClass and used for PlatformClassLoader and AppClassLoader, 514 // which are parallel-capable loaders, so this lock is NOT taken. 515 Handle lockObject = compute_loader_lock_object(class_loader, THREAD); 516 check_loader_lock_contention(lockObject, THREAD); 517 ObjectLocker ol(lockObject, THREAD, DoObjectLock); 518 519 { 520 MutexLocker mu(SystemDictionary_lock, THREAD); 521 Klass* check = find_class(d_hash, name, dictionary); 522 if (check != NULL) { 523 return InstanceKlass::cast(check); 524 } 525 } 526 527 k = load_shared_class_for_builtin_loader(name, class_loader, THREAD); 528 if (k != NULL) { 529 define_instance_class(k, CHECK_NULL); 530 } 531 } 532 533 return k; 534 } 535 536 InstanceKlass* SystemDictionaryShared::load_shared_class_for_builtin_loader( 537 Symbol* class_name, Handle class_loader, TRAPS) { 538 assert(UseAppCDS && shared_dictionary() != NULL, "already checked"); 539 Klass* k = shared_dictionary()->find_class_for_builtin_loader(class_name); 540 541 if (k != NULL) { 542 InstanceKlass* ik = InstanceKlass::cast(k); 543 if ((ik->is_shared_app_class() && 544 SystemDictionary::is_system_class_loader(class_loader())) || 545 (ik->is_shared_platform_class() && 546 SystemDictionary::is_platform_class_loader(class_loader()))) { 547 Handle protection_domain = 548 SystemDictionaryShared::init_security_info(class_loader, ik, CHECK_NULL); 549 return load_shared_class(ik, class_loader, protection_domain, THREAD); 550 } 551 } 552 553 return NULL; 554 } 555 556 void SystemDictionaryShared::oops_do(OopClosure* f) { 557 f->do_oop((oop*)&_shared_protection_domains); 558 f->do_oop((oop*)&_shared_jar_urls); 559 f->do_oop((oop*)&_shared_jar_manifests); 560 } 561 562 void SystemDictionaryShared::allocate_shared_protection_domain_array(int size, TRAPS) { 563 if (_shared_protection_domains == NULL) { 564 _shared_protection_domains = oopFactory::new_objArray( 565 SystemDictionary::ProtectionDomain_klass(), size, CHECK); 566 } 567 } 568 569 void SystemDictionaryShared::allocate_shared_jar_url_array(int size, TRAPS) { 570 if (_shared_jar_urls == NULL) { 571 _shared_jar_urls = oopFactory::new_objArray( 572 SystemDictionary::URL_klass(), size, CHECK); 573 } 574 } 575 576 void SystemDictionaryShared::allocate_shared_jar_manifest_array(int size, TRAPS) { 577 if (_shared_jar_manifests == NULL) { 578 _shared_jar_manifests = oopFactory::new_objArray( 579 SystemDictionary::Jar_Manifest_klass(), size, CHECK); 580 } 581 } 582 583 void SystemDictionaryShared::allocate_shared_data_arrays(int size, TRAPS) { 584 allocate_shared_protection_domain_array(size, CHECK); 585 allocate_shared_jar_url_array(size, CHECK); 586 allocate_shared_jar_manifest_array(size, CHECK); 587 } 588 589 590 InstanceKlass* SystemDictionaryShared::lookup_from_stream(const Symbol* class_name, 591 Handle class_loader, 592 Handle protection_domain, 593 const ClassFileStream* cfs, 594 TRAPS) { 595 if (!UseAppCDS || shared_dictionary() == NULL) { 596 return NULL; 597 } 598 if (class_name == NULL) { // don't do this for anonymous classes 599 return NULL; 600 } 601 if (class_loader.is_null() || 602 SystemDictionary::is_system_class_loader(class_loader()) || 603 SystemDictionary::is_platform_class_loader(class_loader())) { 604 // This function is called for loading only UNREGISTERED classes. 605 // Do nothing for the BUILTIN loaders. 606 return NULL; 607 } 608 609 ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(class_loader()); 610 Klass* k; 611 612 { // UNREGISTERED loader 613 if (!shared_dictionary()->class_exists_for_unregistered_loader(class_name)) { 614 // No classes of this name for unregistered loaders. 615 return NULL; 616 } 617 618 int clsfile_size = cfs->length(); 619 int clsfile_crc32 = ClassLoader::crc32(0, (const char*)cfs->buffer(), cfs->length()); 620 621 k = shared_dictionary()->find_class_for_unregistered_loader(class_name, 622 clsfile_size, clsfile_crc32); 623 } 624 625 if (k == NULL) { // not archived 626 return NULL; 627 } 628 629 return acquire_class_for_current_thread(InstanceKlass::cast(k), class_loader, 630 protection_domain, THREAD); 631 } 632 633 InstanceKlass* SystemDictionaryShared::acquire_class_for_current_thread( 634 InstanceKlass *ik, 635 Handle class_loader, 636 Handle protection_domain, 637 TRAPS) { 638 ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(class_loader()); 639 640 { 641 MutexLocker mu(SharedDictionary_lock, THREAD); 642 if (ik->class_loader_data() != NULL) { 643 // ik is already loaded (by this loader or by a different loader) 644 // or ik is being loaded by a different thread (by this loader or by a different loader) 645 return NULL; 646 } 647 648 // No other thread has acquired this yet, so give it to *this thread* 649 ik->set_class_loader_data(loader_data); 650 } 651 652 // No longer holding SharedDictionary_lock 653 // No need to lock, as <ik> can be held only by a single thread. 654 loader_data->add_class(ik); 655 656 // Load and check super/interfaces, restore unsharable info 657 InstanceKlass* shared_klass = load_shared_class(ik, class_loader, protection_domain, THREAD); 658 if (shared_klass == NULL || HAS_PENDING_EXCEPTION) { 659 // TODO: clean up <ik> so it can be used again 660 return NULL; 661 } 662 663 return shared_klass; 664 } 665 666 bool SystemDictionaryShared::add_non_builtin_klass(Symbol* name, ClassLoaderData* loader_data, 667 InstanceKlass* k, 668 TRAPS) { 669 assert(DumpSharedSpaces, "only when dumping"); 670 assert(UseAppCDS && boot_loader_dictionary() != NULL, "must be"); 671 672 if (boot_loader_dictionary()->add_non_builtin_klass(name, loader_data, k)) { 673 MutexLocker mu_r(Compile_lock, THREAD); // not really necessary, but add_to_hierarchy asserts this. 674 add_to_hierarchy(k, CHECK_0); 675 return true; 676 } 677 return false; 678 } 679 680 // This function is called to resolve the super/interfaces of shared classes for 681 // non-built-in loaders. E.g., ChildClass in the below example 682 // where "super:" (and optionally "interface:") have been specified. 683 // 684 // java/lang/Object id: 0 685 // Interface id: 2 super: 0 source: cust.jar 686 // ChildClass id: 4 super: 0 interfaces: 2 source: cust.jar 687 Klass* SystemDictionaryShared::dump_time_resolve_super_or_fail( 688 Symbol* child_name, Symbol* class_name, Handle class_loader, 689 Handle protection_domain, bool is_superclass, TRAPS) { 690 691 assert(DumpSharedSpaces, "only when dumping"); 692 693 ClassListParser* parser = ClassListParser::instance(); 694 if (parser == NULL) { 695 // We're still loading the well-known classes, before the ClassListParser is created. 696 return NULL; 697 } 698 if (child_name->equals(parser->current_class_name())) { 699 // When this function is called, all the numbered super and interface types 700 // must have already been loaded. Hence this function is never recursively called. 701 if (is_superclass) { 702 return parser->lookup_super_for_current_class(class_name); 703 } else { 704 return parser->lookup_interface_for_current_class(class_name); 705 } 706 } else { 707 // The VM is not trying to resolve a super type of parser->current_class_name(). 708 // Instead, it's resolving an error class (because parser->current_class_name() has 709 // failed parsing or verification). Don't do anything here. 710 return NULL; 711 } 712 } 713 714 struct SharedMiscInfo { 715 Klass* _klass; 716 int _clsfile_size; 717 int _clsfile_crc32; 718 }; 719 720 static GrowableArray<SharedMiscInfo>* misc_info_array = NULL; 721 722 void SystemDictionaryShared::set_shared_class_misc_info(Klass* k, ClassFileStream* cfs) { 723 assert(DumpSharedSpaces, "only when dumping"); 724 int clsfile_size = cfs->length(); 725 int clsfile_crc32 = ClassLoader::crc32(0, (const char*)cfs->buffer(), cfs->length()); 726 727 if (misc_info_array == NULL) { 728 misc_info_array = new (ResourceObj::C_HEAP, mtClass) GrowableArray<SharedMiscInfo>(20, /*c heap*/ true); 729 } 730 731 SharedMiscInfo misc_info; 732 DEBUG_ONLY({ 733 for (int i=0; i<misc_info_array->length(); i++) { 734 misc_info = misc_info_array->at(i); 735 assert(misc_info._klass != k, "cannot call set_shared_class_misc_info twice for the same class"); 736 } 737 }); 738 739 misc_info._klass = k; 740 misc_info._clsfile_size = clsfile_size; 741 misc_info._clsfile_crc32 = clsfile_crc32; 742 743 misc_info_array->append(misc_info); 744 } 745 746 void SystemDictionaryShared::init_shared_dictionary_entry(Klass* k, DictionaryEntry* ent) { 747 SharedDictionaryEntry* entry = (SharedDictionaryEntry*)ent; 748 entry->_id = -1; 749 entry->_clsfile_size = -1; 750 entry->_clsfile_crc32 = -1; 751 entry->_verifier_constraints = NULL; 752 entry->_verifier_constraint_flags = NULL; 753 754 if (misc_info_array != NULL) { 755 for (int i=0; i<misc_info_array->length(); i++) { 756 SharedMiscInfo misc_info = misc_info_array->at(i); 757 if (misc_info._klass == k) { 758 entry->_clsfile_size = misc_info._clsfile_size; 759 entry->_clsfile_crc32 = misc_info._clsfile_crc32; 760 misc_info_array->remove_at(i); 761 return; 762 } 763 } 764 } 765 } 766 767 bool SystemDictionaryShared::add_verification_constraint(Klass* k, Symbol* name, 768 Symbol* from_name, bool from_field_is_protected, bool from_is_array, bool from_is_object) { 769 assert(DumpSharedSpaces, "called at dump time only"); 770 771 // Skip anonymous classes, which are not archived as they are not in 772 // dictionary (see assert_no_anonymoys_classes_in_dictionaries() in 773 // VM_PopulateDumpSharedSpace::doit()). 774 if (k->class_loader_data()->is_anonymous()) { 775 return true; // anonymous classes are not archived, skip 776 } 777 778 SharedDictionaryEntry* entry = ((SharedDictionary*)(k->class_loader_data()->dictionary()))->find_entry_for(k); 779 ResourceMark rm; 780 // Lambda classes are not archived and will be regenerated at runtime. 781 if (entry == NULL && strstr(k->name()->as_C_string(), "Lambda$") != NULL) { 782 return true; 783 } 784 assert(entry != NULL, "class should be in dictionary before being verified"); 785 entry->add_verification_constraint(name, from_name, from_field_is_protected, 786 from_is_array, from_is_object); 787 if (entry->is_builtin()) { 788 // For builtin class loaders, we can try to complete the verification check at dump time, 789 // because we can resolve all the constraint classes. 790 return false; 791 } else { 792 // For non-builtin class loaders, we cannot complete the verification check at dump time, 793 // because at dump time we don't know how to resolve classes for such loaders. 794 return true; 795 } 796 } 797 798 void SystemDictionaryShared::finalize_verification_constraints() { 799 boot_loader_dictionary()->finalize_verification_constraints(); 800 } 801 802 void SystemDictionaryShared::check_verification_constraints(InstanceKlass* klass, 803 TRAPS) { 804 assert(!DumpSharedSpaces && UseSharedSpaces, "called at run time with CDS enabled only"); 805 SharedDictionaryEntry* entry = shared_dictionary()->find_entry_for(klass); 806 assert(entry != NULL, "call this only for shared classes"); 807 entry->check_verification_constraints(klass, THREAD); 808 } 809 810 SharedDictionaryEntry* SharedDictionary::find_entry_for(Klass* klass) { 811 Symbol* class_name = klass->name(); 812 unsigned int hash = compute_hash(class_name); 813 int index = hash_to_index(hash); 814 815 for (SharedDictionaryEntry* entry = bucket(index); 816 entry != NULL; 817 entry = entry->next()) { 818 if (entry->hash() == hash && entry->literal() == klass) { 819 return entry; 820 } 821 } 822 823 return NULL; 824 } 825 826 void SharedDictionary::finalize_verification_constraints() { 827 int bytes = 0, count = 0; 828 for (int index = 0; index < table_size(); index++) { 829 for (SharedDictionaryEntry *probe = bucket(index); 830 probe != NULL; 831 probe = probe->next()) { 832 int n = probe->finalize_verification_constraints(); 833 if (n > 0) { 834 bytes += n; 835 count ++; 836 } 837 } 838 } 839 if (log_is_enabled(Info, cds, verification)) { 840 double avg = 0; 841 if (count > 0) { 842 avg = double(bytes) / double(count); 843 } 844 log_info(cds, verification)("Recorded verification constraints for %d classes = %d bytes (avg = %.2f bytes) ", count, bytes, avg); 845 } 846 } 847 848 void SharedDictionaryEntry::add_verification_constraint(Symbol* name, 849 Symbol* from_name, bool from_field_is_protected, bool from_is_array, bool from_is_object) { 850 if (_verifier_constraints == NULL) { 851 _verifier_constraints = new(ResourceObj::C_HEAP, mtClass) GrowableArray<Symbol*>(8, true, mtClass); 852 } 853 if (_verifier_constraint_flags == NULL) { 854 _verifier_constraint_flags = new(ResourceObj::C_HEAP, mtClass) GrowableArray<char>(4, true, mtClass); 855 } 856 GrowableArray<Symbol*>* vc_array = (GrowableArray<Symbol*>*)_verifier_constraints; 857 for (int i=0; i<vc_array->length(); i+= 2) { 858 if (name == vc_array->at(i) && 859 from_name == vc_array->at(i+1)) { 860 return; 861 } 862 } 863 vc_array->append(name); 864 vc_array->append(from_name); 865 866 GrowableArray<char>* vcflags_array = (GrowableArray<char>*)_verifier_constraint_flags; 867 char c = 0; 868 c |= from_field_is_protected ? FROM_FIELD_IS_PROTECTED : 0; 869 c |= from_is_array ? FROM_IS_ARRAY : 0; 870 c |= from_is_object ? FROM_IS_OBJECT : 0; 871 vcflags_array->append(c); 872 873 if (log_is_enabled(Trace, cds, verification)) { 874 ResourceMark rm; 875 log_trace(cds, verification)("add_verification_constraint: %s: %s must be subclass of %s", 876 instance_klass()->external_name(), from_name->as_klass_external_name(), 877 name->as_klass_external_name()); 878 } 879 } 880 881 int SharedDictionaryEntry::finalize_verification_constraints() { 882 assert(DumpSharedSpaces, "called at dump time only"); 883 Thread* THREAD = Thread::current(); 884 ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data(); 885 GrowableArray<Symbol*>* vc_array = (GrowableArray<Symbol*>*)_verifier_constraints; 886 GrowableArray<char>* vcflags_array = (GrowableArray<char>*)_verifier_constraint_flags; 887 888 if (vc_array != NULL) { 889 if (log_is_enabled(Trace, cds, verification)) { 890 ResourceMark rm; 891 log_trace(cds, verification)("finalize_verification_constraint: %s", 892 literal()->external_name()); 893 } 894 895 // Copy the constraints from C_HEAP-alloced GrowableArrays to Metaspace-alloced 896 // Arrays 897 int size = 0; 898 { 899 // FIXME: change this to be done after relocation, so we can use symbol offset?? 900 int length = vc_array->length(); 901 Array<Symbol*>* out = MetadataFactory::new_array<Symbol*>(loader_data, length, 0, THREAD); 902 assert(out != NULL, "Dump time allocation failure would have aborted VM"); 903 for (int i=0; i<length; i++) { 904 out->at_put(i, vc_array->at(i)); 905 } 906 _verifier_constraints = out; 907 size += out->size() * BytesPerWord; 908 delete vc_array; 909 } 910 { 911 int length = vcflags_array->length(); 912 Array<char>* out = MetadataFactory::new_array<char>(loader_data, length, 0, THREAD); 913 assert(out != NULL, "Dump time allocation failure would have aborted VM"); 914 for (int i=0; i<length; i++) { 915 out->at_put(i, vcflags_array->at(i)); 916 } 917 _verifier_constraint_flags = out; 918 size += out->size() * BytesPerWord; 919 delete vcflags_array; 920 } 921 922 return size; 923 } 924 return 0; 925 } 926 927 void SharedDictionaryEntry::check_verification_constraints(InstanceKlass* klass, TRAPS) { 928 Array<Symbol*>* vc_array = (Array<Symbol*>*)_verifier_constraints; 929 Array<char>* vcflags_array = (Array<char>*)_verifier_constraint_flags; 930 931 if (vc_array != NULL) { 932 int length = vc_array->length(); 933 for (int i=0; i<length; i+=2) { 934 Symbol* name = vc_array->at(i); 935 Symbol* from_name = vc_array->at(i+1); 936 char c = vcflags_array->at(i/2); 937 938 bool from_field_is_protected = (c & FROM_FIELD_IS_PROTECTED) ? true : false; 939 bool from_is_array = (c & FROM_IS_ARRAY) ? true : false; 940 bool from_is_object = (c & FROM_IS_OBJECT) ? true : false; 941 942 bool ok = VerificationType::resolve_and_check_assignability(klass, name, 943 from_name, from_field_is_protected, from_is_array, from_is_object, CHECK); 944 if (!ok) { 945 ResourceMark rm(THREAD); 946 stringStream ss; 947 948 ss.print_cr("Bad type on operand stack"); 949 ss.print_cr("Exception Details:"); 950 ss.print_cr(" Location:\n %s", klass->name()->as_C_string()); 951 ss.print_cr(" Reason:\n Type '%s' is not assignable to '%s'", 952 from_name->as_quoted_ascii(), name->as_quoted_ascii()); 953 THROW_MSG(vmSymbols::java_lang_VerifyError(), ss.as_string()); 954 } 955 } 956 } 957 } 958 959 void SharedDictionaryEntry::metaspace_pointers_do(MetaspaceClosure* it) { 960 it->push((Array<Symbol*>**)&_verifier_constraints); 961 it->push((Array<char>**)&_verifier_constraint_flags); 962 } 963 964 bool SharedDictionary::add_non_builtin_klass(const Symbol* class_name, 965 ClassLoaderData* loader_data, 966 InstanceKlass* klass) { 967 968 assert(DumpSharedSpaces, "supported only when dumping"); 969 assert(klass != NULL, "adding NULL klass"); 970 assert(klass->name() == class_name, "sanity check on name"); 971 assert(klass->shared_classpath_index() < 0, 972 "the shared classpath index should not be set for shared class loaded by the custom loaders"); 973 974 // Add an entry for a non-builtin class. 975 // For a shared class for custom class loaders, SystemDictionary::resolve_or_null will 976 // not find this class, because is_builtin() is false. 977 unsigned int hash = compute_hash(class_name); 978 int index = hash_to_index(hash); 979 980 for (SharedDictionaryEntry* entry = bucket(index); 981 entry != NULL; 982 entry = entry->next()) { 983 if (entry->hash() == hash) { 984 Klass* klass = (Klass*)entry->literal(); 985 if (klass->name() == class_name && klass->class_loader_data() == loader_data) { 986 // There is already a class defined with the same name 987 return false; 988 } 989 } 990 } 991 992 assert(Dictionary::entry_size() >= sizeof(SharedDictionaryEntry), "must be big enough"); 993 SharedDictionaryEntry* entry = (SharedDictionaryEntry*)new_entry(hash, klass); 994 add_entry(index, entry); 995 996 assert(entry->is_unregistered(), "sanity"); 997 assert(!entry->is_builtin(), "sanity"); 998 return true; 999 } 1000 1001 1002 //----------------- 1003 // SharedDictionary 1004 //----------------- 1005 1006 1007 Klass* SharedDictionary::find_class_for_builtin_loader(const Symbol* name) const { 1008 SharedDictionaryEntry* entry = get_entry_for_builtin_loader(name); 1009 return entry != NULL ? entry->instance_klass() : (Klass*)NULL; 1010 } 1011 1012 Klass* SharedDictionary::find_class_for_unregistered_loader(const Symbol* name, 1013 int clsfile_size, 1014 int clsfile_crc32) const { 1015 1016 const SharedDictionaryEntry* entry = get_entry_for_unregistered_loader(name, 1017 clsfile_size, 1018 clsfile_crc32); 1019 return entry != NULL ? entry->instance_klass() : (Klass*)NULL; 1020 } 1021 1022 void SharedDictionary::update_entry(Klass* klass, int id) { 1023 assert(DumpSharedSpaces, "supported only when dumping"); 1024 Symbol* class_name = klass->name(); 1025 unsigned int hash = compute_hash(class_name); 1026 int index = hash_to_index(hash); 1027 1028 for (SharedDictionaryEntry* entry = bucket(index); 1029 entry != NULL; 1030 entry = entry->next()) { 1031 if (entry->hash() == hash && entry->literal() == klass) { 1032 entry->_id = id; 1033 return; 1034 } 1035 } 1036 1037 ShouldNotReachHere(); 1038 } 1039 1040 SharedDictionaryEntry* SharedDictionary::get_entry_for_builtin_loader(const Symbol* class_name) const { 1041 assert(!DumpSharedSpaces, "supported only when at runtime"); 1042 unsigned int hash = compute_hash(class_name); 1043 const int index = hash_to_index(hash); 1044 1045 for (SharedDictionaryEntry* entry = bucket(index); 1046 entry != NULL; 1047 entry = entry->next()) { 1048 if (entry->hash() == hash && entry->equals(class_name)) { 1049 if (entry->is_builtin()) { 1050 return entry; 1051 } 1052 } 1053 } 1054 return NULL; 1055 } 1056 1057 SharedDictionaryEntry* SharedDictionary::get_entry_for_unregistered_loader(const Symbol* class_name, 1058 int clsfile_size, 1059 int clsfile_crc32) const { 1060 assert(!DumpSharedSpaces, "supported only when at runtime"); 1061 unsigned int hash = compute_hash(class_name); 1062 int index = hash_to_index(hash); 1063 1064 for (SharedDictionaryEntry* entry = bucket(index); 1065 entry != NULL; 1066 entry = entry->next()) { 1067 if (entry->hash() == hash && entry->equals(class_name)) { 1068 if (entry->is_unregistered()) { 1069 if (clsfile_size == -1) { 1070 // We're called from class_exists_for_unregistered_loader. At run time, we want to 1071 // compute the CRC of a ClassFileStream only if there is an UNREGISTERED class 1072 // with the matching name. 1073 return entry; 1074 } else { 1075 // We're called from find_class_for_unregistered_loader 1076 if (entry->_clsfile_size && clsfile_crc32 == entry->_clsfile_crc32) { 1077 return entry; 1078 } 1079 } 1080 1081 // There can be only 1 class with this name for unregistered loaders. 1082 return NULL; 1083 } 1084 } 1085 } 1086 return NULL; 1087 }