Skip to content
Permalink
Browse files
8261479: CDS runtime code should check exceptions
Reviewed-by: minqi, dholmes, iklam
  • Loading branch information
calvinccheung committed Mar 23, 2021
1 parent 087c8bf commit 1c9817b0bce64814727e3ac5240e39d88dfc32a1
@@ -464,7 +464,7 @@ InstanceKlass* ClassListParser::load_class_from_source(Symbol* class_name, TRAPS
_interfaces->length(), k->local_interfaces()->length());
}

bool added = SystemDictionaryShared::add_unregistered_class(k, CHECK_NULL);
bool added = SystemDictionaryShared::add_unregistered_class(THREAD, k);
if (!added) {
// We allow only a single unregistered class for each unique name.
error("Duplicated class %s", _class_name);
@@ -237,11 +237,11 @@ const char* ClassPathEntry::copy_path(const char* path) {
return copy;
}

ClassFileStream* ClassPathDirEntry::open_stream(const char* name, TRAPS) {
ClassFileStream* ClassPathDirEntry::open_stream(Thread* current, const char* name) {
// construct full path name
assert((_dir != NULL) && (name != NULL), "sanity");
size_t path_len = strlen(_dir) + strlen(name) + strlen(os::file_separator()) + 1;
char* path = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, path_len);
char* path = NEW_RESOURCE_ARRAY_IN_THREAD(current, char, path_len);
int len = jio_snprintf(path, path_len, "%s%s%s", _dir, os::file_separator(), name);
assert(len == (int)(path_len - 1), "sanity");
// check if file exists
@@ -285,10 +285,9 @@ ClassPathZipEntry::~ClassPathZipEntry() {
FREE_C_HEAP_ARRAY(char, _zip_name);
}

u1* ClassPathZipEntry::open_entry(const char* name, jint* filesize, bool nul_terminate, TRAPS) {
// enable call to C land
JavaThread* thread = THREAD->as_Java_thread();
ThreadToNativeFromVM ttn(thread);
u1* ClassPathZipEntry::open_entry(Thread* current, const char* name, jint* filesize, bool nul_terminate) {
// enable call to C land
ThreadToNativeFromVM ttn(current->as_Java_thread());
// check whether zip archive contains name
jint name_len;
jzentry* entry = (*FindEntry)(_zip, name, filesize, &name_len);
@@ -314,9 +313,9 @@ u1* ClassPathZipEntry::open_entry(const char* name, jint* filesize, bool nul_ter
return buffer;
}

ClassFileStream* ClassPathZipEntry::open_stream(const char* name, TRAPS) {
ClassFileStream* ClassPathZipEntry::open_stream(Thread* current, const char* name) {
jint filesize;
u1* buffer = open_entry(name, &filesize, false, CHECK_NULL);
u1* buffer = open_entry(current, name, &filesize, false);
if (buffer == NULL) {
return NULL;
}
@@ -374,8 +373,8 @@ ClassPathImageEntry::~ClassPathImageEntry() {
}
}

ClassFileStream* ClassPathImageEntry::open_stream(const char* name, TRAPS) {
return open_stream_for_loader(name, ClassLoaderData::the_null_class_loader_data(), THREAD);
ClassFileStream* ClassPathImageEntry::open_stream(Thread* current, const char* name) {
return open_stream_for_loader(current, name, ClassLoaderData::the_null_class_loader_data());
}

// For a class in a named module, look it up in the jimage file using this syntax:
@@ -385,7 +384,7 @@ ClassFileStream* ClassPathImageEntry::open_stream(const char* name, TRAPS) {
// 1. There are no unnamed modules in the jimage file.
// 2. A package is in at most one module in the jimage file.
//
ClassFileStream* ClassPathImageEntry::open_stream_for_loader(const char* name, ClassLoaderData* loader_data, TRAPS) {
ClassFileStream* ClassPathImageEntry::open_stream_for_loader(Thread* current, const char* name, ClassLoaderData* loader_data) {
jlong size;
JImageLocationRef location = (*JImageFindResource)(_jimage, "", get_jimage_version_string(), name, &size);

@@ -399,7 +398,7 @@ ClassFileStream* ClassPathImageEntry::open_stream_for_loader(const char* name, C
} else {
PackageEntry* package_entry = ClassLoader::get_package_entry(pkg_name, loader_data);
if (package_entry != NULL) {
ResourceMark rm(THREAD);
ResourceMark rm(current);
// Get the module name
ModuleEntry* module = package_entry->module();
assert(module != NULL, "Boot classLoader package missing module");
@@ -1156,7 +1155,7 @@ ClassFileStream* ClassLoader::search_module_entries(const GrowableArray<ModuleCl

// Try to load the class from the module's ClassPathEntry list.
while (e != NULL) {
stream = e->open_stream(file_name, CHECK_NULL);
stream = e->open_stream(THREAD, file_name);
// No context.check is required since CDS is not supported
// for an exploded modules build or if --patch-module is specified.
if (NULL != stream) {
@@ -1227,7 +1226,7 @@ InstanceKlass* ClassLoader::load_class(Symbol* name, bool search_append_only, TR
if (!search_append_only && (NULL == stream)) {
if (has_jrt_entry()) {
e = _jrt_entry;
stream = _jrt_entry->open_stream(file_name, CHECK_NULL);
stream = _jrt_entry->open_stream(THREAD, file_name);
} else {
// Exploded build - attempt to locate class in its defining module's location.
assert(_exploded_entries != NULL, "No exploded build entries present");
@@ -1245,7 +1244,7 @@ InstanceKlass* ClassLoader::load_class(Symbol* name, bool search_append_only, TR

e = first_append_entry();
while (e != NULL) {
stream = e->open_stream(file_name, CHECK_NULL);
stream = e->open_stream(THREAD, file_name);
if (NULL != stream) {
break;
}
@@ -1295,7 +1294,7 @@ char* ClassLoader::skip_uri_protocol(char* source) {

// Record the shared classpath index and loader type for classes loaded
// by the builtin loaders at dump time.
void ClassLoader::record_result(InstanceKlass* ik, const ClassFileStream* stream, TRAPS) {
void ClassLoader::record_result(Thread* current, InstanceKlass* ik, const ClassFileStream* stream) {
Arguments::assert_is_dumping_archive();
assert(stream != NULL, "sanity");

@@ -1317,7 +1316,7 @@ void ClassLoader::record_result(InstanceKlass* ik, const ClassFileStream* stream

assert(has_jrt_entry(), "CDS dumping does not support exploded JDK build");

ResourceMark rm(THREAD);
ResourceMark rm(current);
int classpath_index = -1;
PackageEntry* pkg_entry = ik->package();

@@ -1401,7 +1400,7 @@ void ClassLoader::record_result(InstanceKlass* ik, const ClassFileStream* stream
ik->name()->utf8_length());
assert(file_name != NULL, "invariant");

ClassLoaderExt::record_result(classpath_index, ik, CHECK);
ClassLoaderExt::record_result(classpath_index, ik);
}
#endif // INCLUDE_CDS

@@ -65,10 +65,10 @@ class ClassPathEntry : public CHeapObj<mtClass> {
ClassPathEntry() : _next(NULL) {}
// Attempt to locate file_name through this class path entry.
// Returns a class file parsing stream if successfull.
virtual ClassFileStream* open_stream(const char* name, TRAPS) = 0;
virtual ClassFileStream* open_stream(Thread* current, const char* name) = 0;
// Open the stream for a specific class loader
virtual ClassFileStream* open_stream_for_loader(const char* name, ClassLoaderData* loader_data, TRAPS) {
return open_stream(name, THREAD);
virtual ClassFileStream* open_stream_for_loader(Thread* current, const char* name, ClassLoaderData* loader_data) {
return open_stream(current, name);
}
};

@@ -81,7 +81,7 @@ class ClassPathDirEntry: public ClassPathEntry {
_dir = copy_path(dir);
}
virtual ~ClassPathDirEntry() {}
ClassFileStream* open_stream(const char* name, TRAPS);
ClassFileStream* open_stream(Thread* current, const char* name);
};

// Type definitions for zip file and zip file entry
@@ -108,8 +108,8 @@ class ClassPathZipEntry: public ClassPathEntry {
const char* name() const { return _zip_name; }
ClassPathZipEntry(jzfile* zip, const char* zip_name, bool is_boot_append, bool from_class_path_attr);
virtual ~ClassPathZipEntry();
u1* open_entry(const char* name, jint* filesize, bool nul_terminate, TRAPS);
ClassFileStream* open_stream(const char* name, TRAPS);
u1* open_entry(Thread* current, const char* name, jint* filesize, bool nul_terminate);
ClassFileStream* open_stream(Thread* current, const char* name);
void contents_do(void f(const char* name, void* context), void* context);
};

@@ -128,8 +128,8 @@ class ClassPathImageEntry: public ClassPathEntry {
void close_jimage();
ClassPathImageEntry(JImageFile* jimage, const char* name);
virtual ~ClassPathImageEntry();
ClassFileStream* open_stream(const char* name, TRAPS);
ClassFileStream* open_stream_for_loader(const char* name, ClassLoaderData* loader_data, TRAPS);
ClassFileStream* open_stream(Thread* current, const char* name);
ClassFileStream* open_stream_for_loader(Thread* current, const char* name, ClassLoaderData* loader_data);
};

// ModuleClassPathList contains a linked list of ClassPathEntry's
@@ -365,7 +365,7 @@ class ClassLoader: AllStatic {
static int num_module_path_entries();
static void exit_with_path_failure(const char* error, const char* message);
static char* skip_uri_protocol(char* source);
static void record_result(InstanceKlass* ik, const ClassFileStream* stream, TRAPS);
static void record_result(Thread* current, InstanceKlass* ik, const ClassFileStream* stream);
#endif

static char* lookup_vm_options();
@@ -103,13 +103,13 @@ void ClassLoaderExt::setup_module_paths(TRAPS) {
process_module_table(met, CHECK);
}

char* ClassLoaderExt::read_manifest(ClassPathEntry* entry, jint *manifest_size, bool clean_text, TRAPS) {
char* ClassLoaderExt::read_manifest(Thread* current, ClassPathEntry* entry, jint *manifest_size, bool clean_text) {
const char* name = "META-INF/MANIFEST.MF";
char* manifest;
jint size;

assert(entry->is_jar_file(), "must be");
manifest = (char*) ((ClassPathZipEntry*)entry )->open_entry(name, &size, true, CHECK_NULL);
manifest = (char*) ((ClassPathZipEntry*)entry )->open_entry(current, name, &size, true);

if (manifest == NULL) { // No Manifest
*manifest_size = 0;
@@ -167,7 +167,7 @@ void ClassLoaderExt::process_jar_manifest(ClassPathEntry* entry,
bool check_for_duplicates, TRAPS) {
ResourceMark rm(THREAD);
jint manifest_size;
char* manifest = read_manifest(entry, &manifest_size, CHECK);
char* manifest = read_manifest(THREAD, entry, &manifest_size);

if (manifest == NULL) {
return;
@@ -230,9 +230,7 @@ void ClassLoaderExt::setup_search_paths(TRAPS) {
ClassLoaderExt::setup_app_search_path(CHECK);
}

void ClassLoaderExt::record_result(const s2 classpath_index,
InstanceKlass* result,
TRAPS) {
void ClassLoaderExt::record_result(const s2 classpath_index, InstanceKlass* result) {
Arguments::assert_is_dumping_archive();

// We need to remember where the class comes from during dumping.
@@ -275,7 +273,7 @@ InstanceKlass* ClassLoaderExt::load_class(Symbol* name, const char* path, TRAPS)
PerfClassTraceTime vmtimer(perf_sys_class_lookup_time(),
THREAD->as_Java_thread()->get_thread_stat()->perf_timers_addr(),
PerfClassTraceTime::CLASS_LOAD);
stream = e->open_stream(file_name, CHECK_NULL);
stream = e->open_stream(THREAD, file_name);
}

if (stream == NULL) {
@@ -57,7 +57,7 @@ class ClassLoaderExt: public ClassLoader { // AllStatic
static bool _has_app_classes;
static bool _has_platform_classes;

static char* read_manifest(ClassPathEntry* entry, jint *manifest_size, bool clean_text, TRAPS);
static char* read_manifest(Thread* current, ClassPathEntry* entry, jint *manifest_size, bool clean_text);
static ClassPathEntry* find_classpath_entry_from_cache(Thread* current, const char* path);

public:
@@ -69,16 +69,16 @@ class ClassLoaderExt: public ClassLoader { // AllStatic
static void setup_search_paths(TRAPS);
static void setup_module_paths(TRAPS);

static char* read_manifest(ClassPathEntry* entry, jint *manifest_size, TRAPS) {
static char* read_manifest(Thread* current, ClassPathEntry* entry, jint *manifest_size) {
// Remove all the new-line continuations (which wrap long lines at 72 characters, see
// http://docs.oracle.com/javase/6/docs/technotes/guides/jar/jar.html#JAR%20Manifest), so
// that the manifest is easier to parse.
return read_manifest(entry, manifest_size, true, THREAD);
return read_manifest(current, entry, manifest_size, true);
}
static char* read_raw_manifest(ClassPathEntry* entry, jint *manifest_size, TRAPS) {
static char* read_raw_manifest(Thread* current, ClassPathEntry* entry, jint *manifest_size) {
// Do not remove new-line continuations, so we can easily pass it as an argument to
// java.util.jar.Manifest.getManifest() at run-time.
return read_manifest(entry, manifest_size, false, THREAD);
return read_manifest(current, entry, manifest_size, false);
}

static jshort app_class_paths_start_index() { return _app_class_paths_start_index; }
@@ -107,8 +107,7 @@ class ClassLoaderExt: public ClassLoader { // AllStatic
return _has_app_classes || _has_platform_classes;
}

static void record_result(const s2 classpath_index,
InstanceKlass* result, TRAPS);
static void record_result(const s2 classpath_index, InstanceKlass* result);
static InstanceKlass* load_class(Symbol* h_name, const char* path, TRAPS);
static void set_has_app_classes() {
_has_app_classes = true;
@@ -216,7 +216,7 @@ InstanceKlass* KlassFactory::create_from_stream(ClassFileStream* stream,

#if INCLUDE_CDS
if (Arguments::is_dumping_archive()) {
ClassLoader::record_result(result, stream, THREAD);
ClassLoader::record_result(THREAD, result, stream);
}
#endif // INCLUDE_CDS

@@ -736,7 +736,7 @@ Handle SystemDictionaryShared::get_shared_jar_manifest(int shared_path_index, TR
// ByteArrayInputStream bais = new ByteArrayInputStream(buf);
const char* src = ent->manifest();
assert(src != NULL, "No Manifest data");
manifest = create_jar_manifest(src, size, THREAD);
manifest = create_jar_manifest(src, size, CHECK_NH);
atomic_set_shared_jar_manifest(shared_path_index, manifest());
}
manifest = Handle(THREAD, shared_jar_manifest(shared_path_index));
@@ -896,7 +896,7 @@ Handle SystemDictionaryShared::init_security_info(Handle class_loader, InstanceK
// Modules::define_module().
assert(pkg_entry != NULL, "archived class in module image cannot be from unnamed package");
ModuleEntry* mod_entry = pkg_entry->module();
pd = get_shared_protection_domain(class_loader, mod_entry, THREAD);
pd = get_shared_protection_domain(class_loader, mod_entry, CHECK_(pd));
} else {
// For shared app/platform classes originated from JAR files on the class path:
// Each of the 3 SystemDictionaryShared::_shared_xxx arrays has the same length
@@ -1180,7 +1180,7 @@ class LoadedUnregisteredClassesTable : public ResourceHashtable<

static LoadedUnregisteredClassesTable* _loaded_unregistered_classes = NULL;

bool SystemDictionaryShared::add_unregistered_class(InstanceKlass* k, TRAPS) {
bool SystemDictionaryShared::add_unregistered_class(Thread* current, InstanceKlass* k) {
// We don't allow duplicated unregistered classes of the same name.
assert(DumpSharedSpaces, "only when dumping");
Symbol* name = k->name();
@@ -1190,7 +1190,7 @@ bool SystemDictionaryShared::add_unregistered_class(InstanceKlass* k, TRAPS) {
bool created = false;
_loaded_unregistered_classes->put_if_absent(name, true, &created);
if (created) {
MutexLocker mu_r(THREAD, Compile_lock); // add_to_hierarchy asserts this.
MutexLocker mu_r(current, Compile_lock); // add_to_hierarchy asserts this.
SystemDictionary::add_to_hierarchy(k);
}
return created;
@@ -1602,7 +1602,8 @@ void SystemDictionaryShared::add_lambda_proxy_class(InstanceKlass* caller_ik,

lambda_ik->assign_class_loader_type();
lambda_ik->set_shared_classpath_index(caller_ik->shared_classpath_index());
InstanceKlass* nest_host = caller_ik->nest_host(THREAD);
InstanceKlass* nest_host = caller_ik->nest_host(CHECK);
assert(nest_host != NULL, "unexpected NULL nest_host");

DumpTimeSharedClassInfo* info = _dumptime_table->get(lambda_ik);
if (info != NULL && !lambda_ik->is_non_strong_hidden() && is_builtin(lambda_ik) && is_builtin(caller_ik)
@@ -246,7 +246,7 @@ class SystemDictionaryShared: public SystemDictionary {
// Check if sharing is supported for the class loader.
static bool is_sharing_possible(ClassLoaderData* loader_data);

static bool add_unregistered_class(InstanceKlass* k, TRAPS);
static bool add_unregistered_class(Thread* current, InstanceKlass* k);
static InstanceKlass* lookup_super_for_unregistered_class(Symbol* class_name,
Symbol* super_name, bool is_superclass);

@@ -1770,7 +1770,7 @@ void LinkResolver::resolve_invokedynamic(CallInfo& result, const constantPoolHan
// to CPCE state, including f1.

// Log dynamic info to CDS classlist.
ArchiveUtils::log_to_classlist(&bootstrap_specifier, THREAD);
ArchiveUtils::log_to_classlist(&bootstrap_specifier, CHECK);
}

void LinkResolver::resolve_dynamic_call(CallInfo& result,
@@ -339,7 +339,7 @@ void ArchiveUtils::log_to_classlist(BootstrapInfo* bootstrap_specifier, TRAPS) {
ClassListWriter w;
w.stream()->print("%s %s", LAMBDA_PROXY_TAG, pool->pool_holder()->name()->as_C_string());
CDSIndyInfo cii;
ClassListParser::populate_cds_indy_info(pool, pool_index, &cii, THREAD);
ClassListParser::populate_cds_indy_info(pool, pool_index, &cii, CHECK);
GrowableArray<const char*>* indy_items = cii.items();
for (int i = 0; i < indy_items->length(); i++) {
w.stream()->print(" %s", indy_items->at(i));
@@ -657,15 +657,15 @@ void FileMapInfo::update_jar_manifest(ClassPathEntry *cpe, SharedClassPathEntry*
jint manifest_size;

assert(cpe->is_jar_file() && ent->is_jar(), "the shared class path entry is not a JAR file");
char* manifest = ClassLoaderExt::read_manifest(cpe, &manifest_size, CHECK);
char* manifest = ClassLoaderExt::read_manifest(THREAD, cpe, &manifest_size);
if (manifest != NULL) {
ManifestStream* stream = new ManifestStream((u1*)manifest,
manifest_size);
if (stream->check_is_signed()) {
ent->set_is_signed();
} else {
// Copy the manifest into the shared archive
manifest = ClassLoaderExt::read_raw_manifest(cpe, &manifest_size, CHECK);
manifest = ClassLoaderExt::read_raw_manifest(THREAD, cpe, &manifest_size);
Array<u1>* buf = MetadataFactory::new_array<u1>(loader_data,
manifest_size,
CHECK);
@@ -2370,9 +2370,8 @@ ClassFileStream* FileMapInfo::open_stream_for_jvmti(InstanceKlass* ik, Handle cl
const char* const file_name = ClassLoader::file_name_for_class_name(class_name,
name->utf8_length());
ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(class_loader());
ClassFileStream* cfs = cpe->open_stream_for_loader(file_name, loader_data, THREAD);
assert(!HAS_PENDING_EXCEPTION &&
cfs != NULL, "must be able to read the classfile data of shared classes for built-in loaders.");
ClassFileStream* cfs = cpe->open_stream_for_loader(THREAD, file_name, loader_data);
assert(cfs != NULL, "must be able to read the classfile data of shared classes for built-in loaders.");
log_debug(cds, jvmti)("classfile data for %s [%d: %s] = %d bytes", class_name, path_index,
cfs->source(), cfs->length());
return cfs;
Loading

1 comment on commit 1c9817b

@openjdk-notifier

This comment has been minimized.

Copy link

@openjdk-notifier openjdk-notifier bot commented on 1c9817b Mar 23, 2021

Please sign in to comment.