< prev index next >
src/hotspot/share/classfile/classLoaderDataGraph.cpp
Print this page
@@ -228,43 +228,45 @@
MutexLocker ml(ClassLoaderDataGraph_lock);
ClassLoaderData* loader_data = add_to_graph(loader, is_unsafe_anonymous);
return loader_data;
}
-void ClassLoaderDataGraph::cld_do(CLDClosure* cl) {
- assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
- for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->_next) {
- cl->do_cld(cld);
- }
-}
-
void ClassLoaderDataGraph::cld_unloading_do(CLDClosure* cl) {
assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
// Only walk the head until any clds not purged from prior unloading
// (CMS doesn't purge right away).
for (ClassLoaderData* cld = _unloading; cld != _saved_unloading; cld = cld->next()) {
assert(cld->is_unloading(), "invariant");
cl->do_cld(cld);
}
}
+// These are functions called by the GC, which require all of the CLDs, including the
+// unloading ones.
+void ClassLoaderDataGraph::cld_oops_do(CLDClosure* cl) {
+ assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
+ for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->_next) {
+ cl->do_cld(cld);
+ }
+}
+
void ClassLoaderDataGraph::roots_cld_do(CLDClosure* strong, CLDClosure* weak) {
assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->_next) {
CLDClosure* closure = cld->keep_alive() ? strong : weak;
if (closure != NULL) {
closure->do_cld(cld);
}
}
}
-void ClassLoaderDataGraph::always_strong_cld_do(CLDClosure* cl) {
+void ClassLoaderDataGraph::always_strong_cld_oops_do(CLDClosure* cl) {
assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
if (ClassUnloading) {
roots_cld_do(cl, NULL);
} else {
- cld_do(cl);
+ cld_oops_do(cl);
}
}
// Closure for locking and iterating through classes.
LockedClassesDo::LockedClassesDo(classes_do_func_t f) : _function(f) {
@@ -284,13 +286,16 @@
class ClassLoaderDataGraphIterator : public StackObj {
ClassLoaderData* _next;
HandleMark _hm; // clean up handles when this is done.
Handle _holder;
Thread* _thread;
+ NoSafepointVerifier _nsv; // No safepoints allowed in this scope
+ // unless verifying at a safepoint.
public:
- ClassLoaderDataGraphIterator() : _next(ClassLoaderDataGraph::_head) {
+ ClassLoaderDataGraphIterator() : _next(ClassLoaderDataGraph::_head),
+ _nsv(true, !SafepointSynchronize::is_at_safepoint()) {
_thread = Thread::current();
assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
}
ClassLoaderData* get_next() {
@@ -306,13 +311,29 @@
} else {
_next = NULL;
}
return cld;
}
+};
+void ClassLoaderDataGraph::cld_do(CLDClosure* cl) {
+ ClassLoaderDataGraphIterator iter;
+ while (ClassLoaderData* cld = iter.get_next()) {
+ cl->do_cld(cld);
+ }
+}
-};
+void ClassLoaderDataGraph::always_strong_cld_do(CLDClosure* cl) {
+ assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
+ if (ClassUnloading) {
+ // The keep_alive bits are only so GC doesn't unload the classes prematurely,
+ // not for tools to find.
+ cl->do_cld(ClassLoaderData::the_null_class_loader_data());
+ } else {
+ cld_do(cl);
+ }
+}
// These functions assume that the caller has locked the ClassLoaderDataGraph_lock
// if they are not calling the function from a safepoint.
void ClassLoaderDataGraph::classes_do(KlassClosure* klass_closure) {
ClassLoaderDataGraphIterator iter;
< prev index next >