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/ostream.hpp"
82 #include "utilities/utf8.hpp"
83
84 // Entry point in java.dll for path canonicalization
85
86 typedef int (*canonicalize_fn_t)(const char *orig, char *out, int len);
87
88 static canonicalize_fn_t CanonicalizeEntry = nullptr;
89
90 // Entry points for jimage.dll for loading jimage file entries
91
92 static JImageOpen_t JImageOpen = nullptr;
93 static JImageClose_t JImageClose = nullptr;
94 static JImageFindResource_t JImageFindResource = nullptr;
95 static JImageGetResource_t JImageGetResource = nullptr;
96
97 // JimageFile pointer, or null if exploded JDK build.
98 static JImageFile* JImage_file = nullptr;
99
100 // Globals
101
102 PerfCounter* ClassLoader::_perf_accumulated_time = nullptr;
103 PerfCounter* ClassLoader::_perf_classes_inited = nullptr;
104 PerfCounter* ClassLoader::_perf_class_init_time = nullptr;
105 PerfCounter* ClassLoader::_perf_class_init_selftime = 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_ik_link_methods_time = nullptr;
123 PerfCounter* ClassLoader::_perf_method_adapters_time = nullptr;
124 PerfCounter* ClassLoader::_perf_ik_link_methods_count = nullptr;
125 PerfCounter* ClassLoader::_perf_method_adapters_count = nullptr;
126 PerfCounter* ClassLoader::_unsafe_defineClassCallCounter = nullptr;
127 PerfCounter* ClassLoader::_perf_secondary_hash_time = nullptr;
128
129 PerfCounter* ClassLoader::_perf_resolve_indy_time = nullptr;
130 PerfCounter* ClassLoader::_perf_resolve_invokehandle_time = nullptr;
131 PerfCounter* ClassLoader::_perf_resolve_mh_time = nullptr;
132 PerfCounter* ClassLoader::_perf_resolve_mt_time = nullptr;
133
134 PerfCounter* ClassLoader::_perf_resolve_indy_count = nullptr;
135 PerfCounter* ClassLoader::_perf_resolve_invokehandle_count = nullptr;
136 PerfCounter* ClassLoader::_perf_resolve_mh_count = nullptr;
137 PerfCounter* ClassLoader::_perf_resolve_mt_count = nullptr;
138
139 void ClassLoader::print_counters(outputStream *st) {
140 // The counters are only active if the logging is enabled, but
141 // we print to the passed in outputStream as requested.
142 if (log_is_enabled(Info, perf, class, link)) {
143 st->print_cr("ClassLoader:");
144 st->print_cr(" clinit: " JLONG_FORMAT "ms / " JLONG_FORMAT " events", ClassLoader::class_init_time_ms(), ClassLoader::class_init_count());
145 st->print_cr(" link methods: " JLONG_FORMAT "ms / " JLONG_FORMAT " events", Management::ticks_to_ms(_perf_ik_link_methods_time->get_value()) , _perf_ik_link_methods_count->get_value());
146 st->print_cr(" method adapters: " JLONG_FORMAT "ms / " JLONG_FORMAT " events", Management::ticks_to_ms(_perf_method_adapters_time->get_value()) , _perf_method_adapters_count->get_value());
147 st->print_cr(" resolve...");
148 st->print_cr(" invokedynamic: " JLONG_FORMAT "ms / " JLONG_FORMAT " events", Management::ticks_to_ms(_perf_resolve_indy_time->get_value()) , _perf_resolve_indy_count->get_value());
149 st->print_cr(" invokehandle: " JLONG_FORMAT "ms / " JLONG_FORMAT " events", Management::ticks_to_ms(_perf_resolve_invokehandle_time->get_value()) , _perf_resolve_invokehandle_count->get_value());
150 st->print_cr(" CP_MethodHandle: " JLONG_FORMAT "ms / " JLONG_FORMAT " events", Management::ticks_to_ms(_perf_resolve_mh_time->get_value()) , _perf_resolve_mh_count->get_value());
151 st->print_cr(" CP_MethodType: " JLONG_FORMAT "ms / " JLONG_FORMAT " events", Management::ticks_to_ms(_perf_resolve_mt_time->get_value()) , _perf_resolve_mt_count->get_value());
152 st->cr();
153 }
154 }
155
156 GrowableArray<ModuleClassPathList*>* ClassLoader::_patch_mod_entries = nullptr;
157 GrowableArray<ModuleClassPathList*>* ClassLoader::_exploded_entries = nullptr;
158 ClassPathEntry* ClassLoader::_jrt_entry = nullptr;
159
160 ClassPathEntry* volatile ClassLoader::_first_append_entry_list = nullptr;
161 ClassPathEntry* volatile ClassLoader::_last_append_entry = nullptr;
162 #if INCLUDE_CDS
163 ClassPathEntry* ClassLoader::_app_classpath_entries = nullptr;
164 ClassPathEntry* ClassLoader::_last_app_classpath_entry = nullptr;
165 ClassPathEntry* ClassLoader::_module_path_entries = nullptr;
166 ClassPathEntry* ClassLoader::_last_module_path_entry = nullptr;
167 #endif
168
169 // helper routines
170 #if INCLUDE_CDS
171 static bool string_starts_with(const char* str, const char* str_to_find) {
172 size_t str_len = strlen(str);
287 #ifdef ASSERT
288 // Freeing path is a no-op here as buffer prevents it from being reclaimed. But we keep it for
289 // debug builds so that we guard against use-after-free bugs.
290 FREE_RESOURCE_ARRAY_IN_THREAD(current, char, path, path_len);
291 #endif
292 // We don't verify the length of the classfile stream fits in an int, but this is the
293 // bootloader so we have control of this.
294 // Resource allocated
295 return new ClassFileStream(buffer,
296 checked_cast<int>(st.st_size),
297 _dir,
298 ClassFileStream::verify);
299 }
300 }
301 }
302 FREE_RESOURCE_ARRAY_IN_THREAD(current, char, path, path_len);
303 return nullptr;
304 }
305
306 ClassPathZipEntry::ClassPathZipEntry(jzfile* zip, const char* zip_name,
307 bool is_boot_append, bool from_class_path_attr) : ClassPathEntry() {
308 _zip = zip;
309 _zip_name = copy_path(zip_name);
310 _from_class_path_attr = from_class_path_attr;
311 }
312
313 ClassPathZipEntry::~ClassPathZipEntry() {
314 ZipLibrary::close(_zip);
315 FREE_C_HEAP_ARRAY(char, _zip_name);
316 }
317
318 u1* ClassPathZipEntry::open_entry(JavaThread* current, const char* name, jint* filesize, bool nul_terminate) {
319 // enable call to C land
320 ThreadToNativeFromVM ttn(current);
321 // check whether zip archive contains name
322 jint name_len;
323 jzentry* entry = ZipLibrary::find_entry(_zip, name, filesize, &name_len);
324 if (entry == nullptr) return nullptr;
325 u1* buffer;
326 char name_buf[128];
327 char* filename;
328 if (name_len < 128) {
329 filename = name_buf;
330 } else {
331 filename = NEW_RESOURCE_ARRAY(char, name_len + 1);
332 }
333
334 // read contents into resource array
335 size_t size = (uint32_t)(*filesize);
336 if (nul_terminate) {
337 if (sizeof(size) == sizeof(uint32_t) && size == UINT_MAX) {
338 return nullptr; // 32-bit integer overflow will occur.
339 }
340 size++;
341 }
342 buffer = NEW_RESOURCE_ARRAY(u1, size);
343 if (!ZipLibrary::read_entry(_zip, entry, buffer, filename)) {
344 return nullptr;
345 }
346
347 // return result
348 if (nul_terminate) {
349 buffer[size - 1] = 0;
350 }
351 return buffer;
352 }
353
354 ClassFileStream* ClassPathZipEntry::open_stream(JavaThread* current, const char* name) {
355 jint filesize;
356 u1* buffer = open_entry(current, name, &filesize, false);
357 if (buffer == nullptr) {
358 return nullptr;
359 }
360 if (UsePerfData) {
361 ClassLoader::perf_sys_classfile_bytes_read()->inc(filesize);
747 HandleMark hm(thread);
748 return ZipLibrary::open(canonical_path, error_msg);
749 }
750
751 ClassPathEntry* ClassLoader::create_class_path_entry(JavaThread* current,
752 const char *path, const struct stat* st,
753 bool is_boot_append,
754 bool from_class_path_attr) {
755 ClassPathEntry* new_entry = nullptr;
756 if ((st->st_mode & S_IFMT) == S_IFREG) {
757 ResourceMark rm(current);
758 // Regular file, should be a zip file
759 // Canonicalized filename
760 const char* canonical_path = get_canonical_path(path, current);
761 if (canonical_path == nullptr) {
762 return nullptr;
763 }
764 char* error_msg = nullptr;
765 jzfile* zip = open_zip_file(canonical_path, &error_msg, current);
766 if (zip != nullptr && error_msg == nullptr) {
767 new_entry = new ClassPathZipEntry(zip, path, is_boot_append, from_class_path_attr);
768 } else {
769 #if INCLUDE_CDS
770 ClassLoaderExt::set_has_non_jar_in_classpath();
771 #endif
772 return nullptr;
773 }
774 log_info(class, path)("opened: %s", path);
775 log_info(class, load)("opened: %s", path);
776 } else {
777 // Directory
778 new_entry = new ClassPathDirEntry(path);
779 log_info(class, load)("path: %s", path);
780 }
781 return new_entry;
782 }
783
784
785 // Create a class path zip entry for a given path (return null if not found
786 // or zip/JAR file cannot be opened)
787 ClassPathZipEntry* ClassLoader::create_class_path_zip_entry(const char *path, bool is_boot_append) {
788 // check for a regular file
789 struct stat st;
790 if (os::stat(path, &st) == 0) {
791 if ((st.st_mode & S_IFMT) == S_IFREG) {
792 JavaThread* thread = JavaThread::current();
793 ResourceMark rm(thread);
794 const char* canonical_path = get_canonical_path(path, thread);
795 if (canonical_path != nullptr) {
796 char* error_msg = nullptr;
797 jzfile* zip = open_zip_file(canonical_path, &error_msg, thread);
798 if (zip != nullptr && error_msg == nullptr) {
799 // create using canonical path
800 return new ClassPathZipEntry(zip, canonical_path, is_boot_append, false);
801 }
802 }
803 }
804 }
805 return nullptr;
806 }
807
808 // The boot append entries are added with a lock, and read lock free.
809 void ClassLoader::add_to_boot_append_entries(ClassPathEntry *new_entry) {
810 if (new_entry != nullptr) {
811 MutexLocker ml(Bootclasspath_lock, Mutex::_no_safepoint_check_flag);
812 if (_last_append_entry == nullptr) {
813 _last_append_entry = new_entry;
814 assert(first_append_entry() == nullptr, "boot loader's append class path entry list not empty");
815 Atomic::release_store(&_first_append_entry_list, new_entry);
816 } else {
817 _last_append_entry->set_next(new_entry);
818 _last_append_entry = new_entry;
819 }
820 }
1340 #endif // INCLUDE_CDS
1341
1342 // Initialize the class loader's access to methods in libzip. Parse and
1343 // process the boot classpath into a list ClassPathEntry objects. Once
1344 // this list has been created, it must not change order (see class PackageInfo)
1345 // it can be appended to and is by jvmti.
1346
1347 void ClassLoader::initialize(TRAPS) {
1348 if (UsePerfData) {
1349 // jvmstat performance counters
1350 NEWPERFTICKCOUNTER(_perf_accumulated_time, SUN_CLS, "time");
1351 NEWPERFTICKCOUNTER(_perf_class_init_time, SUN_CLS, "classInitTime");
1352 NEWPERFTICKCOUNTER(_perf_class_init_selftime, SUN_CLS, "classInitTime.self");
1353 NEWPERFTICKCOUNTER(_perf_class_verify_time, SUN_CLS, "classVerifyTime");
1354 NEWPERFTICKCOUNTER(_perf_class_verify_selftime, SUN_CLS, "classVerifyTime.self");
1355 NEWPERFTICKCOUNTER(_perf_class_link_time, SUN_CLS, "classLinkedTime");
1356 NEWPERFTICKCOUNTER(_perf_class_link_selftime, SUN_CLS, "classLinkedTime.self");
1357 NEWPERFEVENTCOUNTER(_perf_classes_inited, SUN_CLS, "initializedClasses");
1358 NEWPERFEVENTCOUNTER(_perf_classes_linked, SUN_CLS, "linkedClasses");
1359 NEWPERFEVENTCOUNTER(_perf_classes_verified, SUN_CLS, "verifiedClasses");
1360
1361 NEWPERFTICKCOUNTER(_perf_shared_classload_time, SUN_CLS, "sharedClassLoadTime");
1362 NEWPERFTICKCOUNTER(_perf_sys_classload_time, SUN_CLS, "sysClassLoadTime");
1363 NEWPERFTICKCOUNTER(_perf_app_classload_time, SUN_CLS, "appClassLoadTime");
1364 NEWPERFTICKCOUNTER(_perf_app_classload_selftime, SUN_CLS, "appClassLoadTime.self");
1365 NEWPERFEVENTCOUNTER(_perf_app_classload_count, SUN_CLS, "appClassLoadCount");
1366 NEWPERFTICKCOUNTER(_perf_define_appclasses, SUN_CLS, "defineAppClasses");
1367 NEWPERFTICKCOUNTER(_perf_define_appclass_time, SUN_CLS, "defineAppClassTime");
1368 NEWPERFTICKCOUNTER(_perf_define_appclass_selftime, SUN_CLS, "defineAppClassTime.self");
1369 NEWPERFBYTECOUNTER(_perf_app_classfile_bytes_read, SUN_CLS, "appClassBytes");
1370 NEWPERFBYTECOUNTER(_perf_sys_classfile_bytes_read, SUN_CLS, "sysClassBytes");
1371 NEWPERFEVENTCOUNTER(_unsafe_defineClassCallCounter, SUN_CLS, "unsafeDefineClassCalls");
1372 NEWPERFTICKCOUNTER(_perf_secondary_hash_time, SUN_CLS, "secondarySuperHashTime");
1373
1374 if (log_is_enabled(Info, perf, class, link)) {
1375 NEWPERFTICKCOUNTER(_perf_ik_link_methods_time, SUN_CLS, "linkMethodsTime");
1376 NEWPERFTICKCOUNTER(_perf_method_adapters_time, SUN_CLS, "makeAdaptersTime");
1377 NEWPERFEVENTCOUNTER(_perf_ik_link_methods_count, SUN_CLS, "linkMethodsCount");
1378 NEWPERFEVENTCOUNTER(_perf_method_adapters_count, SUN_CLS, "makeAdaptersCount");
1379
1380 NEWPERFTICKCOUNTER(_perf_resolve_indy_time, SUN_CLS, "resolve_invokedynamic_time");
1381 NEWPERFTICKCOUNTER(_perf_resolve_invokehandle_time, SUN_CLS, "resolve_invokehandle_time");
1382 NEWPERFTICKCOUNTER(_perf_resolve_mh_time, SUN_CLS, "resolve_MethodHandle_time");
1383 NEWPERFTICKCOUNTER(_perf_resolve_mt_time, SUN_CLS, "resolve_MethodType_time");
1384
1385 NEWPERFEVENTCOUNTER(_perf_resolve_indy_count, SUN_CLS, "resolve_invokedynamic_count");
1386 NEWPERFEVENTCOUNTER(_perf_resolve_invokehandle_count, SUN_CLS, "resolve_invokehandle_count");
1387 NEWPERFEVENTCOUNTER(_perf_resolve_mh_count, SUN_CLS, "resolve_MethodHandle_count");
1388 NEWPERFEVENTCOUNTER(_perf_resolve_mt_count, SUN_CLS, "resolve_MethodType_count");
1389 }
1390 }
1391
1392 // lookup java library entry points
1393 load_java_library();
1394 // jimage library entry points are loaded below, in lookup_vm_options
1395 setup_bootstrap_search_path(THREAD);
1396 }
1397
1398 static char* lookup_vm_resource(JImageFile *jimage, const char *jimage_version, const char *path) {
1399 jlong size;
1400 JImageLocationRef location = (*JImageFindResource)(jimage, "java.base", jimage_version, path, &size);
1401 if (location == 0)
1402 return nullptr;
1403 char *val = NEW_C_HEAP_ARRAY(char, size+1, mtClass);
1456
1457 // Helper function used by CDS code to get the number of module path
1458 // entries during shared classpath setup time.
1459 int ClassLoader::num_module_path_entries() {
1460 assert(CDSConfig::is_dumping_archive(), "sanity");
1461 int num_entries = 0;
1462 ClassPathEntry* e= ClassLoader::_module_path_entries;
1463 while (e != nullptr) {
1464 num_entries ++;
1465 e = e->next();
1466 }
1467 return num_entries;
1468 }
1469 #endif
1470
1471 jlong ClassLoader::classloader_time_ms() {
1472 return UsePerfData ?
1473 Management::ticks_to_ms(_perf_accumulated_time->get_value()) : -1;
1474 }
1475
1476 jlong ClassLoader::class_init_count() {
1477 return UsePerfData ? _perf_classes_inited->get_value() : -1;
1478 }
1479
1480 jlong ClassLoader::class_init_time_ms() {
1481 return UsePerfData ?
1482 Management::ticks_to_ms(_perf_class_init_time->get_value()) : -1;
1483 }
1484
1485 jlong ClassLoader::class_verify_time_ms() {
1486 return UsePerfData ?
1487 Management::ticks_to_ms(_perf_class_verify_time->get_value()) : -1;
1488 }
1489
1490 jlong ClassLoader::class_link_count() {
1491 return UsePerfData ? _perf_classes_linked->get_value() : -1;
1492 }
1493
1494 jlong ClassLoader::class_link_time_ms() {
1495 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/ostream.hpp"
82 #include "utilities/utf8.hpp"
83
84 // Entry point in java.dll for path canonicalization
85
86 typedef int (*canonicalize_fn_t)(const char *orig, char *out, int len);
87
88 static canonicalize_fn_t CanonicalizeEntry = nullptr;
89
90 // Entry points for jimage.dll for loading jimage file entries
91
92 static JImageOpen_t JImageOpen = nullptr;
93 static JImageClose_t JImageClose = nullptr;
94 static JImageFindResource_t JImageFindResource = nullptr;
95 static JImageGetResource_t JImageGetResource = nullptr;
96
97 // JimageFile pointer, or null if exploded JDK build.
98 static JImageFile* JImage_file = nullptr;
99
100 // Globals
101
102 PerfCounter* ClassLoader::_perf_accumulated_time = nullptr;
103 PerfCounter* ClassLoader::_perf_classes_inited = nullptr;
104 PerfCounter* ClassLoader::_perf_class_init_time = nullptr;
105 PerfCounter* ClassLoader::_perf_class_init_selftime = nullptr;
106 PerfCounter* ClassLoader::_perf_class_init_bytecodes_count = nullptr;
107 PerfCounter* ClassLoader::_perf_classes_verified = nullptr;
108 PerfCounter* ClassLoader::_perf_class_verify_time = nullptr;
109 PerfCounter* ClassLoader::_perf_class_verify_selftime = nullptr;
110 PerfCounter* ClassLoader::_perf_classes_linked = nullptr;
111 PerfCounter* ClassLoader::_perf_class_link_time = nullptr;
112 PerfCounter* ClassLoader::_perf_class_link_selftime = nullptr;
113 PerfCounter* ClassLoader::_perf_shared_classload_time = nullptr;
114 PerfCounter* ClassLoader::_perf_sys_classload_time = nullptr;
115 PerfCounter* ClassLoader::_perf_app_classload_time = nullptr;
116 PerfCounter* ClassLoader::_perf_app_classload_selftime = nullptr;
117 PerfCounter* ClassLoader::_perf_app_classload_count = nullptr;
118 PerfCounter* ClassLoader::_perf_define_appclasses = nullptr;
119 PerfCounter* ClassLoader::_perf_define_appclass_time = nullptr;
120 PerfCounter* ClassLoader::_perf_define_appclass_selftime = nullptr;
121 PerfCounter* ClassLoader::_perf_app_classfile_bytes_read = nullptr;
122 PerfCounter* ClassLoader::_perf_sys_classfile_bytes_read = nullptr;
123 PerfCounter* ClassLoader::_perf_preload_total_time = nullptr;
124 PerfCounter* ClassLoader::_perf_preload_time = nullptr;
125 PerfCounter* ClassLoader::_perf_prelink_time = nullptr;
126 PerfCounter* ClassLoader::_perf_preinit_time = nullptr;
127 PerfCounter* ClassLoader::_perf_preresolve_time = nullptr;
128 PerfCounter* ClassLoader::_perf_ik_link_methods_time = nullptr;
129 PerfCounter* ClassLoader::_perf_method_adapters_time = nullptr;
130 PerfCounter* ClassLoader::_perf_ik_link_methods_count = nullptr;
131 PerfCounter* ClassLoader::_perf_method_adapters_count = nullptr;
132 PerfCounter* ClassLoader::_unsafe_defineClassCallCounter = nullptr;
133 PerfCounter* ClassLoader::_perf_secondary_hash_time = nullptr;
134
135 PerfTickCounters* ClassLoader::_perf_resolve_indy_time = nullptr;
136 PerfTickCounters* ClassLoader::_perf_resolve_invokehandle_time = nullptr;
137 PerfTickCounters* ClassLoader::_perf_resolve_mh_time = nullptr;
138 PerfTickCounters* ClassLoader::_perf_resolve_mt_time = nullptr;
139
140 PerfCounter* ClassLoader::_perf_resolve_indy_count = nullptr;
141 PerfCounter* ClassLoader::_perf_resolve_invokehandle_count = nullptr;
142 PerfCounter* ClassLoader::_perf_resolve_mh_count = nullptr;
143 PerfCounter* ClassLoader::_perf_resolve_mt_count = nullptr;
144
145 void ClassLoader::print_counters(outputStream *st) {
146 // The counters are only active if the logging is enabled, but
147 // we print to the passed in outputStream as requested.
148 if (log_is_enabled(Info, perf, class, link)) {
149 st->print_cr("ClassLoader:");
150 st->print_cr( " clinit: " JLONG_FORMAT "ms / " JLONG_FORMAT " events",
151 ClassLoader::class_init_time_ms(), ClassLoader::class_init_count());
152 st->print_cr(" link methods: " JLONG_FORMAT "ms / " JLONG_FORMAT " events",
153 Management::ticks_to_ms(_perf_ik_link_methods_time->get_value()) , _perf_ik_link_methods_count->get_value());
154 st->print_cr(" method adapters: " JLONG_FORMAT "ms / " JLONG_FORMAT " events",
155 Management::ticks_to_ms(_perf_method_adapters_time->get_value()) , _perf_method_adapters_count->get_value());
156 if (CountBytecodes || CountBytecodesPerThread) {
157 st->print_cr("; executed " JLONG_FORMAT " bytecodes", ClassLoader::class_init_bytecodes_count());
158 }
159 st->print_cr(" resolve...");
160 st->print_cr(" invokedynamic: " JLONG_FORMAT "ms (elapsed) " JLONG_FORMAT "ms (thread) / " JLONG_FORMAT " events",
161 _perf_resolve_indy_time->elapsed_counter_value_ms(),
162 _perf_resolve_indy_time->thread_counter_value_ms(),
163 _perf_resolve_indy_count->get_value());
164 st->print_cr(" invokehandle: " JLONG_FORMAT "ms (elapsed) " JLONG_FORMAT "ms (thread) / " JLONG_FORMAT " events",
165 _perf_resolve_invokehandle_time->elapsed_counter_value_ms(),
166 _perf_resolve_invokehandle_time->thread_counter_value_ms(),
167 _perf_resolve_invokehandle_count->get_value());
168 st->print_cr(" CP_MethodHandle: " JLONG_FORMAT "ms (elapsed) " JLONG_FORMAT "ms (thread) / " JLONG_FORMAT " events",
169 _perf_resolve_mh_time->elapsed_counter_value_ms(),
170 _perf_resolve_mh_time->thread_counter_value_ms(),
171 _perf_resolve_mh_count->get_value());
172 st->print_cr(" CP_MethodType: " JLONG_FORMAT "ms (elapsed) " JLONG_FORMAT "ms (thread) / " JLONG_FORMAT " events",
173 _perf_resolve_mt_time->elapsed_counter_value_ms(),
174 _perf_resolve_mt_time->thread_counter_value_ms(),
175 _perf_resolve_mt_count->get_value());
176 }
177 }
178
179 GrowableArray<ModuleClassPathList*>* ClassLoader::_patch_mod_entries = nullptr;
180 GrowableArray<ModuleClassPathList*>* ClassLoader::_exploded_entries = nullptr;
181 ClassPathEntry* ClassLoader::_jrt_entry = nullptr;
182
183 ClassPathEntry* volatile ClassLoader::_first_append_entry_list = nullptr;
184 ClassPathEntry* volatile ClassLoader::_last_append_entry = nullptr;
185 #if INCLUDE_CDS
186 ClassPathEntry* ClassLoader::_app_classpath_entries = nullptr;
187 ClassPathEntry* ClassLoader::_last_app_classpath_entry = nullptr;
188 ClassPathEntry* ClassLoader::_module_path_entries = nullptr;
189 ClassPathEntry* ClassLoader::_last_module_path_entry = nullptr;
190 #endif
191
192 // helper routines
193 #if INCLUDE_CDS
194 static bool string_starts_with(const char* str, const char* str_to_find) {
195 size_t str_len = strlen(str);
310 #ifdef ASSERT
311 // Freeing path is a no-op here as buffer prevents it from being reclaimed. But we keep it for
312 // debug builds so that we guard against use-after-free bugs.
313 FREE_RESOURCE_ARRAY_IN_THREAD(current, char, path, path_len);
314 #endif
315 // We don't verify the length of the classfile stream fits in an int, but this is the
316 // bootloader so we have control of this.
317 // Resource allocated
318 return new ClassFileStream(buffer,
319 checked_cast<int>(st.st_size),
320 _dir,
321 ClassFileStream::verify);
322 }
323 }
324 }
325 FREE_RESOURCE_ARRAY_IN_THREAD(current, char, path, path_len);
326 return nullptr;
327 }
328
329 ClassPathZipEntry::ClassPathZipEntry(jzfile* zip, const char* zip_name,
330 bool from_class_path_attr) : ClassPathEntry() {
331 _zip = zip;
332 _zip_name = copy_path(zip_name);
333 _from_class_path_attr = from_class_path_attr;
334 }
335
336 ClassPathZipEntry::~ClassPathZipEntry() {
337 ZipLibrary::close(_zip);
338 FREE_C_HEAP_ARRAY(char, _zip_name);
339 }
340
341 bool ClassPathZipEntry::has_entry(JavaThread* current, const char* name) {
342 ThreadToNativeFromVM ttn(current);
343 // check whether zip archive contains name
344 jint name_len;
345 jint filesize;
346 jzentry* entry = ZipLibrary::find_entry(_zip, name, &filesize, &name_len);
347 if (entry == nullptr) {
348 return false;
349 } else {
350 ZipLibrary::free_entry(_zip, entry);
351 return true;
352 }
353 }
354
355 u1* ClassPathZipEntry::open_entry(JavaThread* current, const char* name, jint* filesize, bool nul_terminate) {
356 // enable call to C land
357 ThreadToNativeFromVM ttn(current);
358 // check whether zip archive contains name
359 jint name_len;
360 jzentry* entry = ZipLibrary::find_entry(_zip, name, filesize, &name_len);
361 if (entry == nullptr) return nullptr;
362 u1* buffer;
363 char name_buf[128];
364 char* filename;
365 if (name_len < 128) {
366 filename = name_buf;
367 } else {
368 filename = NEW_RESOURCE_ARRAY(char, name_len + 1);
369 }
370
371 // read contents into resource array
372 size_t size = (uint32_t)(*filesize);
373 if (nul_terminate) {
374 if (sizeof(size) == sizeof(uint32_t) && size == UINT_MAX) {
375 return nullptr; // 32-bit integer overflow will occur.
376 }
377 size++;
378 }
379
380 // ZIP_ReadEntry also frees zentry
381 buffer = NEW_RESOURCE_ARRAY(u1, size);
382 if (!ZipLibrary::read_entry(_zip, entry, buffer, filename)) {
383 return nullptr;
384 }
385
386 // return result
387 if (nul_terminate) {
388 buffer[size - 1] = 0;
389 }
390 return buffer;
391 }
392
393 ClassFileStream* ClassPathZipEntry::open_stream(JavaThread* current, const char* name) {
394 jint filesize;
395 u1* buffer = open_entry(current, name, &filesize, false);
396 if (buffer == nullptr) {
397 return nullptr;
398 }
399 if (UsePerfData) {
400 ClassLoader::perf_sys_classfile_bytes_read()->inc(filesize);
786 HandleMark hm(thread);
787 return ZipLibrary::open(canonical_path, error_msg);
788 }
789
790 ClassPathEntry* ClassLoader::create_class_path_entry(JavaThread* current,
791 const char *path, const struct stat* st,
792 bool is_boot_append,
793 bool from_class_path_attr) {
794 ClassPathEntry* new_entry = nullptr;
795 if ((st->st_mode & S_IFMT) == S_IFREG) {
796 ResourceMark rm(current);
797 // Regular file, should be a zip file
798 // Canonicalized filename
799 const char* canonical_path = get_canonical_path(path, current);
800 if (canonical_path == nullptr) {
801 return nullptr;
802 }
803 char* error_msg = nullptr;
804 jzfile* zip = open_zip_file(canonical_path, &error_msg, current);
805 if (zip != nullptr && error_msg == nullptr) {
806 new_entry = new ClassPathZipEntry(zip, path, from_class_path_attr);
807 } else {
808 #if INCLUDE_CDS
809 ClassLoaderExt::set_has_non_jar_in_classpath();
810 #endif
811 return nullptr;
812 }
813 log_info(class, path)("opened: %s", path);
814 log_info(class, load)("opened: %s", path);
815 } else {
816 // Directory
817 new_entry = new ClassPathDirEntry(path);
818 log_info(class, load)("path: %s", path);
819 }
820 return new_entry;
821 }
822
823
824 // Create a class path zip entry for a given path (return null if not found
825 // or zip/JAR file cannot be opened)
826 ClassPathZipEntry* ClassLoader::create_class_path_zip_entry(const char *path) {
827 // check for a regular file
828 struct stat st;
829 if (os::stat(path, &st) == 0) {
830 if ((st.st_mode & S_IFMT) == S_IFREG) {
831 JavaThread* thread = JavaThread::current();
832 ResourceMark rm(thread);
833 const char* canonical_path = get_canonical_path(path, thread);
834 if (canonical_path != nullptr) {
835 char* error_msg = nullptr;
836 jzfile* zip = open_zip_file(canonical_path, &error_msg, thread);
837 if (zip != nullptr && error_msg == nullptr) {
838 // create using canonical path
839 return new ClassPathZipEntry(zip, canonical_path, false);
840 }
841 }
842 }
843 }
844 return nullptr;
845 }
846
847 // The boot append entries are added with a lock, and read lock free.
848 void ClassLoader::add_to_boot_append_entries(ClassPathEntry *new_entry) {
849 if (new_entry != nullptr) {
850 MutexLocker ml(Bootclasspath_lock, Mutex::_no_safepoint_check_flag);
851 if (_last_append_entry == nullptr) {
852 _last_append_entry = new_entry;
853 assert(first_append_entry() == nullptr, "boot loader's append class path entry list not empty");
854 Atomic::release_store(&_first_append_entry_list, new_entry);
855 } else {
856 _last_append_entry->set_next(new_entry);
857 _last_append_entry = new_entry;
858 }
859 }
1379 #endif // INCLUDE_CDS
1380
1381 // Initialize the class loader's access to methods in libzip. Parse and
1382 // process the boot classpath into a list ClassPathEntry objects. Once
1383 // this list has been created, it must not change order (see class PackageInfo)
1384 // it can be appended to and is by jvmti.
1385
1386 void ClassLoader::initialize(TRAPS) {
1387 if (UsePerfData) {
1388 // jvmstat performance counters
1389 NEWPERFTICKCOUNTER(_perf_accumulated_time, SUN_CLS, "time");
1390 NEWPERFTICKCOUNTER(_perf_class_init_time, SUN_CLS, "classInitTime");
1391 NEWPERFTICKCOUNTER(_perf_class_init_selftime, SUN_CLS, "classInitTime.self");
1392 NEWPERFTICKCOUNTER(_perf_class_verify_time, SUN_CLS, "classVerifyTime");
1393 NEWPERFTICKCOUNTER(_perf_class_verify_selftime, SUN_CLS, "classVerifyTime.self");
1394 NEWPERFTICKCOUNTER(_perf_class_link_time, SUN_CLS, "classLinkedTime");
1395 NEWPERFTICKCOUNTER(_perf_class_link_selftime, SUN_CLS, "classLinkedTime.self");
1396 NEWPERFEVENTCOUNTER(_perf_classes_inited, SUN_CLS, "initializedClasses");
1397 NEWPERFEVENTCOUNTER(_perf_classes_linked, SUN_CLS, "linkedClasses");
1398 NEWPERFEVENTCOUNTER(_perf_classes_verified, SUN_CLS, "verifiedClasses");
1399 NEWPERFEVENTCOUNTER(_perf_class_init_bytecodes_count, SUN_CLS, "clinitBytecodesCount");
1400
1401 NEWPERFTICKCOUNTER(_perf_shared_classload_time, SUN_CLS, "sharedClassLoadTime");
1402 NEWPERFTICKCOUNTER(_perf_sys_classload_time, SUN_CLS, "sysClassLoadTime");
1403 NEWPERFTICKCOUNTER(_perf_app_classload_time, SUN_CLS, "appClassLoadTime");
1404 NEWPERFTICKCOUNTER(_perf_app_classload_selftime, SUN_CLS, "appClassLoadTime.self");
1405 NEWPERFEVENTCOUNTER(_perf_app_classload_count, SUN_CLS, "appClassLoadCount");
1406 NEWPERFTICKCOUNTER(_perf_define_appclasses, SUN_CLS, "defineAppClasses");
1407 NEWPERFTICKCOUNTER(_perf_define_appclass_time, SUN_CLS, "defineAppClassTime");
1408 NEWPERFTICKCOUNTER(_perf_define_appclass_selftime, SUN_CLS, "defineAppClassTime.self");
1409 NEWPERFBYTECOUNTER(_perf_app_classfile_bytes_read, SUN_CLS, "appClassBytes");
1410 NEWPERFBYTECOUNTER(_perf_sys_classfile_bytes_read, SUN_CLS, "sysClassBytes");
1411 NEWPERFEVENTCOUNTER(_unsafe_defineClassCallCounter, SUN_CLS, "unsafeDefineClassCalls");
1412 NEWPERFTICKCOUNTER(_perf_secondary_hash_time, SUN_CLS, "secondarySuperHashTime");
1413
1414 if (log_is_enabled(Info, perf, class, link)) {
1415 NEWPERFTICKCOUNTER(_perf_preload_total_time, SUN_CLS, "preloadTotalTime");
1416 NEWPERFTICKCOUNTER(_perf_preload_time, SUN_CLS, "preloadTime");
1417 NEWPERFTICKCOUNTER(_perf_prelink_time, SUN_CLS, "prelinkTime");
1418 NEWPERFTICKCOUNTER(_perf_preinit_time, SUN_CLS, "preinitTime");
1419 NEWPERFTICKCOUNTER(_perf_preresolve_time, SUN_CLS, "preresolveTime");
1420
1421 NEWPERFTICKCOUNTER(_perf_ik_link_methods_time, SUN_CLS, "linkMethodsTime");
1422 NEWPERFTICKCOUNTER(_perf_method_adapters_time, SUN_CLS, "makeAdaptersTime");
1423 NEWPERFEVENTCOUNTER(_perf_ik_link_methods_count, SUN_CLS, "linkMethodsCount");
1424 NEWPERFEVENTCOUNTER(_perf_method_adapters_count, SUN_CLS, "makeAdaptersCount");
1425
1426 NEWPERFTICKCOUNTERS(_perf_resolve_indy_time, SUN_CLS, "resolve_invokedynamic_time");
1427 NEWPERFTICKCOUNTERS(_perf_resolve_invokehandle_time, SUN_CLS, "resolve_invokehandle_time");
1428 NEWPERFTICKCOUNTERS(_perf_resolve_mh_time, SUN_CLS, "resolve_MethodHandle_time");
1429 NEWPERFTICKCOUNTERS(_perf_resolve_mt_time, SUN_CLS, "resolve_MethodType_time");
1430
1431 NEWPERFEVENTCOUNTER(_perf_resolve_indy_count, SUN_CLS, "resolve_invokedynamic_count");
1432 NEWPERFEVENTCOUNTER(_perf_resolve_invokehandle_count, SUN_CLS, "resolve_invokehandle_count");
1433 NEWPERFEVENTCOUNTER(_perf_resolve_mh_count, SUN_CLS, "resolve_MethodHandle_count");
1434 NEWPERFEVENTCOUNTER(_perf_resolve_mt_count, SUN_CLS, "resolve_MethodType_count");
1435 }
1436 }
1437
1438 // lookup java library entry points
1439 load_java_library();
1440 // jimage library entry points are loaded below, in lookup_vm_options
1441 setup_bootstrap_search_path(THREAD);
1442 }
1443
1444 static char* lookup_vm_resource(JImageFile *jimage, const char *jimage_version, const char *path) {
1445 jlong size;
1446 JImageLocationRef location = (*JImageFindResource)(jimage, "java.base", jimage_version, path, &size);
1447 if (location == 0)
1448 return nullptr;
1449 char *val = NEW_C_HEAP_ARRAY(char, size+1, mtClass);
1502
1503 // Helper function used by CDS code to get the number of module path
1504 // entries during shared classpath setup time.
1505 int ClassLoader::num_module_path_entries() {
1506 assert(CDSConfig::is_dumping_archive(), "sanity");
1507 int num_entries = 0;
1508 ClassPathEntry* e= ClassLoader::_module_path_entries;
1509 while (e != nullptr) {
1510 num_entries ++;
1511 e = e->next();
1512 }
1513 return num_entries;
1514 }
1515 #endif
1516
1517 jlong ClassLoader::classloader_time_ms() {
1518 return UsePerfData ?
1519 Management::ticks_to_ms(_perf_accumulated_time->get_value()) : -1;
1520 }
1521
1522 jlong ClassLoader::class_init_bytecodes_count() {
1523 return UsePerfData ? _perf_class_init_bytecodes_count->get_value() : -1;
1524 }
1525
1526 jlong ClassLoader::class_init_count() {
1527 return UsePerfData ? _perf_classes_inited->get_value() : -1;
1528 }
1529
1530 jlong ClassLoader::class_init_time_ms() {
1531 return UsePerfData ?
1532 Management::ticks_to_ms(_perf_class_init_time->get_value()) : -1;
1533 }
1534
1535 jlong ClassLoader::class_verify_time_ms() {
1536 return UsePerfData ?
1537 Management::ticks_to_ms(_perf_class_verify_time->get_value()) : -1;
1538 }
1539
1540 jlong ClassLoader::class_link_count() {
1541 return UsePerfData ? _perf_classes_linked->get_value() : -1;
1542 }
1543
1544 jlong ClassLoader::class_link_time_ms() {
1545 return UsePerfData ?
|