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 #include <stdlib.h>
85 #include <ctype.h>
86
87 // Entry point in java.dll for path canonicalization
88
89 typedef int (*canonicalize_fn_t)(const char *orig, char *out, int len);
90
91 static canonicalize_fn_t CanonicalizeEntry = nullptr;
92
93 // Entry points for jimage.dll for loading jimage file entries
94
95 static JImageOpen_t JImageOpen = nullptr;
96 static JImageClose_t JImageClose = nullptr;
97 static JImageFindResource_t JImageFindResource = nullptr;
98 static JImageGetResource_t JImageGetResource = nullptr;
99
100 // JimageFile pointer, or null if exploded JDK build.
101 static JImageFile* JImage_file = nullptr;
102
103 // Globals
104
105 PerfCounter* ClassLoader::_perf_accumulated_time = nullptr;
106 PerfCounter* ClassLoader::_perf_classes_inited = nullptr;
107 PerfCounter* ClassLoader::_perf_class_init_time = nullptr;
108 PerfCounter* ClassLoader::_perf_class_init_selftime = nullptr;
109 PerfCounter* ClassLoader::_perf_classes_verified = nullptr;
110 PerfCounter* ClassLoader::_perf_class_verify_time = nullptr;
111 PerfCounter* ClassLoader::_perf_class_verify_selftime = nullptr;
112 PerfCounter* ClassLoader::_perf_classes_linked = nullptr;
113 PerfCounter* ClassLoader::_perf_class_link_time = nullptr;
114 PerfCounter* ClassLoader::_perf_class_link_selftime = nullptr;
115 PerfCounter* ClassLoader::_perf_shared_classload_time = nullptr;
116 PerfCounter* ClassLoader::_perf_sys_classload_time = nullptr;
117 PerfCounter* ClassLoader::_perf_app_classload_time = nullptr;
118 PerfCounter* ClassLoader::_perf_app_classload_selftime = nullptr;
119 PerfCounter* ClassLoader::_perf_app_classload_count = nullptr;
120 PerfCounter* ClassLoader::_perf_define_appclasses = nullptr;
121 PerfCounter* ClassLoader::_perf_define_appclass_time = nullptr;
122 PerfCounter* ClassLoader::_perf_define_appclass_selftime = nullptr;
123 PerfCounter* ClassLoader::_perf_app_classfile_bytes_read = nullptr;
124 PerfCounter* ClassLoader::_perf_sys_classfile_bytes_read = nullptr;
125 PerfCounter* ClassLoader::_perf_ik_link_methods_time = nullptr;
126 PerfCounter* ClassLoader::_perf_method_adapters_time = nullptr;
127 PerfCounter* ClassLoader::_perf_ik_link_methods_count = nullptr;
128 PerfCounter* ClassLoader::_perf_method_adapters_count = nullptr;
129 PerfCounter* ClassLoader::_unsafe_defineClassCallCounter = nullptr;
130 PerfCounter* ClassLoader::_perf_secondary_hash_time = nullptr;
131
132 PerfCounter* ClassLoader::_perf_resolve_indy_time = nullptr;
133 PerfCounter* ClassLoader::_perf_resolve_invokehandle_time = nullptr;
134 PerfCounter* ClassLoader::_perf_resolve_mh_time = nullptr;
135 PerfCounter* ClassLoader::_perf_resolve_mt_time = nullptr;
136
137 PerfCounter* ClassLoader::_perf_resolve_indy_count = nullptr;
138 PerfCounter* ClassLoader::_perf_resolve_invokehandle_count = nullptr;
139 PerfCounter* ClassLoader::_perf_resolve_mh_count = nullptr;
140 PerfCounter* ClassLoader::_perf_resolve_mt_count = nullptr;
141
142 void ClassLoader::print_counters(outputStream *st) {
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 GrowableArray<ModuleClassPathList*>* ClassLoader::_patch_mod_entries = nullptr;
156 GrowableArray<ModuleClassPathList*>* ClassLoader::_exploded_entries = nullptr;
157 ClassPathEntry* ClassLoader::_jrt_entry = nullptr;
158
159 ClassPathEntry* volatile ClassLoader::_first_append_entry_list = nullptr;
160 ClassPathEntry* volatile ClassLoader::_last_append_entry = nullptr;
161
162 // helper routines
163 #if INCLUDE_CDS
164 static bool string_starts_with(const char* str, const char* str_to_find) {
165 size_t str_len = strlen(str);
166 size_t str_to_find_len = strlen(str_to_find);
167 if (str_to_find_len > str_len) {
168 return false;
169 }
170 return (strncmp(str, str_to_find, str_to_find_len) == 0);
171 }
172 #endif
288 return new ClassFileStream(buffer,
289 checked_cast<int>(st.st_size),
290 _dir);
291 }
292 }
293 }
294 FREE_RESOURCE_ARRAY_IN_THREAD(current, char, path, path_len);
295 return nullptr;
296 }
297
298 ClassPathZipEntry::ClassPathZipEntry(jzfile* zip, const char* zip_name) : ClassPathEntry() {
299 _zip = zip;
300 _zip_name = copy_path(zip_name);
301 }
302
303 ClassPathZipEntry::~ClassPathZipEntry() {
304 ZipLibrary::close(_zip);
305 FREE_C_HEAP_ARRAY(char, _zip_name);
306 }
307
308 u1* ClassPathZipEntry::open_entry(JavaThread* current, const char* name, jint* filesize, bool nul_terminate) {
309 // enable call to C land
310 ThreadToNativeFromVM ttn(current);
311 // check whether zip archive contains name
312 jint name_len;
313 jzentry* entry = ZipLibrary::find_entry(_zip, name, filesize, &name_len);
314 if (entry == nullptr) return nullptr;
315 u1* buffer;
316 char name_buf[128];
317 char* filename;
318 if (name_len < 128) {
319 filename = name_buf;
320 } else {
321 filename = NEW_RESOURCE_ARRAY(char, name_len + 1);
322 }
323
324 // read contents into resource array
325 size_t size = (uint32_t)(*filesize);
326 if (nul_terminate) {
327 if (sizeof(size) == sizeof(uint32_t) && size == UINT_MAX) {
328 return nullptr; // 32-bit integer overflow will occur.
329 }
330 size++;
331 }
332 buffer = NEW_RESOURCE_ARRAY(u1, size);
333 if (!ZipLibrary::read_entry(_zip, entry, buffer, filename)) {
334 return nullptr;
335 }
336
337 // return result
338 if (nul_terminate) {
339 buffer[size - 1] = 0;
340 }
341 return buffer;
342 }
343
344 ClassFileStream* ClassPathZipEntry::open_stream(JavaThread* current, const char* name) {
345 jint filesize;
346 u1* buffer = open_entry(current, name, &filesize, false);
347 if (buffer == nullptr) {
348 return nullptr;
349 }
350 if (UsePerfData) {
351 ClassLoader::perf_sys_classfile_bytes_read()->inc(filesize);
1306 #endif // INCLUDE_CDS
1307
1308 // Initialize the class loader's access to methods in libzip. Parse and
1309 // process the boot classpath into a list ClassPathEntry objects. Once
1310 // this list has been created, it must not change order (see class PackageInfo)
1311 // it can be appended to and is by jvmti.
1312
1313 void ClassLoader::initialize(TRAPS) {
1314 if (UsePerfData) {
1315 // jvmstat performance counters
1316 NEWPERFTICKCOUNTER(_perf_accumulated_time, SUN_CLS, "time");
1317 NEWPERFTICKCOUNTER(_perf_class_init_time, SUN_CLS, "classInitTime");
1318 NEWPERFTICKCOUNTER(_perf_class_init_selftime, SUN_CLS, "classInitTime.self");
1319 NEWPERFTICKCOUNTER(_perf_class_verify_time, SUN_CLS, "classVerifyTime");
1320 NEWPERFTICKCOUNTER(_perf_class_verify_selftime, SUN_CLS, "classVerifyTime.self");
1321 NEWPERFTICKCOUNTER(_perf_class_link_time, SUN_CLS, "classLinkedTime");
1322 NEWPERFTICKCOUNTER(_perf_class_link_selftime, SUN_CLS, "classLinkedTime.self");
1323 NEWPERFEVENTCOUNTER(_perf_classes_inited, SUN_CLS, "initializedClasses");
1324 NEWPERFEVENTCOUNTER(_perf_classes_linked, SUN_CLS, "linkedClasses");
1325 NEWPERFEVENTCOUNTER(_perf_classes_verified, SUN_CLS, "verifiedClasses");
1326
1327 NEWPERFTICKCOUNTER(_perf_shared_classload_time, SUN_CLS, "sharedClassLoadTime");
1328 NEWPERFTICKCOUNTER(_perf_sys_classload_time, SUN_CLS, "sysClassLoadTime");
1329 NEWPERFTICKCOUNTER(_perf_app_classload_time, SUN_CLS, "appClassLoadTime");
1330 NEWPERFTICKCOUNTER(_perf_app_classload_selftime, SUN_CLS, "appClassLoadTime.self");
1331 NEWPERFEVENTCOUNTER(_perf_app_classload_count, SUN_CLS, "appClassLoadCount");
1332 NEWPERFTICKCOUNTER(_perf_define_appclasses, SUN_CLS, "defineAppClasses");
1333 NEWPERFTICKCOUNTER(_perf_define_appclass_time, SUN_CLS, "defineAppClassTime");
1334 NEWPERFTICKCOUNTER(_perf_define_appclass_selftime, SUN_CLS, "defineAppClassTime.self");
1335 NEWPERFBYTECOUNTER(_perf_app_classfile_bytes_read, SUN_CLS, "appClassBytes");
1336 NEWPERFBYTECOUNTER(_perf_sys_classfile_bytes_read, SUN_CLS, "sysClassBytes");
1337 NEWPERFEVENTCOUNTER(_unsafe_defineClassCallCounter, SUN_CLS, "unsafeDefineClassCalls");
1338 NEWPERFTICKCOUNTER(_perf_secondary_hash_time, SUN_CLS, "secondarySuperHashTime");
1339
1340 if (log_is_enabled(Info, perf, class, link)) {
1341 NEWPERFTICKCOUNTER(_perf_ik_link_methods_time, SUN_CLS, "linkMethodsTime");
1342 NEWPERFTICKCOUNTER(_perf_method_adapters_time, SUN_CLS, "makeAdaptersTime");
1343 NEWPERFEVENTCOUNTER(_perf_ik_link_methods_count, SUN_CLS, "linkMethodsCount");
1344 NEWPERFEVENTCOUNTER(_perf_method_adapters_count, SUN_CLS, "makeAdaptersCount");
1345
1346 NEWPERFTICKCOUNTER(_perf_resolve_indy_time, SUN_CLS, "resolve_invokedynamic_time");
1347 NEWPERFTICKCOUNTER(_perf_resolve_invokehandle_time, SUN_CLS, "resolve_invokehandle_time");
1348 NEWPERFTICKCOUNTER(_perf_resolve_mh_time, SUN_CLS, "resolve_MethodHandle_time");
1349 NEWPERFTICKCOUNTER(_perf_resolve_mt_time, SUN_CLS, "resolve_MethodType_time");
1350
1351 NEWPERFEVENTCOUNTER(_perf_resolve_indy_count, SUN_CLS, "resolve_invokedynamic_count");
1352 NEWPERFEVENTCOUNTER(_perf_resolve_invokehandle_count, SUN_CLS, "resolve_invokehandle_count");
1353 NEWPERFEVENTCOUNTER(_perf_resolve_mh_count, SUN_CLS, "resolve_MethodHandle_count");
1354 NEWPERFEVENTCOUNTER(_perf_resolve_mt_count, SUN_CLS, "resolve_MethodType_count");
1355 }
1356 }
1357
1358 // lookup java library entry points
1359 load_java_library();
1360 // jimage library entry points are loaded below, in lookup_vm_options
1361 setup_bootstrap_search_path(THREAD);
1362 }
1363
1364 static char* lookup_vm_resource(JImageFile *jimage, const char *jimage_version, const char *path) {
1365 jlong size;
1366 JImageLocationRef location = (*JImageFindResource)(jimage, "java.base", jimage_version, path, &size);
1367 if (location == 0)
1368 return nullptr;
1369 char *val = NEW_C_HEAP_ARRAY(char, size+1, mtClass);
1394
1395 bool ClassLoader::is_module_observable(const char* module_name) {
1396 assert(JImageOpen != nullptr, "jimage library should have been opened");
1397 if (JImage_file == nullptr) {
1398 struct stat st;
1399 const char *path = get_exploded_module_path(module_name, true);
1400 bool res = os::stat(path, &st) == 0;
1401 FREE_C_HEAP_ARRAY(char, path);
1402 return res;
1403 }
1404 jlong size;
1405 const char *jimage_version = get_jimage_version_string();
1406 return (*JImageFindResource)(JImage_file, module_name, jimage_version, "module-info.class", &size) != 0;
1407 }
1408
1409 jlong ClassLoader::classloader_time_ms() {
1410 return UsePerfData ?
1411 Management::ticks_to_ms(_perf_accumulated_time->get_value()) : -1;
1412 }
1413
1414 jlong ClassLoader::class_init_count() {
1415 return UsePerfData ? _perf_classes_inited->get_value() : -1;
1416 }
1417
1418 jlong ClassLoader::class_init_time_ms() {
1419 return UsePerfData ?
1420 Management::ticks_to_ms(_perf_class_init_time->get_value()) : -1;
1421 }
1422
1423 jlong ClassLoader::class_verify_time_ms() {
1424 return UsePerfData ?
1425 Management::ticks_to_ms(_perf_class_verify_time->get_value()) : -1;
1426 }
1427
1428 jlong ClassLoader::class_link_count() {
1429 return UsePerfData ? _perf_classes_linked->get_value() : -1;
1430 }
1431
1432 jlong ClassLoader::class_link_time_ms() {
1433 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 #include <stdlib.h>
85 #include <ctype.h>
86
87 // Entry point in java.dll for path canonicalization
88
89 typedef int (*canonicalize_fn_t)(const char *orig, char *out, int len);
90
91 static canonicalize_fn_t CanonicalizeEntry = nullptr;
92
93 // Entry points for jimage.dll for loading jimage file entries
94
95 static JImageOpen_t JImageOpen = nullptr;
96 static JImageClose_t JImageClose = nullptr;
97 static JImageFindResource_t JImageFindResource = nullptr;
98 static JImageGetResource_t JImageGetResource = nullptr;
99
100 // JimageFile pointer, or null if exploded JDK build.
101 static JImageFile* JImage_file = nullptr;
102
103 // Globals
104
105 PerfCounter* ClassLoader::_perf_accumulated_time = nullptr;
106 PerfCounter* ClassLoader::_perf_classes_inited = nullptr;
107 PerfCounter* ClassLoader::_perf_class_init_time = nullptr;
108 PerfCounter* ClassLoader::_perf_class_init_selftime = nullptr;
109 PerfCounter* ClassLoader::_perf_class_init_bytecodes_count = nullptr;
110 PerfCounter* ClassLoader::_perf_classes_verified = nullptr;
111 PerfCounter* ClassLoader::_perf_class_verify_time = nullptr;
112 PerfCounter* ClassLoader::_perf_class_verify_selftime = nullptr;
113 PerfCounter* ClassLoader::_perf_classes_linked = nullptr;
114 PerfCounter* ClassLoader::_perf_class_link_time = nullptr;
115 PerfCounter* ClassLoader::_perf_class_link_selftime = nullptr;
116 PerfCounter* ClassLoader::_perf_shared_classload_time = nullptr;
117 PerfCounter* ClassLoader::_perf_sys_classload_time = nullptr;
118 PerfCounter* ClassLoader::_perf_app_classload_time = nullptr;
119 PerfCounter* ClassLoader::_perf_app_classload_selftime = nullptr;
120 PerfCounter* ClassLoader::_perf_app_classload_count = nullptr;
121 PerfCounter* ClassLoader::_perf_define_appclasses = nullptr;
122 PerfCounter* ClassLoader::_perf_define_appclass_time = nullptr;
123 PerfCounter* ClassLoader::_perf_define_appclass_selftime = nullptr;
124 PerfCounter* ClassLoader::_perf_app_classfile_bytes_read = nullptr;
125 PerfCounter* ClassLoader::_perf_sys_classfile_bytes_read = nullptr;
126 PerfCounter* ClassLoader::_perf_preload_total_time = nullptr;
127 PerfCounter* ClassLoader::_perf_preload_time = nullptr;
128 PerfCounter* ClassLoader::_perf_prelink_time = nullptr;
129 PerfCounter* ClassLoader::_perf_preinit_time = nullptr;
130 PerfCounter* ClassLoader::_perf_preresolve_time = nullptr;
131 PerfCounter* ClassLoader::_perf_ik_link_methods_time = nullptr;
132 PerfCounter* ClassLoader::_perf_method_adapters_time = nullptr;
133 PerfCounter* ClassLoader::_perf_ik_link_methods_count = nullptr;
134 PerfCounter* ClassLoader::_perf_method_adapters_count = nullptr;
135 PerfCounter* ClassLoader::_unsafe_defineClassCallCounter = nullptr;
136 PerfCounter* ClassLoader::_perf_secondary_hash_time = nullptr;
137
138 PerfTickCounters* ClassLoader::_perf_resolve_indy_time = nullptr;
139 PerfTickCounters* ClassLoader::_perf_resolve_invokehandle_time = nullptr;
140 PerfTickCounters* ClassLoader::_perf_resolve_mh_time = nullptr;
141 PerfTickCounters* ClassLoader::_perf_resolve_mt_time = nullptr;
142
143 PerfCounter* ClassLoader::_perf_resolve_indy_count = nullptr;
144 PerfCounter* ClassLoader::_perf_resolve_invokehandle_count = nullptr;
145 PerfCounter* ClassLoader::_perf_resolve_mh_count = nullptr;
146 PerfCounter* ClassLoader::_perf_resolve_mt_count = nullptr;
147
148 void ClassLoader::print_counters(outputStream *st) {
149 st->print_cr("ClassLoader:");
150 st->print_cr( " clinit: " JLONG_FORMAT_W(6) "us / " JLONG_FORMAT " events",
151 ClassLoader::class_init_time_ms(), ClassLoader::class_init_count());
152 st->print_cr(" link methods: " JLONG_FORMAT_W(6) "us / " JLONG_FORMAT " events",
153 Management::ticks_to_us(_perf_ik_link_methods_time->get_value()) , _perf_ik_link_methods_count->get_value());
154 st->print_cr(" method adapters: " JLONG_FORMAT_W(6) "us / " JLONG_FORMAT " events",
155 Management::ticks_to_us(_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_W(6) "us (elapsed) " JLONG_FORMAT_W(6) "us (thread) / " JLONG_FORMAT_W(5) " events",
161 _perf_resolve_indy_time->elapsed_counter_value_us(),
162 _perf_resolve_indy_time->thread_counter_value_us(),
163 _perf_resolve_indy_count->get_value());
164 st->print_cr(" invokehandle: " JLONG_FORMAT_W(6) "us (elapsed) " JLONG_FORMAT_W(6) "us (thread) / " JLONG_FORMAT_W(5) " events",
165 _perf_resolve_invokehandle_time->elapsed_counter_value_us(),
166 _perf_resolve_invokehandle_time->thread_counter_value_us(),
167 _perf_resolve_invokehandle_count->get_value());
168 st->print_cr(" CP_MethodHandle: " JLONG_FORMAT_W(6) "us (elapsed) " JLONG_FORMAT_W(6) "us (thread) / " JLONG_FORMAT_W(5) " events",
169 _perf_resolve_mh_time->elapsed_counter_value_us(),
170 _perf_resolve_mh_time->thread_counter_value_us(),
171 _perf_resolve_mh_count->get_value());
172 st->print_cr(" CP_MethodType: " JLONG_FORMAT_W(6) "us (elapsed) " JLONG_FORMAT_W(6) "us (thread) / " JLONG_FORMAT_W(5) " events",
173 _perf_resolve_mt_time->elapsed_counter_value_us(),
174 _perf_resolve_mt_time->thread_counter_value_us(),
175 _perf_resolve_mt_count->get_value());
176 }
177
178 GrowableArray<ModuleClassPathList*>* ClassLoader::_patch_mod_entries = nullptr;
179 GrowableArray<ModuleClassPathList*>* ClassLoader::_exploded_entries = nullptr;
180 ClassPathEntry* ClassLoader::_jrt_entry = nullptr;
181
182 ClassPathEntry* volatile ClassLoader::_first_append_entry_list = nullptr;
183 ClassPathEntry* volatile ClassLoader::_last_append_entry = nullptr;
184
185 // helper routines
186 #if INCLUDE_CDS
187 static bool string_starts_with(const char* str, const char* str_to_find) {
188 size_t str_len = strlen(str);
189 size_t str_to_find_len = strlen(str_to_find);
190 if (str_to_find_len > str_len) {
191 return false;
192 }
193 return (strncmp(str, str_to_find, str_to_find_len) == 0);
194 }
195 #endif
311 return new ClassFileStream(buffer,
312 checked_cast<int>(st.st_size),
313 _dir);
314 }
315 }
316 }
317 FREE_RESOURCE_ARRAY_IN_THREAD(current, char, path, path_len);
318 return nullptr;
319 }
320
321 ClassPathZipEntry::ClassPathZipEntry(jzfile* zip, const char* zip_name) : ClassPathEntry() {
322 _zip = zip;
323 _zip_name = copy_path(zip_name);
324 }
325
326 ClassPathZipEntry::~ClassPathZipEntry() {
327 ZipLibrary::close(_zip);
328 FREE_C_HEAP_ARRAY(char, _zip_name);
329 }
330
331 bool ClassPathZipEntry::has_entry(JavaThread* current, const char* name) {
332 ThreadToNativeFromVM ttn(current);
333 // check whether zip archive contains name
334 jint name_len;
335 jint filesize;
336 jzentry* entry = ZipLibrary::find_entry(_zip, name, &filesize, &name_len);
337 if (entry == nullptr) {
338 return false;
339 } else {
340 ZipLibrary::free_entry(_zip, entry);
341 return true;
342 }
343 }
344
345 u1* ClassPathZipEntry::open_entry(JavaThread* current, const char* name, jint* filesize, bool nul_terminate) {
346 // enable call to C land
347 ThreadToNativeFromVM ttn(current);
348 // check whether zip archive contains name
349 jint name_len;
350 jzentry* entry = ZipLibrary::find_entry(_zip, name, filesize, &name_len);
351 if (entry == nullptr) return nullptr;
352 u1* buffer;
353 char name_buf[128];
354 char* filename;
355 if (name_len < 128) {
356 filename = name_buf;
357 } else {
358 filename = NEW_RESOURCE_ARRAY(char, name_len + 1);
359 }
360
361 // read contents into resource array
362 size_t size = (uint32_t)(*filesize);
363 if (nul_terminate) {
364 if (sizeof(size) == sizeof(uint32_t) && size == UINT_MAX) {
365 return nullptr; // 32-bit integer overflow will occur.
366 }
367 size++;
368 }
369
370 // ZIP_ReadEntry also frees zentry
371 buffer = NEW_RESOURCE_ARRAY(u1, size);
372 if (!ZipLibrary::read_entry(_zip, entry, buffer, filename)) {
373 return nullptr;
374 }
375
376 // return result
377 if (nul_terminate) {
378 buffer[size - 1] = 0;
379 }
380 return buffer;
381 }
382
383 ClassFileStream* ClassPathZipEntry::open_stream(JavaThread* current, const char* name) {
384 jint filesize;
385 u1* buffer = open_entry(current, name, &filesize, false);
386 if (buffer == nullptr) {
387 return nullptr;
388 }
389 if (UsePerfData) {
390 ClassLoader::perf_sys_classfile_bytes_read()->inc(filesize);
1345 #endif // INCLUDE_CDS
1346
1347 // Initialize the class loader's access to methods in libzip. Parse and
1348 // process the boot classpath into a list ClassPathEntry objects. Once
1349 // this list has been created, it must not change order (see class PackageInfo)
1350 // it can be appended to and is by jvmti.
1351
1352 void ClassLoader::initialize(TRAPS) {
1353 if (UsePerfData) {
1354 // jvmstat performance counters
1355 NEWPERFTICKCOUNTER(_perf_accumulated_time, SUN_CLS, "time");
1356 NEWPERFTICKCOUNTER(_perf_class_init_time, SUN_CLS, "classInitTime");
1357 NEWPERFTICKCOUNTER(_perf_class_init_selftime, SUN_CLS, "classInitTime.self");
1358 NEWPERFTICKCOUNTER(_perf_class_verify_time, SUN_CLS, "classVerifyTime");
1359 NEWPERFTICKCOUNTER(_perf_class_verify_selftime, SUN_CLS, "classVerifyTime.self");
1360 NEWPERFTICKCOUNTER(_perf_class_link_time, SUN_CLS, "classLinkedTime");
1361 NEWPERFTICKCOUNTER(_perf_class_link_selftime, SUN_CLS, "classLinkedTime.self");
1362 NEWPERFEVENTCOUNTER(_perf_classes_inited, SUN_CLS, "initializedClasses");
1363 NEWPERFEVENTCOUNTER(_perf_classes_linked, SUN_CLS, "linkedClasses");
1364 NEWPERFEVENTCOUNTER(_perf_classes_verified, SUN_CLS, "verifiedClasses");
1365 NEWPERFEVENTCOUNTER(_perf_class_init_bytecodes_count, SUN_CLS, "clinitBytecodesCount");
1366
1367 NEWPERFTICKCOUNTER(_perf_shared_classload_time, SUN_CLS, "sharedClassLoadTime");
1368 NEWPERFTICKCOUNTER(_perf_sys_classload_time, SUN_CLS, "sysClassLoadTime");
1369 NEWPERFTICKCOUNTER(_perf_app_classload_time, SUN_CLS, "appClassLoadTime");
1370 NEWPERFTICKCOUNTER(_perf_app_classload_selftime, SUN_CLS, "appClassLoadTime.self");
1371 NEWPERFEVENTCOUNTER(_perf_app_classload_count, SUN_CLS, "appClassLoadCount");
1372 NEWPERFTICKCOUNTER(_perf_define_appclasses, SUN_CLS, "defineAppClasses");
1373 NEWPERFTICKCOUNTER(_perf_define_appclass_time, SUN_CLS, "defineAppClassTime");
1374 NEWPERFTICKCOUNTER(_perf_define_appclass_selftime, SUN_CLS, "defineAppClassTime.self");
1375 NEWPERFBYTECOUNTER(_perf_app_classfile_bytes_read, SUN_CLS, "appClassBytes");
1376 NEWPERFBYTECOUNTER(_perf_sys_classfile_bytes_read, SUN_CLS, "sysClassBytes");
1377 NEWPERFEVENTCOUNTER(_unsafe_defineClassCallCounter, SUN_CLS, "unsafeDefineClassCalls");
1378 NEWPERFTICKCOUNTER(_perf_secondary_hash_time, SUN_CLS, "secondarySuperHashTime");
1379
1380 if (log_is_enabled(Info, perf, class, link) || log_is_enabled(Info, init)) {
1381 NEWPERFTICKCOUNTER(_perf_preload_total_time, SUN_CLS, "preloadTotalTime");
1382 NEWPERFTICKCOUNTER(_perf_preload_time, SUN_CLS, "preloadTime");
1383 NEWPERFTICKCOUNTER(_perf_prelink_time, SUN_CLS, "prelinkTime");
1384 NEWPERFTICKCOUNTER(_perf_preinit_time, SUN_CLS, "preinitTime");
1385 NEWPERFTICKCOUNTER(_perf_preresolve_time, SUN_CLS, "preresolveTime");
1386
1387 NEWPERFTICKCOUNTER(_perf_ik_link_methods_time, SUN_CLS, "linkMethodsTime");
1388 NEWPERFTICKCOUNTER(_perf_method_adapters_time, SUN_CLS, "makeAdaptersTime");
1389 NEWPERFEVENTCOUNTER(_perf_ik_link_methods_count, SUN_CLS, "linkMethodsCount");
1390 NEWPERFEVENTCOUNTER(_perf_method_adapters_count, SUN_CLS, "makeAdaptersCount");
1391
1392 NEWPERFTICKCOUNTERS(_perf_resolve_indy_time, SUN_CLS, "resolve_invokedynamic_time");
1393 NEWPERFTICKCOUNTERS(_perf_resolve_invokehandle_time, SUN_CLS, "resolve_invokehandle_time");
1394 NEWPERFTICKCOUNTERS(_perf_resolve_mh_time, SUN_CLS, "resolve_MethodHandle_time");
1395 NEWPERFTICKCOUNTERS(_perf_resolve_mt_time, SUN_CLS, "resolve_MethodType_time");
1396
1397 NEWPERFEVENTCOUNTER(_perf_resolve_indy_count, SUN_CLS, "resolve_invokedynamic_count");
1398 NEWPERFEVENTCOUNTER(_perf_resolve_invokehandle_count, SUN_CLS, "resolve_invokehandle_count");
1399 NEWPERFEVENTCOUNTER(_perf_resolve_mh_count, SUN_CLS, "resolve_MethodHandle_count");
1400 NEWPERFEVENTCOUNTER(_perf_resolve_mt_count, SUN_CLS, "resolve_MethodType_count");
1401 }
1402 }
1403
1404 // lookup java library entry points
1405 load_java_library();
1406 // jimage library entry points are loaded below, in lookup_vm_options
1407 setup_bootstrap_search_path(THREAD);
1408 }
1409
1410 static char* lookup_vm_resource(JImageFile *jimage, const char *jimage_version, const char *path) {
1411 jlong size;
1412 JImageLocationRef location = (*JImageFindResource)(jimage, "java.base", jimage_version, path, &size);
1413 if (location == 0)
1414 return nullptr;
1415 char *val = NEW_C_HEAP_ARRAY(char, size+1, mtClass);
1440
1441 bool ClassLoader::is_module_observable(const char* module_name) {
1442 assert(JImageOpen != nullptr, "jimage library should have been opened");
1443 if (JImage_file == nullptr) {
1444 struct stat st;
1445 const char *path = get_exploded_module_path(module_name, true);
1446 bool res = os::stat(path, &st) == 0;
1447 FREE_C_HEAP_ARRAY(char, path);
1448 return res;
1449 }
1450 jlong size;
1451 const char *jimage_version = get_jimage_version_string();
1452 return (*JImageFindResource)(JImage_file, module_name, jimage_version, "module-info.class", &size) != 0;
1453 }
1454
1455 jlong ClassLoader::classloader_time_ms() {
1456 return UsePerfData ?
1457 Management::ticks_to_ms(_perf_accumulated_time->get_value()) : -1;
1458 }
1459
1460 jlong ClassLoader::class_init_bytecodes_count() {
1461 return UsePerfData ? _perf_class_init_bytecodes_count->get_value() : -1;
1462 }
1463
1464 jlong ClassLoader::class_init_count() {
1465 return UsePerfData ? _perf_classes_inited->get_value() : -1;
1466 }
1467
1468 jlong ClassLoader::class_init_time_ms() {
1469 return UsePerfData ?
1470 Management::ticks_to_ms(_perf_class_init_time->get_value()) : -1;
1471 }
1472
1473 jlong ClassLoader::class_verify_time_ms() {
1474 return UsePerfData ?
1475 Management::ticks_to_ms(_perf_class_verify_time->get_value()) : -1;
1476 }
1477
1478 jlong ClassLoader::class_link_count() {
1479 return UsePerfData ? _perf_classes_linked->get_value() : -1;
1480 }
1481
1482 jlong ClassLoader::class_link_time_ms() {
1483 return UsePerfData ?
|