51 #include "logging/logTag.hpp"
52 #include "memory/allocation.inline.hpp"
53 #include "memory/oopFactory.hpp"
54 #include "memory/resourceArea.hpp"
55 #include "memory/universe.hpp"
56 #include "oops/instanceKlass.hpp"
57 #include "oops/instanceRefKlass.hpp"
58 #include "oops/klass.inline.hpp"
59 #include "oops/method.inline.hpp"
60 #include "oops/objArrayOop.inline.hpp"
61 #include "oops/oop.inline.hpp"
62 #include "oops/symbol.hpp"
63 #include "prims/jvm_misc.hpp"
64 #include "runtime/arguments.hpp"
65 #include "runtime/handles.inline.hpp"
66 #include "runtime/init.hpp"
67 #include "runtime/interfaceSupport.inline.hpp"
68 #include "runtime/java.hpp"
69 #include "runtime/javaCalls.hpp"
70 #include "runtime/os.hpp"
71 #include "runtime/perfData.hpp"
72 #include "runtime/threadCritical.hpp"
73 #include "runtime/timer.hpp"
74 #include "runtime/vm_version.hpp"
75 #include "services/management.hpp"
76 #include "services/threadService.hpp"
77 #include "utilities/checkedCast.hpp"
78 #include "utilities/classpathStream.hpp"
79 #include "utilities/events.hpp"
80 #include "utilities/macros.hpp"
81 #include "utilities/utf8.hpp"
82
83 // Entry point in java.dll for path canonicalization
84
85 typedef int (*canonicalize_fn_t)(const char *orig, char *out, int len);
86
87 static canonicalize_fn_t CanonicalizeEntry = nullptr;
88
89 // Entry points for jimage.dll for loading jimage file entries
90
91 static JImageOpen_t JImageOpen = nullptr;
92 static JImageClose_t JImageClose = nullptr;
93 static JImageFindResource_t JImageFindResource = nullptr;
94 static JImageGetResource_t JImageGetResource = nullptr;
95
96 // JimageFile pointer, or null if exploded JDK build.
97 static JImageFile* JImage_file = nullptr;
98
99 // Globals
100
101 PerfCounter* ClassLoader::_perf_accumulated_time = nullptr;
102 PerfCounter* ClassLoader::_perf_classes_inited = nullptr;
103 PerfCounter* ClassLoader::_perf_class_init_time = nullptr;
104 PerfCounter* ClassLoader::_perf_class_init_selftime = nullptr;
105 PerfCounter* ClassLoader::_perf_classes_verified = nullptr;
106 PerfCounter* ClassLoader::_perf_class_verify_time = nullptr;
107 PerfCounter* ClassLoader::_perf_class_verify_selftime = nullptr;
108 PerfCounter* ClassLoader::_perf_classes_linked = nullptr;
109 PerfCounter* ClassLoader::_perf_class_link_time = nullptr;
110 PerfCounter* ClassLoader::_perf_class_link_selftime = nullptr;
111 PerfCounter* ClassLoader::_perf_shared_classload_time = nullptr;
112 PerfCounter* ClassLoader::_perf_sys_classload_time = nullptr;
113 PerfCounter* ClassLoader::_perf_app_classload_time = nullptr;
114 PerfCounter* ClassLoader::_perf_app_classload_selftime = nullptr;
115 PerfCounter* ClassLoader::_perf_app_classload_count = nullptr;
116 PerfCounter* ClassLoader::_perf_define_appclasses = nullptr;
117 PerfCounter* ClassLoader::_perf_define_appclass_time = nullptr;
118 PerfCounter* ClassLoader::_perf_define_appclass_selftime = nullptr;
119 PerfCounter* ClassLoader::_perf_app_classfile_bytes_read = nullptr;
120 PerfCounter* ClassLoader::_perf_sys_classfile_bytes_read = nullptr;
121 PerfCounter* ClassLoader::_unsafe_defineClassCallCounter = nullptr;
122 PerfCounter* ClassLoader::_perf_secondary_hash_time = nullptr;
123
124 GrowableArray<ModuleClassPathList*>* ClassLoader::_patch_mod_entries = nullptr;
125 GrowableArray<ModuleClassPathList*>* ClassLoader::_exploded_entries = nullptr;
126 ClassPathEntry* ClassLoader::_jrt_entry = nullptr;
127
128 ClassPathEntry* volatile ClassLoader::_first_append_entry_list = nullptr;
129 ClassPathEntry* volatile ClassLoader::_last_append_entry = nullptr;
130 #if INCLUDE_CDS
131 ClassPathEntry* ClassLoader::_app_classpath_entries = nullptr;
132 ClassPathEntry* ClassLoader::_last_app_classpath_entry = nullptr;
133 ClassPathEntry* ClassLoader::_module_path_entries = nullptr;
134 ClassPathEntry* ClassLoader::_last_module_path_entry = nullptr;
135 #endif
136
137 // helper routines
138 #if INCLUDE_CDS
139 static bool string_starts_with(const char* str, const char* str_to_find) {
140 size_t str_len = strlen(str);
141 size_t str_to_find_len = strlen(str_to_find);
142 if (str_to_find_len > str_len) {
143 return false;
255 #ifdef ASSERT
256 // Freeing path is a no-op here as buffer prevents it from being reclaimed. But we keep it for
257 // debug builds so that we guard against use-after-free bugs.
258 FREE_RESOURCE_ARRAY_IN_THREAD(current, char, path, path_len);
259 #endif
260 // We don't verify the length of the classfile stream fits in an int, but this is the
261 // bootloader so we have control of this.
262 // Resource allocated
263 return new ClassFileStream(buffer,
264 checked_cast<int>(st.st_size),
265 _dir,
266 ClassFileStream::verify);
267 }
268 }
269 }
270 FREE_RESOURCE_ARRAY_IN_THREAD(current, char, path, path_len);
271 return nullptr;
272 }
273
274 ClassPathZipEntry::ClassPathZipEntry(jzfile* zip, const char* zip_name,
275 bool is_boot_append, bool from_class_path_attr) : ClassPathEntry() {
276 _zip = zip;
277 _zip_name = copy_path(zip_name);
278 _from_class_path_attr = from_class_path_attr;
279 }
280
281 ClassPathZipEntry::~ClassPathZipEntry() {
282 ZipLibrary::close(_zip);
283 FREE_C_HEAP_ARRAY(char, _zip_name);
284 }
285
286 u1* ClassPathZipEntry::open_entry(JavaThread* current, const char* name, jint* filesize, bool nul_terminate) {
287 // enable call to C land
288 ThreadToNativeFromVM ttn(current);
289 // check whether zip archive contains name
290 jint name_len;
291 jzentry* entry = ZipLibrary::find_entry(_zip, name, filesize, &name_len);
292 if (entry == nullptr) return nullptr;
293 u1* buffer;
294 char name_buf[128];
295 char* filename;
296 if (name_len < 128) {
297 filename = name_buf;
298 } else {
299 filename = NEW_RESOURCE_ARRAY(char, name_len + 1);
300 }
301
302 // read contents into resource array
303 size_t size = (uint32_t)(*filesize);
304 if (nul_terminate) {
305 if (sizeof(size) == sizeof(uint32_t) && size == UINT_MAX) {
306 return nullptr; // 32-bit integer overflow will occur.
307 }
308 size++;
309 }
310 buffer = NEW_RESOURCE_ARRAY(u1, size);
311 if (!ZipLibrary::read_entry(_zip, entry, buffer, filename)) {
312 return nullptr;
313 }
314
315 // return result
316 if (nul_terminate) {
317 buffer[size - 1] = 0;
318 }
319 return buffer;
320 }
321
322 ClassFileStream* ClassPathZipEntry::open_stream(JavaThread* current, const char* name) {
323 jint filesize;
324 u1* buffer = open_entry(current, name, &filesize, false);
325 if (buffer == nullptr) {
326 return nullptr;
327 }
328 if (UsePerfData) {
329 ClassLoader::perf_sys_classfile_bytes_read()->inc(filesize);
715 HandleMark hm(thread);
716 return ZipLibrary::open(canonical_path, error_msg);
717 }
718
719 ClassPathEntry* ClassLoader::create_class_path_entry(JavaThread* current,
720 const char *path, const struct stat* st,
721 bool is_boot_append,
722 bool from_class_path_attr) {
723 ClassPathEntry* new_entry = nullptr;
724 if ((st->st_mode & S_IFMT) == S_IFREG) {
725 ResourceMark rm(current);
726 // Regular file, should be a zip file
727 // Canonicalized filename
728 const char* canonical_path = get_canonical_path(path, current);
729 if (canonical_path == nullptr) {
730 return nullptr;
731 }
732 char* error_msg = nullptr;
733 jzfile* zip = open_zip_file(canonical_path, &error_msg, current);
734 if (zip != nullptr && error_msg == nullptr) {
735 new_entry = new ClassPathZipEntry(zip, path, is_boot_append, from_class_path_attr);
736 } else {
737 #if INCLUDE_CDS
738 ClassLoaderExt::set_has_non_jar_in_classpath();
739 #endif
740 return nullptr;
741 }
742 log_info(class, path)("opened: %s", path);
743 log_info(class, load)("opened: %s", path);
744 } else {
745 // Directory
746 new_entry = new ClassPathDirEntry(path);
747 log_info(class, load)("path: %s", path);
748 }
749 return new_entry;
750 }
751
752
753 // Create a class path zip entry for a given path (return null if not found
754 // or zip/JAR file cannot be opened)
755 ClassPathZipEntry* ClassLoader::create_class_path_zip_entry(const char *path, bool is_boot_append) {
756 // check for a regular file
757 struct stat st;
758 if (os::stat(path, &st) == 0) {
759 if ((st.st_mode & S_IFMT) == S_IFREG) {
760 JavaThread* thread = JavaThread::current();
761 ResourceMark rm(thread);
762 const char* canonical_path = get_canonical_path(path, thread);
763 if (canonical_path != nullptr) {
764 char* error_msg = nullptr;
765 jzfile* zip = open_zip_file(canonical_path, &error_msg, thread);
766 if (zip != nullptr && error_msg == nullptr) {
767 // create using canonical path
768 return new ClassPathZipEntry(zip, canonical_path, is_boot_append, false);
769 }
770 }
771 }
772 }
773 return nullptr;
774 }
775
776 // The boot append entries are added with a lock, and read lock free.
777 void ClassLoader::add_to_boot_append_entries(ClassPathEntry *new_entry) {
778 if (new_entry != nullptr) {
779 MutexLocker ml(Bootclasspath_lock, Mutex::_no_safepoint_check_flag);
780 if (_last_append_entry == nullptr) {
781 _last_append_entry = new_entry;
782 assert(first_append_entry() == nullptr, "boot loader's append class path entry list not empty");
783 Atomic::release_store(&_first_append_entry_list, new_entry);
784 } else {
785 _last_append_entry->set_next(new_entry);
786 _last_append_entry = new_entry;
787 }
788 }
1308 #endif // INCLUDE_CDS
1309
1310 // Initialize the class loader's access to methods in libzip. Parse and
1311 // process the boot classpath into a list ClassPathEntry objects. Once
1312 // this list has been created, it must not change order (see class PackageInfo)
1313 // it can be appended to and is by jvmti.
1314
1315 void ClassLoader::initialize(TRAPS) {
1316 if (UsePerfData) {
1317 // jvmstat performance counters
1318 NEWPERFTICKCOUNTER(_perf_accumulated_time, SUN_CLS, "time");
1319 NEWPERFTICKCOUNTER(_perf_class_init_time, SUN_CLS, "classInitTime");
1320 NEWPERFTICKCOUNTER(_perf_class_init_selftime, SUN_CLS, "classInitTime.self");
1321 NEWPERFTICKCOUNTER(_perf_class_verify_time, SUN_CLS, "classVerifyTime");
1322 NEWPERFTICKCOUNTER(_perf_class_verify_selftime, SUN_CLS, "classVerifyTime.self");
1323 NEWPERFTICKCOUNTER(_perf_class_link_time, SUN_CLS, "classLinkedTime");
1324 NEWPERFTICKCOUNTER(_perf_class_link_selftime, SUN_CLS, "classLinkedTime.self");
1325 NEWPERFEVENTCOUNTER(_perf_classes_inited, SUN_CLS, "initializedClasses");
1326 NEWPERFEVENTCOUNTER(_perf_classes_linked, SUN_CLS, "linkedClasses");
1327 NEWPERFEVENTCOUNTER(_perf_classes_verified, SUN_CLS, "verifiedClasses");
1328
1329 NEWPERFTICKCOUNTER(_perf_shared_classload_time, SUN_CLS, "sharedClassLoadTime");
1330 NEWPERFTICKCOUNTER(_perf_sys_classload_time, SUN_CLS, "sysClassLoadTime");
1331 NEWPERFTICKCOUNTER(_perf_app_classload_time, SUN_CLS, "appClassLoadTime");
1332 NEWPERFTICKCOUNTER(_perf_app_classload_selftime, SUN_CLS, "appClassLoadTime.self");
1333 NEWPERFEVENTCOUNTER(_perf_app_classload_count, SUN_CLS, "appClassLoadCount");
1334 NEWPERFTICKCOUNTER(_perf_define_appclasses, SUN_CLS, "defineAppClasses");
1335 NEWPERFTICKCOUNTER(_perf_define_appclass_time, SUN_CLS, "defineAppClassTime");
1336 NEWPERFTICKCOUNTER(_perf_define_appclass_selftime, SUN_CLS, "defineAppClassTime.self");
1337 NEWPERFBYTECOUNTER(_perf_app_classfile_bytes_read, SUN_CLS, "appClassBytes");
1338 NEWPERFBYTECOUNTER(_perf_sys_classfile_bytes_read, SUN_CLS, "sysClassBytes");
1339
1340 NEWPERFEVENTCOUNTER(_unsafe_defineClassCallCounter, SUN_CLS, "unsafeDefineClassCalls");
1341 NEWPERFTICKCOUNTER(_perf_secondary_hash_time, SUN_CLS, "secondarySuperHashTime");
1342 }
1343
1344 // lookup java library entry points
1345 load_java_library();
1346 // jimage library entry points are loaded below, in lookup_vm_options
1347 setup_bootstrap_search_path(THREAD);
1348 }
1349
1350 static char* lookup_vm_resource(JImageFile *jimage, const char *jimage_version, const char *path) {
1351 jlong size;
1352 JImageLocationRef location = (*JImageFindResource)(jimage, "java.base", jimage_version, path, &size);
1353 if (location == 0)
1354 return nullptr;
1355 char *val = NEW_C_HEAP_ARRAY(char, size+1, mtClass);
1356 (*JImageGetResource)(jimage, location, val, size);
1357 val[size] = '\0';
1358 return val;
1359 }
1360
1361 // Lookup VM options embedded in the modules jimage file
1408
1409 // Helper function used by CDS code to get the number of module path
1410 // entries during shared classpath setup time.
1411 int ClassLoader::num_module_path_entries() {
1412 assert(CDSConfig::is_dumping_archive(), "sanity");
1413 int num_entries = 0;
1414 ClassPathEntry* e= ClassLoader::_module_path_entries;
1415 while (e != nullptr) {
1416 num_entries ++;
1417 e = e->next();
1418 }
1419 return num_entries;
1420 }
1421 #endif
1422
1423 jlong ClassLoader::classloader_time_ms() {
1424 return UsePerfData ?
1425 Management::ticks_to_ms(_perf_accumulated_time->get_value()) : -1;
1426 }
1427
1428 jlong ClassLoader::class_init_count() {
1429 return UsePerfData ? _perf_classes_inited->get_value() : -1;
1430 }
1431
1432 jlong ClassLoader::class_init_time_ms() {
1433 return UsePerfData ?
1434 Management::ticks_to_ms(_perf_class_init_time->get_value()) : -1;
1435 }
1436
1437 jlong ClassLoader::class_verify_time_ms() {
1438 return UsePerfData ?
1439 Management::ticks_to_ms(_perf_class_verify_time->get_value()) : -1;
1440 }
1441
1442 jlong ClassLoader::class_link_count() {
1443 return UsePerfData ? _perf_classes_linked->get_value() : -1;
1444 }
1445
1446 jlong ClassLoader::class_link_time_ms() {
1447 return UsePerfData ?
|
51 #include "logging/logTag.hpp"
52 #include "memory/allocation.inline.hpp"
53 #include "memory/oopFactory.hpp"
54 #include "memory/resourceArea.hpp"
55 #include "memory/universe.hpp"
56 #include "oops/instanceKlass.hpp"
57 #include "oops/instanceRefKlass.hpp"
58 #include "oops/klass.inline.hpp"
59 #include "oops/method.inline.hpp"
60 #include "oops/objArrayOop.inline.hpp"
61 #include "oops/oop.inline.hpp"
62 #include "oops/symbol.hpp"
63 #include "prims/jvm_misc.hpp"
64 #include "runtime/arguments.hpp"
65 #include "runtime/handles.inline.hpp"
66 #include "runtime/init.hpp"
67 #include "runtime/interfaceSupport.inline.hpp"
68 #include "runtime/java.hpp"
69 #include "runtime/javaCalls.hpp"
70 #include "runtime/os.hpp"
71 #include "runtime/perfData.inline.hpp"
72 #include "runtime/threadCritical.hpp"
73 #include "runtime/timer.hpp"
74 #include "runtime/vm_version.hpp"
75 #include "services/management.hpp"
76 #include "services/threadService.hpp"
77 #include "utilities/checkedCast.hpp"
78 #include "utilities/classpathStream.hpp"
79 #include "utilities/events.hpp"
80 #include "utilities/macros.hpp"
81 #include "utilities/utf8.hpp"
82
83 // Entry point in java.dll for path canonicalization
84
85 typedef int (*canonicalize_fn_t)(const char *orig, char *out, int len);
86
87 static canonicalize_fn_t CanonicalizeEntry = nullptr;
88
89 // Entry points for jimage.dll for loading jimage file entries
90
91 static JImageOpen_t JImageOpen = nullptr;
92 static JImageClose_t JImageClose = nullptr;
93 static JImageFindResource_t JImageFindResource = nullptr;
94 static JImageGetResource_t JImageGetResource = nullptr;
95
96 // JimageFile pointer, or null if exploded JDK build.
97 static JImageFile* JImage_file = nullptr;
98
99 // Globals
100
101 PerfCounter* ClassLoader::_perf_accumulated_time = nullptr;
102 PerfCounter* ClassLoader::_perf_classes_inited = nullptr;
103 PerfCounter* ClassLoader::_perf_class_init_time = nullptr;
104 PerfCounter* ClassLoader::_perf_class_init_selftime = nullptr;
105 PerfCounter* ClassLoader::_perf_class_init_bytecodes_count = nullptr;
106 PerfCounter* ClassLoader::_perf_classes_verified = nullptr;
107 PerfCounter* ClassLoader::_perf_class_verify_time = nullptr;
108 PerfCounter* ClassLoader::_perf_class_verify_selftime = nullptr;
109 PerfCounter* ClassLoader::_perf_classes_linked = nullptr;
110 PerfCounter* ClassLoader::_perf_class_link_time = nullptr;
111 PerfCounter* ClassLoader::_perf_class_link_selftime = nullptr;
112 PerfCounter* ClassLoader::_perf_shared_classload_time = nullptr;
113 PerfCounter* ClassLoader::_perf_sys_classload_time = nullptr;
114 PerfCounter* ClassLoader::_perf_app_classload_time = nullptr;
115 PerfCounter* ClassLoader::_perf_app_classload_selftime = nullptr;
116 PerfCounter* ClassLoader::_perf_app_classload_count = nullptr;
117 PerfCounter* ClassLoader::_perf_define_appclasses = nullptr;
118 PerfCounter* ClassLoader::_perf_define_appclass_time = nullptr;
119 PerfCounter* ClassLoader::_perf_define_appclass_selftime = nullptr;
120 PerfCounter* ClassLoader::_perf_app_classfile_bytes_read = nullptr;
121 PerfCounter* ClassLoader::_perf_sys_classfile_bytes_read = nullptr;
122 PerfCounter* ClassLoader::_perf_preload_total_time = nullptr;
123 PerfCounter* ClassLoader::_perf_preload_time = nullptr;
124 PerfCounter* ClassLoader::_perf_prelink_time = nullptr;
125 PerfCounter* ClassLoader::_perf_preinit_time = nullptr;
126 PerfCounter* ClassLoader::_perf_preresolve_time = nullptr;
127 PerfCounter* ClassLoader::_perf_ik_link_methods_time = nullptr;
128 PerfCounter* ClassLoader::_perf_method_adapters_time = nullptr;
129 PerfCounter* ClassLoader::_perf_ik_link_methods_count = nullptr;
130 PerfCounter* ClassLoader::_perf_method_adapters_count = nullptr;
131 PerfCounter* ClassLoader::_unsafe_defineClassCallCounter = nullptr;
132 PerfCounter* ClassLoader::_perf_secondary_hash_time = nullptr;
133
134 PerfTickCounters* ClassLoader::_perf_resolve_indy_time = nullptr;
135 PerfTickCounters* ClassLoader::_perf_resolve_invokehandle_time = nullptr;
136 PerfTickCounters* ClassLoader::_perf_resolve_mh_time = nullptr;
137 PerfTickCounters* ClassLoader::_perf_resolve_mt_time = nullptr;
138
139 PerfCounter* ClassLoader::_perf_resolve_indy_count = nullptr;
140 PerfCounter* ClassLoader::_perf_resolve_invokehandle_count = nullptr;
141 PerfCounter* ClassLoader::_perf_resolve_mh_count = nullptr;
142 PerfCounter* ClassLoader::_perf_resolve_mt_count = nullptr;
143
144 void ClassLoader::print_counters() {
145 if (UsePerfData) {
146 LogStreamHandle(Info, init) log;
147 if (log.is_enabled()) {
148 log.print_cr("ClassLoader:");
149 log.print( " clinit: %ldms / %ld events",
150 ClassLoader::class_init_time_ms(), ClassLoader::class_init_count());
151 if (CountBytecodes || CountBytecodesPerThread) {
152 log.print("; executed %ld bytecodes", ClassLoader::class_init_bytecodes_count());
153 }
154 log.cr();
155 log.print_cr(" resolve...");
156 log.print_cr(" invokedynamic: %ldms (elapsed) %ldms (thread) / %ld events",
157 _perf_resolve_indy_time->elapsed_counter_value_ms(),
158 _perf_resolve_indy_time->thread_counter_value_ms(),
159 _perf_resolve_indy_count->get_value());
160 log.print_cr(" invokehandle: %ldms (elapsed) %ldms (thread) / %ld events",
161 _perf_resolve_invokehandle_time->elapsed_counter_value_ms(),
162 _perf_resolve_invokehandle_time->thread_counter_value_ms(),
163 _perf_resolve_invokehandle_count->get_value());
164 log.print_cr(" CP_MethodHandle: %ldms (elapsed) %ldms (thread) / %ld events",
165 _perf_resolve_mh_time->elapsed_counter_value_ms(),
166 _perf_resolve_mh_time->thread_counter_value_ms(),
167 _perf_resolve_mh_count->get_value());
168 log.print_cr(" CP_MethodType: %ldms (elapsed) %ldms (thread) / %ld events",
169 _perf_resolve_mt_time->elapsed_counter_value_ms(),
170 _perf_resolve_mt_time->thread_counter_value_ms(),
171 _perf_resolve_mt_count->get_value());
172 }
173 }
174 }
175
176 GrowableArray<ModuleClassPathList*>* ClassLoader::_patch_mod_entries = nullptr;
177 GrowableArray<ModuleClassPathList*>* ClassLoader::_exploded_entries = nullptr;
178 ClassPathEntry* ClassLoader::_jrt_entry = nullptr;
179
180 ClassPathEntry* volatile ClassLoader::_first_append_entry_list = nullptr;
181 ClassPathEntry* volatile ClassLoader::_last_append_entry = nullptr;
182 #if INCLUDE_CDS
183 ClassPathEntry* ClassLoader::_app_classpath_entries = nullptr;
184 ClassPathEntry* ClassLoader::_last_app_classpath_entry = nullptr;
185 ClassPathEntry* ClassLoader::_module_path_entries = nullptr;
186 ClassPathEntry* ClassLoader::_last_module_path_entry = nullptr;
187 #endif
188
189 // helper routines
190 #if INCLUDE_CDS
191 static bool string_starts_with(const char* str, const char* str_to_find) {
192 size_t str_len = strlen(str);
193 size_t str_to_find_len = strlen(str_to_find);
194 if (str_to_find_len > str_len) {
195 return false;
307 #ifdef ASSERT
308 // Freeing path is a no-op here as buffer prevents it from being reclaimed. But we keep it for
309 // debug builds so that we guard against use-after-free bugs.
310 FREE_RESOURCE_ARRAY_IN_THREAD(current, char, path, path_len);
311 #endif
312 // We don't verify the length of the classfile stream fits in an int, but this is the
313 // bootloader so we have control of this.
314 // Resource allocated
315 return new ClassFileStream(buffer,
316 checked_cast<int>(st.st_size),
317 _dir,
318 ClassFileStream::verify);
319 }
320 }
321 }
322 FREE_RESOURCE_ARRAY_IN_THREAD(current, char, path, path_len);
323 return nullptr;
324 }
325
326 ClassPathZipEntry::ClassPathZipEntry(jzfile* zip, const char* zip_name,
327 bool from_class_path_attr) : ClassPathEntry() {
328 _zip = zip;
329 _zip_name = copy_path(zip_name);
330 _from_class_path_attr = from_class_path_attr;
331 }
332
333 ClassPathZipEntry::~ClassPathZipEntry() {
334 ZipLibrary::close(_zip);
335 FREE_C_HEAP_ARRAY(char, _zip_name);
336 }
337
338 bool ClassPathZipEntry::has_entry(JavaThread* current, const char* name) {
339 ThreadToNativeFromVM ttn(current);
340 // check whether zip archive contains name
341 jint name_len;
342 jint filesize;
343 jzentry* entry = ZipLibrary::find_entry(_zip, name, &filesize, &name_len);
344 if (entry == nullptr) {
345 return false;
346 } else {
347 ZipLibrary::free_entry(_zip, entry);
348 return true;
349 }
350 }
351
352 u1* ClassPathZipEntry::open_entry(JavaThread* current, const char* name, jint* filesize, bool nul_terminate) {
353 // enable call to C land
354 ThreadToNativeFromVM ttn(current);
355 // check whether zip archive contains name
356 jint name_len;
357 jzentry* entry = ZipLibrary::find_entry(_zip, name, filesize, &name_len);
358 if (entry == nullptr) return nullptr;
359 u1* buffer;
360 char name_buf[128];
361 char* filename;
362 if (name_len < 128) {
363 filename = name_buf;
364 } else {
365 filename = NEW_RESOURCE_ARRAY(char, name_len + 1);
366 }
367
368 // read contents into resource array
369 size_t size = (uint32_t)(*filesize);
370 if (nul_terminate) {
371 if (sizeof(size) == sizeof(uint32_t) && size == UINT_MAX) {
372 return nullptr; // 32-bit integer overflow will occur.
373 }
374 size++;
375 }
376
377 // ZIP_ReadEntry also frees zentry
378 buffer = NEW_RESOURCE_ARRAY(u1, size);
379 if (!ZipLibrary::read_entry(_zip, entry, buffer, filename)) {
380 return nullptr;
381 }
382
383 // return result
384 if (nul_terminate) {
385 buffer[size - 1] = 0;
386 }
387 return buffer;
388 }
389
390 ClassFileStream* ClassPathZipEntry::open_stream(JavaThread* current, const char* name) {
391 jint filesize;
392 u1* buffer = open_entry(current, name, &filesize, false);
393 if (buffer == nullptr) {
394 return nullptr;
395 }
396 if (UsePerfData) {
397 ClassLoader::perf_sys_classfile_bytes_read()->inc(filesize);
783 HandleMark hm(thread);
784 return ZipLibrary::open(canonical_path, error_msg);
785 }
786
787 ClassPathEntry* ClassLoader::create_class_path_entry(JavaThread* current,
788 const char *path, const struct stat* st,
789 bool is_boot_append,
790 bool from_class_path_attr) {
791 ClassPathEntry* new_entry = nullptr;
792 if ((st->st_mode & S_IFMT) == S_IFREG) {
793 ResourceMark rm(current);
794 // Regular file, should be a zip file
795 // Canonicalized filename
796 const char* canonical_path = get_canonical_path(path, current);
797 if (canonical_path == nullptr) {
798 return nullptr;
799 }
800 char* error_msg = nullptr;
801 jzfile* zip = open_zip_file(canonical_path, &error_msg, current);
802 if (zip != nullptr && error_msg == nullptr) {
803 new_entry = new ClassPathZipEntry(zip, path, from_class_path_attr);
804 } else {
805 #if INCLUDE_CDS
806 ClassLoaderExt::set_has_non_jar_in_classpath();
807 #endif
808 return nullptr;
809 }
810 log_info(class, path)("opened: %s", path);
811 log_info(class, load)("opened: %s", path);
812 } else {
813 // Directory
814 new_entry = new ClassPathDirEntry(path);
815 log_info(class, load)("path: %s", path);
816 }
817 return new_entry;
818 }
819
820
821 // Create a class path zip entry for a given path (return null if not found
822 // or zip/JAR file cannot be opened)
823 ClassPathZipEntry* ClassLoader::create_class_path_zip_entry(const char *path) {
824 // check for a regular file
825 struct stat st;
826 if (os::stat(path, &st) == 0) {
827 if ((st.st_mode & S_IFMT) == S_IFREG) {
828 JavaThread* thread = JavaThread::current();
829 ResourceMark rm(thread);
830 const char* canonical_path = get_canonical_path(path, thread);
831 if (canonical_path != nullptr) {
832 char* error_msg = nullptr;
833 jzfile* zip = open_zip_file(canonical_path, &error_msg, thread);
834 if (zip != nullptr && error_msg == nullptr) {
835 // create using canonical path
836 return new ClassPathZipEntry(zip, canonical_path, false);
837 }
838 }
839 }
840 }
841 return nullptr;
842 }
843
844 // The boot append entries are added with a lock, and read lock free.
845 void ClassLoader::add_to_boot_append_entries(ClassPathEntry *new_entry) {
846 if (new_entry != nullptr) {
847 MutexLocker ml(Bootclasspath_lock, Mutex::_no_safepoint_check_flag);
848 if (_last_append_entry == nullptr) {
849 _last_append_entry = new_entry;
850 assert(first_append_entry() == nullptr, "boot loader's append class path entry list not empty");
851 Atomic::release_store(&_first_append_entry_list, new_entry);
852 } else {
853 _last_append_entry->set_next(new_entry);
854 _last_append_entry = new_entry;
855 }
856 }
1376 #endif // INCLUDE_CDS
1377
1378 // Initialize the class loader's access to methods in libzip. Parse and
1379 // process the boot classpath into a list ClassPathEntry objects. Once
1380 // this list has been created, it must not change order (see class PackageInfo)
1381 // it can be appended to and is by jvmti.
1382
1383 void ClassLoader::initialize(TRAPS) {
1384 if (UsePerfData) {
1385 // jvmstat performance counters
1386 NEWPERFTICKCOUNTER(_perf_accumulated_time, SUN_CLS, "time");
1387 NEWPERFTICKCOUNTER(_perf_class_init_time, SUN_CLS, "classInitTime");
1388 NEWPERFTICKCOUNTER(_perf_class_init_selftime, SUN_CLS, "classInitTime.self");
1389 NEWPERFTICKCOUNTER(_perf_class_verify_time, SUN_CLS, "classVerifyTime");
1390 NEWPERFTICKCOUNTER(_perf_class_verify_selftime, SUN_CLS, "classVerifyTime.self");
1391 NEWPERFTICKCOUNTER(_perf_class_link_time, SUN_CLS, "classLinkedTime");
1392 NEWPERFTICKCOUNTER(_perf_class_link_selftime, SUN_CLS, "classLinkedTime.self");
1393 NEWPERFEVENTCOUNTER(_perf_classes_inited, SUN_CLS, "initializedClasses");
1394 NEWPERFEVENTCOUNTER(_perf_classes_linked, SUN_CLS, "linkedClasses");
1395 NEWPERFEVENTCOUNTER(_perf_classes_verified, SUN_CLS, "verifiedClasses");
1396 NEWPERFEVENTCOUNTER(_perf_class_init_bytecodes_count, SUN_CLS, "clinitBytecodesCount");
1397
1398 NEWPERFTICKCOUNTER(_perf_shared_classload_time, SUN_CLS, "sharedClassLoadTime");
1399 NEWPERFTICKCOUNTER(_perf_sys_classload_time, SUN_CLS, "sysClassLoadTime");
1400 NEWPERFTICKCOUNTER(_perf_app_classload_time, SUN_CLS, "appClassLoadTime");
1401 NEWPERFTICKCOUNTER(_perf_app_classload_selftime, SUN_CLS, "appClassLoadTime.self");
1402 NEWPERFEVENTCOUNTER(_perf_app_classload_count, SUN_CLS, "appClassLoadCount");
1403 NEWPERFTICKCOUNTER(_perf_define_appclasses, SUN_CLS, "defineAppClasses");
1404 NEWPERFTICKCOUNTER(_perf_define_appclass_time, SUN_CLS, "defineAppClassTime");
1405 NEWPERFTICKCOUNTER(_perf_define_appclass_selftime, SUN_CLS, "defineAppClassTime.self");
1406 NEWPERFBYTECOUNTER(_perf_app_classfile_bytes_read, SUN_CLS, "appClassBytes");
1407 NEWPERFBYTECOUNTER(_perf_sys_classfile_bytes_read, SUN_CLS, "sysClassBytes");
1408
1409 NEWPERFEVENTCOUNTER(_unsafe_defineClassCallCounter, SUN_CLS, "unsafeDefineClassCalls");
1410 NEWPERFTICKCOUNTER(_perf_secondary_hash_time, SUN_CLS, "secondarySuperHashTime");
1411
1412 NEWPERFTICKCOUNTER(_perf_preload_total_time, SUN_CLS, "preloadTotalTime");
1413 NEWPERFTICKCOUNTER(_perf_preload_time, SUN_CLS, "preloadTime");
1414 NEWPERFTICKCOUNTER(_perf_prelink_time, SUN_CLS, "prelinkTime");
1415 NEWPERFTICKCOUNTER(_perf_preinit_time, SUN_CLS, "preinitTime");
1416 NEWPERFTICKCOUNTER(_perf_preresolve_time, SUN_CLS, "preresolveTime");
1417
1418 NEWPERFTICKCOUNTER(_perf_ik_link_methods_time, SUN_CLS, "linkMethodsTime");
1419 NEWPERFTICKCOUNTER(_perf_method_adapters_time, SUN_CLS, "makeAdaptersTime");
1420 NEWPERFEVENTCOUNTER(_perf_ik_link_methods_count, SUN_CLS, "linkMethodsCount");
1421 NEWPERFEVENTCOUNTER(_perf_method_adapters_count, SUN_CLS, "makeAdaptersCount");
1422
1423 NEWPERFTICKCOUNTERS(_perf_resolve_indy_time, SUN_CLS, "resolve_invokedynamic");
1424 NEWPERFTICKCOUNTERS(_perf_resolve_invokehandle_time, SUN_CLS, "resolve_invokehandle");
1425 NEWPERFTICKCOUNTERS(_perf_resolve_mh_time, SUN_CLS, "resolve_MethodHandle");
1426 NEWPERFTICKCOUNTERS(_perf_resolve_mt_time, SUN_CLS, "resolve_MethodType");
1427
1428 NEWPERFEVENTCOUNTER(_perf_resolve_indy_count, SUN_CLS, "resolve_invokedynamic_count");
1429 NEWPERFEVENTCOUNTER(_perf_resolve_invokehandle_count, SUN_CLS, "resolve_invokehandle_count");
1430 NEWPERFEVENTCOUNTER(_perf_resolve_mh_count, SUN_CLS, "resolve_MethodHandle_count");
1431 NEWPERFEVENTCOUNTER(_perf_resolve_mt_count, SUN_CLS, "resolve_MethodType_count");
1432 }
1433
1434 // lookup java library entry points
1435 load_java_library();
1436 // jimage library entry points are loaded below, in lookup_vm_options
1437 setup_bootstrap_search_path(THREAD);
1438 }
1439
1440 static char* lookup_vm_resource(JImageFile *jimage, const char *jimage_version, const char *path) {
1441 jlong size;
1442 JImageLocationRef location = (*JImageFindResource)(jimage, "java.base", jimage_version, path, &size);
1443 if (location == 0)
1444 return nullptr;
1445 char *val = NEW_C_HEAP_ARRAY(char, size+1, mtClass);
1446 (*JImageGetResource)(jimage, location, val, size);
1447 val[size] = '\0';
1448 return val;
1449 }
1450
1451 // Lookup VM options embedded in the modules jimage file
1498
1499 // Helper function used by CDS code to get the number of module path
1500 // entries during shared classpath setup time.
1501 int ClassLoader::num_module_path_entries() {
1502 assert(CDSConfig::is_dumping_archive(), "sanity");
1503 int num_entries = 0;
1504 ClassPathEntry* e= ClassLoader::_module_path_entries;
1505 while (e != nullptr) {
1506 num_entries ++;
1507 e = e->next();
1508 }
1509 return num_entries;
1510 }
1511 #endif
1512
1513 jlong ClassLoader::classloader_time_ms() {
1514 return UsePerfData ?
1515 Management::ticks_to_ms(_perf_accumulated_time->get_value()) : -1;
1516 }
1517
1518 jlong ClassLoader::class_init_bytecodes_count() {
1519 return UsePerfData ? _perf_class_init_bytecodes_count->get_value() : -1;
1520 }
1521
1522 jlong ClassLoader::class_init_count() {
1523 return UsePerfData ? _perf_classes_inited->get_value() : -1;
1524 }
1525
1526 jlong ClassLoader::class_init_time_ms() {
1527 return UsePerfData ?
1528 Management::ticks_to_ms(_perf_class_init_time->get_value()) : -1;
1529 }
1530
1531 jlong ClassLoader::class_verify_time_ms() {
1532 return UsePerfData ?
1533 Management::ticks_to_ms(_perf_class_verify_time->get_value()) : -1;
1534 }
1535
1536 jlong ClassLoader::class_link_count() {
1537 return UsePerfData ? _perf_classes_linked->get_value() : -1;
1538 }
1539
1540 jlong ClassLoader::class_link_time_ms() {
1541 return UsePerfData ?
|