213 }
214
215 // Lastly log, if requested
216 LogTarget(Trace, class, loader, data) lt;
217 if (lt.is_enabled()) {
218 ResourceMark rm;
219 LogStream ls(lt);
220 ls.print("create ");
221 cld->print_value_on(&ls);
222 ls.cr();
223 }
224 return cld;
225 }
226
227 ClassLoaderData* ClassLoaderDataGraph::add(Handle loader, bool is_unsafe_anonymous) {
228 MutexLocker ml(ClassLoaderDataGraph_lock);
229 ClassLoaderData* loader_data = add_to_graph(loader, is_unsafe_anonymous);
230 return loader_data;
231 }
232
233 void ClassLoaderDataGraph::cld_do(CLDClosure* cl) {
234 assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
235 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->_next) {
236 cl->do_cld(cld);
237 }
238 }
239
240 void ClassLoaderDataGraph::cld_unloading_do(CLDClosure* cl) {
241 assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
242 // Only walk the head until any clds not purged from prior unloading
243 // (CMS doesn't purge right away).
244 for (ClassLoaderData* cld = _unloading; cld != _saved_unloading; cld = cld->next()) {
245 assert(cld->is_unloading(), "invariant");
246 cl->do_cld(cld);
247 }
248 }
249
250 void ClassLoaderDataGraph::roots_cld_do(CLDClosure* strong, CLDClosure* weak) {
251 assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
252 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->_next) {
253 CLDClosure* closure = cld->keep_alive() ? strong : weak;
254 if (closure != NULL) {
255 closure->do_cld(cld);
256 }
257 }
258 }
259
260 void ClassLoaderDataGraph::always_strong_cld_do(CLDClosure* cl) {
261 assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
262 if (ClassUnloading) {
263 roots_cld_do(cl, NULL);
264 } else {
265 cld_do(cl);
266 }
267 }
268
269 // Closure for locking and iterating through classes.
270 LockedClassesDo::LockedClassesDo(classes_do_func_t f) : _function(f) {
271 ClassLoaderDataGraph_lock->lock();
272 }
273
274 LockedClassesDo::LockedClassesDo() : _function(NULL) {
275 // callers provide their own do_klass
276 ClassLoaderDataGraph_lock->lock();
277 }
278
279 LockedClassesDo::~LockedClassesDo() { ClassLoaderDataGraph_lock->unlock(); }
280
281
282 // Iterating over the CLDG needs to be locked because
283 // unloading can remove entries concurrently soon.
284 class ClassLoaderDataGraphIterator : public StackObj {
285 ClassLoaderData* _next;
286 HandleMark _hm; // clean up handles when this is done.
287 Handle _holder;
288 Thread* _thread;
289
290 public:
291 ClassLoaderDataGraphIterator() : _next(ClassLoaderDataGraph::_head) {
292 _thread = Thread::current();
293 assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
294 }
295
296 ClassLoaderData* get_next() {
297 ClassLoaderData* cld = _next;
298 // Skip already unloaded CLD for concurrent unloading.
299 while (cld != NULL && !cld->is_alive()) {
300 cld = cld->next();
301 }
302 if (cld != NULL) {
303 // Keep cld that is being returned alive.
304 _holder = Handle(_thread, cld->holder_phantom());
305 _next = cld->next();
306 } else {
307 _next = NULL;
308 }
309 return cld;
310 }
311
312
313 };
314
315 // These functions assume that the caller has locked the ClassLoaderDataGraph_lock
316 // if they are not calling the function from a safepoint.
317 void ClassLoaderDataGraph::classes_do(KlassClosure* klass_closure) {
318 ClassLoaderDataGraphIterator iter;
319 while (ClassLoaderData* cld = iter.get_next()) {
320 cld->classes_do(klass_closure);
321 }
322 }
323
324 void ClassLoaderDataGraph::classes_do(void f(Klass* const)) {
325 ClassLoaderDataGraphIterator iter;
326 while (ClassLoaderData* cld = iter.get_next()) {
327 cld->classes_do(f);
328 }
329 }
330
331 void ClassLoaderDataGraph::methods_do(void f(Method*)) {
332 ClassLoaderDataGraphIterator iter;
333 while (ClassLoaderData* cld = iter.get_next()) {
|
213 }
214
215 // Lastly log, if requested
216 LogTarget(Trace, class, loader, data) lt;
217 if (lt.is_enabled()) {
218 ResourceMark rm;
219 LogStream ls(lt);
220 ls.print("create ");
221 cld->print_value_on(&ls);
222 ls.cr();
223 }
224 return cld;
225 }
226
227 ClassLoaderData* ClassLoaderDataGraph::add(Handle loader, bool is_unsafe_anonymous) {
228 MutexLocker ml(ClassLoaderDataGraph_lock);
229 ClassLoaderData* loader_data = add_to_graph(loader, is_unsafe_anonymous);
230 return loader_data;
231 }
232
233 void ClassLoaderDataGraph::cld_unloading_do(CLDClosure* cl) {
234 assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
235 // Only walk the head until any clds not purged from prior unloading
236 // (CMS doesn't purge right away).
237 for (ClassLoaderData* cld = _unloading; cld != _saved_unloading; cld = cld->next()) {
238 assert(cld->is_unloading(), "invariant");
239 cl->do_cld(cld);
240 }
241 }
242
243 // These are functions called by the GC, which require all of the CLDs, including the
244 // unloading ones.
245 void ClassLoaderDataGraph::cld_oops_do(CLDClosure* cl) {
246 assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
247 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->_next) {
248 cl->do_cld(cld);
249 }
250 }
251
252 void ClassLoaderDataGraph::roots_cld_do(CLDClosure* strong, CLDClosure* weak) {
253 assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
254 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->_next) {
255 CLDClosure* closure = cld->keep_alive() ? strong : weak;
256 if (closure != NULL) {
257 closure->do_cld(cld);
258 }
259 }
260 }
261
262 void ClassLoaderDataGraph::always_strong_cld_oops_do(CLDClosure* cl) {
263 assert_locked_or_safepoint_weak(ClassLoaderDataGraph_lock);
264 if (ClassUnloading) {
265 roots_cld_do(cl, NULL);
266 } else {
267 cld_oops_do(cl);
268 }
269 }
270
271 // Closure for locking and iterating through classes.
272 LockedClassesDo::LockedClassesDo(classes_do_func_t f) : _function(f) {
273 ClassLoaderDataGraph_lock->lock();
274 }
275
276 LockedClassesDo::LockedClassesDo() : _function(NULL) {
277 // callers provide their own do_klass
278 ClassLoaderDataGraph_lock->lock();
279 }
280
281 LockedClassesDo::~LockedClassesDo() { ClassLoaderDataGraph_lock->unlock(); }
282
283
284 // Iterating over the CLDG needs to be locked because
285 // unloading can remove entries concurrently soon.
286 class ClassLoaderDataGraphIterator : public StackObj {
287 ClassLoaderData* _next;
288 HandleMark _hm; // clean up handles when this is done.
289 Handle _holder;
290 Thread* _thread;
291 NoSafepointVerifier _nsv; // No safepoints allowed in this scope
292 // unless verifying at a safepoint.
293
294 public:
295 ClassLoaderDataGraphIterator() : _next(ClassLoaderDataGraph::_head),
296 _nsv(true, !SafepointSynchronize::is_at_safepoint()) {
297 _thread = Thread::current();
298 assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
299 }
300
301 ClassLoaderData* get_next() {
302 ClassLoaderData* cld = _next;
303 // Skip already unloaded CLD for concurrent unloading.
304 while (cld != NULL && !cld->is_alive()) {
305 cld = cld->next();
306 }
307 if (cld != NULL) {
308 // Keep cld that is being returned alive.
309 _holder = Handle(_thread, cld->holder_phantom());
310 _next = cld->next();
311 } else {
312 _next = NULL;
313 }
314 return cld;
315 }
316 };
317
318 void ClassLoaderDataGraph::cld_do(CLDClosure* cl) {
319 ClassLoaderDataGraphIterator iter;
320 while (ClassLoaderData* cld = iter.get_next()) {
321 cl->do_cld(cld);
322 }
323 }
324
325 void ClassLoaderDataGraph::always_strong_cld_do(CLDClosure* cl) {
326 assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
327 if (ClassUnloading) {
328 // The keep_alive bits are only so GC doesn't unload the classes prematurely,
329 // not for tools to find.
330 cl->do_cld(ClassLoaderData::the_null_class_loader_data());
331 } else {
332 cld_do(cl);
333 }
334 }
335
336 // These functions assume that the caller has locked the ClassLoaderDataGraph_lock
337 // if they are not calling the function from a safepoint.
338 void ClassLoaderDataGraph::classes_do(KlassClosure* klass_closure) {
339 ClassLoaderDataGraphIterator iter;
340 while (ClassLoaderData* cld = iter.get_next()) {
341 cld->classes_do(klass_closure);
342 }
343 }
344
345 void ClassLoaderDataGraph::classes_do(void f(Klass* const)) {
346 ClassLoaderDataGraphIterator iter;
347 while (ClassLoaderData* cld = iter.get_next()) {
348 cld->classes_do(f);
349 }
350 }
351
352 void ClassLoaderDataGraph::methods_do(void f(Method*)) {
353 ClassLoaderDataGraphIterator iter;
354 while (ClassLoaderData* cld = iter.get_next()) {
|