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 // extension, 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/javaClasses.hpp"
  53 #include "classfile/metadataOnStackMark.hpp"
  54 #include "classfile/systemDictionary.hpp"
  55 #include "code/codeCache.hpp"
  56 #include "memory/gcLocker.hpp"
  57 #include "memory/metadataFactory.hpp"
  58 #include "memory/metaspaceShared.hpp"
  59 #include "memory/oopFactory.hpp"
  60 #include "runtime/jniHandles.hpp"
  61 #include "runtime/mutex.hpp"
  62 #include "runtime/safepoint.hpp"
  63 #include "runtime/synchronizer.hpp"
  64 #include "utilities/growableArray.hpp"
  65 #include "utilities/macros.hpp"
  66 #include "utilities/ostream.hpp"
  67 #if INCLUDE_TRACE
  68 #include "trace/tracing.hpp"
  69 #endif
  70 
  71 ClassLoaderData * ClassLoaderData::_the_null_class_loader_data = NULL;
  72 
  73 ClassLoaderData::ClassLoaderData(Handle h_class_loader, bool is_anonymous, Dependencies dependencies) :
  74   _class_loader(h_class_loader()),
  75   _is_anonymous(is_anonymous),
  76   // An anonymous class loader data doesn't have anything to keep
  77   // it from being unloaded during parsing of the anonymous class.
  78   // The null-class-loader should always be kept alive.
  79   _keep_alive(is_anonymous || h_class_loader.is_null()),
  80   _metaspace(NULL), _unloading(false), _klasses(NULL),
  81   _claimed(0), _jmethod_ids(NULL), _handles(), _deallocate_list(NULL),
  82   _next(NULL), _dependencies(dependencies),
  83   _metaspace_lock(new Mutex(Monitor::leaf+1, "Metaspace allocation lock", true)) {
  84     // empty

  85 }
  86 
  87 void ClassLoaderData::init_dependencies(TRAPS) {
  88   assert(!Universe::is_fully_initialized(), "should only be called when initializing");
  89   assert(is_the_null_class_loader_data(), "should only call this for the null class loader");
  90   _dependencies.init(CHECK);
  91 }
  92 
  93 void ClassLoaderData::Dependencies::init(TRAPS) {
  94   // Create empty dependencies array to add to. CMS requires this to be
  95   // an oop so that it can track additions via card marks.  We think.
  96   _list_head = oopFactory::new_objectArray(2, CHECK);
  97 }
  98 
  99 ClassLoaderData::ChunkedHandleList::~ChunkedHandleList() {
 100   Chunk* c = _head;
 101   while (c != NULL) {
 102     Chunk* next = c->_next;
 103     delete c;
 104     c = next;
 105   }
 106 }
 107 
 108 oop* ClassLoaderData::ChunkedHandleList::add(oop o) {
 109   if (_head == NULL || _head->_size == Chunk::CAPACITY) {
 110     Chunk* next = new Chunk(_head);
 111     OrderAccess::release_store_ptr(&_head, next);
 112   }
 113   oop* handle = &_head->_data[_head->_size];
 114   *handle = o;
 115   OrderAccess::release_store(&_head->_size, _head->_size + 1);
 116   return handle;
 117 }
 118 
 119 inline void ClassLoaderData::ChunkedHandleList::oops_do_chunk(OopClosure* f, Chunk* c, const juint size) {
 120   for (juint i = 0; i < size; i++) {
 121     if (c->_data[i] != NULL) {
 122       f->do_oop(&c->_data[i]);
 123     }
 124   }
 125 }
 126 
 127 void ClassLoaderData::ChunkedHandleList::oops_do(OopClosure* f) {
 128   Chunk* head = (Chunk*) OrderAccess::load_ptr_acquire(&_head);
 129   if (head != NULL) {
 130     // Must be careful when reading size of head
 131     oops_do_chunk(f, head, OrderAccess::load_acquire(&head->_size));
 132     for (Chunk* c = head->_next; c != NULL; c = c->_next) {
 133       oops_do_chunk(f, c, c->_size);
 134     }
 135   }
 136 }
 137 
 138 bool ClassLoaderData::claim() {
 139   if (_claimed == 1) {
 140     return false;
 141   }
 142 
 143   return (int) Atomic::cmpxchg(1, &_claimed, 0) == 0;
 144 }
 145 
 146 void ClassLoaderData::oops_do(OopClosure* f, KlassClosure* klass_closure, bool must_claim) {
 147   if (must_claim && !claim()) {
 148     return;
 149   }
 150 
 151   f->do_oop(&_class_loader);
 152   _dependencies.oops_do(f);
 153   _handles.oops_do(f);
 154   if (klass_closure != NULL) {
 155     classes_do(klass_closure);
 156   }
 157 }
 158 
 159 void ClassLoaderData::Dependencies::oops_do(OopClosure* f) {
 160   f->do_oop((oop*)&_list_head);
 161 }
 162 
 163 void ClassLoaderData::classes_do(KlassClosure* klass_closure) {
 164   for (Klass* k = _klasses; k != NULL; k = k->next_link()) {
 165     klass_closure->do_klass(k);
 166     assert(k != k->next_link(), "no loops!");
 167   }
 168 }
 169 
 170 void ClassLoaderData::classes_do(void f(Klass * const)) {
 171   for (Klass* k = _klasses; k != NULL; k = k->next_link()) {
 172     f(k);
 173   }
 174 }
 175 
 176 void ClassLoaderData::loaded_classes_do(KlassClosure* klass_closure) {
 177   // Lock to avoid classes being modified/added/removed during iteration
 178   MutexLockerEx ml(metaspace_lock(),  Mutex::_no_safepoint_check_flag);
 179   for (Klass* k = _klasses; k != NULL; k = k->next_link()) {
 180     // Do not filter ArrayKlass oops here...
 181     if (k->oop_is_array() || (k->oop_is_instance() && InstanceKlass::cast(k)->is_loaded())) {
 182       klass_closure->do_klass(k);
 183     }
 184   }
 185 }
 186 
 187 void ClassLoaderData::classes_do(void f(InstanceKlass*)) {
 188   for (Klass* k = _klasses; k != NULL; k = k->next_link()) {
 189     if (k->oop_is_instance()) {
 190       f(InstanceKlass::cast(k));
 191     }
 192     assert(k != k->next_link(), "no loops!");
 193   }
 194 }
 195 
 196 void ClassLoaderData::record_dependency(Klass* k, TRAPS) {
 197   ClassLoaderData * const from_cld = this;
 198   ClassLoaderData * const to_cld = k->class_loader_data();
 199 
 200   // Dependency to the null class loader data doesn't need to be recorded
 201   // because the null class loader data never goes away.
 202   if (to_cld->is_the_null_class_loader_data()) {
 203     return;
 204   }
 205 
 206   oop to;
 207   if (to_cld->is_anonymous()) {
 208     // Anonymous class dependencies are through the mirror.
 209     to = k->java_mirror();
 210   } else {
 211     to = to_cld->class_loader();
 212 
 213     // If from_cld is anonymous, even if it's class_loader is a parent of 'to'
 214     // we still have to add it.  The class_loader won't keep from_cld alive.
 215     if (!from_cld->is_anonymous()) {
 216       // Check that this dependency isn't from the same or parent class_loader
 217       oop from = from_cld->class_loader();
 218 
 219       oop curr = from;
 220       while (curr != NULL) {
 221         if (curr == to) {
 222           return; // this class loader is in the parent list, no need to add it.
 223         }
 224         curr = java_lang_ClassLoader::parent(curr);
 225       }
 226     }
 227   }
 228 
 229   // It's a dependency we won't find through GC, add it. This is relatively rare
 230   // Must handle over GC point.
 231   Handle dependency(THREAD, to);
 232   from_cld->_dependencies.add(dependency, CHECK);
 233 }
 234 
 235 
 236 void ClassLoaderData::Dependencies::add(Handle dependency, TRAPS) {
 237   // Check first if this dependency is already in the list.
 238   // Save a pointer to the last to add to under the lock.
 239   objArrayOop ok = _list_head;
 240   objArrayOop last = NULL;
 241   while (ok != NULL) {
 242     last = ok;
 243     if (ok->obj_at(0) == dependency()) {
 244       // Don't need to add it
 245       return;
 246     }
 247     ok = (objArrayOop)ok->obj_at(1);
 248   }
 249 
 250   // Must handle over GC points
 251   assert (last != NULL, "dependencies should be initialized");
 252   objArrayHandle last_handle(THREAD, last);
 253 
 254   // Create a new dependency node with fields for (class_loader or mirror, next)
 255   objArrayOop deps = oopFactory::new_objectArray(2, CHECK);
 256   deps->obj_at_put(0, dependency());
 257 
 258   // Must handle over GC points
 259   objArrayHandle new_dependency(THREAD, deps);
 260 
 261   // Add the dependency under lock
 262   locked_add(last_handle, new_dependency, THREAD);
 263 }
 264 
 265 void ClassLoaderData::Dependencies::locked_add(objArrayHandle last_handle,
 266                                                objArrayHandle new_dependency,
 267                                                Thread* THREAD) {
 268 
 269   // Have to lock and put the new dependency on the end of the dependency
 270   // array so the card mark for CMS sees that this dependency is new.
 271   // Can probably do this lock free with some effort.
 272   ObjectLocker ol(Handle(THREAD, _list_head), THREAD);
 273 
 274   oop loader_or_mirror = new_dependency->obj_at(0);
 275 
 276   // Since the dependencies are only added, add to the end.
 277   objArrayOop end = last_handle();
 278   objArrayOop last = NULL;
 279   while (end != NULL) {
 280     last = end;
 281     // check again if another thread added it to the end.
 282     if (end->obj_at(0) == loader_or_mirror) {
 283       // Don't need to add it
 284       return;
 285     }
 286     end = (objArrayOop)end->obj_at(1);
 287   }
 288   assert (last != NULL, "dependencies should be initialized");
 289   // fill in the first element with the oop in new_dependency.
 290   if (last->obj_at(0) == NULL) {
 291     last->obj_at_put(0, new_dependency->obj_at(0));
 292   } else {
 293     last->obj_at_put(1, new_dependency());
 294   }
 295 }
 296 
 297 void ClassLoaderDataGraph::clear_claimed_marks() {
 298   for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
 299     cld->clear_claimed();
 300   }
 301 }
 302 
 303 void ClassLoaderData::add_class(Klass* k) {
 304   MutexLockerEx ml(metaspace_lock(),  Mutex::_no_safepoint_check_flag);
 305   Klass* old_value = _klasses;
 306   k->set_next_link(old_value);
 307   // link the new item into the list
 308   _klasses = k;
 309 
 310   if (TraceClassLoaderData && Verbose && k->class_loader_data() != NULL) {
 311     ResourceMark rm;
 312     tty->print_cr("[TraceClassLoaderData] Adding k: " PTR_FORMAT " %s to CLD: "
 313                   PTR_FORMAT " loader: " PTR_FORMAT " %s",
 314                   p2i(k),
 315                   k->external_name(),
 316                   p2i(k->class_loader_data()),
 317                   p2i((void *)k->class_loader()),
 318                   loader_name());
 319   }
 320 }
 321 
 322 // This is called by InstanceKlass::deallocate_contents() to remove the
 323 // scratch_class for redefine classes.  We need a lock because there it may not
 324 // be called at a safepoint if there's an error.
 325 void ClassLoaderData::remove_class(Klass* scratch_class) {
 326   MutexLockerEx ml(metaspace_lock(),  Mutex::_no_safepoint_check_flag);
 327   Klass* prev = NULL;
 328   for (Klass* k = _klasses; k != NULL; k = k->next_link()) {
 329     if (k == scratch_class) {
 330       if (prev == NULL) {
 331         _klasses = k->next_link();
 332       } else {
 333         Klass* next = k->next_link();
 334         prev->set_next_link(next);
 335       }
 336       return;
 337     }
 338     prev = k;
 339     assert(k != k->next_link(), "no loops!");
 340   }
 341   ShouldNotReachHere();   // should have found this class!!
 342 }
 343 
 344 void ClassLoaderData::unload() {
 345   _unloading = true;
 346 
 347   // Tell serviceability tools these classes are unloading
 348   classes_do(InstanceKlass::notify_unload_class);
 349 
 350   if (TraceClassLoaderData) {
 351     ResourceMark rm;
 352     tty->print("[ClassLoaderData: unload loader data " INTPTR_FORMAT, p2i(this));
 353     tty->print(" for instance " INTPTR_FORMAT " of %s", p2i((void *)class_loader()),
 354                loader_name());
 355     if (is_anonymous()) {
 356       tty->print(" for anonymous class  " INTPTR_FORMAT " ", p2i(_klasses));
 357     }
 358     tty->print_cr("]");
 359   }
 360 }
 361 
 362 oop ClassLoaderData::keep_alive_object() const {
 363   assert(!keep_alive(), "Don't use with CLDs that are artificially kept alive");
 364   return is_anonymous() ? _klasses->java_mirror() : class_loader();
 365 }
 366 
 367 bool ClassLoaderData::is_alive(BoolObjectClosure* is_alive_closure) const {
 368   bool alive = keep_alive() // null class loader and incomplete anonymous klasses.
 369       || is_alive_closure->do_object_b(keep_alive_object());
 370 
 371   return alive;
 372 }
 373 
 374 
 375 ClassLoaderData::~ClassLoaderData() {
 376   // Release C heap structures for all the classes.
 377   classes_do(InstanceKlass::release_C_heap_structures);
 378 
 379   Metaspace *m = _metaspace;
 380   if (m != NULL) {
 381     _metaspace = NULL;
 382     // release the metaspace
 383     delete m;
 384   }
 385 
 386   // Clear all the JNI handles for methods
 387   // These aren't deallocated and are going to look like a leak, but that's
 388   // needed because we can't really get rid of jmethodIDs because we don't
 389   // know when native code is going to stop using them.  The spec says that
 390   // they're "invalid" but existing programs likely rely on their being
 391   // NULL after class unloading.
 392   if (_jmethod_ids != NULL) {
 393     Method::clear_jmethod_ids(this);
 394   }
 395   // Delete lock
 396   delete _metaspace_lock;
 397 
 398   // Delete free list
 399   if (_deallocate_list != NULL) {
 400     delete _deallocate_list;
 401   }
 402 }
 403 
 404 /**
 405  * Returns true if this class loader data is for the extension class loader.
 406  */
 407 bool ClassLoaderData::is_ext_class_loader_data() const {
 408   return SystemDictionary::is_ext_class_loader(class_loader());
 409 }
 410 
 411 Metaspace* ClassLoaderData::metaspace_non_null() {
 412   assert(!DumpSharedSpaces, "wrong metaspace!");
 413   // If the metaspace has not been allocated, create a new one.  Might want
 414   // to create smaller arena for Reflection class loaders also.
 415   // The reason for the delayed allocation is because some class loaders are
 416   // simply for delegating with no metadata of their own.
 417   if (_metaspace == NULL) {
 418     MutexLockerEx ml(metaspace_lock(),  Mutex::_no_safepoint_check_flag);
 419     // Check again if metaspace has been allocated while we were getting this lock.
 420     if (_metaspace != NULL) {
 421       return _metaspace;
 422     }
 423     if (this == the_null_class_loader_data()) {
 424       assert (class_loader() == NULL, "Must be");
 425       set_metaspace(new Metaspace(_metaspace_lock, Metaspace::BootMetaspaceType));
 426     } else if (is_anonymous()) {
 427       if (TraceClassLoaderData && Verbose && class_loader() != NULL) {
 428         tty->print_cr("is_anonymous: %s", class_loader()->klass()->internal_name());
 429       }
 430       set_metaspace(new Metaspace(_metaspace_lock, Metaspace::AnonymousMetaspaceType));
 431     } else if (class_loader()->is_a(SystemDictionary::reflect_DelegatingClassLoader_klass())) {
 432       if (TraceClassLoaderData && Verbose && class_loader() != NULL) {
 433         tty->print_cr("is_reflection: %s", class_loader()->klass()->internal_name());
 434       }
 435       set_metaspace(new Metaspace(_metaspace_lock, Metaspace::ReflectionMetaspaceType));
 436     } else {
 437       set_metaspace(new Metaspace(_metaspace_lock, Metaspace::StandardMetaspaceType));
 438     }
 439   }
 440   return _metaspace;
 441 }
 442 
 443 jobject ClassLoaderData::add_handle(Handle h) {
 444   MutexLockerEx ml(metaspace_lock(),  Mutex::_no_safepoint_check_flag);
 445   return (jobject) _handles.add(h());
 446 }
 447 
 448 // Add this metadata pointer to be freed when it's safe.  This is only during
 449 // class unloading because Handles might point to this metadata field.
 450 void ClassLoaderData::add_to_deallocate_list(Metadata* m) {
 451   // Metadata in shared region isn't deleted.
 452   if (!m->is_shared()) {
 453     MutexLockerEx ml(metaspace_lock(),  Mutex::_no_safepoint_check_flag);
 454     if (_deallocate_list == NULL) {
 455       _deallocate_list = new (ResourceObj::C_HEAP, mtClass) GrowableArray<Metadata*>(100, true);
 456     }
 457     _deallocate_list->append_if_missing(m);
 458   }
 459 }
 460 
 461 // Deallocate free metadata on the free list.  How useful the PermGen was!
 462 void ClassLoaderData::free_deallocate_list() {
 463   // Don't need lock, at safepoint
 464   assert(SafepointSynchronize::is_at_safepoint(), "only called at safepoint");
 465   if (_deallocate_list == NULL) {
 466     return;
 467   }
 468   // Go backwards because this removes entries that are freed.
 469   for (int i = _deallocate_list->length() - 1; i >= 0; i--) {
 470     Metadata* m = _deallocate_list->at(i);
 471     if (!m->on_stack()) {
 472       _deallocate_list->remove_at(i);
 473       // There are only three types of metadata that we deallocate directly.
 474       // Cast them so they can be used by the template function.
 475       if (m->is_method()) {
 476         MetadataFactory::free_metadata(this, (Method*)m);
 477       } else if (m->is_constantPool()) {
 478         MetadataFactory::free_metadata(this, (ConstantPool*)m);
 479       } else if (m->is_klass()) {
 480         MetadataFactory::free_metadata(this, (InstanceKlass*)m);
 481       } else {
 482         ShouldNotReachHere();
 483       }
 484     }
 485   }
 486 }
 487 
 488 // These anonymous class loaders are to contain classes used for JSR292
 489 ClassLoaderData* ClassLoaderData::anonymous_class_loader_data(oop loader, TRAPS) {
 490   // Add a new class loader data to the graph.
 491   return ClassLoaderDataGraph::add(loader, true, THREAD);
 492 }
 493 
 494 const char* ClassLoaderData::loader_name() {
 495   // Handles null class loader
 496   return SystemDictionary::loader_name(class_loader());
 497 }
 498 
 499 #ifndef PRODUCT
 500 // Define to dump klasses
 501 #undef CLD_DUMP_KLASSES
 502 
 503 void ClassLoaderData::dump(outputStream * const out) {
 504   ResourceMark rm;
 505   out->print("ClassLoaderData CLD: " PTR_FORMAT ", loader: " PTR_FORMAT ", loader_klass: " PTR_FORMAT " %s {",
 506       p2i(this), p2i((void *)class_loader()),
 507       p2i(class_loader() != NULL ? class_loader()->klass() : NULL), loader_name());
 508   if (claimed()) out->print(" claimed ");
 509   if (is_unloading()) out->print(" unloading ");
 510   out->cr();
 511   if (metaspace_or_null() != NULL) {
 512     out->print_cr("metaspace: " INTPTR_FORMAT, p2i(metaspace_or_null()));
 513     metaspace_or_null()->dump(out);
 514   } else {
 515     out->print_cr("metaspace: NULL");
 516   }
 517 
 518 #ifdef CLD_DUMP_KLASSES
 519   if (Verbose) {
 520     ResourceMark rm;
 521     Klass* k = _klasses;
 522     while (k != NULL) {
 523       out->print_cr("klass " PTR_FORMAT ", %s, CT: %d, MUT: %d", k, k->name()->as_C_string(),
 524           k->has_modified_oops(), k->has_accumulated_modified_oops());
 525       assert(k != k->next_link(), "no loops!");
 526       k = k->next_link();
 527     }
 528   }
 529 #endif  // CLD_DUMP_KLASSES
 530 #undef CLD_DUMP_KLASSES
 531   if (_jmethod_ids != NULL) {
 532     Method::print_jmethod_ids(this, out);
 533   }
 534   out->print_cr("}");
 535 }
 536 #endif // PRODUCT
 537 
 538 void ClassLoaderData::verify() {
 539   oop cl = class_loader();
 540 
 541   guarantee(this == class_loader_data(cl) || is_anonymous(), "Must be the same");
 542   guarantee(cl != NULL || this == ClassLoaderData::the_null_class_loader_data() || is_anonymous(), "must be");
 543 
 544   // Verify the integrity of the allocated space.
 545   if (metaspace_or_null() != NULL) {
 546     metaspace_or_null()->verify();
 547   }
 548 
 549   for (Klass* k = _klasses; k != NULL; k = k->next_link()) {
 550     guarantee(k->class_loader_data() == this, "Must be the same");
 551     k->verify();
 552     assert(k != k->next_link(), "no loops!");
 553   }
 554 }
 555 
 556 bool ClassLoaderData::contains_klass(Klass* klass) {
 557   for (Klass* k = _klasses; k != NULL; k = k->next_link()) {
 558     if (k == klass) return true;
 559   }
 560   return false;
 561 }
 562 
 563 
 564 // GC root of class loader data created.
 565 ClassLoaderData* ClassLoaderDataGraph::_head = NULL;
 566 ClassLoaderData* ClassLoaderDataGraph::_unloading = NULL;
 567 ClassLoaderData* ClassLoaderDataGraph::_saved_unloading = NULL;
 568 ClassLoaderData* ClassLoaderDataGraph::_saved_head = NULL;
 569 
 570 bool ClassLoaderDataGraph::_should_purge = false;
 571 
 572 // Add a new class loader data node to the list.  Assign the newly created
 573 // ClassLoaderData into the java/lang/ClassLoader object as a hidden field
 574 ClassLoaderData* ClassLoaderDataGraph::add(Handle loader, bool is_anonymous, TRAPS) {
 575   // We need to allocate all the oops for the ClassLoaderData before allocating the
 576   // actual ClassLoaderData object.
 577   ClassLoaderData::Dependencies dependencies(CHECK_NULL);
 578 
 579   No_Safepoint_Verifier no_safepoints; // we mustn't GC until we've installed the
 580                                        // ClassLoaderData in the graph since the CLD
 581                                        // contains unhandled oops
 582 
 583   ClassLoaderData* cld = new ClassLoaderData(loader, is_anonymous, dependencies);
 584 
 585 
 586   if (!is_anonymous) {
 587     ClassLoaderData** cld_addr = java_lang_ClassLoader::loader_data_addr(loader());
 588     // First, Atomically set it
 589     ClassLoaderData* old = (ClassLoaderData*) Atomic::cmpxchg_ptr(cld, cld_addr, NULL);
 590     if (old != NULL) {
 591       delete cld;
 592       // Returns the data.
 593       return old;
 594     }
 595   }
 596 
 597   // We won the race, and therefore the task of adding the data to the list of
 598   // class loader data
 599   ClassLoaderData** list_head = &_head;
 600   ClassLoaderData* next = _head;
 601 
 602   do {
 603     cld->set_next(next);
 604     ClassLoaderData* exchanged = (ClassLoaderData*)Atomic::cmpxchg_ptr(cld, list_head, next);
 605     if (exchanged == next) {
 606       if (TraceClassLoaderData) {
 607         ResourceMark rm;
 608         tty->print("[ClassLoaderData: ");
 609         tty->print("create class loader data " INTPTR_FORMAT, p2i(cld));
 610         tty->print(" for instance " INTPTR_FORMAT " of %s", p2i((void *)cld->class_loader()),
 611                    cld->loader_name());
 612         tty->print_cr("]");
 613       }
 614       return cld;
 615     }
 616     next = exchanged;
 617   } while (true);
 618 
 619 }
 620 
 621 void ClassLoaderDataGraph::oops_do(OopClosure* f, KlassClosure* klass_closure, bool must_claim) {
 622   for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
 623     cld->oops_do(f, klass_closure, must_claim);
 624   }
 625 }
 626 
 627 void ClassLoaderDataGraph::keep_alive_oops_do(OopClosure* f, KlassClosure* klass_closure, bool must_claim) {
 628   for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
 629     if (cld->keep_alive()) {
 630       cld->oops_do(f, klass_closure, must_claim);
 631     }
 632   }
 633 }
 634 
 635 void ClassLoaderDataGraph::always_strong_oops_do(OopClosure* f, KlassClosure* klass_closure, bool must_claim) {
 636   if (ClassUnloading) {
 637     keep_alive_oops_do(f, klass_closure, must_claim);
 638   } else {
 639     oops_do(f, klass_closure, must_claim);
 640   }
 641 }
 642 
 643 void ClassLoaderDataGraph::cld_do(CLDClosure* cl) {
 644   for (ClassLoaderData* cld = _head; cl != NULL && cld != NULL; cld = cld->next()) {
 645     cl->do_cld(cld);
 646   }
 647 }
 648 










 649 void ClassLoaderDataGraph::roots_cld_do(CLDClosure* strong, CLDClosure* weak) {
 650   for (ClassLoaderData* cld = _head;  cld != NULL; cld = cld->_next) {
 651     CLDClosure* closure = cld->keep_alive() ? strong : weak;
 652     if (closure != NULL) {
 653       closure->do_cld(cld);
 654     }
 655   }
 656 }
 657 
 658 void ClassLoaderDataGraph::keep_alive_cld_do(CLDClosure* cl) {
 659   roots_cld_do(cl, NULL);
 660 }
 661 
 662 void ClassLoaderDataGraph::always_strong_cld_do(CLDClosure* cl) {
 663   if (ClassUnloading) {
 664     keep_alive_cld_do(cl);
 665   } else {
 666     cld_do(cl);
 667   }
 668 }
 669 
 670 void ClassLoaderDataGraph::classes_do(KlassClosure* klass_closure) {
 671   for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
 672     cld->classes_do(klass_closure);
 673   }
 674 }
 675 
 676 void ClassLoaderDataGraph::classes_do(void f(Klass* const)) {
 677   for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
 678     cld->classes_do(f);
 679   }
 680 }
 681 
 682 void ClassLoaderDataGraph::loaded_classes_do(KlassClosure* klass_closure) {
 683   for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
 684     cld->loaded_classes_do(klass_closure);
 685   }
 686 }
 687 
 688 void ClassLoaderDataGraph::classes_unloading_do(void f(Klass* const)) {
 689   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!");
 690   // Only walk the head until any clds not purged from prior unloading
 691   // (CMS doesn't purge right away).
 692   for (ClassLoaderData* cld = _unloading; cld != _saved_unloading; cld = cld->next()) {
 693     cld->classes_do(f);
 694   }
 695 }
 696 
 697 GrowableArray<ClassLoaderData*>* ClassLoaderDataGraph::new_clds() {
 698   assert(_head == NULL || _saved_head != NULL, "remember_new_clds(true) not called?");
 699 
 700   GrowableArray<ClassLoaderData*>* array = new GrowableArray<ClassLoaderData*>();
 701 
 702   // The CLDs in [_head, _saved_head] were all added during last call to remember_new_clds(true);
 703   ClassLoaderData* curr = _head;
 704   while (curr != _saved_head) {
 705     if (!curr->claimed()) {
 706       array->push(curr);
 707 
 708       if (TraceClassLoaderData) {
 709         tty->print("[ClassLoaderData] found new CLD: ");
 710         curr->print_value_on(tty);
 711         tty->cr();
 712       }
 713     }
 714 
 715     curr = curr->_next;
 716   }
 717 
 718   return array;
 719 }
 720 
 721 bool ClassLoaderDataGraph::unload_list_contains(const void* x) {
 722   assert(SafepointSynchronize::is_at_safepoint(), "only safe to call at safepoint");
 723   for (ClassLoaderData* cld = _unloading; cld != NULL; cld = cld->next()) {
 724     if (cld->metaspace_or_null() != NULL && cld->metaspace_or_null()->contains(x)) {
 725       return true;
 726     }
 727   }
 728   return false;
 729 }
 730 
 731 #ifndef PRODUCT
 732 bool ClassLoaderDataGraph::contains_loader_data(ClassLoaderData* loader_data) {
 733   for (ClassLoaderData* data = _head; data != NULL; data = data->next()) {
 734     if (loader_data == data) {
 735       return true;
 736     }
 737   }
 738 
 739   return false;
 740 }
 741 #endif // PRODUCT
 742 
 743 
 744 // Move class loader data from main list to the unloaded list for unloading
 745 // and deallocation later.
 746 bool ClassLoaderDataGraph::do_unloading(BoolObjectClosure* is_alive_closure, bool clean_alive) {
 747   ClassLoaderData* data = _head;
 748   ClassLoaderData* prev = NULL;
 749   bool seen_dead_loader = false;
 750 
 751   // Save previous _unloading pointer for CMS which may add to unloading list before
 752   // purging and we don't want to rewalk the previously unloaded class loader data.
 753   _saved_unloading = _unloading;
 754 
 755   while (data != NULL) {
 756     if (data->is_alive(is_alive_closure)) {
 757       prev = data;
 758       data = data->next();
 759       continue;
 760     }
 761     seen_dead_loader = true;
 762     ClassLoaderData* dead = data;
 763     dead->unload();
 764     data = data->next();
 765     // Remove from loader list.
 766     // This class loader data will no longer be found
 767     // in the ClassLoaderDataGraph.
 768     if (prev != NULL) {
 769       prev->set_next(data);
 770     } else {
 771       assert(dead == _head, "sanity check");
 772       _head = data;
 773     }
 774     dead->set_next(_unloading);
 775     _unloading = dead;
 776   }
 777 
 778   if (clean_alive) {
 779     // Clean previous versions and the deallocate list.
 780     ClassLoaderDataGraph::clean_metaspaces();
 781   }
 782 
 783   if (seen_dead_loader) {
 784     post_class_unload_events();
 785   }
 786 
 787   return seen_dead_loader;
 788 }
 789 
 790 void ClassLoaderDataGraph::clean_metaspaces() {
 791   // mark metadata seen on the stack and code cache so we can delete unneeded entries.
 792   bool has_redefined_a_class = JvmtiExport::has_redefined_a_class();
 793   MetadataOnStackMark md_on_stack(has_redefined_a_class);
 794 
 795   if (has_redefined_a_class) {
 796     // purge_previous_versions also cleans weak method links. Because
 797     // one method's MDO can reference another method from another
 798     // class loader, we need to first clean weak method links for all
 799     // class loaders here. Below, we can then free redefined methods
 800     // for all class loaders.
 801     for (ClassLoaderData* data = _head; data != NULL; data = data->next()) {
 802       data->classes_do(InstanceKlass::purge_previous_versions);
 803     }
 804   }
 805 
 806   // Need to purge the previous version before deallocating.
 807   free_deallocate_lists();
 808 }
 809 
 810 void ClassLoaderDataGraph::purge() {
 811   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!");
 812   ClassLoaderData* list = _unloading;
 813   _unloading = NULL;
 814   ClassLoaderData* next = list;
 815   while (next != NULL) {
 816     ClassLoaderData* purge_me = next;
 817     next = purge_me->next();
 818     delete purge_me;
 819   }
 820   Metaspace::purge();
 821 }
 822 
 823 void ClassLoaderDataGraph::post_class_unload_events(void) {
 824 #if INCLUDE_TRACE
 825   assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint!");
 826   if (Tracing::enabled()) {
 827     if (Tracing::is_event_enabled(TraceClassUnloadEvent)) {
 828       assert(_unloading != NULL, "need class loader data unload list!");
 829       _class_unload_time = Ticks::now();
 830       classes_unloading_do(&class_unload_event);
 831     }
 832     Tracing::on_unloading_classes();
 833   }
 834 #endif
 835 }
 836 
 837 void ClassLoaderDataGraph::free_deallocate_lists() {
 838   for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
 839     // We need to keep this data until InstanceKlass::purge_previous_version has been
 840     // called on all alive classes. See the comment in ClassLoaderDataGraph::clean_metaspaces.
 841     cld->free_deallocate_list();
 842   }
 843 
 844   // In some rare cases items added to the unloading list will not be freed elsewhere.
 845   // To keep it simple, walk the _unloading list also.
 846   for (ClassLoaderData* cld = _unloading; cld != _saved_unloading; cld = cld->next()) {
 847     cld->free_deallocate_list();
 848   }
 849 }
 850 
 851 // CDS support
 852 
 853 // Global metaspaces for writing information to the shared archive.  When
 854 // application CDS is supported, we may need one per metaspace, so this
 855 // sort of looks like it.
 856 Metaspace* ClassLoaderData::_ro_metaspace = NULL;
 857 Metaspace* ClassLoaderData::_rw_metaspace = NULL;
 858 static bool _shared_metaspaces_initialized = false;
 859 
 860 // Initialize shared metaspaces (change to call from somewhere not lazily)
 861 void ClassLoaderData::initialize_shared_metaspaces() {
 862   assert(DumpSharedSpaces, "only use this for dumping shared spaces");
 863   assert(this == ClassLoaderData::the_null_class_loader_data(),
 864          "only supported for null loader data for now");
 865   assert (!_shared_metaspaces_initialized, "only initialize once");
 866   MutexLockerEx ml(metaspace_lock(),  Mutex::_no_safepoint_check_flag);
 867   _ro_metaspace = new Metaspace(_metaspace_lock, Metaspace::ROMetaspaceType);
 868   _rw_metaspace = new Metaspace(_metaspace_lock, Metaspace::ReadWriteMetaspaceType);
 869   _shared_metaspaces_initialized = true;
 870 }
 871 
 872 Metaspace* ClassLoaderData::ro_metaspace() {
 873   assert(_ro_metaspace != NULL, "should already be initialized");
 874   return _ro_metaspace;
 875 }
 876 
 877 Metaspace* ClassLoaderData::rw_metaspace() {
 878   assert(_rw_metaspace != NULL, "should already be initialized");
 879   return _rw_metaspace;
 880 }
 881 
 882 ClassLoaderDataGraphKlassIteratorAtomic::ClassLoaderDataGraphKlassIteratorAtomic()
 883     : _next_klass(NULL) {
 884   ClassLoaderData* cld = ClassLoaderDataGraph::_head;
 885   Klass* klass = NULL;
 886 
 887   // Find the first klass in the CLDG.
 888   while (cld != NULL) {
 889     klass = cld->_klasses;
 890     if (klass != NULL) {
 891       _next_klass = klass;
 892       return;
 893     }
 894     cld = cld->next();
 895   }
 896 }
 897 
 898 Klass* ClassLoaderDataGraphKlassIteratorAtomic::next_klass_in_cldg(Klass* klass) {
 899   Klass* next = klass->next_link();
 900   if (next != NULL) {
 901     return next;
 902   }
 903 
 904   // No more klasses in the current CLD. Time to find a new CLD.
 905   ClassLoaderData* cld = klass->class_loader_data();
 906   while (next == NULL) {
 907     cld = cld->next();
 908     if (cld == NULL) {
 909       break;
 910     }
 911     next = cld->_klasses;
 912   }
 913 
 914   return next;
 915 }
 916 
 917 Klass* ClassLoaderDataGraphKlassIteratorAtomic::next_klass() {
 918   Klass* head = _next_klass;
 919 
 920   while (head != NULL) {
 921     Klass* next = next_klass_in_cldg(head);
 922 
 923     Klass* old_head = (Klass*)Atomic::cmpxchg_ptr(next, &_next_klass, head);
 924 
 925     if (old_head == head) {
 926       return head; // Won the CAS.
 927     }
 928 
 929     head = old_head;
 930   }
 931 
 932   // Nothing more for the iterator to hand out.
 933   assert(head == NULL, err_msg("head is " PTR_FORMAT ", expected not null:", p2i(head)));
 934   return NULL;
 935 }
 936 
 937 ClassLoaderDataGraphMetaspaceIterator::ClassLoaderDataGraphMetaspaceIterator() {
 938   _data = ClassLoaderDataGraph::_head;
 939 }
 940 
 941 ClassLoaderDataGraphMetaspaceIterator::~ClassLoaderDataGraphMetaspaceIterator() {}
 942 
 943 #ifndef PRODUCT
 944 // callable from debugger
 945 extern "C" int print_loader_data_graph() {
 946   ClassLoaderDataGraph::dump_on(tty);
 947   return 0;
 948 }
 949 
 950 void ClassLoaderDataGraph::verify() {
 951   for (ClassLoaderData* data = _head; data != NULL; data = data->next()) {
 952     data->verify();
 953   }
 954 }
 955 
 956 void ClassLoaderDataGraph::dump_on(outputStream * const out) {
 957   for (ClassLoaderData* data = _head; data != NULL; data = data->next()) {
 958     data->dump(out);
 959   }
 960   MetaspaceAux::dump(out);
 961 }
 962 #endif // PRODUCT
 963 
 964 void ClassLoaderData::print_value_on(outputStream* out) const {
 965   if (class_loader() == NULL) {
 966     out->print("NULL class_loader");
 967   } else {
 968     out->print("class loader " INTPTR_FORMAT, p2i(this));
 969     class_loader()->print_value_on(out);
 970   }
 971 }
 972 
 973 #if INCLUDE_TRACE
 974 
 975 Ticks ClassLoaderDataGraph::_class_unload_time;
 976 
 977 void ClassLoaderDataGraph::class_unload_event(Klass* const k) {
 978 
 979   // post class unload event
 980   EventClassUnload event(UNTIMED);
 981   event.set_endtime(_class_unload_time);
 982   event.set_unloadedClass(k);
 983   oop defining_class_loader = k->class_loader();
 984   event.set_definingClassLoader(defining_class_loader != NULL ?
 985                                 defining_class_loader->klass() : (Klass*)NULL);
 986   event.commit();
 987 }
 988 
 989 #endif // INCLUDE_TRACE
--- EOF ---