315 }
316
317 void ClassLoaderData::unload() {
318 _unloading = true;
319
320 // Tell serviceability tools these classes are unloading
321 classes_do(InstanceKlass::notify_unload_class);
322
323 if (TraceClassLoaderData) {
324 ResourceMark rm;
325 tty->print("[ClassLoaderData: unload loader data " INTPTR_FORMAT, p2i(this));
326 tty->print(" for instance " INTPTR_FORMAT " of %s", p2i((void *)class_loader()),
327 loader_name());
328 if (is_anonymous()) {
329 tty->print(" for anonymous class " INTPTR_FORMAT " ", p2i(_klasses));
330 }
331 tty->print_cr("]");
332 }
333 }
334
335 oop ClassLoaderData::keep_alive_object() const {
336 assert(!keep_alive(), "Don't use with CLDs that are artificially kept alive");
337 return is_anonymous() ? _klasses->java_mirror() : class_loader();
338 }
339
340 bool ClassLoaderData::is_alive(BoolObjectClosure* is_alive_closure) const {
341 bool alive = keep_alive() // null class loader and incomplete anonymous klasses.
342 || is_alive_closure->do_object_b(keep_alive_object());
343
344 assert(!alive || claimed(), "must be claimed");
345 return alive;
346 }
347
348
349 ClassLoaderData::~ClassLoaderData() {
350 // Release C heap structures for all the classes.
351 classes_do(InstanceKlass::release_C_heap_structures);
352
353 Metaspace *m = _metaspace;
354 if (m != NULL) {
355 _metaspace = NULL;
356 // release the metaspace
357 delete m;
358 // release the handles
359 if (_handles != NULL) {
360 JNIHandleBlock::release_block(_handles);
361 _handles = NULL;
362 }
363 }
364
602 } while (true);
603
604 }
605
606 void ClassLoaderDataGraph::oops_do(OopClosure* f, KlassClosure* klass_closure, bool must_claim) {
607 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
608 cld->oops_do(f, klass_closure, must_claim);
609 }
610 }
611
612 void ClassLoaderDataGraph::keep_alive_oops_do(OopClosure* f, KlassClosure* klass_closure, bool must_claim) {
613 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
614 if (cld->keep_alive()) {
615 cld->oops_do(f, klass_closure, must_claim);
616 }
617 }
618 }
619
620 void ClassLoaderDataGraph::always_strong_oops_do(OopClosure* f, KlassClosure* klass_closure, bool must_claim) {
621 if (ClassUnloading) {
622 ClassLoaderDataGraph::keep_alive_oops_do(f, klass_closure, must_claim);
623 } else {
624 ClassLoaderDataGraph::oops_do(f, klass_closure, must_claim);
625 }
626 }
627
628 void ClassLoaderDataGraph::cld_do(CLDClosure* cl) {
629 for (ClassLoaderData* cld = _head; cl != NULL && cld != NULL; cld = cld->next()) {
630 cl->do_cld(cld);
631 }
632 }
633
634 void ClassLoaderDataGraph::classes_do(KlassClosure* klass_closure) {
635 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
636 cld->classes_do(klass_closure);
637 }
638 }
639
640 void ClassLoaderDataGraph::classes_do(void f(Klass* const)) {
641 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
642 cld->classes_do(f);
643 }
644 }
645
646 void ClassLoaderDataGraph::methods_do(void f(Method*)) {
647 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
648 cld->methods_do(f);
649 }
650 }
651
652 void ClassLoaderDataGraph::loaded_classes_do(KlassClosure* klass_closure) {
653 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
669
670 // The CLDs in [_head, _saved_head] were all added during last call to remember_new_clds(true);
671 ClassLoaderData* curr = _head;
672 while (curr != _saved_head) {
673 if (!curr->claimed()) {
674 array->push(curr);
675
676 if (TraceClassLoaderData) {
677 tty->print("[ClassLoaderData] found new CLD: ");
678 curr->print_value_on(tty);
679 tty->cr();
680 }
681 }
682
683 curr = curr->_next;
684 }
685
686 return array;
687 }
688
689 #ifndef PRODUCT
690 bool ClassLoaderDataGraph::contains_loader_data(ClassLoaderData* loader_data) {
691 for (ClassLoaderData* data = _head; data != NULL; data = data->next()) {
692 if (loader_data == data) {
693 return true;
694 }
695 }
696
697 return false;
698 }
699 #endif // PRODUCT
700
701
702 // Move class loader data from main list to the unloaded list for unloading
703 // and deallocation later.
704 bool ClassLoaderDataGraph::do_unloading(BoolObjectClosure* is_alive_closure) {
705 ClassLoaderData* data = _head;
706 ClassLoaderData* prev = NULL;
707 bool seen_dead_loader = false;
708 // mark metadata seen on the stack and code cache so we can delete
784 assert(DumpSharedSpaces, "only use this for dumping shared spaces");
785 assert(this == ClassLoaderData::the_null_class_loader_data(),
786 "only supported for null loader data for now");
787 assert (!_shared_metaspaces_initialized, "only initialize once");
788 MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag);
789 _ro_metaspace = new Metaspace(_metaspace_lock, Metaspace::ROMetaspaceType);
790 _rw_metaspace = new Metaspace(_metaspace_lock, Metaspace::ReadWriteMetaspaceType);
791 _shared_metaspaces_initialized = true;
792 }
793
794 Metaspace* ClassLoaderData::ro_metaspace() {
795 assert(_ro_metaspace != NULL, "should already be initialized");
796 return _ro_metaspace;
797 }
798
799 Metaspace* ClassLoaderData::rw_metaspace() {
800 assert(_rw_metaspace != NULL, "should already be initialized");
801 return _rw_metaspace;
802 }
803
804
805 ClassLoaderDataGraphMetaspaceIterator::ClassLoaderDataGraphMetaspaceIterator() {
806 _data = ClassLoaderDataGraph::_head;
807 }
808
809 ClassLoaderDataGraphMetaspaceIterator::~ClassLoaderDataGraphMetaspaceIterator() {}
810
811 #ifndef PRODUCT
812 // callable from debugger
813 extern "C" int print_loader_data_graph() {
814 ClassLoaderDataGraph::dump_on(tty);
815 return 0;
816 }
817
818 void ClassLoaderDataGraph::verify() {
819 for (ClassLoaderData* data = _head; data != NULL; data = data->next()) {
820 data->verify();
821 }
822 }
823
|
315 }
316
317 void ClassLoaderData::unload() {
318 _unloading = true;
319
320 // Tell serviceability tools these classes are unloading
321 classes_do(InstanceKlass::notify_unload_class);
322
323 if (TraceClassLoaderData) {
324 ResourceMark rm;
325 tty->print("[ClassLoaderData: unload loader data " INTPTR_FORMAT, p2i(this));
326 tty->print(" for instance " INTPTR_FORMAT " of %s", p2i((void *)class_loader()),
327 loader_name());
328 if (is_anonymous()) {
329 tty->print(" for anonymous class " INTPTR_FORMAT " ", p2i(_klasses));
330 }
331 tty->print_cr("]");
332 }
333 }
334
335 #ifdef ASSERT
336 class AllAliveClosure : public OopClosure {
337 BoolObjectClosure* _is_alive_closure;
338 bool _found_dead;
339 public:
340 AllAliveClosure(BoolObjectClosure* is_alive_closure) : _is_alive_closure(is_alive_closure), _found_dead(false) {}
341 template <typename T> void do_oop_work(T* p) {
342 T heap_oop = oopDesc::load_heap_oop(p);
343 if (!oopDesc::is_null(heap_oop)) {
344 oop obj = oopDesc::decode_heap_oop_not_null(heap_oop);
345 if (!_is_alive_closure->do_object_b(obj)) {
346 _found_dead = true;
347 }
348 }
349 }
350 void do_oop(oop* p) { do_oop_work<oop>(p); }
351 void do_oop(narrowOop* p) { do_oop_work<narrowOop>(p); }
352 bool found_dead() { return _found_dead; }
353 };
354 #endif
355
356 oop ClassLoaderData::keep_alive_object() const {
357 assert(!keep_alive(), "Don't use with CLDs that are artificially kept alive");
358 return is_anonymous() ? _klasses->java_mirror() : class_loader();
359 }
360
361 bool ClassLoaderData::is_alive(BoolObjectClosure* is_alive_closure) const {
362 bool alive = keep_alive() // null class loader and incomplete anonymous klasses.
363 || is_alive_closure->do_object_b(keep_alive_object());
364
365 #ifdef ASSERT
366 if (alive) {
367 AllAliveClosure all_alive_closure(is_alive_closure);
368 KlassToOopClosure klass_closure(&all_alive_closure);
369 const_cast<ClassLoaderData*>(this)->oops_do(&all_alive_closure, &klass_closure, false);
370 assert(!all_alive_closure.found_dead(), err_msg("Found dead oop in alive cld: " PTR_FORMAT, p2i(this)));
371 }
372 #endif
373
374 return alive;
375 }
376
377
378 ClassLoaderData::~ClassLoaderData() {
379 // Release C heap structures for all the classes.
380 classes_do(InstanceKlass::release_C_heap_structures);
381
382 Metaspace *m = _metaspace;
383 if (m != NULL) {
384 _metaspace = NULL;
385 // release the metaspace
386 delete m;
387 // release the handles
388 if (_handles != NULL) {
389 JNIHandleBlock::release_block(_handles);
390 _handles = NULL;
391 }
392 }
393
631 } while (true);
632
633 }
634
635 void ClassLoaderDataGraph::oops_do(OopClosure* f, KlassClosure* klass_closure, bool must_claim) {
636 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
637 cld->oops_do(f, klass_closure, must_claim);
638 }
639 }
640
641 void ClassLoaderDataGraph::keep_alive_oops_do(OopClosure* f, KlassClosure* klass_closure, bool must_claim) {
642 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
643 if (cld->keep_alive()) {
644 cld->oops_do(f, klass_closure, must_claim);
645 }
646 }
647 }
648
649 void ClassLoaderDataGraph::always_strong_oops_do(OopClosure* f, KlassClosure* klass_closure, bool must_claim) {
650 if (ClassUnloading) {
651 keep_alive_oops_do(f, klass_closure, must_claim);
652 } else {
653 oops_do(f, klass_closure, must_claim);
654 }
655 }
656
657 void ClassLoaderDataGraph::cld_do(CLDClosure* cl) {
658 for (ClassLoaderData* cld = _head; cl != NULL && cld != NULL; cld = cld->next()) {
659 cl->do_cld(cld);
660 }
661 }
662
663 void ClassLoaderDataGraph::roots_cld_do(CLDClosure* strong, CLDClosure* weak) {
664 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->_next) {
665 CLDClosure* closure = cld->keep_alive() ? strong : weak;
666 if (closure != NULL) {
667 closure->do_cld(cld);
668 }
669 }
670 }
671
672 void ClassLoaderDataGraph::keep_alive_cld_do(CLDClosure* cl) {
673 roots_cld_do(cl, NULL);
674 }
675
676 void ClassLoaderDataGraph::always_strong_cld_do(CLDClosure* cl) {
677 if (ClassUnloading) {
678 keep_alive_cld_do(cl);
679 } else {
680 cld_do(cl);
681 }
682 }
683
684 void ClassLoaderDataGraph::classes_do(KlassClosure* klass_closure) {
685 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
686 cld->classes_do(klass_closure);
687 }
688 }
689
690 void ClassLoaderDataGraph::classes_do(void f(Klass* const)) {
691 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
692 cld->classes_do(f);
693 }
694 }
695
696 void ClassLoaderDataGraph::methods_do(void f(Method*)) {
697 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
698 cld->methods_do(f);
699 }
700 }
701
702 void ClassLoaderDataGraph::loaded_classes_do(KlassClosure* klass_closure) {
703 for (ClassLoaderData* cld = _head; cld != NULL; cld = cld->next()) {
719
720 // The CLDs in [_head, _saved_head] were all added during last call to remember_new_clds(true);
721 ClassLoaderData* curr = _head;
722 while (curr != _saved_head) {
723 if (!curr->claimed()) {
724 array->push(curr);
725
726 if (TraceClassLoaderData) {
727 tty->print("[ClassLoaderData] found new CLD: ");
728 curr->print_value_on(tty);
729 tty->cr();
730 }
731 }
732
733 curr = curr->_next;
734 }
735
736 return array;
737 }
738
739 bool ClassLoaderDataGraph::unload_list_contains(const void* x) {
740 assert(SafepointSynchronize::is_at_safepoint(), "only safe to call at safepoint");
741 for (ClassLoaderData* cld = _unloading; cld != NULL; cld = cld->next()) {
742 if (cld->metaspace_or_null() != NULL && cld->metaspace_or_null()->contains(x)) {
743 return true;
744 }
745 }
746 return false;
747 }
748
749 #ifndef PRODUCT
750 bool ClassLoaderDataGraph::contains_loader_data(ClassLoaderData* loader_data) {
751 for (ClassLoaderData* data = _head; data != NULL; data = data->next()) {
752 if (loader_data == data) {
753 return true;
754 }
755 }
756
757 return false;
758 }
759 #endif // PRODUCT
760
761
762 // Move class loader data from main list to the unloaded list for unloading
763 // and deallocation later.
764 bool ClassLoaderDataGraph::do_unloading(BoolObjectClosure* is_alive_closure) {
765 ClassLoaderData* data = _head;
766 ClassLoaderData* prev = NULL;
767 bool seen_dead_loader = false;
768 // mark metadata seen on the stack and code cache so we can delete
844 assert(DumpSharedSpaces, "only use this for dumping shared spaces");
845 assert(this == ClassLoaderData::the_null_class_loader_data(),
846 "only supported for null loader data for now");
847 assert (!_shared_metaspaces_initialized, "only initialize once");
848 MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag);
849 _ro_metaspace = new Metaspace(_metaspace_lock, Metaspace::ROMetaspaceType);
850 _rw_metaspace = new Metaspace(_metaspace_lock, Metaspace::ReadWriteMetaspaceType);
851 _shared_metaspaces_initialized = true;
852 }
853
854 Metaspace* ClassLoaderData::ro_metaspace() {
855 assert(_ro_metaspace != NULL, "should already be initialized");
856 return _ro_metaspace;
857 }
858
859 Metaspace* ClassLoaderData::rw_metaspace() {
860 assert(_rw_metaspace != NULL, "should already be initialized");
861 return _rw_metaspace;
862 }
863
864 ClassLoaderDataGraphKlassIteratorAtomic::ClassLoaderDataGraphKlassIteratorAtomic()
865 : _next_klass(NULL) {
866 ClassLoaderData* cld = ClassLoaderDataGraph::_head;
867 Klass* klass = NULL;
868
869 // Find the first klass in the CLDG.
870 while (cld != NULL) {
871 klass = cld->_klasses;
872 if (klass != NULL) {
873 _next_klass = klass;
874 return;
875 }
876 cld = cld->next();
877 }
878 }
879
880 Klass* ClassLoaderDataGraphKlassIteratorAtomic::next_klass_in_cldg(Klass* klass) {
881 Klass* next = klass->next_link();
882 if (next != NULL) {
883 return next;
884 }
885
886 // No more klasses in the current CLD. Time to find a new CLD.
887 ClassLoaderData* cld = klass->class_loader_data();
888 while (next == NULL) {
889 cld = cld->next();
890 if (cld == NULL) {
891 break;
892 }
893 next = cld->_klasses;
894 }
895
896 return next;
897 }
898
899 Klass* ClassLoaderDataGraphKlassIteratorAtomic::next_klass() {
900 Klass* head = (Klass*)_next_klass;
901
902 while (head != NULL) {
903 Klass* next = next_klass_in_cldg(head);
904
905 Klass* old_head = (Klass*)Atomic::cmpxchg_ptr(next, &_next_klass, head);
906
907 if (old_head == head) {
908 return head; // Won the CAS.
909 }
910
911 head = old_head;
912 }
913
914 // Nothing more for the iterator to hand out.
915 assert(head == NULL, err_msg("head is " PTR_FORMAT ", expected not null:", p2i(head)));
916 return NULL;
917 }
918
919 ClassLoaderDataGraphMetaspaceIterator::ClassLoaderDataGraphMetaspaceIterator() {
920 _data = ClassLoaderDataGraph::_head;
921 }
922
923 ClassLoaderDataGraphMetaspaceIterator::~ClassLoaderDataGraphMetaspaceIterator() {}
924
925 #ifndef PRODUCT
926 // callable from debugger
927 extern "C" int print_loader_data_graph() {
928 ClassLoaderDataGraph::dump_on(tty);
929 return 0;
930 }
931
932 void ClassLoaderDataGraph::verify() {
933 for (ClassLoaderData* data = _head; data != NULL; data = data->next()) {
934 data->verify();
935 }
936 }
937
|