Metaspace* ClassLoaderData::metaspace_non_null() { assert(!DumpSharedSpaces, "wrong metaspace!"); // If the metaspace has not been allocated, create a new one. Might want // to create smaller arena for Reflection class loaders also. // The reason for the delayed allocation is because some class loaders are // simply for delegating with no metadata of their own. if (_metaspace == NULL) { MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag); // Check again if metaspace has been allocated while we were getting this lock. if (_metaspace != NULL) { return _metaspace; } if (this == the_null_class_loader_data()) { assert (class_loader() == NULL, "Must be"); set_metaspace(new Metaspace(_metaspace_lock, Metaspace::BootMetaspaceType)); } else if (is_anonymous()) { if (TraceClassLoaderData && Verbose && class_loader() != NULL) { tty->print_cr("is_anonymous: %s", class_loader()->klass()->internal_name()); } set_metaspace(new Metaspace(_metaspace_lock, Metaspace::AnonymousMetaspaceType)); } else if (class_loader()->is_a(SystemDictionary::reflect_DelegatingClassLoader_klass())) { if (TraceClassLoaderData && Verbose && class_loader() != NULL) { tty->print_cr("is_reflection: %s", class_loader()->klass()->internal_name()); } set_metaspace(new Metaspace(_metaspace_lock, Metaspace::ReflectionMetaspaceType)); } else { set_metaspace(new Metaspace(_metaspace_lock, Metaspace::StandardMetaspaceType)); } } return _metaspace; }
jobject ClassLoaderData::add_handle(Handle h) { MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag); if (handles() == NULL) { set_handles(JNIHandleBlock::allocate_block()); } return handles()->allocate_handle(h()); }
// Initialize shared metaspaces (change to call from somewhere not lazily) void ClassLoaderData::initialize_shared_metaspaces() { assert(DumpSharedSpaces, "only use this for dumping shared spaces"); assert(this == ClassLoaderData::the_null_class_loader_data(), "only supported for null loader data for now"); assert (!_shared_metaspaces_initialized, "only initialize once"); MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag); _ro_metaspace = new Metaspace(_metaspace_lock, Metaspace::ROMetaspaceType); _rw_metaspace = new Metaspace(_metaspace_lock, Metaspace::ReadWriteMetaspaceType); _shared_metaspaces_initialized = true; }
// Add this metadata pointer to be freed when it's safe. This is only during // class unloading because Handles might point to this metadata field. void ClassLoaderData::add_to_deallocate_list(Metadata* m) { // Metadata in shared region isn't deleted. if (!m->is_shared()) { MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag); if (_deallocate_list == NULL) { _deallocate_list = new (ResourceObj::C_HEAP, mtClass) GrowableArray<Metadata*>(100, true); } _deallocate_list->append_if_missing(m); } }
void ClassLoaderData::loaded_classes_do(KlassClosure* klass_closure) { // Lock to avoid classes being modified/added/removed during iteration MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag); for (Klass* k = _klasses; k != NULL; k = k->next_link()) { // Do not filter ArrayKlass oops here... if (k->oop_is_array() || (k->oop_is_instance() && InstanceKlass::cast(k)->is_loaded())) { klass_closure->do_klass(k); } } }
// This is called by InstanceKlass::deallocate_contents() to remove the // scratch_class for redefine classes. We need a lock because there it may not // be called at a safepoint if there's an error. void ClassLoaderData::remove_class(Klass* scratch_class) { MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag); Klass* prev = NULL; for (Klass* k = _klasses; k != NULL; k = k->next_link()) { if (k == scratch_class) { if (prev == NULL) { _klasses = k->next_link(); } else { Klass* next = k->next_link(); prev->set_next_link(next); } return; } prev = k; assert(k != k->next_link(), "no loops!"); } ShouldNotReachHere(); // should have found this class!! }
void ClassLoaderData::add_class(Klass* k) { MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag); Klass* old_value = _klasses; k->set_next_link(old_value); // link the new item into the list _klasses = k; if (TraceClassLoaderData && Verbose && k->class_loader_data() != NULL) { ResourceMark rm; tty->print_cr("[TraceClassLoaderData] Adding k: " PTR_FORMAT " %s to CLD: " PTR_FORMAT " loader: " PTR_FORMAT " %s", p2i(k), k->external_name(), p2i(k->class_loader_data()), p2i((void *)k->class_loader()), loader_name()); } }
void ClassLoaderData::add_class(Klass* k, bool publicize /* true */) { { MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag); Klass* old_value = _klasses; k->set_next_link(old_value); // Link the new item into the list, making sure the linked class is stable // since the list can be walked without a lock OrderAccess::release_store_ptr(&_klasses, k); } if (publicize && k->class_loader_data() != NULL) { ResourceMark rm; log_trace(class, loader, data)("Adding k: " PTR_FORMAT " %s to CLD: " PTR_FORMAT " loader: " PTR_FORMAT " %s", p2i(k), k->external_name(), p2i(k->class_loader_data()), p2i((void *)k->class_loader()), loader_name()); }
void ClassLoaderData::add_class(Klass* k, bool publicize /* true */) { { MutexLockerEx ml(metaspace_lock(), Mutex::_no_safepoint_check_flag); Klass* old_value = _klasses; k->set_next_link(old_value); // Make sure linked class is stable, since the class list is walked without a lock OrderAccess::storestore(); // link the new item into the list _klasses = k; } if (publicize && TraceClassLoaderData && Verbose && k->class_loader_data() != NULL) { ResourceMark rm; tty->print_cr("[TraceClassLoaderData] Adding k: " PTR_FORMAT " %s to CLD: " PTR_FORMAT " loader: " PTR_FORMAT " %s", p2i(k), k->external_name(), p2i(k->class_loader_data()), p2i((void *)k->class_loader()), loader_name()); } }