1 /* 2 * Copyright (c) 2003, 2017, 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.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->protection_domain() == 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->protection_domain() == 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 216 void Dictionary::do_unloading() { 217 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint"); 218 219 // The NULL class loader doesn't initiate loading classes from other class loaders 220 if (loader_data() == ClassLoaderData::the_null_class_loader_data()) { 221 return; 222 } 223 224 // Remove unloaded entries and classes from this dictionary 225 DictionaryEntry* probe = NULL; 226 for (int index = 0; index < table_size(); index++) { 227 for (DictionaryEntry** p = bucket_addr(index); *p != NULL; ) { 228 probe = *p; 229 InstanceKlass* ik = probe->instance_klass(); 230 ClassLoaderData* k_def_class_loader_data = ik->class_loader_data(); 231 232 // If the klass that this loader initiated is dead, 233 // (determined by checking the defining class loader) 234 // remove this entry. 235 if (k_def_class_loader_data->is_unloading()) { 236 assert(k_def_class_loader_data != loader_data(), 237 "cannot have live defining loader and unreachable klass"); 238 *p = probe->next(); 239 free_entry(probe); 240 continue; 241 } 242 p = probe->next_addr(); 243 } 244 } 245 } 246 247 void Dictionary::remove_classes_in_error_state() { 248 assert(DumpSharedSpaces, "supported only when dumping"); 249 DictionaryEntry* probe = NULL; 250 for (int index = 0; index < table_size(); index++) { 251 for (DictionaryEntry** p = bucket_addr(index); *p != NULL; ) { 252 probe = *p; 253 InstanceKlass* ik = probe->instance_klass(); 254 if (ik->is_in_error_state()) { // purge this entry 255 *p = probe->next(); 256 free_entry(probe); 257 ResourceMark rm; 258 tty->print_cr("Preload Warning: Removed error class: %s", ik->external_name()); 259 continue; 260 } 261 262 p = probe->next_addr(); 263 } 264 } 265 } 266 267 // Just the classes from defining class loaders 268 void Dictionary::classes_do(void f(InstanceKlass*)) { 269 for (int index = 0; index < table_size(); index++) { 270 for (DictionaryEntry* probe = bucket(index); 271 probe != NULL; 272 probe = probe->next()) { 273 InstanceKlass* k = probe->instance_klass(); 274 if (loader_data() == k->class_loader_data()) { 275 f(k); 276 } 277 } 278 } 279 } 280 281 // Added for initialize_itable_for_klass to handle exceptions 282 // Just the classes from defining class loaders 283 void Dictionary::classes_do(void f(InstanceKlass*, TRAPS), TRAPS) { 284 for (int index = 0; index < table_size(); index++) { 285 for (DictionaryEntry* probe = bucket(index); 286 probe != NULL; 287 probe = probe->next()) { 288 InstanceKlass* k = probe->instance_klass(); 289 if (loader_data() == k->class_loader_data()) { 290 f(k, CHECK); 291 } 292 } 293 } 294 } 295 296 // All classes, and their class loaders, including initiating class loaders 297 void Dictionary::all_entries_do(void f(InstanceKlass*, ClassLoaderData*)) { 298 for (int index = 0; index < table_size(); index++) { 299 for (DictionaryEntry* probe = bucket(index); 300 probe != NULL; 301 probe = probe->next()) { 302 InstanceKlass* k = probe->instance_klass(); 303 f(k, loader_data()); 304 } 305 } 306 } 307 308 // Used to scan and relocate the classes during CDS archive dump. 309 void Dictionary::classes_do(MetaspaceClosure* it) { 310 assert(DumpSharedSpaces, "dump-time only"); 311 for (int index = 0; index < table_size(); index++) { 312 for (DictionaryEntry* probe = bucket(index); 313 probe != NULL; 314 probe = probe->next()) { 315 it->push(probe->klass_addr()); 316 ((SharedDictionaryEntry*)probe)->metaspace_pointers_do(it); 317 } 318 } 319 } 320 321 322 323 // Add a loaded class to the dictionary. 324 // Readers of the SystemDictionary aren't always locked, so _buckets 325 // is volatile. The store of the next field in the constructor is 326 // also cast to volatile; we do this to ensure store order is maintained 327 // by the compilers. 328 329 void Dictionary::add_klass(unsigned int hash, Symbol* class_name, 330 InstanceKlass* obj) { 331 assert_locked_or_safepoint(SystemDictionary_lock); 332 assert(obj != NULL, "adding NULL obj"); 333 assert(obj->name() == class_name, "sanity check on name"); 334 335 DictionaryEntry* entry = new_entry(hash, obj); 336 int index = hash_to_index(hash); 337 add_entry(index, entry); 338 check_if_needs_resize(); 339 } 340 341 342 // This routine does not lock the dictionary. 343 // 344 // Since readers don't hold a lock, we must make sure that system 345 // dictionary entries are only removed at a safepoint (when only one 346 // thread is running), and are added to in a safe way (all links must 347 // be updated in an MT-safe manner). 348 // 349 // Callers should be aware that an entry could be added just after 350 // _buckets[index] is read here, so the caller will not see the new entry. 351 DictionaryEntry* Dictionary::get_entry(int index, unsigned int hash, 352 Symbol* class_name) { 353 for (DictionaryEntry* entry = bucket(index); 354 entry != NULL; 355 entry = entry->next()) { 356 if (entry->hash() == hash && entry->equals(class_name)) { 357 if (!DumpSharedSpaces || SystemDictionaryShared::is_builtin(entry)) { 358 return entry; 359 } 360 } 361 } 362 return NULL; 363 } 364 365 366 InstanceKlass* Dictionary::find(unsigned int hash, Symbol* name, 367 Handle protection_domain) { 368 NoSafepointVerifier nsv; 369 370 int index = hash_to_index(hash); 371 DictionaryEntry* entry = get_entry(index, hash, name); 372 if (entry != NULL && entry->is_valid_protection_domain(protection_domain)) { 373 return entry->instance_klass(); 374 } else { 375 return NULL; 376 } 377 } 378 379 380 InstanceKlass* Dictionary::find_class(int index, unsigned int hash, 381 Symbol* name) { 382 assert_locked_or_safepoint(SystemDictionary_lock); 383 assert (index == index_for(name), "incorrect index?"); 384 385 DictionaryEntry* entry = get_entry(index, hash, name); 386 return (entry != NULL) ? entry->instance_klass() : NULL; 387 } 388 389 390 // Variant of find_class for shared classes. No locking required, as 391 // that table is static. 392 393 InstanceKlass* Dictionary::find_shared_class(int index, unsigned int hash, 394 Symbol* name) { 395 assert (index == index_for(name), "incorrect index?"); 396 397 DictionaryEntry* entry = get_entry(index, hash, name); 398 return (entry != NULL) ? entry->instance_klass() : NULL; 399 } 400 401 402 void Dictionary::add_protection_domain(int index, unsigned int hash, 403 InstanceKlass* klass, 404 Handle protection_domain, 405 TRAPS) { 406 Symbol* klass_name = klass->name(); 407 DictionaryEntry* entry = get_entry(index, hash, klass_name); 408 409 assert(entry != NULL,"entry must be present, we just created it"); 410 assert(protection_domain() != NULL, 411 "real protection domain should be present"); 412 413 entry->add_protection_domain(this, protection_domain); 414 415 assert(entry->contains_protection_domain(protection_domain()), 416 "now protection domain should be present"); 417 } 418 419 420 bool Dictionary::is_valid_protection_domain(unsigned int hash, 421 Symbol* name, 422 Handle protection_domain) { 423 int index = hash_to_index(hash); 424 DictionaryEntry* entry = get_entry(index, hash, name); 425 return entry->is_valid_protection_domain(protection_domain); 426 } 427 428 #if INCLUDE_CDS 429 static bool is_jfr_event_class(Klass *k) { 430 while (k) { 431 if (k->name()->equals("jdk/jfr/Event")) { 432 return true; 433 } 434 k = k->super(); 435 } 436 return false; 437 } 438 439 void Dictionary::reorder_dictionary_for_sharing() { 440 441 // Copy all the dictionary entries into a single master list. 442 443 DictionaryEntry* master_list = NULL; 444 for (int i = 0; i < table_size(); ++i) { 445 DictionaryEntry* p = bucket(i); 446 while (p != NULL) { 447 DictionaryEntry* next = p->next(); 448 InstanceKlass*ik = p->instance_klass(); 449 if (ik->signers() != NULL) { 450 // We cannot include signed classes in the archive because the certificates 451 // used during dump time may be different than those used during 452 // runtime (due to expiration, etc). 453 ResourceMark rm; 454 tty->print_cr("Preload Warning: Skipping %s from signed JAR", 455 ik->name()->as_C_string()); 456 free_entry(p); 457 } else if (is_jfr_event_class(ik)) { 458 // We cannot include JFR event classes because they need runtime-specific 459 // instrumentation in order to work with -XX:FlightRecorderOptions=retransform=false. 460 // There are only a small number of these classes, so it's not worthwhile to 461 // support them and make CDS more complicated. 462 ResourceMark rm; 463 tty->print_cr("Skipping JFR event class %s", ik->name()->as_C_string()); 464 free_entry(p); 465 } else { 466 p->set_next(master_list); 467 master_list = p; 468 } 469 p = next; 470 } 471 set_entry(i, NULL); 472 } 473 474 // Add the dictionary entries back to the list in the correct buckets. 475 while (master_list != NULL) { 476 DictionaryEntry* p = master_list; 477 master_list = master_list->next(); 478 p->set_next(NULL); 479 Symbol* class_name = p->instance_klass()->name(); 480 // Since the null class loader data isn't copied to the CDS archive, 481 // compute the hash with NULL for loader data. 482 unsigned int hash = compute_hash(class_name); 483 int index = hash_to_index(hash); 484 p->set_hash(hash); 485 p->set_next(bucket(index)); 486 set_entry(index, p); 487 } 488 } 489 #endif 490 491 SymbolPropertyTable::SymbolPropertyTable(int table_size) 492 : Hashtable<Symbol*, mtSymbol>(table_size, sizeof(SymbolPropertyEntry)) 493 { 494 } 495 SymbolPropertyTable::SymbolPropertyTable(int table_size, HashtableBucket<mtSymbol>* t, 496 int number_of_entries) 497 : Hashtable<Symbol*, mtSymbol>(table_size, sizeof(SymbolPropertyEntry), t, number_of_entries) 498 { 499 } 500 501 502 SymbolPropertyEntry* SymbolPropertyTable::find_entry(int index, unsigned int hash, 503 Symbol* sym, 504 intptr_t sym_mode) { 505 assert(index == index_for(sym, sym_mode), "incorrect index?"); 506 for (SymbolPropertyEntry* p = bucket(index); p != NULL; p = p->next()) { 507 if (p->hash() == hash && p->symbol() == sym && p->symbol_mode() == sym_mode) { 508 return p; 509 } 510 } 511 return NULL; 512 } 513 514 515 SymbolPropertyEntry* SymbolPropertyTable::add_entry(int index, unsigned int hash, 516 Symbol* sym, intptr_t sym_mode) { 517 assert_locked_or_safepoint(SystemDictionary_lock); 518 assert(index == index_for(sym, sym_mode), "incorrect index?"); 519 assert(find_entry(index, hash, sym, sym_mode) == NULL, "no double entry"); 520 521 SymbolPropertyEntry* p = new_entry(hash, sym, sym_mode); 522 Hashtable<Symbol*, mtSymbol>::add_entry(index, p); 523 return p; 524 } 525 526 void SymbolPropertyTable::oops_do(OopClosure* f) { 527 for (int index = 0; index < table_size(); index++) { 528 for (SymbolPropertyEntry* p = bucket(index); p != NULL; p = p->next()) { 529 if (p->method_type() != NULL) { 530 f->do_oop(p->method_type_addr()); 531 } 532 } 533 } 534 } 535 536 void SymbolPropertyTable::methods_do(void f(Method*)) { 537 for (int index = 0; index < table_size(); index++) { 538 for (SymbolPropertyEntry* p = bucket(index); p != NULL; p = p->next()) { 539 Method* prop = p->method(); 540 if (prop != NULL) { 541 f((Method*)prop); 542 } 543 } 544 } 545 } 546 547 548 // ---------------------------------------------------------------------------- 549 550 void Dictionary::print_on(outputStream* st) const { 551 ResourceMark rm; 552 553 assert(loader_data() != NULL, "loader data should not be null"); 554 st->print_cr("Java dictionary (table_size=%d, classes=%d)", 555 table_size(), number_of_entries()); 556 st->print_cr("^ indicates that initiating loader is different from defining loader"); 557 558 for (int index = 0; index < table_size(); index++) { 559 for (DictionaryEntry* probe = bucket(index); 560 probe != NULL; 561 probe = probe->next()) { 562 Klass* e = probe->instance_klass(); 563 bool is_defining_class = 564 (loader_data() == e->class_loader_data()); 565 st->print("%4d: %s%s, loader ", index, is_defining_class ? " " : "^", e->external_name()); 566 ClassLoaderData* loader_data = e->class_loader_data(); 567 if (loader_data == NULL) { 568 // Shared class not restored yet in shared dictionary 569 st->print("<shared, not restored>"); 570 } else { 571 loader_data->print_value_on(st); 572 } 573 st->cr(); 574 } 575 } 576 tty->cr(); 577 } 578 579 void DictionaryEntry::verify() { 580 Klass* e = instance_klass(); 581 guarantee(e->is_instance_klass(), 582 "Verify of dictionary failed"); 583 e->verify(); 584 verify_protection_domain_set(); 585 } 586 587 void Dictionary::verify() { 588 guarantee(number_of_entries() >= 0, "Verify of dictionary failed"); 589 590 ClassLoaderData* cld = loader_data(); 591 // class loader must be present; a null class loader is the 592 // boostrap loader 593 guarantee(cld != NULL || DumpSharedSpaces || 594 cld->class_loader() == NULL || 595 cld->class_loader()->is_instance(), 596 "checking type of class_loader"); 597 598 ResourceMark rm; 599 stringStream tempst; 600 tempst.print("System Dictionary for %s", cld->loader_name()); 601 verify_table<DictionaryEntry>(tempst.as_string()); 602 }