1 /* 2 * Copyright (c) 2003, 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/classLoaderData.inline.hpp" 27 #include "classfile/dictionary.inline.hpp" 28 #include "classfile/protectionDomainCache.hpp" 29 #include "classfile/systemDictionary.hpp" 30 #include "classfile/systemDictionaryShared.hpp" 31 #include "logging/log.hpp" 32 #include "logging/logStream.hpp" 33 #include "memory/iterator.hpp" 34 #include "memory/metaspaceClosure.hpp" 35 #include "memory/resourceArea.hpp" 36 #include "oops/oop.inline.hpp" 37 #include "runtime/atomic.hpp" 38 #include "runtime/orderAccess.inline.hpp" 39 #include "runtime/safepointVerifiers.hpp" 40 #include "utilities/hashtable.inline.hpp" 41 42 // Optimization: if any dictionary needs resizing, we set this flag, 43 // so that we dont't have to walk all dictionaries to check if any actually 44 // needs resizing, which is costly to do at Safepoint. 45 bool Dictionary::_some_dictionary_needs_resizing = false; 46 47 size_t Dictionary::entry_size() { 48 if (DumpSharedSpaces) { 49 return SystemDictionaryShared::dictionary_entry_size(); 50 } else { 51 return sizeof(DictionaryEntry); 52 } 53 } 54 55 Dictionary::Dictionary(ClassLoaderData* loader_data, int table_size, bool resizable) 56 : _loader_data(loader_data), _resizable(resizable), _needs_resizing(false), 57 Hashtable<InstanceKlass*, mtClass>(table_size, (int)entry_size()) { 58 }; 59 60 61 Dictionary::Dictionary(ClassLoaderData* loader_data, 62 int table_size, HashtableBucket<mtClass>* t, 63 int number_of_entries, bool resizable) 64 : _loader_data(loader_data), _resizable(resizable), _needs_resizing(false), 65 Hashtable<InstanceKlass*, mtClass>(table_size, (int)entry_size(), t, number_of_entries) { 66 }; 67 68 Dictionary::~Dictionary() { 69 DictionaryEntry* probe = NULL; 70 for (int index = 0; index < table_size(); index++) { 71 for (DictionaryEntry** p = bucket_addr(index); *p != NULL; ) { 72 probe = *p; 73 *p = probe->next(); 74 free_entry(probe); 75 } 76 } 77 assert(number_of_entries() == 0, "should have removed all entries"); 78 assert(new_entry_free_list() == NULL, "entry present on Dictionary's free list"); 79 free_buckets(); 80 } 81 82 DictionaryEntry* Dictionary::new_entry(unsigned int hash, InstanceKlass* klass) { 83 DictionaryEntry* entry = (DictionaryEntry*)Hashtable<InstanceKlass*, mtClass>::allocate_new_entry(hash, klass); 84 entry->set_pd_set(NULL); 85 assert(klass->is_instance_klass(), "Must be"); 86 if (DumpSharedSpaces) { 87 SystemDictionaryShared::init_shared_dictionary_entry(klass, entry); 88 } 89 return entry; 90 } 91 92 93 void Dictionary::free_entry(DictionaryEntry* entry) { 94 // avoid recursion when deleting linked list 95 // pd_set is accessed during a safepoint. 96 while (entry->pd_set() != NULL) { 97 ProtectionDomainEntry* to_delete = entry->pd_set(); 98 entry->set_pd_set(to_delete->next()); 99 delete to_delete; 100 } 101 // Unlink from the Hashtable prior to freeing 102 unlink_entry(entry); 103 FREE_C_HEAP_ARRAY(char, entry); 104 } 105 106 const int _resize_load_trigger = 5; // load factor that will trigger the resize 107 const double _resize_factor = 2.0; // by how much we will resize using current number of entries 108 const int _resize_max_size = 40423; // the max dictionary size allowed 109 const int _primelist[] = {107, 1009, 2017, 4049, 5051, 10103, 20201, _resize_max_size}; 110 const int _prime_array_size = sizeof(_primelist)/sizeof(int); 111 112 // Calculate next "good" dictionary size based on requested count 113 static int calculate_dictionary_size(int requested) { 114 int newsize = _primelist[0]; 115 int index = 0; 116 for (newsize = _primelist[index]; index < (_prime_array_size - 1); 117 newsize = _primelist[++index]) { 118 if (requested <= newsize) { 119 break; 120 } 121 } 122 return newsize; 123 } 124 125 bool Dictionary::does_any_dictionary_needs_resizing() { 126 return Dictionary::_some_dictionary_needs_resizing; 127 } 128 129 void Dictionary::check_if_needs_resize() { 130 if (_resizable == true) { 131 if (number_of_entries() > (_resize_load_trigger*table_size())) { 132 _needs_resizing = true; 133 Dictionary::_some_dictionary_needs_resizing = true; 134 } 135 } 136 } 137 138 bool Dictionary::resize_if_needed() { 139 int desired_size = 0; 140 if (_needs_resizing == true) { 141 desired_size = calculate_dictionary_size((int)(_resize_factor*number_of_entries())); 142 if (desired_size >= _resize_max_size) { 143 desired_size = _resize_max_size; 144 // We have reached the limit, turn resizing off 145 _resizable = false; 146 } 147 if ((desired_size != 0) && (desired_size != table_size())) { 148 if (!resize(desired_size)) { 149 // Something went wrong, turn resizing off 150 _resizable = false; 151 } 152 } 153 } 154 155 _needs_resizing = false; 156 Dictionary::_some_dictionary_needs_resizing = false; 157 158 return (desired_size != 0); 159 } 160 161 bool DictionaryEntry::contains_protection_domain(oop protection_domain) const { 162 #ifdef ASSERT 163 if (oopDesc::equals(protection_domain, instance_klass()->protection_domain())) { 164 // Ensure this doesn't show up in the pd_set (invariant) 165 bool in_pd_set = false; 166 for (ProtectionDomainEntry* current = pd_set_acquire(); 167 current != NULL; 168 current = current->next()) { 169 if (oopDesc::equals(current->object_no_keepalive(), protection_domain)) { 170 in_pd_set = true; 171 break; 172 } 173 } 174 if (in_pd_set) { 175 assert(false, "A klass's protection domain should not show up " 176 "in its sys. dict. PD set"); 177 } 178 } 179 #endif /* ASSERT */ 180 181 if (oopDesc::equals(protection_domain, instance_klass()->protection_domain())) { 182 // Succeeds trivially 183 return true; 184 } 185 186 for (ProtectionDomainEntry* current = pd_set_acquire(); 187 current != NULL; 188 current = current->next()) { 189 if (oopDesc::equals(current->object_no_keepalive(), protection_domain)) return true; 190 } 191 return false; 192 } 193 194 195 void DictionaryEntry::add_protection_domain(Dictionary* dict, Handle protection_domain) { 196 assert_locked_or_safepoint(SystemDictionary_lock); 197 if (!contains_protection_domain(protection_domain())) { 198 ProtectionDomainCacheEntry* entry = SystemDictionary::cache_get(protection_domain); 199 ProtectionDomainEntry* new_head = 200 new ProtectionDomainEntry(entry, pd_set()); 201 // Warning: Preserve store ordering. The SystemDictionary is read 202 // without locks. The new ProtectionDomainEntry must be 203 // complete before other threads can be allowed to see it 204 // via a store to _pd_set. 205 release_set_pd_set(new_head); 206 } 207 LogTarget(Trace, protectiondomain) lt; 208 if (lt.is_enabled()) { 209 LogStream ls(lt); 210 print_count(&ls); 211 } 212 } 213 214 // During class loading we may have cached a protection domain that has 215 // since been unreferenced, so this entry should be cleared. 216 void Dictionary::clean_cached_protection_domains(DictionaryEntry* probe) { 217 assert_locked_or_safepoint(SystemDictionary_lock); 218 219 ProtectionDomainEntry* current = probe->pd_set(); 220 ProtectionDomainEntry* prev = NULL; 221 while (current != NULL) { 222 if (current->object_no_keepalive() == NULL) { 223 LogTarget(Debug, protectiondomain) lt; 224 if (lt.is_enabled()) { 225 ResourceMark rm; 226 // Print out trace information 227 LogStream ls(lt); 228 ls.print_cr("PD in set is not alive:"); 229 ls.print("class loader: "); loader_data()->class_loader()->print_value_on(&ls); 230 ls.print(" loading: "); probe->instance_klass()->print_value_on(&ls); 231 ls.cr(); 232 } 233 if (probe->pd_set() == current) { 234 probe->set_pd_set(current->next()); 235 } else { 236 assert(prev != NULL, "should be set by alive entry"); 237 prev->set_next(current->next()); 238 } 239 ProtectionDomainEntry* to_delete = current; 240 current = current->next(); 241 delete to_delete; 242 } else { 243 prev = current; 244 current = current->next(); 245 } 246 } 247 } 248 249 250 void Dictionary::do_unloading() { 251 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); 252 253 // The NULL class loader doesn't initiate loading classes from other class loaders 254 if (loader_data() == ClassLoaderData::the_null_class_loader_data()) { 255 return; 256 } 257 258 // Remove unloaded entries and classes from this dictionary 259 DictionaryEntry* probe = NULL; 260 for (int index = 0; index < table_size(); index++) { 261 for (DictionaryEntry** p = bucket_addr(index); *p != NULL; ) { 262 probe = *p; 263 InstanceKlass* ik = probe->instance_klass(); 264 ClassLoaderData* k_def_class_loader_data = ik->class_loader_data(); 265 266 // If the klass that this loader initiated is dead, 267 // (determined by checking the defining class loader) 268 // remove this entry. 269 if (k_def_class_loader_data->is_unloading()) { 270 assert(k_def_class_loader_data != loader_data(), 271 "cannot have live defining loader and unreachable klass"); 272 *p = probe->next(); 273 free_entry(probe); 274 continue; 275 } 276 // Clean pd_set 277 clean_cached_protection_domains(probe); 278 p = probe->next_addr(); 279 } 280 } 281 } 282 283 void Dictionary::remove_classes_in_error_state() { 284 assert(DumpSharedSpaces, "supported only when dumping"); 285 DictionaryEntry* probe = NULL; 286 for (int index = 0; index < table_size(); index++) { 287 for (DictionaryEntry** p = bucket_addr(index); *p != NULL; ) { 288 probe = *p; 289 InstanceKlass* ik = probe->instance_klass(); 290 if (ik->is_in_error_state()) { // purge this entry 291 *p = probe->next(); 292 free_entry(probe); 293 ResourceMark rm; 294 tty->print_cr("Preload Warning: Removed error class: %s", ik->external_name()); 295 continue; 296 } 297 298 p = probe->next_addr(); 299 } 300 } 301 } 302 303 // Just the classes from defining class loaders 304 void Dictionary::classes_do(void f(InstanceKlass*)) { 305 for (int index = 0; index < table_size(); index++) { 306 for (DictionaryEntry* probe = bucket(index); 307 probe != NULL; 308 probe = probe->next()) { 309 InstanceKlass* k = probe->instance_klass(); 310 if (loader_data() == k->class_loader_data()) { 311 f(k); 312 } 313 } 314 } 315 } 316 317 // Added for initialize_itable_for_klass to handle exceptions 318 // Just the classes from defining class loaders 319 void Dictionary::classes_do(void f(InstanceKlass*, TRAPS), TRAPS) { 320 for (int index = 0; index < table_size(); index++) { 321 for (DictionaryEntry* probe = bucket(index); 322 probe != NULL; 323 probe = probe->next()) { 324 InstanceKlass* k = probe->instance_klass(); 325 if (loader_data() == k->class_loader_data()) { 326 f(k, CHECK); 327 } 328 } 329 } 330 } 331 332 // All classes, and their class loaders, including initiating class loaders 333 void Dictionary::all_entries_do(void f(InstanceKlass*, ClassLoaderData*)) { 334 for (int index = 0; index < table_size(); index++) { 335 for (DictionaryEntry* probe = bucket(index); 336 probe != NULL; 337 probe = probe->next()) { 338 InstanceKlass* k = probe->instance_klass(); 339 f(k, loader_data()); 340 } 341 } 342 } 343 344 // Used to scan and relocate the classes during CDS archive dump. 345 void Dictionary::classes_do(MetaspaceClosure* it) { 346 assert(DumpSharedSpaces, "dump-time only"); 347 for (int index = 0; index < table_size(); index++) { 348 for (DictionaryEntry* probe = bucket(index); 349 probe != NULL; 350 probe = probe->next()) { 351 it->push(probe->klass_addr()); 352 ((SharedDictionaryEntry*)probe)->metaspace_pointers_do(it); 353 } 354 } 355 } 356 357 358 359 // Add a loaded class to the dictionary. 360 // Readers of the SystemDictionary aren't always locked, so _buckets 361 // is volatile. The store of the next field in the constructor is 362 // also cast to volatile; we do this to ensure store order is maintained 363 // by the compilers. 364 365 void Dictionary::add_klass(unsigned int hash, Symbol* class_name, 366 InstanceKlass* obj) { 367 assert_locked_or_safepoint(SystemDictionary_lock); 368 assert(obj != NULL, "adding NULL obj"); 369 assert(obj->name() == class_name, "sanity check on name"); 370 371 DictionaryEntry* entry = new_entry(hash, obj); 372 int index = hash_to_index(hash); 373 add_entry(index, entry); 374 check_if_needs_resize(); 375 } 376 377 378 // This routine does not lock the dictionary. 379 // 380 // Since readers don't hold a lock, we must make sure that system 381 // dictionary entries are only removed at a safepoint (when only one 382 // thread is running), and are added to in a safe way (all links must 383 // be updated in an MT-safe manner). 384 // 385 // Callers should be aware that an entry could be added just after 386 // _buckets[index] is read here, so the caller will not see the new entry. 387 DictionaryEntry* Dictionary::get_entry(int index, unsigned int hash, 388 Symbol* class_name) { 389 for (DictionaryEntry* entry = bucket(index); 390 entry != NULL; 391 entry = entry->next()) { 392 if (entry->hash() == hash && entry->equals(class_name)) { 393 if (!DumpSharedSpaces || SystemDictionaryShared::is_builtin(entry)) { 394 return entry; 395 } 396 } 397 } 398 return NULL; 399 } 400 401 402 InstanceKlass* Dictionary::find(unsigned int hash, Symbol* name, 403 Handle protection_domain) { 404 NoSafepointVerifier nsv; 405 406 int index = hash_to_index(hash); 407 DictionaryEntry* entry = get_entry(index, hash, name); 408 if (entry != NULL && entry->is_valid_protection_domain(protection_domain)) { 409 return entry->instance_klass(); 410 } else { 411 return NULL; 412 } 413 } 414 415 416 InstanceKlass* Dictionary::find_class(int index, unsigned int hash, 417 Symbol* name) { 418 assert_locked_or_safepoint(SystemDictionary_lock); 419 assert (index == index_for(name), "incorrect index?"); 420 421 DictionaryEntry* entry = get_entry(index, hash, name); 422 return (entry != NULL) ? entry->instance_klass() : NULL; 423 } 424 425 426 // Variant of find_class for shared classes. No locking required, as 427 // that table is static. 428 429 InstanceKlass* Dictionary::find_shared_class(int index, unsigned int hash, 430 Symbol* name) { 431 assert (index == index_for(name), "incorrect index?"); 432 433 DictionaryEntry* entry = get_entry(index, hash, name); 434 return (entry != NULL) ? entry->instance_klass() : NULL; 435 } 436 437 438 void Dictionary::add_protection_domain(int index, unsigned int hash, 439 InstanceKlass* klass, 440 Handle protection_domain, 441 TRAPS) { 442 Symbol* klass_name = klass->name(); 443 DictionaryEntry* entry = get_entry(index, hash, klass_name); 444 445 assert(entry != NULL,"entry must be present, we just created it"); 446 assert(protection_domain() != NULL, 447 "real protection domain should be present"); 448 449 entry->add_protection_domain(this, protection_domain); 450 451 #ifdef ASSERT 452 assert(loader_data() != ClassLoaderData::the_null_class_loader_data(), "doesn't make sense"); 453 #endif 454 455 assert(entry->contains_protection_domain(protection_domain()), 456 "now protection domain should be present"); 457 } 458 459 460 bool Dictionary::is_valid_protection_domain(unsigned int hash, 461 Symbol* name, 462 Handle protection_domain) { 463 int index = hash_to_index(hash); 464 DictionaryEntry* entry = get_entry(index, hash, name); 465 return entry->is_valid_protection_domain(protection_domain); 466 } 467 468 #if INCLUDE_CDS 469 static bool is_jfr_event_class(Klass *k) { 470 while (k) { 471 if (k->name()->equals("jdk/jfr/Event")) { 472 return true; 473 } 474 k = k->super(); 475 } 476 return false; 477 } 478 479 void Dictionary::reorder_dictionary_for_sharing() { 480 481 // Copy all the dictionary entries into a single master list. 482 assert(DumpSharedSpaces, "Should only be used at dump time"); 483 484 DictionaryEntry* master_list = NULL; 485 for (int i = 0; i < table_size(); ++i) { 486 DictionaryEntry* p = bucket(i); 487 while (p != NULL) { 488 DictionaryEntry* next = p->next(); 489 InstanceKlass*ik = p->instance_klass(); 490 if (ik->has_signer_and_not_archived()) { 491 // We cannot include signed classes in the archive because the certificates 492 // used during dump time may be different than those used during 493 // runtime (due to expiration, etc). 494 ResourceMark rm; 495 tty->print_cr("Preload Warning: Skipping %s from signed JAR", 496 ik->name()->as_C_string()); 497 free_entry(p); 498 } else if (is_jfr_event_class(ik)) { 499 // We cannot include JFR event classes because they need runtime-specific 500 // instrumentation in order to work with -XX:FlightRecorderOptions=retransform=false. 501 // There are only a small number of these classes, so it's not worthwhile to 502 // support them and make CDS more complicated. 503 ResourceMark rm; 504 tty->print_cr("Skipping JFR event class %s", ik->name()->as_C_string()); 505 free_entry(p); 506 } else { 507 p->set_next(master_list); 508 master_list = p; 509 } 510 p = next; 511 } 512 set_entry(i, NULL); 513 } 514 515 // Add the dictionary entries back to the list in the correct buckets. 516 while (master_list != NULL) { 517 DictionaryEntry* p = master_list; 518 master_list = master_list->next(); 519 p->set_next(NULL); 520 Symbol* class_name = p->instance_klass()->name(); 521 // Since the null class loader data isn't copied to the CDS archive, 522 // compute the hash with NULL for loader data. 523 unsigned int hash = compute_hash(class_name); 524 int index = hash_to_index(hash); 525 p->set_hash(hash); 526 p->set_next(bucket(index)); 527 set_entry(index, p); 528 } 529 } 530 #endif 531 532 SymbolPropertyTable::SymbolPropertyTable(int table_size) 533 : Hashtable<Symbol*, mtSymbol>(table_size, sizeof(SymbolPropertyEntry)) 534 { 535 } 536 SymbolPropertyTable::SymbolPropertyTable(int table_size, HashtableBucket<mtSymbol>* t, 537 int number_of_entries) 538 : Hashtable<Symbol*, mtSymbol>(table_size, sizeof(SymbolPropertyEntry), t, number_of_entries) 539 { 540 } 541 542 543 SymbolPropertyEntry* SymbolPropertyTable::find_entry(int index, unsigned int hash, 544 Symbol* sym, 545 intptr_t sym_mode) { 546 assert(index == index_for(sym, sym_mode), "incorrect index?"); 547 for (SymbolPropertyEntry* p = bucket(index); p != NULL; p = p->next()) { 548 if (p->hash() == hash && p->symbol() == sym && p->symbol_mode() == sym_mode) { 549 return p; 550 } 551 } 552 return NULL; 553 } 554 555 556 SymbolPropertyEntry* SymbolPropertyTable::add_entry(int index, unsigned int hash, 557 Symbol* sym, intptr_t sym_mode) { 558 assert_locked_or_safepoint(SystemDictionary_lock); 559 assert(index == index_for(sym, sym_mode), "incorrect index?"); 560 assert(find_entry(index, hash, sym, sym_mode) == NULL, "no double entry"); 561 562 SymbolPropertyEntry* p = new_entry(hash, sym, sym_mode); 563 Hashtable<Symbol*, mtSymbol>::add_entry(index, p); 564 return p; 565 } 566 567 void SymbolPropertyTable::oops_do(OopClosure* f) { 568 for (int index = 0; index < table_size(); index++) { 569 for (SymbolPropertyEntry* p = bucket(index); p != NULL; p = p->next()) { 570 if (p->method_type() != NULL) { 571 f->do_oop(p->method_type_addr()); 572 } 573 } 574 } 575 } 576 577 void SymbolPropertyTable::methods_do(void f(Method*)) { 578 for (int index = 0; index < table_size(); index++) { 579 for (SymbolPropertyEntry* p = bucket(index); p != NULL; p = p->next()) { 580 Method* prop = p->method(); 581 if (prop != NULL) { 582 f((Method*)prop); 583 } 584 } 585 } 586 } 587 588 589 // ---------------------------------------------------------------------------- 590 591 void Dictionary::print_on(outputStream* st) const { 592 ResourceMark rm; 593 594 assert(loader_data() != NULL, "loader data should not be null"); 595 st->print_cr("Java dictionary (table_size=%d, classes=%d)", 596 table_size(), number_of_entries()); 597 st->print_cr("^ indicates that initiating loader is different from defining loader"); 598 599 for (int index = 0; index < table_size(); index++) { 600 for (DictionaryEntry* probe = bucket(index); 601 probe != NULL; 602 probe = probe->next()) { 603 Klass* e = probe->instance_klass(); 604 bool is_defining_class = 605 (loader_data() == e->class_loader_data()); 606 st->print("%4d: %s%s", index, is_defining_class ? " " : "^", e->external_name()); 607 ClassLoaderData* cld = e->class_loader_data(); 608 if (cld == NULL) { 609 // Shared class not restored yet in shared dictionary 610 st->print(", loader data <shared, not restored>"); 611 } else if (!loader_data()->is_the_null_class_loader_data()) { 612 // Class loader output for the dictionary for the null class loader data is 613 // redundant and obvious. 614 st->print(", "); 615 cld->print_value_on(st); 616 } 617 st->cr(); 618 } 619 } 620 tty->cr(); 621 } 622 623 void DictionaryEntry::verify() { 624 Klass* e = instance_klass(); 625 guarantee(e->is_instance_klass(), 626 "Verify of dictionary failed"); 627 e->verify(); 628 verify_protection_domain_set(); 629 } 630 631 void Dictionary::verify() { 632 guarantee(number_of_entries() >= 0, "Verify of dictionary failed"); 633 634 ClassLoaderData* cld = loader_data(); 635 // class loader must be present; a null class loader is the 636 // boostrap loader 637 guarantee(cld != NULL || DumpSharedSpaces || 638 cld->class_loader() == NULL || 639 cld->class_loader()->is_instance(), 640 "checking type of class_loader"); 641 642 ResourceMark rm; 643 stringStream tempst; 644 tempst.print("System Dictionary for %s", cld->loader_name()); 645 verify_table<DictionaryEntry>(tempst.as_string()); 646 }