1 /* 2 * Copyright (c) 2012, 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 // A ClassLoaderData identifies the full set of class types that a class 26 // loader's name resolution strategy produces for a given configuration of the 27 // class loader. 28 // Class types in the ClassLoaderData may be defined by from class file binaries 29 // provided by the class loader, or from other class loader it interacts with 30 // according to its name resolution strategy. 31 // 32 // Class loaders that implement a deterministic name resolution strategy 33 // (including with respect to their delegation behavior), such as the boot, the 34 // platform, and the system loaders of the JDK's built-in class loader 35 // hierarchy, always produce the same linkset for a given configuration. 36 // 37 // ClassLoaderData carries information related to a linkset (e.g., 38 // metaspace holding its klass definitions). 39 // The System Dictionary and related data structures (e.g., placeholder table, 40 // loader constraints table) as well as the runtime representation of classes 41 // only reference ClassLoaderData. 42 // 43 // Instances of java.lang.ClassLoader holds a pointer to a ClassLoaderData that 44 // that represent the loader's "linking domain" in the JVM. 45 // 46 // The bootstrap loader (represented by NULL) also has a ClassLoaderData, 47 // the singleton class the_null_class_loader_data(). 48 49 #include "precompiled.hpp" 50 #include "classfile/classLoaderData.hpp" 51 #include "classfile/classLoaderData.inline.hpp" 52 #include "classfile/dictionary.hpp" 53 #include "classfile/javaClasses.hpp" 54 #include "classfile/metadataOnStackMark.hpp" 55 #include "classfile/moduleEntry.hpp" 56 #include "classfile/packageEntry.hpp" 57 #include "classfile/symbolTable.hpp" 58 #include "classfile/systemDictionary.hpp" 59 #include "logging/log.hpp" 60 #include "logging/logStream.hpp" 61 #include "memory/allocation.inline.hpp" 62 #include "memory/metadataFactory.hpp" 63 #include "memory/metaspaceShared.hpp" 64 #include "memory/resourceArea.hpp" 65 #include "memory/universe.hpp" 66 #include "oops/access.inline.hpp" 67 #include "oops/oop.inline.hpp" 68 #include "oops/oopHandle.inline.hpp" 69 #include "oops/weakHandle.inline.hpp" 70 #include "runtime/atomic.hpp" 71 #include "runtime/handles.inline.hpp" 72 #include "runtime/mutex.hpp" 73 #include "runtime/orderAccess.hpp" 74 #include "runtime/safepoint.hpp" 75 #include "runtime/safepointVerifiers.hpp" 76 #include "utilities/growableArray.hpp" 77 #include "utilities/macros.hpp" 78 #include "utilities/ostream.hpp" 79 80 volatile size_t ClassLoaderDataGraph::_num_array_classes = 0; 81 volatile size_t ClassLoaderDataGraph::_num_instance_classes = 0; 82 83 ClassLoaderData * ClassLoaderData::_the_null_class_loader_data = NULL; 84 85 void ClassLoaderData::init_null_class_loader_data() { 86 assert(_the_null_class_loader_data == NULL, "cannot initialize twice"); 87 assert(ClassLoaderDataGraph::_head == NULL, "cannot initialize twice"); 88 89 _the_null_class_loader_data = new ClassLoaderData(Handle(), false); 90 ClassLoaderDataGraph::_head = _the_null_class_loader_data; 91 assert(_the_null_class_loader_data->is_the_null_class_loader_data(), "Must be"); 92 93 LogTarget(Trace, class, loader, data) lt; 94 if (lt.is_enabled()) { 95 ResourceMark rm; 96 LogStream ls(lt); 97 ls.print("create "); 98 _the_null_class_loader_data->print_value_on(&ls); 99 ls.cr(); 100 } 101 } 102 103 // Obtain and set the class loader's name within the ClassLoaderData so 104 // it will be available for error messages, logging, JFR, etc. The name 105 // and klass are available after the class_loader oop is no longer alive, 106 // during unloading. 107 void ClassLoaderData::initialize_name(Handle class_loader) { 108 Thread* THREAD = Thread::current(); 109 ResourceMark rm(THREAD); 110 111 // Obtain the class loader's name. If the class loader's name was not 112 // explicitly set during construction, the CLD's _name field will be null. 113 oop cl_name = java_lang_ClassLoader::name(class_loader()); 114 if (cl_name != NULL) { 115 const char* cl_instance_name = java_lang_String::as_utf8_string(cl_name); 116 117 if (cl_instance_name != NULL && cl_instance_name[0] != '\0') { 118 // Can't throw InternalError and SymbolTable doesn't throw OOM anymore. 119 _name = SymbolTable::new_symbol(cl_instance_name, CATCH); 120 } 121 } 122 123 // Obtain the class loader's name and identity hash. If the class loader's 124 // name was not explicitly set during construction, the class loader's name and id 125 // will be set to the qualified class name of the class loader along with its 126 // identity hash. 127 // If for some reason the ClassLoader's constructor has not been run, instead of 128 // leaving the _name_and_id field null, fall back to the external qualified class 129 // name. Thus CLD's _name_and_id field should never have a null value. 130 oop cl_name_and_id = java_lang_ClassLoader::nameAndId(class_loader()); 131 const char* cl_instance_name_and_id = 132 (cl_name_and_id == NULL) ? _class_loader_klass->external_name() : 133 java_lang_String::as_utf8_string(cl_name_and_id); 134 assert(cl_instance_name_and_id != NULL && cl_instance_name_and_id[0] != '\0', "class loader has no name and id"); 135 // Can't throw InternalError and SymbolTable doesn't throw OOM anymore. 136 _name_and_id = SymbolTable::new_symbol(cl_instance_name_and_id, CATCH); 137 } 138 139 ClassLoaderData::ClassLoaderData(Handle h_class_loader, bool is_unsafe_anonymous) : 140 _metaspace(NULL), 141 _metaspace_lock(new Mutex(Monitor::leaf+1, "Metaspace allocation lock", true, 142 Monitor::_safepoint_check_never)), 143 _unloading(false), _is_unsafe_anonymous(is_unsafe_anonymous), 144 _modified_oops(true), _accumulated_modified_oops(false), 145 // An unsafe anonymous class loader data doesn't have anything to keep 146 // it from being unloaded during parsing of the unsafe anonymous class. 147 // The null-class-loader should always be kept alive. 148 _keep_alive((is_unsafe_anonymous || h_class_loader.is_null()) ? 1 : 0), 149 _claimed(0), 150 _handles(), 151 _klasses(NULL), _packages(NULL), _modules(NULL), _unnamed_module(NULL), _dictionary(NULL), 152 _jmethod_ids(NULL), 153 _deallocate_list(NULL), 154 _next(NULL), 155 _class_loader_klass(NULL), _name(NULL), _name_and_id(NULL) { 156 157 if (!h_class_loader.is_null()) { 158 _class_loader = _handles.add(h_class_loader()); 159 _class_loader_klass = h_class_loader->klass(); 160 } 161 162 if (!is_unsafe_anonymous) { 163 // The holder is initialized later for unsafe anonymous classes, and before calling anything 164 // that call class_loader(). 165 initialize_holder(h_class_loader); 166 167 // A ClassLoaderData created solely for an unsafe anonymous class should never have a 168 // ModuleEntryTable or PackageEntryTable created for it. The defining package 169 // and module for an unsafe anonymous class will be found in its host class. 170 _packages = new PackageEntryTable(PackageEntryTable::_packagetable_entry_size); 171 if (h_class_loader.is_null()) { 172 // Create unnamed module for boot loader 173 _unnamed_module = ModuleEntry::create_boot_unnamed_module(this); 174 } else { 175 // Create unnamed module for all other loaders 176 _unnamed_module = ModuleEntry::create_unnamed_module(this); 177 } 178 _dictionary = create_dictionary(); 179 } 180 181 NOT_PRODUCT(_dependency_count = 0); // number of class loader dependencies 182 183 JFR_ONLY(INIT_ID(this);) 184 } 185 186 ClassLoaderData::ChunkedHandleList::~ChunkedHandleList() { 187 Chunk* c = _head; 188 while (c != NULL) { 189 Chunk* next = c->_next; 190 delete c; 191 c = next; 192 } 193 } 194 195 oop* ClassLoaderData::ChunkedHandleList::add(oop o) { 196 if (_head == NULL || _head->_size == Chunk::CAPACITY) { 197 Chunk* next = new Chunk(_head); 198 OrderAccess::release_store(&_head, next); 199 } 200 oop* handle = &_head->_data[_head->_size]; 201 *handle = o; 202 OrderAccess::release_store(&_head->_size, _head->_size + 1); 203 return handle; 204 } 205 206 int ClassLoaderData::ChunkedHandleList::count() const { 207 int count = 0; 208 Chunk* chunk = _head; 209 while (chunk != NULL) { 210 count += chunk->_size; 211 chunk = chunk->_next; 212 } 213 return count; 214 } 215 216 inline void ClassLoaderData::ChunkedHandleList::oops_do_chunk(OopClosure* f, Chunk* c, const juint size) { 217 for (juint i = 0; i < size; i++) { 218 if (c->_data[i] != NULL) { 219 f->do_oop(&c->_data[i]); 220 } 221 } 222 } 223 224 void ClassLoaderData::ChunkedHandleList::oops_do(OopClosure* f) { 225 Chunk* head = OrderAccess::load_acquire(&_head); 226 if (head != NULL) { 227 // Must be careful when reading size of head 228 oops_do_chunk(f, head, OrderAccess::load_acquire(&head->_size)); 229 for (Chunk* c = head->_next; c != NULL; c = c->_next) { 230 oops_do_chunk(f, c, c->_size); 231 } 232 } 233 } 234 235 class VerifyContainsOopClosure : public OopClosure { 236 oop _target; 237 bool _found; 238 239 public: 240 VerifyContainsOopClosure(oop target) : _target(target), _found(false) {} 241 242 void do_oop(oop* p) { 243 if (p != NULL && oopDesc::equals(RawAccess<>::oop_load(p), _target)) { 244 _found = true; 245 } 246 } 247 248 void do_oop(narrowOop* p) { 249 // The ChunkedHandleList should not contain any narrowOop 250 ShouldNotReachHere(); 251 } 252 253 bool found() const { 254 return _found; 255 } 256 }; 257 258 bool ClassLoaderData::ChunkedHandleList::contains(oop p) { 259 VerifyContainsOopClosure cl(p); 260 oops_do(&cl); 261 return cl.found(); 262 } 263 264 #ifndef PRODUCT 265 bool ClassLoaderData::ChunkedHandleList::owner_of(oop* oop_handle) { 266 Chunk* chunk = _head; 267 while (chunk != NULL) { 268 if (&(chunk->_data[0]) <= oop_handle && oop_handle < &(chunk->_data[chunk->_size])) { 269 return true; 270 } 271 chunk = chunk->_next; 272 } 273 return false; 274 } 275 #endif // PRODUCT 276 277 bool ClassLoaderData::claim() { 278 if (_claimed == 1) { 279 return false; 280 } 281 282 return (int) Atomic::cmpxchg(1, &_claimed, 0) == 0; 283 } 284 285 // Unsafe anonymous classes have their own ClassLoaderData that is marked to keep alive 286 // while the class is being parsed, and if the class appears on the module fixup list. 287 // Due to the uniqueness that no other class shares the unsafe anonymous class' name or 288 // ClassLoaderData, no other non-GC thread has knowledge of the unsafe anonymous class while 289 // it is being defined, therefore _keep_alive is not volatile or atomic. 290 void ClassLoaderData::inc_keep_alive() { 291 if (is_unsafe_anonymous()) { 292 assert(_keep_alive >= 0, "Invalid keep alive increment count"); 293 _keep_alive++; 294 } 295 } 296 297 void ClassLoaderData::dec_keep_alive() { 298 if (is_unsafe_anonymous()) { 299 assert(_keep_alive > 0, "Invalid keep alive decrement count"); 300 _keep_alive--; 301 } 302 } 303 304 void ClassLoaderData::oops_do(OopClosure* f, bool must_claim, bool clear_mod_oops) { 305 if (must_claim && !claim()) { 306 return; 307 } 308 309 // Only clear modified_oops after the ClassLoaderData is claimed. 310 if (clear_mod_oops) { 311 clear_modified_oops(); 312 } 313 314 _handles.oops_do(f); 315 } 316 317 void ClassLoaderData::classes_do(KlassClosure* klass_closure) { 318 // Lock-free access requires load_acquire 319 for (Klass* k = OrderAccess::load_acquire(&_klasses); k != NULL; k = k->next_link()) { 320 klass_closure->do_klass(k); 321 assert(k != k->next_link(), "no loops!"); 322 } 323 } 324 325 void ClassLoaderData::classes_do(void f(Klass * const)) { 326 // Lock-free access requires load_acquire 327 for (Klass* k = OrderAccess::load_acquire(&_klasses); k != NULL; k = k->next_link()) { 328 f(k); 329 assert(k != k->next_link(), "no loops!"); 330 } 331 } 332 333 void ClassLoaderData::methods_do(void f(Method*)) { 334 // Lock-free access requires load_acquire 335 for (Klass* k = OrderAccess::load_acquire(&_klasses); k != NULL; k = k->next_link()) { 336 if (k->is_instance_klass() && InstanceKlass::cast(k)->is_loaded()) { 337 InstanceKlass::cast(k)->methods_do(f); 338 } 339 } 340 } 341 342 void ClassLoaderData::loaded_classes_do(KlassClosure* klass_closure) { 343 // Lock-free access requires load_acquire 344 for (Klass* k = OrderAccess::load_acquire(&_klasses); k != NULL; k = k->next_link()) { 345 // Do not filter ArrayKlass oops here... 346 if (k->is_array_klass() || (k->is_instance_klass() && InstanceKlass::cast(k)->is_loaded())) { 347 klass_closure->do_klass(k); 348 } 349 } 350 } 351 352 void ClassLoaderData::classes_do(void f(InstanceKlass*)) { 353 // Lock-free access requires load_acquire 354 for (Klass* k = OrderAccess::load_acquire(&_klasses); k != NULL; k = k->next_link()) { 355 if (k->is_instance_klass()) { 356 f(InstanceKlass::cast(k)); 357 } 358 assert(k != k->next_link(), "no loops!"); 359 } 360 } 361 362 void ClassLoaderData::modules_do(void f(ModuleEntry*)) { 363 assert_locked_or_safepoint(Module_lock); 364 if (_unnamed_module != NULL) { 365 f(_unnamed_module); 366 } 367 if (_modules != NULL) { 368 for (int i = 0; i < _modules->table_size(); i++) { 369 for (ModuleEntry* entry = _modules->bucket(i); 370 entry != NULL; 371 entry = entry->next()) { 372 f(entry); 373 } 374 } 375 } 376 } 377 378 void ClassLoaderData::packages_do(void f(PackageEntry*)) { 379 assert_locked_or_safepoint(Module_lock); 380 if (_packages != NULL) { 381 for (int i = 0; i < _packages->table_size(); i++) { 382 for (PackageEntry* entry = _packages->bucket(i); 383 entry != NULL; 384 entry = entry->next()) { 385 f(entry); 386 } 387 } 388 } 389 } 390 391 void ClassLoaderData::record_dependency(const Klass* k) { 392 assert(k != NULL, "invariant"); 393 394 ClassLoaderData * const from_cld = this; 395 ClassLoaderData * const to_cld = k->class_loader_data(); 396 397 // Do not need to record dependency if the dependency is to a class whose 398 // class loader data is never freed. (i.e. the dependency's class loader 399 // is one of the three builtin class loaders and the dependency is not 400 // unsafe anonymous.) 401 if (to_cld->is_permanent_class_loader_data()) { 402 return; 403 } 404 405 oop to; 406 if (to_cld->is_unsafe_anonymous()) { 407 // Just return if an unsafe anonymous class is attempting to record a dependency 408 // to itself. (Note that every unsafe anonymous class has its own unique class 409 // loader data.) 410 if (to_cld == from_cld) { 411 return; 412 } 413 // Unsafe anonymous class dependencies are through the mirror. 414 to = k->java_mirror(); 415 } else { 416 to = to_cld->class_loader(); 417 oop from = from_cld->class_loader(); 418 419 // Just return if this dependency is to a class with the same or a parent 420 // class_loader. 421 if (oopDesc::equals(from, to) || java_lang_ClassLoader::isAncestor(from, to)) { 422 return; // this class loader is in the parent list, no need to add it. 423 } 424 } 425 426 // It's a dependency we won't find through GC, add it. 427 if (!_handles.contains(to)) { 428 NOT_PRODUCT(Atomic::inc(&_dependency_count)); 429 LogTarget(Trace, class, loader, data) lt; 430 if (lt.is_enabled()) { 431 ResourceMark rm; 432 LogStream ls(lt); 433 ls.print("adding dependency from "); 434 print_value_on(&ls); 435 ls.print(" to "); 436 to_cld->print_value_on(&ls); 437 ls.cr(); 438 } 439 Handle dependency(Thread::current(), to); 440 add_handle(dependency); 441 // Added a potentially young gen oop to the ClassLoaderData 442 record_modified_oops(); 443 } 444 } 445 446 447 void ClassLoaderDataGraph::clear_claimed_marks() { 448 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) { 449 cld->clear_claimed(); 450 } 451 } 452 453 void ClassLoaderData::add_class(Klass* k, bool publicize /* true */) { 454 { 455 MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag); 456 Klass* old_value = _klasses; 457 k->set_next_link(old_value); 458 // Link the new item into the list, making sure the linked class is stable 459 // since the list can be walked without a lock 460 OrderAccess::release_store(&_klasses, k); 461 if (k->is_array_klass()) { 462 ClassLoaderDataGraph::inc_array_classes(1); 463 } else { 464 ClassLoaderDataGraph::inc_instance_classes(1); 465 } 466 } 467 468 if (publicize) { 469 LogTarget(Trace, class, loader, data) lt; 470 if (lt.is_enabled()) { 471 ResourceMark rm; 472 LogStream ls(lt); 473 ls.print("Adding k: " PTR_FORMAT " %s to ", p2i(k), k->external_name()); 474 print_value_on(&ls); 475 ls.cr(); 476 } 477 } 478 } 479 480 // Class iterator used by the compiler. It gets some number of classes at 481 // a safepoint to decay invocation counters on the methods. 482 class ClassLoaderDataGraphKlassIteratorStatic { 483 ClassLoaderData* _current_loader_data; 484 Klass* _current_class_entry; 485 public: 486 487 ClassLoaderDataGraphKlassIteratorStatic() : _current_loader_data(NULL), _current_class_entry(NULL) {} 488 489 InstanceKlass* try_get_next_class() { 490 assert(SafepointSynchronize::is_at_safepoint(), "only called at safepoint"); 491 size_t max_classes = ClassLoaderDataGraph::num_instance_classes(); 492 assert(max_classes > 0, "should not be called with no instance classes"); 493 for (size_t i = 0; i < max_classes; ) { 494 495 if (_current_class_entry != NULL) { 496 Klass* k = _current_class_entry; 497 _current_class_entry = _current_class_entry->next_link(); 498 499 if (k->is_instance_klass()) { 500 InstanceKlass* ik = InstanceKlass::cast(k); 501 i++; // count all instance classes found 502 // Not yet loaded classes are counted in max_classes 503 // but only return loaded classes. 504 if (ik->is_loaded()) { 505 return ik; 506 } 507 } 508 } else { 509 // Go to next CLD 510 if (_current_loader_data != NULL) { 511 _current_loader_data = _current_loader_data->next(); 512 } 513 // Start at the beginning 514 if (_current_loader_data == NULL) { 515 _current_loader_data = ClassLoaderDataGraph::_head; 516 } 517 518 _current_class_entry = _current_loader_data->klasses(); 519 } 520 } 521 // Should never be reached unless all instance classes have failed or are not fully loaded. 522 // Caller handles NULL. 523 return NULL; 524 } 525 526 // If the current class for the static iterator is a class being unloaded or 527 // deallocated, adjust the current class. 528 void adjust_saved_class(ClassLoaderData* cld) { 529 if (_current_loader_data == cld) { 530 _current_loader_data = cld->next(); 531 if (_current_loader_data != NULL) { 532 _current_class_entry = _current_loader_data->klasses(); 533 } // else try_get_next_class will start at the head 534 } 535 } 536 537 void adjust_saved_class(Klass* klass) { 538 if (_current_class_entry == klass) { 539 _current_class_entry = klass->next_link(); 540 } 541 } 542 }; 543 544 static ClassLoaderDataGraphKlassIteratorStatic static_klass_iterator; 545 546 InstanceKlass* ClassLoaderDataGraph::try_get_next_class() { 547 assert(SafepointSynchronize::is_at_safepoint(), "only called at safepoint"); 548 return static_klass_iterator.try_get_next_class(); 549 } 550 551 552 void ClassLoaderData::initialize_holder(Handle loader_or_mirror) { 553 if (loader_or_mirror() != NULL) { 554 assert(_holder.is_null(), "never replace holders"); 555 _holder = WeakHandle<vm_class_loader_data>::create(loader_or_mirror); 556 } 557 } 558 559 // Remove a klass from the _klasses list for scratch_class during redefinition 560 // or parsed class in the case of an error. 561 void ClassLoaderData::remove_class(Klass* scratch_class) { 562 assert(SafepointSynchronize::is_at_safepoint(), "only called at safepoint"); 563 564 // Adjust global class iterator. 565 static_klass_iterator.adjust_saved_class(scratch_class); 566 567 Klass* prev = NULL; 568 for (Klass* k = _klasses; k != NULL; k = k->next_link()) { 569 if (k == scratch_class) { 570 if (prev == NULL) { 571 _klasses = k->next_link(); 572 } else { 573 Klass* next = k->next_link(); 574 prev->set_next_link(next); 575 } 576 577 if (k->is_array_klass()) { 578 ClassLoaderDataGraph::dec_array_classes(1); 579 } else { 580 ClassLoaderDataGraph::dec_instance_classes(1); 581 } 582 583 return; 584 } 585 prev = k; 586 assert(k != k->next_link(), "no loops!"); 587 } 588 ShouldNotReachHere(); // should have found this class!! 589 } 590 591 void ClassLoaderData::unload() { 592 _unloading = true; 593 594 LogTarget(Trace, class, loader, data) lt; 595 if (lt.is_enabled()) { 596 ResourceMark rm; 597 LogStream ls(lt); 598 ls.print("unload"); 599 print_value_on(&ls); 600 ls.cr(); 601 } 602 603 // Some items on the _deallocate_list need to free their C heap structures 604 // if they are not already on the _klasses list. 605 free_deallocate_list_C_heap_structures(); 606 607 // Tell serviceability tools these classes are unloading 608 // after erroneous classes are released. 609 classes_do(InstanceKlass::notify_unload_class); 610 611 // Clean up global class iterator for compiler 612 static_klass_iterator.adjust_saved_class(this); 613 } 614 615 ModuleEntryTable* ClassLoaderData::modules() { 616 // Lazily create the module entry table at first request. 617 // Lock-free access requires load_acquire. 618 ModuleEntryTable* modules = OrderAccess::load_acquire(&_modules); 619 if (modules == NULL) { 620 MutexLocker m1(Module_lock); 621 // Check if _modules got allocated while we were waiting for this lock. 622 if ((modules = _modules) == NULL) { 623 modules = new ModuleEntryTable(ModuleEntryTable::_moduletable_entry_size); 624 625 { 626 MutexLockerEx m1(metaspace_lock(), Mutex::_no_safepoint_check_flag); 627 // Ensure _modules is stable, since it is examined without a lock 628 OrderAccess::release_store(&_modules, modules); 629 } 630 } 631 } 632 return modules; 633 } 634 635 const int _boot_loader_dictionary_size = 1009; 636 const int _default_loader_dictionary_size = 107; 637 638 Dictionary* ClassLoaderData::create_dictionary() { 639 assert(!is_unsafe_anonymous(), "unsafe anonymous class loader data do not have a dictionary"); 640 int size; 641 bool resizable = false; 642 if (_the_null_class_loader_data == NULL) { 643 size = _boot_loader_dictionary_size; 644 resizable = true; 645 } else if (class_loader()->is_a(SystemDictionary::reflect_DelegatingClassLoader_klass())) { 646 size = 1; // there's only one class in relection class loader and no initiated classes 647 } else if (is_system_class_loader_data()) { 648 size = _boot_loader_dictionary_size; 649 resizable = true; 650 } else { 651 size = _default_loader_dictionary_size; 652 resizable = true; 653 } 654 if (!DynamicallyResizeSystemDictionaries || DumpSharedSpaces) { 655 resizable = false; 656 } 657 return new Dictionary(this, size, resizable); 658 } 659 660 // Tell the GC to keep this klass alive while iterating ClassLoaderDataGraph 661 oop ClassLoaderData::holder_phantom() const { 662 // A klass that was previously considered dead can be looked up in the 663 // CLD/SD, and its _java_mirror or _class_loader can be stored in a root 664 // or a reachable object making it alive again. The SATB part of G1 needs 665 // to get notified about this potential resurrection, otherwise the marking 666 // might not find the object. 667 if (!_holder.is_null()) { // NULL class_loader 668 return _holder.resolve(); 669 } else { 670 return NULL; 671 } 672 } 673 674 // Unloading support 675 bool ClassLoaderData::is_alive() const { 676 bool alive = keep_alive() // null class loader and incomplete unsafe anonymous klasses. 677 || (_holder.peek() != NULL); // and not cleaned by the GC weak handle processing. 678 679 return alive; 680 } 681 682 class ReleaseKlassClosure: public KlassClosure { 683 private: 684 size_t _instance_class_released; 685 size_t _array_class_released; 686 public: 687 ReleaseKlassClosure() : _instance_class_released(0), _array_class_released(0) { } 688 689 size_t instance_class_released() const { return _instance_class_released; } 690 size_t array_class_released() const { return _array_class_released; } 691 692 void do_klass(Klass* k) { 693 if (k->is_array_klass()) { 694 _array_class_released ++; 695 } else { 696 assert(k->is_instance_klass(), "Must be"); 697 _instance_class_released ++; 698 InstanceKlass::release_C_heap_structures(InstanceKlass::cast(k)); 699 } 700 } 701 }; 702 703 ClassLoaderData::~ClassLoaderData() { 704 // Release C heap structures for all the classes. 705 ReleaseKlassClosure cl; 706 classes_do(&cl); 707 708 ClassLoaderDataGraph::dec_array_classes(cl.array_class_released()); 709 ClassLoaderDataGraph::dec_instance_classes(cl.instance_class_released()); 710 711 // Release the WeakHandle 712 _holder.release(); 713 714 // Release C heap allocated hashtable for all the packages. 715 if (_packages != NULL) { 716 // Destroy the table itself 717 delete _packages; 718 _packages = NULL; 719 } 720 721 // Release C heap allocated hashtable for all the modules. 722 if (_modules != NULL) { 723 // Destroy the table itself 724 delete _modules; 725 _modules = NULL; 726 } 727 728 // Release C heap allocated hashtable for the dictionary 729 if (_dictionary != NULL) { 730 // Destroy the table itself 731 delete _dictionary; 732 _dictionary = NULL; 733 } 734 735 if (_unnamed_module != NULL) { 736 _unnamed_module->delete_unnamed_module(); 737 _unnamed_module = NULL; 738 } 739 740 // release the metaspace 741 ClassLoaderMetaspace *m = _metaspace; 742 if (m != NULL) { 743 _metaspace = NULL; 744 delete m; 745 } 746 // Clear all the JNI handles for methods 747 // These aren't deallocated and are going to look like a leak, but that's 748 // needed because we can't really get rid of jmethodIDs because we don't 749 // know when native code is going to stop using them. The spec says that 750 // they're "invalid" but existing programs likely rely on their being 751 // NULL after class unloading. 752 if (_jmethod_ids != NULL) { 753 Method::clear_jmethod_ids(this); 754 } 755 // Delete lock 756 delete _metaspace_lock; 757 758 // Delete free list 759 if (_deallocate_list != NULL) { 760 delete _deallocate_list; 761 } 762 } 763 764 // Returns true if this class loader data is for the app class loader 765 // or a user defined system class loader. (Note that the class loader 766 // data may be unsafe anonymous.) 767 bool ClassLoaderData::is_system_class_loader_data() const { 768 return SystemDictionary::is_system_class_loader(class_loader()); 769 } 770 771 // Returns true if this class loader data is for the platform class loader. 772 // (Note that the class loader data may be unsafe anonymous.) 773 bool ClassLoaderData::is_platform_class_loader_data() const { 774 return SystemDictionary::is_platform_class_loader(class_loader()); 775 } 776 777 // Returns true if the class loader for this class loader data is one of 778 // the 3 builtin (boot application/system or platform) class loaders, 779 // including a user-defined system class loader. Note that if the class 780 // loader data is for an unsafe anonymous class then it may get freed by a GC 781 // even if its class loader is one of these loaders. 782 bool ClassLoaderData::is_builtin_class_loader_data() const { 783 return (is_boot_class_loader_data() || 784 SystemDictionary::is_system_class_loader(class_loader()) || 785 SystemDictionary::is_platform_class_loader(class_loader())); 786 } 787 788 // Returns true if this class loader data is a class loader data 789 // that is not ever freed by a GC. It must be the CLD for one of the builtin 790 // class loaders and not the CLD for an unsafe anonymous class. 791 bool ClassLoaderData::is_permanent_class_loader_data() const { 792 return is_builtin_class_loader_data() && !is_unsafe_anonymous(); 793 } 794 795 ClassLoaderMetaspace* ClassLoaderData::metaspace_non_null() { 796 // If the metaspace has not been allocated, create a new one. Might want 797 // to create smaller arena for Reflection class loaders also. 798 // The reason for the delayed allocation is because some class loaders are 799 // simply for delegating with no metadata of their own. 800 // Lock-free access requires load_acquire. 801 ClassLoaderMetaspace* metaspace = OrderAccess::load_acquire(&_metaspace); 802 if (metaspace == NULL) { 803 MutexLockerEx ml(_metaspace_lock, Mutex::_no_safepoint_check_flag); 804 // Check if _metaspace got allocated while we were waiting for this lock. 805 if ((metaspace = _metaspace) == NULL) { 806 if (this == the_null_class_loader_data()) { 807 assert (class_loader() == NULL, "Must be"); 808 metaspace = new ClassLoaderMetaspace(_metaspace_lock, Metaspace::BootMetaspaceType); 809 } else if (is_unsafe_anonymous()) { 810 metaspace = new ClassLoaderMetaspace(_metaspace_lock, Metaspace::UnsafeAnonymousMetaspaceType); 811 } else if (class_loader()->is_a(SystemDictionary::reflect_DelegatingClassLoader_klass())) { 812 metaspace = new ClassLoaderMetaspace(_metaspace_lock, Metaspace::ReflectionMetaspaceType); 813 } else { 814 metaspace = new ClassLoaderMetaspace(_metaspace_lock, Metaspace::StandardMetaspaceType); 815 } 816 // Ensure _metaspace is stable, since it is examined without a lock 817 OrderAccess::release_store(&_metaspace, metaspace); 818 } 819 } 820 return metaspace; 821 } 822 823 OopHandle ClassLoaderData::add_handle(Handle h) { 824 MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag); 825 record_modified_oops(); 826 return OopHandle(_handles.add(h())); 827 } 828 829 void ClassLoaderData::remove_handle(OopHandle h) { 830 assert(!is_unloading(), "Do not remove a handle for a CLD that is unloading"); 831 oop* ptr = h.ptr_raw(); 832 if (ptr != NULL) { 833 assert(_handles.owner_of(ptr), "Got unexpected handle " PTR_FORMAT, p2i(ptr)); 834 NativeAccess<>::oop_store(ptr, oop(NULL)); 835 } 836 } 837 838 void ClassLoaderData::init_handle_locked(OopHandle& dest, Handle h) { 839 MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag); 840 if (dest.resolve() != NULL) { 841 return; 842 } else { 843 dest = _handles.add(h()); 844 } 845 } 846 847 // Add this metadata pointer to be freed when it's safe. This is only during 848 // a safepoint which checks if handles point to this metadata field. 849 void ClassLoaderData::add_to_deallocate_list(Metadata* m) { 850 // Metadata in shared region isn't deleted. 851 if (!m->is_shared()) { 852 MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag); 853 if (_deallocate_list == NULL) { 854 _deallocate_list = new (ResourceObj::C_HEAP, mtClass) GrowableArray<Metadata*>(100, true); 855 } 856 _deallocate_list->append_if_missing(m); 857 log_debug(class, loader, data)("deallocate added for %s", m->print_value_string()); 858 ClassLoaderDataGraph::set_should_clean_deallocate_lists(); 859 } 860 } 861 862 // Deallocate free metadata on the free list. How useful the PermGen was! 863 void ClassLoaderData::free_deallocate_list() { 864 // Don't need lock, at safepoint 865 assert(SafepointSynchronize::is_at_safepoint(), "only called at safepoint"); 866 assert(!is_unloading(), "only called for ClassLoaderData that are not unloading"); 867 if (_deallocate_list == NULL) { 868 return; 869 } 870 // Go backwards because this removes entries that are freed. 871 for (int i = _deallocate_list->length() - 1; i >= 0; i--) { 872 Metadata* m = _deallocate_list->at(i); 873 if (!m->on_stack()) { 874 _deallocate_list->remove_at(i); 875 // There are only three types of metadata that we deallocate directly. 876 // Cast them so they can be used by the template function. 877 if (m->is_method()) { 878 MetadataFactory::free_metadata(this, (Method*)m); 879 } else if (m->is_constantPool()) { 880 MetadataFactory::free_metadata(this, (ConstantPool*)m); 881 } else if (m->is_klass()) { 882 MetadataFactory::free_metadata(this, (InstanceKlass*)m); 883 } else { 884 ShouldNotReachHere(); 885 } 886 } else { 887 // Metadata is alive. 888 // If scratch_class is on stack then it shouldn't be on this list! 889 assert(!m->is_klass() || !((InstanceKlass*)m)->is_scratch_class(), 890 "scratch classes on this list should be dead"); 891 // Also should assert that other metadata on the list was found in handles. 892 // Some cleaning remains. 893 ClassLoaderDataGraph::set_should_clean_deallocate_lists(); 894 } 895 } 896 } 897 898 void ClassLoaderDataGraph::clean_deallocate_lists(bool walk_previous_versions) { 899 assert(SafepointSynchronize::is_at_safepoint(), "must only be called at safepoint"); 900 uint loaders_processed = 0; 901 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) { 902 // is_alive check will be necessary for concurrent class unloading. 903 if (cld->is_alive()) { 904 // clean metaspace 905 if (walk_previous_versions) { 906 cld->classes_do(InstanceKlass::purge_previous_versions); 907 } 908 cld->free_deallocate_list(); 909 loaders_processed++; 910 } 911 } 912 log_debug(class, loader, data)("clean_deallocate_lists: loaders processed %u %s", 913 loaders_processed, walk_previous_versions ? "walk_previous_versions" : ""); 914 } 915 916 void ClassLoaderDataGraph::walk_metadata_and_clean_metaspaces() { 917 assert(SafepointSynchronize::is_at_safepoint(), "must only be called at safepoint"); 918 919 _should_clean_deallocate_lists = false; // assume everything gets cleaned 920 921 // Mark metadata seen on the stack so we can delete unreferenced entries. 922 // Walk all metadata, including the expensive code cache walk, only for class redefinition. 923 // The MetadataOnStackMark walk during redefinition saves previous versions if it finds old methods 924 // on the stack or in the code cache, so we only have to repeat the full walk if 925 // they were found at that time. 926 // TODO: have redefinition clean old methods out of the code cache. They still exist in some places. 927 bool walk_all_metadata = InstanceKlass::has_previous_versions_and_reset(); 928 929 MetadataOnStackMark md_on_stack(walk_all_metadata); 930 clean_deallocate_lists(walk_all_metadata); 931 } 932 933 // This is distinct from free_deallocate_list. For class loader data that are 934 // unloading, this frees the C heap memory for items on the list, and unlinks 935 // scratch or error classes so that unloading events aren't triggered for these 936 // classes. The metadata is removed with the unloading metaspace. 937 // There isn't C heap memory allocated for methods, so nothing is done for them. 938 void ClassLoaderData::free_deallocate_list_C_heap_structures() { 939 // Don't need lock, at safepoint 940 assert(SafepointSynchronize::is_at_safepoint(), "only called at safepoint"); 941 assert(is_unloading(), "only called for ClassLoaderData that are unloading"); 942 if (_deallocate_list == NULL) { 943 return; 944 } 945 // Go backwards because this removes entries that are freed. 946 for (int i = _deallocate_list->length() - 1; i >= 0; i--) { 947 Metadata* m = _deallocate_list->at(i); 948 _deallocate_list->remove_at(i); 949 if (m->is_constantPool()) { 950 ((ConstantPool*)m)->release_C_heap_structures(); 951 } else if (m->is_klass()) { 952 InstanceKlass* ik = (InstanceKlass*)m; 953 // also releases ik->constants() C heap memory 954 InstanceKlass::release_C_heap_structures(ik); 955 // Remove the class so unloading events aren't triggered for 956 // this class (scratch or error class) in do_unloading(). 957 remove_class(ik); 958 } 959 } 960 } 961 962 // These CLDs are to contain unsafe anonymous classes used for JSR292 963 ClassLoaderData* ClassLoaderData::unsafe_anonymous_class_loader_data(Handle loader) { 964 // Add a new class loader data to the graph. 965 return ClassLoaderDataGraph::add(loader, true); 966 } 967 968 // Caller needs ResourceMark 969 // If the class loader's _name has not been explicitly set, the class loader's 970 // qualified class name is returned. 971 const char* ClassLoaderData::loader_name() const { 972 if (_class_loader_klass == NULL) { 973 return BOOTSTRAP_LOADER_NAME; 974 } else if (_name != NULL) { 975 return _name->as_C_string(); 976 } else { 977 return _class_loader_klass->external_name(); 978 } 979 } 980 981 // Caller needs ResourceMark 982 // Format of the _name_and_id is as follows: 983 // If the defining loader has a name explicitly set then '<loader-name>' @<id> 984 // If the defining loader has no name then <qualified-class-name> @<id> 985 // If built-in loader, then omit '@<id>' as there is only one instance. 986 const char* ClassLoaderData::loader_name_and_id() const { 987 if (_class_loader_klass == NULL) { 988 return "'" BOOTSTRAP_LOADER_NAME "'"; 989 } else if (_name_and_id != NULL) { 990 return _name_and_id->as_C_string(); 991 } else { 992 // May be called in a race before _name_and_id is initialized. 993 return _class_loader_klass->external_name(); 994 } 995 } 996 997 void ClassLoaderData::print_value_on(outputStream* out) const { 998 if (!is_unloading() && class_loader() != NULL) { 999 out->print("loader data: " INTPTR_FORMAT " for instance ", p2i(this)); 1000 class_loader()->print_value_on(out); // includes loader_name_and_id() and address of class loader instance 1001 } else { 1002 // loader data: 0xsomeaddr of 'bootstrap' 1003 out->print("loader data: " INTPTR_FORMAT " of %s", p2i(this), loader_name_and_id()); 1004 } 1005 if (is_unsafe_anonymous()) { 1006 out->print(" unsafe anonymous"); 1007 } 1008 } 1009 1010 #ifndef PRODUCT 1011 void ClassLoaderData::print_on(outputStream* out) const { 1012 out->print("ClassLoaderData CLD: " PTR_FORMAT ", loader: " PTR_FORMAT ", loader_klass: %s {", 1013 p2i(this), p2i(_class_loader.ptr_raw()), loader_name_and_id()); 1014 if (is_unsafe_anonymous()) out->print(" unsafe anonymous"); 1015 if (claimed()) out->print(" claimed"); 1016 if (is_unloading()) out->print(" unloading"); 1017 out->print(" metaspace: " INTPTR_FORMAT, p2i(metaspace_or_null())); 1018 1019 if (_jmethod_ids != NULL) { 1020 Method::print_jmethod_ids(this, out); 1021 } 1022 out->print(" handles count %d", _handles.count()); 1023 out->print(" dependencies %d", _dependency_count); 1024 out->print_cr("}"); 1025 } 1026 #endif // PRODUCT 1027 1028 void ClassLoaderData::verify() { 1029 assert_locked_or_safepoint(_metaspace_lock); 1030 oop cl = class_loader(); 1031 1032 guarantee(this == class_loader_data(cl) || is_unsafe_anonymous(), "Must be the same"); 1033 guarantee(cl != NULL || this == ClassLoaderData::the_null_class_loader_data() || is_unsafe_anonymous(), "must be"); 1034 1035 // Verify the integrity of the allocated space. 1036 if (metaspace_or_null() != NULL) { 1037 metaspace_or_null()->verify(); 1038 } 1039 1040 for (Klass* k = _klasses; k != NULL; k = k->next_link()) { 1041 guarantee(k->class_loader_data() == this, "Must be the same"); 1042 k->verify(); 1043 assert(k != k->next_link(), "no loops!"); 1044 } 1045 } 1046 1047 bool ClassLoaderData::contains_klass(Klass* klass) { 1048 // Lock-free access requires load_acquire 1049 for (Klass* k = OrderAccess::load_acquire(&_klasses); k != NULL; k = k->next_link()) { 1050 if (k == klass) return true; 1051 } 1052 return false; 1053 } 1054 1055 1056 // GC root of class loader data created. 1057 ClassLoaderData* ClassLoaderDataGraph::_head = NULL; 1058 ClassLoaderData* ClassLoaderDataGraph::_unloading = NULL; 1059 ClassLoaderData* ClassLoaderDataGraph::_saved_unloading = NULL; 1060 ClassLoaderData* ClassLoaderDataGraph::_saved_head = NULL; 1061 1062 bool ClassLoaderDataGraph::_should_purge = false; 1063 bool ClassLoaderDataGraph::_should_clean_deallocate_lists = false; 1064 bool ClassLoaderDataGraph::_safepoint_cleanup_needed = false; 1065 bool ClassLoaderDataGraph::_metaspace_oom = false; 1066 1067 // Add a new class loader data node to the list. Assign the newly created 1068 // ClassLoaderData into the java/lang/ClassLoader object as a hidden field 1069 ClassLoaderData* ClassLoaderDataGraph::add_to_graph(Handle loader, bool is_unsafe_anonymous) { 1070 1071 1072 ClassLoaderData* cld; 1073 { 1074 NoSafepointVerifier no_safepoints; // we mustn't GC until we've installed the 1075 // ClassLoaderData in the loader since the CLD 1076 // contains oops in _handles that must be walked. 1077 // GC will find the CLD through the loader after this. 1078 1079 cld = new ClassLoaderData(loader, is_unsafe_anonymous); 1080 1081 if (!is_unsafe_anonymous) { 1082 // First, Atomically set it 1083 ClassLoaderData* old = java_lang_ClassLoader::cmpxchg_loader_data(cld, loader(), NULL); 1084 if (old != NULL) { 1085 delete cld; 1086 // Returns the data. 1087 return old; 1088 } 1089 } 1090 } 1091 1092 MutexLocker ml(ClassLoaderDataGraph_lock); 1093 1094 // We won the race, and therefore the task of adding the data to the list of 1095 // class loader data 1096 cld->set_next(_head); 1097 _head = cld; 1098 LogTarget(Trace, class, loader, data) lt; 1099 if (lt.is_enabled()) { 1100 ResourceMark rm; 1101 LogStream ls(lt); 1102 ls.print("create "); 1103 cld->print_value_on(&ls); 1104 ls.cr(); 1105 } 1106 return cld; 1107 } 1108 1109 ClassLoaderData* ClassLoaderDataGraph::add(Handle loader, bool is_unsafe_anonymous) { 1110 ClassLoaderData* loader_data = add_to_graph(loader, is_unsafe_anonymous); 1111 // Initialize _name and _name_and_id after the loader data is added to the 1112 // CLDG because adding the Symbol for _name and _name_and_id might safepoint. 1113 if (loader.not_null()) { 1114 loader_data->initialize_name(loader); 1115 } 1116 return loader_data; 1117 } 1118 1119 void ClassLoaderDataGraph::cld_do(CLDClosure* cl) { 1120 assert_locked_or_safepoint(ClassLoaderDataGraph_lock); 1121 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->_next) { 1122 cl->do_cld(cld); 1123 } 1124 } 1125 1126 void ClassLoaderDataGraph::cld_unloading_do(CLDClosure* cl) { 1127 assert_locked_or_safepoint(ClassLoaderDataGraph_lock); 1128 // Only walk the head until any clds not purged from prior unloading 1129 // (CMS doesn't purge right away). 1130 for (ClassLoaderData* cld = _unloading; cld != _saved_unloading; cld = cld->next()) { 1131 assert(cld->is_unloading(), "invariant"); 1132 cl->do_cld(cld); 1133 } 1134 } 1135 1136 void ClassLoaderDataGraph::roots_cld_do(CLDClosure* strong, CLDClosure* weak) { 1137 assert_locked_or_safepoint(ClassLoaderDataGraph_lock); 1138 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->_next) { 1139 CLDClosure* closure = cld->keep_alive() ? strong : weak; 1140 if (closure != NULL) { 1141 closure->do_cld(cld); 1142 } 1143 } 1144 } 1145 1146 void ClassLoaderDataGraph::always_strong_cld_do(CLDClosure* cl) { 1147 assert_locked_or_safepoint(ClassLoaderDataGraph_lock); 1148 if (ClassUnloading) { 1149 roots_cld_do(cl, NULL); 1150 } else { 1151 cld_do(cl); 1152 } 1153 } 1154 1155 // Closure for locking and iterating through classes. 1156 LockedClassesDo::LockedClassesDo(classes_do_func_t f) : _function(f) { 1157 ClassLoaderDataGraph_lock->lock(); 1158 } 1159 1160 LockedClassesDo::LockedClassesDo() : _function(NULL) { 1161 // callers provide their own do_klass 1162 ClassLoaderDataGraph_lock->lock(); 1163 } 1164 1165 LockedClassesDo::~LockedClassesDo() { ClassLoaderDataGraph_lock->unlock(); } 1166 1167 1168 // Iterating over the CLDG needs to be locked because 1169 // unloading can remove entries concurrently soon. 1170 class ClassLoaderDataGraphIterator : public StackObj { 1171 ClassLoaderData* _next; 1172 HandleMark _hm; // clean up handles when this is done. 1173 Handle _holder; 1174 Thread* _thread; 1175 1176 void hold_next() { 1177 if (_next != NULL) { 1178 _holder = Handle(_thread, _next->holder_phantom()); 1179 } 1180 } 1181 public: 1182 ClassLoaderDataGraphIterator() : _next(ClassLoaderDataGraph::_head) { 1183 _thread = Thread::current(); 1184 assert_locked_or_safepoint(ClassLoaderDataGraph_lock); 1185 hold_next(); 1186 } 1187 1188 bool repeat() const { 1189 return _next != NULL; 1190 } 1191 1192 ClassLoaderData* get_next() { 1193 ClassLoaderData* next = _next; 1194 if (_next != NULL) { 1195 _next = _next->next(); 1196 hold_next(); 1197 } 1198 return next; 1199 } 1200 }; 1201 1202 // These functions assume that the caller has locked the ClassLoaderDataGraph_lock 1203 // if they are not calling the function from a safepoint. 1204 void ClassLoaderDataGraph::classes_do(KlassClosure* klass_closure) { 1205 ClassLoaderDataGraphIterator iter; 1206 while (iter.repeat()) { 1207 ClassLoaderData* cld = iter.get_next(); 1208 cld->classes_do(klass_closure); 1209 } 1210 } 1211 1212 void ClassLoaderDataGraph::classes_do(void f(Klass* const)) { 1213 ClassLoaderDataGraphIterator iter; 1214 while (iter.repeat()) { 1215 ClassLoaderData* cld = iter.get_next(); 1216 cld->classes_do(f); 1217 } 1218 } 1219 1220 void ClassLoaderDataGraph::methods_do(void f(Method*)) { 1221 ClassLoaderDataGraphIterator iter; 1222 while (iter.repeat()) { 1223 ClassLoaderData* cld = iter.get_next(); 1224 cld->methods_do(f); 1225 } 1226 } 1227 1228 void ClassLoaderDataGraph::modules_do(void f(ModuleEntry*)) { 1229 assert_locked_or_safepoint(Module_lock); 1230 ClassLoaderDataGraphIterator iter; 1231 while (iter.repeat()) { 1232 ClassLoaderData* cld = iter.get_next(); 1233 cld->modules_do(f); 1234 } 1235 } 1236 1237 void ClassLoaderDataGraph::modules_unloading_do(void f(ModuleEntry*)) { 1238 assert_locked_or_safepoint(ClassLoaderDataGraph_lock); 1239 // Only walk the head until any clds not purged from prior unloading 1240 // (CMS doesn't purge right away). 1241 for (ClassLoaderData* cld = _unloading; cld != _saved_unloading; cld = cld->next()) { 1242 assert(cld->is_unloading(), "invariant"); 1243 cld->modules_do(f); 1244 } 1245 } 1246 1247 void ClassLoaderDataGraph::packages_do(void f(PackageEntry*)) { 1248 assert_locked_or_safepoint(Module_lock); 1249 ClassLoaderDataGraphIterator iter; 1250 while (iter.repeat()) { 1251 ClassLoaderData* cld = iter.get_next(); 1252 cld->packages_do(f); 1253 } 1254 } 1255 1256 void ClassLoaderDataGraph::packages_unloading_do(void f(PackageEntry*)) { 1257 assert_locked_or_safepoint(ClassLoaderDataGraph_lock); 1258 // Only walk the head until any clds not purged from prior unloading 1259 // (CMS doesn't purge right away). 1260 for (ClassLoaderData* cld = _unloading; cld != _saved_unloading; cld = cld->next()) { 1261 assert(cld->is_unloading(), "invariant"); 1262 cld->packages_do(f); 1263 } 1264 } 1265 1266 void ClassLoaderDataGraph::loaded_classes_do(KlassClosure* klass_closure) { 1267 ClassLoaderDataGraphIterator iter; 1268 while (iter.repeat()) { 1269 ClassLoaderData* cld = iter.get_next(); 1270 cld->loaded_classes_do(klass_closure); 1271 } 1272 } 1273 1274 // This case can block but cannot do unloading (called from CDS) 1275 void ClassLoaderDataGraph::unlocked_loaded_classes_do(KlassClosure* klass_closure) { 1276 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) { 1277 cld->loaded_classes_do(klass_closure); 1278 } 1279 } 1280 1281 1282 void ClassLoaderDataGraph::classes_unloading_do(void f(Klass* const)) { 1283 assert_locked_or_safepoint(ClassLoaderDataGraph_lock); 1284 // Only walk the head until any clds not purged from prior unloading 1285 // (CMS doesn't purge right away). 1286 for (ClassLoaderData* cld = _unloading; cld != _saved_unloading; cld = cld->next()) { 1287 assert(cld->is_unloading(), "invariant"); 1288 cld->classes_do(f); 1289 } 1290 } 1291 1292 #define FOR_ALL_DICTIONARY(X) ClassLoaderDataGraphIterator iter; \ 1293 ClassLoaderData* X; \ 1294 while ((X = iter.get_next()) != NULL) \ 1295 if (X->dictionary() != NULL) 1296 1297 // Walk classes in the loaded class dictionaries in various forms. 1298 // Only walks the classes defined in this class loader. 1299 void ClassLoaderDataGraph::dictionary_classes_do(void f(InstanceKlass*)) { 1300 FOR_ALL_DICTIONARY(cld) { 1301 cld->dictionary()->classes_do(f); 1302 } 1303 } 1304 1305 // Only walks the classes defined in this class loader. 1306 void ClassLoaderDataGraph::dictionary_classes_do(void f(InstanceKlass*, TRAPS), TRAPS) { 1307 FOR_ALL_DICTIONARY(cld) { 1308 cld->dictionary()->classes_do(f, CHECK); 1309 } 1310 } 1311 1312 void ClassLoaderDataGraph::verify_dictionary() { 1313 FOR_ALL_DICTIONARY(cld) { 1314 cld->dictionary()->verify(); 1315 } 1316 } 1317 1318 void ClassLoaderDataGraph::print_dictionary(outputStream* st) { 1319 FOR_ALL_DICTIONARY(cld) { 1320 st->print("Dictionary for "); 1321 cld->print_value_on(st); 1322 st->cr(); 1323 cld->dictionary()->print_on(st); 1324 st->cr(); 1325 } 1326 } 1327 1328 void ClassLoaderDataGraph::print_dictionary_statistics(outputStream* st) { 1329 FOR_ALL_DICTIONARY(cld) { 1330 ResourceMark rm; 1331 stringStream tempst; 1332 tempst.print("System Dictionary for %s class loader", cld->loader_name_and_id()); 1333 cld->dictionary()->print_table_statistics(st, tempst.as_string()); 1334 } 1335 } 1336 1337 GrowableArray<ClassLoaderData*>* ClassLoaderDataGraph::new_clds() { 1338 assert_locked_or_safepoint(ClassLoaderDataGraph_lock); 1339 assert(_head == NULL || _saved_head != NULL, "remember_new_clds(true) not called?"); 1340 1341 GrowableArray<ClassLoaderData*>* array = new GrowableArray<ClassLoaderData*>(); 1342 1343 // The CLDs in [_head, _saved_head] were all added during last call to remember_new_clds(true); 1344 ClassLoaderData* curr = _head; 1345 while (curr != _saved_head) { 1346 if (!curr->claimed()) { 1347 array->push(curr); 1348 LogTarget(Debug, class, loader, data) lt; 1349 if (lt.is_enabled()) { 1350 LogStream ls(lt); 1351 ls.print("found new CLD: "); 1352 curr->print_value_on(&ls); 1353 ls.cr(); 1354 } 1355 } 1356 1357 curr = curr->_next; 1358 } 1359 1360 return array; 1361 } 1362 1363 #ifndef PRODUCT 1364 bool ClassLoaderDataGraph::contains_loader_data(ClassLoaderData* loader_data) { 1365 assert_locked_or_safepoint(ClassLoaderDataGraph_lock); 1366 for (ClassLoaderData* data = _head; data != NULL; data = data->next()) { 1367 if (loader_data == data) { 1368 return true; 1369 } 1370 } 1371 1372 return false; 1373 } 1374 #endif // PRODUCT 1375 1376 // Move class loader data from main list to the unloaded list for unloading 1377 // and deallocation later. 1378 bool ClassLoaderDataGraph::do_unloading(bool do_cleaning) { 1379 assert_locked_or_safepoint(ClassLoaderDataGraph_lock); 1380 1381 // Indicate whether safepoint cleanup is needed. 1382 _safepoint_cleanup_needed |= do_cleaning; 1383 1384 ClassLoaderData* data = _head; 1385 ClassLoaderData* prev = NULL; 1386 bool seen_dead_loader = false; 1387 uint loaders_processed = 0; 1388 uint loaders_removed = 0; 1389 1390 // Save previous _unloading pointer for CMS which may add to unloading list before 1391 // purging and we don't want to rewalk the previously unloaded class loader data. 1392 _saved_unloading = _unloading; 1393 1394 data = _head; 1395 while (data != NULL) { 1396 if (data->is_alive()) { 1397 prev = data; 1398 data = data->next(); 1399 loaders_processed++; 1400 continue; 1401 } 1402 seen_dead_loader = true; 1403 loaders_removed++; 1404 ClassLoaderData* dead = data; 1405 dead->unload(); 1406 data = data->next(); 1407 // Remove from loader list. 1408 // This class loader data will no longer be found 1409 // in the ClassLoaderDataGraph. 1410 if (prev != NULL) { 1411 prev->set_next(data); 1412 } else { 1413 assert(dead == _head, "sanity check"); 1414 _head = data; 1415 } 1416 dead->set_next(_unloading); 1417 _unloading = dead; 1418 } 1419 1420 log_debug(class, loader, data)("do_unloading: loaders processed %u, loaders removed %u", loaders_processed, loaders_removed); 1421 1422 return seen_dead_loader; 1423 } 1424 1425 // There's at least one dead class loader. Purge refererences of healthy module 1426 // reads lists and package export lists to modules belonging to dead loaders. 1427 void ClassLoaderDataGraph::clean_module_and_package_info() { 1428 assert_locked_or_safepoint(ClassLoaderDataGraph_lock); 1429 1430 ClassLoaderData* data = _head; 1431 while (data != NULL) { 1432 // Remove entries in the dictionary of live class loader that have 1433 // initiated loading classes in a dead class loader. 1434 if (data->dictionary() != NULL) { 1435 data->dictionary()->do_unloading(); 1436 } 1437 // Walk a ModuleEntry's reads, and a PackageEntry's exports 1438 // lists to determine if there are modules on those lists that are now 1439 // dead and should be removed. A module's life cycle is equivalent 1440 // to its defining class loader's life cycle. Since a module is 1441 // considered dead if its class loader is dead, these walks must 1442 // occur after each class loader's aliveness is determined. 1443 if (data->packages() != NULL) { 1444 data->packages()->purge_all_package_exports(); 1445 } 1446 if (data->modules_defined()) { 1447 data->modules()->purge_all_module_reads(); 1448 } 1449 data = data->next(); 1450 } 1451 } 1452 1453 void ClassLoaderDataGraph::purge() { 1454 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!"); 1455 ClassLoaderData* list = _unloading; 1456 _unloading = NULL; 1457 ClassLoaderData* next = list; 1458 bool classes_unloaded = false; 1459 while (next != NULL) { 1460 ClassLoaderData* purge_me = next; 1461 next = purge_me->next(); 1462 delete purge_me; 1463 classes_unloaded = true; 1464 } 1465 if (classes_unloaded) { 1466 Metaspace::purge(); 1467 set_metaspace_oom(false); 1468 } 1469 } 1470 1471 int ClassLoaderDataGraph::resize_if_needed() { 1472 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!"); 1473 int resized = 0; 1474 if (Dictionary::does_any_dictionary_needs_resizing()) { 1475 FOR_ALL_DICTIONARY(cld) { 1476 if (cld->dictionary()->resize_if_needed()) { 1477 resized++; 1478 } 1479 } 1480 } 1481 return resized; 1482 } 1483 1484 ClassLoaderDataGraphKlassIteratorAtomic::ClassLoaderDataGraphKlassIteratorAtomic() 1485 : _next_klass(NULL) { 1486 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!"); 1487 ClassLoaderData* cld = ClassLoaderDataGraph::_head; 1488 Klass* klass = NULL; 1489 1490 // Find the first klass in the CLDG. 1491 while (cld != NULL) { 1492 assert_locked_or_safepoint(cld->metaspace_lock()); 1493 klass = cld->_klasses; 1494 if (klass != NULL) { 1495 _next_klass = klass; 1496 return; 1497 } 1498 cld = cld->next(); 1499 } 1500 } 1501 1502 Klass* ClassLoaderDataGraphKlassIteratorAtomic::next_klass_in_cldg(Klass* klass) { 1503 Klass* next = klass->next_link(); 1504 if (next != NULL) { 1505 return next; 1506 } 1507 1508 // No more klasses in the current CLD. Time to find a new CLD. 1509 ClassLoaderData* cld = klass->class_loader_data(); 1510 assert_locked_or_safepoint(cld->metaspace_lock()); 1511 while (next == NULL) { 1512 cld = cld->next(); 1513 if (cld == NULL) { 1514 break; 1515 } 1516 next = cld->_klasses; 1517 } 1518 1519 return next; 1520 } 1521 1522 Klass* ClassLoaderDataGraphKlassIteratorAtomic::next_klass() { 1523 Klass* head = _next_klass; 1524 1525 while (head != NULL) { 1526 Klass* next = next_klass_in_cldg(head); 1527 1528 Klass* old_head = Atomic::cmpxchg(next, &_next_klass, head); 1529 1530 if (old_head == head) { 1531 return head; // Won the CAS. 1532 } 1533 1534 head = old_head; 1535 } 1536 1537 // Nothing more for the iterator to hand out. 1538 assert(head == NULL, "head is " PTR_FORMAT ", expected not null:", p2i(head)); 1539 return NULL; 1540 } 1541 1542 ClassLoaderDataGraphMetaspaceIterator::ClassLoaderDataGraphMetaspaceIterator() { 1543 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!"); 1544 _data = ClassLoaderDataGraph::_head; 1545 } 1546 1547 ClassLoaderDataGraphMetaspaceIterator::~ClassLoaderDataGraphMetaspaceIterator() {} 1548 1549 #ifndef PRODUCT 1550 // callable from debugger 1551 extern "C" int print_loader_data_graph() { 1552 ResourceMark rm; 1553 ClassLoaderDataGraph::print_on(tty); 1554 return 0; 1555 } 1556 1557 void ClassLoaderDataGraph::verify() { 1558 ClassLoaderDataGraphIterator iter; 1559 while (iter.repeat()) { 1560 ClassLoaderData* cld = iter.get_next(); 1561 cld->verify(); 1562 } 1563 } 1564 1565 void ClassLoaderDataGraph::print_on(outputStream * const out) { 1566 ClassLoaderDataGraphIterator iter; 1567 while (iter.repeat()) { 1568 ClassLoaderData* cld = iter.get_next(); 1569 cld->print_on(out); 1570 } 1571 } 1572 #endif // PRODUCT