src/hotspot/share/classfile/systemDictionary.cpp

rev 49800 : 8199852: Print more information about class loaders in LinkageErrors.
Reviewed-by: dholmes

*** 2158,2223 ****
  // if defining is true, then LinkageError if already in dictionary
  // if initiating loader, then ok if InstanceKlass matches existing entry
  
  void SystemDictionary::check_constraints(unsigned int d_hash,
                                           InstanceKlass* k,
!                                          Handle class_loader, bool defining,
                                           TRAPS) {
    const char *linkage_error1 = NULL;
    const char *linkage_error2 = NULL;
    {
      Symbol*  name  = k->name();
      ClassLoaderData *loader_data = class_loader_data(class_loader);
  
      MutexLocker mu(SystemDictionary_lock, THREAD);
  
      InstanceKlass* check = find_class(d_hash, name, loader_data->dictionary());
      if (check != NULL) {
!       // if different InstanceKlass - duplicate class definition,
!       // else - ok, class loaded by a different thread in parallel,
!       // we should only have found it if it was done loading and ok to use
!       // dictionary only holds instance classes, placeholders
!       // also holds array classes
  
        assert(check->is_instance_klass(), "noninstance in systemdictionary");
        if ((defining == true) || (k != check)) {
!         linkage_error1 = "loader (instance of ";
!         linkage_error2 = "): attempted duplicate class definition for name: \"";
        } else {
          return;
        }
      }
  
  #ifdef ASSERT
      Symbol* ph_check = find_placeholder(name, loader_data);
      assert(ph_check == NULL || ph_check == name, "invalid symbol");
  #endif
  
!     if (linkage_error1 == NULL) {
        if (constraints()->check_or_update(k, class_loader, name) == false) {
!         linkage_error1 = "loader constraint violation: loader (instance of ";
!         linkage_error2 = ") previously initiated loading for a different type with name \"";
        }
      }
    }
  
    // Throw error now if needed (cannot throw while holding
    // SystemDictionary_lock because of rank ordering)
! 
!   if (linkage_error1) {
!     ResourceMark rm(THREAD);
!     const char* class_loader_name = loader_name(class_loader());
!     char* type_name = k->name()->as_C_string();
!     size_t buflen = strlen(linkage_error1) + strlen(class_loader_name) +
!       strlen(linkage_error2) + strlen(type_name) + 2; // +2 for '"' and null byte.
!     char* buf = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, buflen);
!     jio_snprintf(buf, buflen, "%s%s%s%s\"", linkage_error1, class_loader_name, linkage_error2, type_name);
!     THROW_MSG(vmSymbols::java_lang_LinkageError(), buf);
    }
  }
  
- 
  // Update class loader data dictionary - done after check_constraint and add_to_hierachy
  // have been called.
  void SystemDictionary::update_dictionary(unsigned int d_hash,
                                           int p_index, unsigned int p_hash,
                                           InstanceKlass* k,
--- 2158,2234 ----
  // if defining is true, then LinkageError if already in dictionary
  // if initiating loader, then ok if InstanceKlass matches existing entry
  
  void SystemDictionary::check_constraints(unsigned int d_hash,
                                           InstanceKlass* k,
!                                          Handle class_loader,
!                                          bool defining,
                                           TRAPS) {
+   ResourceMark rm(THREAD);
+   stringStream ss;
+   bool throwException = false;
+ 
    const char *linkage_error1 = NULL;
    const char *linkage_error2 = NULL;
+   const char *linkage_error3 = "";
+   // Remember the loader of the similar class that is already loaded.
+   const char *existing_klass_loader_name = "";
+ 
    {
      Symbol*  name  = k->name();
      ClassLoaderData *loader_data = class_loader_data(class_loader);
  
      MutexLocker mu(SystemDictionary_lock, THREAD);
  
      InstanceKlass* check = find_class(d_hash, name, loader_data->dictionary());
      if (check != NULL) {
!       // If different InstanceKlass - duplicate class definition,
!       // else - ok, class loaded by a different thread in parallel.
!       // We should only have found it if it was done loading and ok to use.
!       // The dictionary only holds instance classes, placeholders
!       // also hold array classes.
  
        assert(check->is_instance_klass(), "noninstance in systemdictionary");
        if ((defining == true) || (k != check)) {
!         throwException = true;
!         ss.print("loader %s", java_lang_ClassLoader::describe_external(class_loader()));
!         ss.print(" attempted duplicate %s definition for %s.",
!                  k->external_kind(), k->external_name());
        } else {
          return;
        }
      }
  
  #ifdef ASSERT
      Symbol* ph_check = find_placeholder(name, loader_data);
      assert(ph_check == NULL || ph_check == name, "invalid symbol");
  #endif
  
!     if (throwException == false) {
        if (constraints()->check_or_update(k, class_loader, name) == false) {
!         throwException = true;
!         ss.print("loader constraint violation: loader %s",
!                  java_lang_ClassLoader::describe_external(class_loader()));
!         ss.print(" wants to load %s %s.",
!                  k->external_kind(), k->external_name());
!         Klass *existing_klass = constraints()->find_constrained_klass(name, class_loader);
!         if (existing_klass->class_loader() != class_loader()) {
!           ss.print(" A different %s with the same name was previously loaded by %s.",
!                    existing_klass->external_kind(),
!                    java_lang_ClassLoader::describe_external(existing_klass->class_loader()));
!         }
        }
      }
    }
  
    // Throw error now if needed (cannot throw while holding
    // SystemDictionary_lock because of rank ordering)
!   if (throwException == true) {
!     THROW_MSG(vmSymbols::java_lang_LinkageError(), ss.as_string());
    }
  }
  
  // Update class loader data dictionary - done after check_constraint and add_to_hierachy
  // have been called.
  void SystemDictionary::update_dictionary(unsigned int d_hash,
                                           int p_index, unsigned int p_hash,
                                           InstanceKlass* k,
*** 3109,3119 ****
    _loader_constraints  = new LoaderConstraintTable(_loader_constraint_size);
  
    NOT_PRODUCT(SystemDictionary::verify());
  }
  
! // caller needs ResourceMark
  const char* SystemDictionary::loader_name(const oop loader) {
    return ((loader) == NULL ? "<bootloader>" :
            InstanceKlass::cast((loader)->klass())->name()->as_C_string());
  }
  
--- 3120,3130 ----
    _loader_constraints  = new LoaderConstraintTable(_loader_constraint_size);
  
    NOT_PRODUCT(SystemDictionary::verify());
  }
  
! // Caller needs ResourceMark.
  const char* SystemDictionary::loader_name(const oop loader) {
    return ((loader) == NULL ? "<bootloader>" :
            InstanceKlass::cast((loader)->klass())->name()->as_C_string());
  }