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