1 /*
2 * Copyright (c) 1997, 2016, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "classfile/classFileStream.hpp"
27 #include "classfile/classLoader.hpp"
28 #include "classfile/classLoaderData.inline.hpp"
29 #include "classfile/classLoaderExt.hpp"
30 #include "classfile/javaClasses.hpp"
31 #include "classfile/jimage.hpp"
32 #include "classfile/klassFactory.hpp"
33 #include "classfile/systemDictionary.hpp"
34 #include "classfile/vmSymbols.hpp"
35 #include "compiler/compileBroker.hpp"
36 #include "gc/shared/collectedHeap.inline.hpp"
37 #include "gc/shared/generation.hpp"
38 #include "interpreter/bytecodeStream.hpp"
39 #include "interpreter/oopMapCache.hpp"
40 #include "logging/log.hpp"
41 #include "memory/allocation.inline.hpp"
42 #include "memory/filemap.hpp"
43 #include "memory/oopFactory.hpp"
44 #include "memory/universe.inline.hpp"
45 #include "oops/instanceKlass.hpp"
46 #include "oops/instanceRefKlass.hpp"
47 #include "oops/oop.inline.hpp"
48 #include "oops/symbol.hpp"
49 #include "prims/jvm_misc.hpp"
50 #include "runtime/arguments.hpp"
51 #include "runtime/compilationPolicy.hpp"
52 #include "runtime/fprofiler.hpp"
53 #include "runtime/handles.hpp"
54 #include "runtime/handles.inline.hpp"
55 #include "runtime/init.hpp"
56 #include "runtime/interfaceSupport.hpp"
57 #include "runtime/java.hpp"
58 #include "runtime/javaCalls.hpp"
59 #include "runtime/os.hpp"
60 #include "runtime/threadCritical.hpp"
61 #include "runtime/timer.hpp"
62 #include "runtime/vm_version.hpp"
63 #include "services/management.hpp"
64 #include "services/threadService.hpp"
65 #include "utilities/events.hpp"
66 #include "utilities/hashtable.inline.hpp"
67 #include "utilities/macros.hpp"
68 #if INCLUDE_CDS
69 #include "classfile/sharedClassUtil.hpp"
70 #include "classfile/sharedPathsMiscInfo.hpp"
71 #endif
72
73 // Entry points in zip.dll for loading zip/jar file entries
74
75 typedef void * * (JNICALL *ZipOpen_t)(const char *name, char **pmsg);
76 typedef void (JNICALL *ZipClose_t)(jzfile *zip);
77 typedef jzentry* (JNICALL *FindEntry_t)(jzfile *zip, const char *name, jint *sizeP, jint *nameLen);
78 typedef jboolean (JNICALL *ReadEntry_t)(jzfile *zip, jzentry *entry, unsigned char *buf, char *namebuf);
79 typedef jboolean (JNICALL *ReadMappedEntry_t)(jzfile *zip, jzentry *entry, unsigned char **buf, char *namebuf);
80 typedef jzentry* (JNICALL *GetNextEntry_t)(jzfile *zip, jint n);
81 typedef jboolean (JNICALL *ZipInflateFully_t)(void *inBuf, jlong inLen, void *outBuf, jlong outLen, char **pmsg);
82 typedef jint (JNICALL *Crc32_t)(jint crc, const jbyte *buf, jint len);
83
84 static ZipOpen_t ZipOpen = NULL;
85 static ZipClose_t ZipClose = NULL;
86 static FindEntry_t FindEntry = NULL;
87 static ReadEntry_t ReadEntry = NULL;
88 static ReadMappedEntry_t ReadMappedEntry = NULL;
89 static GetNextEntry_t GetNextEntry = NULL;
90 static canonicalize_fn_t CanonicalizeEntry = NULL;
91 static ZipInflateFully_t ZipInflateFully = NULL;
92 static Crc32_t Crc32 = NULL;
93
94 // Entry points for jimage.dll for loading jimage file entries
95
96 static JImageOpen_t JImageOpen = NULL;
97 static JImageClose_t JImageClose = NULL;
98 static JImagePackageToModule_t JImagePackageToModule = NULL;
99 static JImageFindResource_t JImageFindResource = NULL;
100 static JImageGetResource_t JImageGetResource = NULL;
101 static JImageResourceIterator_t JImageResourceIterator = NULL;
102
103 // Globals
104
105 PerfCounter* ClassLoader::_perf_accumulated_time = NULL;
106 PerfCounter* ClassLoader::_perf_classes_inited = NULL;
107 PerfCounter* ClassLoader::_perf_class_init_time = NULL;
108 PerfCounter* ClassLoader::_perf_class_init_selftime = NULL;
109 PerfCounter* ClassLoader::_perf_classes_verified = NULL;
110 PerfCounter* ClassLoader::_perf_class_verify_time = NULL;
111 PerfCounter* ClassLoader::_perf_class_verify_selftime = NULL;
112 PerfCounter* ClassLoader::_perf_classes_linked = NULL;
113 PerfCounter* ClassLoader::_perf_class_link_time = NULL;
114 PerfCounter* ClassLoader::_perf_class_link_selftime = NULL;
115 PerfCounter* ClassLoader::_perf_class_parse_time = NULL;
116 PerfCounter* ClassLoader::_perf_class_parse_selftime = NULL;
117 PerfCounter* ClassLoader::_perf_sys_class_lookup_time = NULL;
118 PerfCounter* ClassLoader::_perf_shared_classload_time = NULL;
119 PerfCounter* ClassLoader::_perf_sys_classload_time = NULL;
120 PerfCounter* ClassLoader::_perf_app_classload_time = NULL;
121 PerfCounter* ClassLoader::_perf_app_classload_selftime = NULL;
122 PerfCounter* ClassLoader::_perf_app_classload_count = NULL;
123 PerfCounter* ClassLoader::_perf_define_appclasses = NULL;
124 PerfCounter* ClassLoader::_perf_define_appclass_time = NULL;
125 PerfCounter* ClassLoader::_perf_define_appclass_selftime = NULL;
126 PerfCounter* ClassLoader::_perf_app_classfile_bytes_read = NULL;
127 PerfCounter* ClassLoader::_perf_sys_classfile_bytes_read = NULL;
128 PerfCounter* ClassLoader::_sync_systemLoaderLockContentionRate = NULL;
129 PerfCounter* ClassLoader::_sync_nonSystemLoaderLockContentionRate = NULL;
130 PerfCounter* ClassLoader::_sync_JVMFindLoadedClassLockFreeCounter = NULL;
131 PerfCounter* ClassLoader::_sync_JVMDefineClassLockFreeCounter = NULL;
132 PerfCounter* ClassLoader::_sync_JNIDefineClassLockFreeCounter = NULL;
133 PerfCounter* ClassLoader::_unsafe_defineClassCallCounter = NULL;
134 PerfCounter* ClassLoader::_isUnsyncloadClass = NULL;
135 PerfCounter* ClassLoader::_load_instance_class_failCounter = NULL;
136
137 ClassPathEntry* ClassLoader::_first_entry = NULL;
138 ClassPathEntry* ClassLoader::_last_entry = NULL;
139 int ClassLoader::_num_entries = 0;
140 PackageHashtable* ClassLoader::_package_hash_table = NULL;
141
142 #if INCLUDE_CDS
143 SharedPathsMiscInfo* ClassLoader::_shared_paths_misc_info = NULL;
144 #endif
145 // helper routines
146 bool string_starts_with(const char* str, const char* str_to_find) {
147 size_t str_len = strlen(str);
148 size_t str_to_find_len = strlen(str_to_find);
149 if (str_to_find_len > str_len) {
150 return false;
151 }
152 return (strncmp(str, str_to_find, str_to_find_len) == 0);
153 }
154
155 static const char* get_jimage_version_string() {
156 static char version_string[10] = "";
157 if (version_string[0] == '\0') {
158 jio_snprintf(version_string, sizeof(version_string), "%d.%d",
159 Abstract_VM_Version::vm_major_version(), Abstract_VM_Version::vm_minor_version());
160 }
161 return (const char*)version_string;
162 }
163
164 bool string_ends_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_len - str_to_find_len), str_to_find, str_to_find_len) == 0);
171 }
172
173
174 ClassPathDirEntry::ClassPathDirEntry(const char* dir) : ClassPathEntry() {
175 char* copy = NEW_C_HEAP_ARRAY(char, strlen(dir)+1, mtClass);
176 strcpy(copy, dir);
177 _dir = copy;
178 }
179
180
181 ClassFileStream* ClassPathDirEntry::open_stream(const char* name, TRAPS) {
182 // construct full path name
183 char path[JVM_MAXPATHLEN];
184 if (jio_snprintf(path, sizeof(path), "%s%s%s", _dir, os::file_separator(), name) == -1) {
185 return NULL;
186 }
187 // check if file exists
188 struct stat st;
189 if (os::stat(path, &st) == 0) {
190 #if INCLUDE_CDS
191 if (DumpSharedSpaces) {
192 // We have already check in ClassLoader::check_shared_classpath() that the directory is empty, so
193 // we should never find a file underneath it -- unless user has added a new file while we are running
194 // the dump, in which case let's quit!
195 ShouldNotReachHere();
196 }
197 #endif
198 // found file, open it
199 int file_handle = os::open(path, 0, 0);
200 if (file_handle != -1) {
201 // read contents into resource array
202 u1* buffer = NEW_RESOURCE_ARRAY(u1, st.st_size);
203 size_t num_read = os::read(file_handle, (char*) buffer, st.st_size);
204 // close file
205 os::close(file_handle);
206 // construct ClassFileStream
207 if (num_read == (size_t)st.st_size) {
208 if (UsePerfData) {
209 ClassLoader::perf_sys_classfile_bytes_read()->inc(num_read);
210 }
211 // Resource allocated
212 return new ClassFileStream(buffer,
213 st.st_size,
214 _dir,
215 ClassFileStream::verify);
216 }
217 }
218 }
219 return NULL;
220 }
221
222 ClassPathZipEntry::ClassPathZipEntry(jzfile* zip, const char* zip_name) : ClassPathEntry() {
223 _zip = zip;
224 char *copy = NEW_C_HEAP_ARRAY(char, strlen(zip_name)+1, mtClass);
225 strcpy(copy, zip_name);
226 _zip_name = copy;
227 }
228
229 ClassPathZipEntry::~ClassPathZipEntry() {
230 if (ZipClose != NULL) {
231 (*ZipClose)(_zip);
232 }
233 FREE_C_HEAP_ARRAY(char, _zip_name);
234 }
235
236 u1* ClassPathZipEntry::open_entry(const char* name, jint* filesize, bool nul_terminate, TRAPS) {
237 // enable call to C land
238 JavaThread* thread = JavaThread::current();
239 ThreadToNativeFromVM ttn(thread);
240 // check whether zip archive contains name
241 jint name_len;
242 jzentry* entry = (*FindEntry)(_zip, name, filesize, &name_len);
243 if (entry == NULL) return NULL;
244 u1* buffer;
245 char name_buf[128];
246 char* filename;
247 if (name_len < 128) {
248 filename = name_buf;
249 } else {
250 filename = NEW_RESOURCE_ARRAY(char, name_len + 1);
251 }
252
253 // file found, get pointer to the entry in mmapped jar file.
254 if (ReadMappedEntry == NULL ||
255 !(*ReadMappedEntry)(_zip, entry, &buffer, filename)) {
256 // mmapped access not available, perhaps due to compression,
257 // read contents into resource array
258 int size = (*filesize) + ((nul_terminate) ? 1 : 0);
259 buffer = NEW_RESOURCE_ARRAY(u1, size);
260 if (!(*ReadEntry)(_zip, entry, buffer, filename)) return NULL;
261 }
262
263 // return result
264 if (nul_terminate) {
265 buffer[*filesize] = 0;
266 }
267 return buffer;
268 }
269
270 ClassFileStream* ClassPathZipEntry::open_stream(const char* name, TRAPS) {
271 jint filesize;
272 const u1* buffer = open_entry(name, &filesize, false, CHECK_NULL);
273 if (buffer == NULL) {
274 return NULL;
275 }
276 if (UsePerfData) {
277 ClassLoader::perf_sys_classfile_bytes_read()->inc(filesize);
278 }
279 // Resource allocated
280 return new ClassFileStream(buffer,
281 filesize,
282 _zip_name,
283 ClassFileStream::verify);
284 }
285
286 // invoke function for each entry in the zip file
287 void ClassPathZipEntry::contents_do(void f(const char* name, void* context), void* context) {
288 JavaThread* thread = JavaThread::current();
289 HandleMark handle_mark(thread);
290 ThreadToNativeFromVM ttn(thread);
291 for (int n = 0; ; n++) {
292 jzentry * ze = ((*GetNextEntry)(_zip, n));
293 if (ze == NULL) break;
294 (*f)(ze->name, context);
295 }
296 }
297
298 ClassPathImageEntry::ClassPathImageEntry(JImageFile* jimage, const char* name) :
299 ClassPathEntry(),
300 _jimage(jimage) {
301 guarantee(jimage != NULL, "jimage file is null");
302 guarantee(name != NULL, "jimage file name is null");
303 size_t len = strlen(name) + 1;
304 _name = NEW_C_HEAP_ARRAY(const char, len, mtClass);
305 strncpy((char *)_name, name, len);
306 }
307
308 ClassPathImageEntry::~ClassPathImageEntry() {
309 if (_name != NULL) {
310 FREE_C_HEAP_ARRAY(const char, _name);
311 _name = NULL;
312 }
313 if (_jimage != NULL) {
314 (*JImageClose)(_jimage);
315 _jimage = NULL;
316 }
317 }
318
319 void ClassPathImageEntry::name_to_package(const char* name, char* buffer, int length) {
320 const char *pslash = strrchr(name, '/');
321 if (pslash == NULL) {
322 buffer[0] = '\0';
323 return;
324 }
325 int len = pslash - name;
326 #if INCLUDE_CDS
327 if (len <= 0 && DumpSharedSpaces) {
328 buffer[0] = '\0';
329 return;
330 }
331 #endif
332 assert(len > 0, "Bad length for package name");
333 if (len >= length) {
334 buffer[0] = '\0';
335 return;
336 }
337 // drop name after last slash (including slash)
338 // Ex., "java/lang/String.class" => "java/lang"
339 strncpy(buffer, name, len);
340 // ensure string termination (strncpy does not guarantee)
341 buffer[len] = '\0';
342 }
343
344 // For a class in a named module, look it up in the jimage file using this syntax:
345 // /<module-name>/<package-name>/<base-class>
346 //
347 // Assumptions:
348 // 1. There are no unnamed modules in the jimage file.
349 // 2. A package is in at most one module in the jimage file.
350 //
351 ClassFileStream* ClassPathImageEntry::open_stream(const char* name, TRAPS) {
352 jlong size;
353 JImageLocationRef location = (*JImageFindResource)(_jimage, "", get_jimage_version_string(), name, &size);
354
355 if (location == 0) {
356 char package[JIMAGE_MAX_PATH];
357 name_to_package(name, package, JIMAGE_MAX_PATH);
358 if (package[0] != '\0') {
359 const char* module = (*JImagePackageToModule)(_jimage, package);
360 if (module == NULL) {
361 module = "java.base";
362 }
363 location = (*JImageFindResource)(_jimage, module, get_jimage_version_string(), name, &size);
364 }
365 }
366
367 if (location != 0) {
368 if (UsePerfData) {
369 ClassLoader::perf_sys_classfile_bytes_read()->inc(size);
370 }
371 char* data = NEW_RESOURCE_ARRAY(char, size);
372 (*JImageGetResource)(_jimage, location, data, size);
373 // Resource allocated
374 return new ClassFileStream((u1*)data,
375 (int)size,
376 _name,
377 ClassFileStream::verify);
378 }
379
380 return NULL;
381 }
382
383 #ifndef PRODUCT
384 bool ctw_visitor(JImageFile* jimage,
385 const char* module_name, const char* version, const char* package,
386 const char* name, const char* extension, void* arg) {
387 if (strcmp(extension, "class") == 0) {
388 Thread* THREAD = Thread::current();
389 char path[JIMAGE_MAX_PATH];
390 jio_snprintf(path, JIMAGE_MAX_PATH - 1, "%s/%s.class", package, name);
391 ClassLoader::compile_the_world_in(path, *(Handle*)arg, THREAD);
392 return !HAS_PENDING_EXCEPTION;
393 }
394 return true;
395 }
396
397 void ClassPathImageEntry::compile_the_world(Handle loader, TRAPS) {
398 tty->print_cr("CompileTheWorld : Compiling all classes in %s", name());
399 tty->cr();
400 (*JImageResourceIterator)(_jimage, (JImageResourceVisitor_t)ctw_visitor, (void *)&loader);
401 if (HAS_PENDING_EXCEPTION) {
402 if (PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())) {
403 CLEAR_PENDING_EXCEPTION;
404 tty->print_cr("\nCompileTheWorld : Ran out of memory\n");
405 tty->print_cr("Increase class metadata storage if a limit was set");
406 } else {
407 tty->print_cr("\nCompileTheWorld : Unexpected exception occurred\n");
408 }
409 }
410 }
411
412 bool ClassPathImageEntry::is_jrt() {
413 return string_ends_with(name(), BOOT_IMAGE_NAME);
414 }
415 #endif
416
417 #if INCLUDE_CDS
418 void ClassLoader::exit_with_path_failure(const char* error, const char* message) {
419 assert(DumpSharedSpaces, "only called at dump time");
420 tty->print_cr("Hint: enable -XX:+TraceClassPaths to diagnose the failure");
421 vm_exit_during_initialization(error, message);
422 }
423 #endif
424
425 void ClassLoader::trace_class_path(outputStream* out, const char* msg, const char* name) {
426 if (!TraceClassPaths) {
427 return;
428 }
429
430 if (msg) {
431 out->print("%s", msg);
432 }
433 if (name) {
434 if (strlen(name) < 256) {
435 out->print("%s", name);
436 } else {
437 // For very long paths, we need to print each character separately,
438 // as print_cr() has a length limit
439 while (name[0] != '\0') {
440 out->print("%c", name[0]);
441 name++;
442 }
443 }
444 }
445 if (msg && msg[0] == '[') {
446 out->print_cr("]");
447 } else {
448 out->cr();
449 }
450 }
451
452 #if INCLUDE_CDS
453 void ClassLoader::check_shared_classpath(const char *path) {
454 if (strcmp(path, "") == 0) {
455 exit_with_path_failure("Cannot have empty path in archived classpaths", NULL);
456 }
457
458 struct stat st;
459 if (os::stat(path, &st) == 0) {
460 if ((st.st_mode & S_IFREG) != S_IFREG) { // is directory
461 if (!os::dir_is_empty(path)) {
462 tty->print_cr("Error: non-empty directory '%s'", path);
463 exit_with_path_failure("CDS allows only empty directories in archived classpaths", NULL);
464 }
465 }
466 }
467 }
468 #endif
469
470 void ClassLoader::setup_bootstrap_search_path() {
471 assert(_first_entry == NULL, "should not setup bootstrap class search path twice");
472 const char* sys_class_path = Arguments::get_sysclasspath();
473 if (PrintSharedArchiveAndExit) {
474 // Don't print sys_class_path - this is the bootcp of this current VM process, not necessarily
475 // the same as the bootcp of the shared archive.
476 } else {
477 trace_class_path(tty, "[Bootstrap loader class path=", sys_class_path);
478 }
479 #if INCLUDE_CDS
480 if (DumpSharedSpaces) {
481 _shared_paths_misc_info->add_boot_classpath(sys_class_path);
482 }
483 #endif
484 setup_search_path(sys_class_path);
485 }
486
487 #if INCLUDE_CDS
488 int ClassLoader::get_shared_paths_misc_info_size() {
489 return _shared_paths_misc_info->get_used_bytes();
490 }
491
492 void* ClassLoader::get_shared_paths_misc_info() {
493 return _shared_paths_misc_info->buffer();
494 }
495
496 bool ClassLoader::check_shared_paths_misc_info(void *buf, int size) {
497 SharedPathsMiscInfo* checker = SharedClassUtil::allocate_shared_paths_misc_info((char*)buf, size);
498 bool result = checker->check();
499 delete checker;
500 return result;
501 }
502 #endif
503
504 void ClassLoader::setup_search_path(const char *class_path) {
505 int offset = 0;
506 int len = (int)strlen(class_path);
507 int end = 0;
508
509 // Iterate over class path entries
510 for (int start = 0; start < len; start = end) {
511 while (class_path[end] && class_path[end] != os::path_separator()[0]) {
512 end++;
513 }
514 EXCEPTION_MARK;
515 ResourceMark rm(THREAD);
516 char* path = NEW_RESOURCE_ARRAY(char, end - start + 1);
517 strncpy(path, &class_path[start], end - start);
518 path[end - start] = '\0';
519 update_class_path_entry_list(path, false);
520 #if INCLUDE_CDS
521 if (DumpSharedSpaces) {
522 check_shared_classpath(path);
523 }
524 #endif
525 while (class_path[end] == os::path_separator()[0]) {
526 end++;
527 }
528 }
529 }
530
531 ClassPathEntry* ClassLoader::create_class_path_entry(const char *path, const struct stat* st,
532 bool throw_exception, TRAPS) {
533 JavaThread* thread = JavaThread::current();
534 ClassPathEntry* new_entry = NULL;
535 if ((st->st_mode & S_IFREG) == S_IFREG) {
536 // Regular file, should be a zip or jimage file
537 // Canonicalized filename
538 char canonical_path[JVM_MAXPATHLEN];
539 if (!get_canonical_path(path, canonical_path, JVM_MAXPATHLEN)) {
540 // This matches the classic VM
541 if (throw_exception) {
542 THROW_MSG_(vmSymbols::java_io_IOException(), "Bad pathname", NULL);
543 } else {
544 return NULL;
545 }
546 }
547 jint error;
548 JImageFile* jimage =(*JImageOpen)(canonical_path, &error);
549 if (jimage != NULL) {
550 new_entry = new ClassPathImageEntry(jimage, canonical_path);
551 } else {
552 char* error_msg = NULL;
553 jzfile* zip;
554 {
555 // enable call to C land
556 ThreadToNativeFromVM ttn(thread);
557 HandleMark hm(thread);
558 zip = (*ZipOpen)(canonical_path, &error_msg);
559 }
560 if (zip != NULL && error_msg == NULL) {
561 new_entry = new ClassPathZipEntry(zip, path);
562 } else {
563 ResourceMark rm(thread);
564 char *msg;
565 if (error_msg == NULL) {
566 msg = NEW_RESOURCE_ARRAY(char, strlen(path) + 128); ;
567 jio_snprintf(msg, strlen(path) + 127, "error in opening JAR file %s", path);
568 } else {
569 int len = (int)(strlen(path) + strlen(error_msg) + 128);
570 msg = NEW_RESOURCE_ARRAY(char, len); ;
571 jio_snprintf(msg, len - 1, "error in opening JAR file <%s> %s", error_msg, path);
572 }
573 // Don't complain about bad jar files added via -Xbootclasspath/a:.
574 if (throw_exception && is_init_completed()) {
575 THROW_MSG_(vmSymbols::java_lang_ClassNotFoundException(), msg, NULL);
576 } else {
577 return NULL;
578 }
579 }
580 }
581 if (log_is_enabled(Info, classload)) {
582 outputStream* log = LogHandle(classload)::info_stream();
583 log->print_cr("[Opened %s]", path);
584 }
585 } else {
586 // Directory
587 new_entry = new ClassPathDirEntry(path);
588 if (log_is_enabled(Info, classload)) {
589 outputStream* log = LogHandle(classload)::info_stream();
590 log->print_cr("[Path %s]", path);
591 }
592 }
593 return new_entry;
594 }
595
596
597 // Create a class path zip entry for a given path (return NULL if not found
598 // or zip/JAR file cannot be opened)
599 ClassPathZipEntry* ClassLoader::create_class_path_zip_entry(const char *path) {
600 // check for a regular file
601 struct stat st;
602 if (os::stat(path, &st) == 0) {
603 if ((st.st_mode & S_IFREG) == S_IFREG) {
604 char canonical_path[JVM_MAXPATHLEN];
605 if (get_canonical_path(path, canonical_path, JVM_MAXPATHLEN)) {
606 char* error_msg = NULL;
607 jzfile* zip;
608 {
609 // enable call to C land
610 JavaThread* thread = JavaThread::current();
611 ThreadToNativeFromVM ttn(thread);
612 HandleMark hm(thread);
613 zip = (*ZipOpen)(canonical_path, &error_msg);
614 }
615 if (zip != NULL && error_msg == NULL) {
616 // create using canonical path
617 return new ClassPathZipEntry(zip, canonical_path);
618 }
619 }
620 }
621 }
622 return NULL;
623 }
624
625 // returns true if entry already on class path
626 bool ClassLoader::contains_entry(ClassPathEntry *entry) {
627 ClassPathEntry* e = _first_entry;
628 while (e != NULL) {
629 // assume zip entries have been canonicalized
630 if (strcmp(entry->name(), e->name()) == 0) {
631 return true;
632 }
633 e = e->next();
634 }
635 return false;
636 }
637
638 void ClassLoader::add_to_list(ClassPathEntry *new_entry) {
639 if (new_entry != NULL) {
640 if (_last_entry == NULL) {
641 _first_entry = _last_entry = new_entry;
642 } else {
643 _last_entry->set_next(new_entry);
644 _last_entry = new_entry;
645 }
646 }
647 _num_entries ++;
648 }
649
650 // Returns true IFF the file/dir exists and the entry was successfully created.
651 bool ClassLoader::update_class_path_entry_list(const char *path,
652 bool check_for_duplicates,
653 bool throw_exception) {
654 struct stat st;
655 if (os::stat(path, &st) == 0) {
656 // File or directory found
657 ClassPathEntry* new_entry = NULL;
658 Thread* THREAD = Thread::current();
659 new_entry = create_class_path_entry(path, &st, throw_exception, CHECK_(false));
660 if (new_entry == NULL) {
661 return false;
662 }
663 // The kernel VM adds dynamically to the end of the classloader path and
664 // doesn't reorder the bootclasspath which would break java.lang.Package
665 // (see PackageInfo).
666 // Add new entry to linked list
667 if (!check_for_duplicates || !contains_entry(new_entry)) {
668 ClassLoaderExt::add_class_path_entry(path, check_for_duplicates, new_entry);
669 }
670 return true;
671 } else {
672 #if INCLUDE_CDS
673 if (DumpSharedSpaces) {
674 _shared_paths_misc_info->add_nonexist_path(path);
675 }
676 #endif
677 return false;
678 }
679 }
680
681 void ClassLoader::print_bootclasspath() {
682 ClassPathEntry* e = _first_entry;
683 tty->print("[bootclasspath= ");
684 while (e != NULL) {
685 tty->print("%s ;", e->name());
686 e = e->next();
687 }
688 tty->print_cr("]");
689 }
690
691 void ClassLoader::load_zip_library() {
692 assert(ZipOpen == NULL, "should not load zip library twice");
693 // First make sure native library is loaded
694 os::native_java_library();
695 // Load zip library
696 char path[JVM_MAXPATHLEN];
697 char ebuf[1024];
698 void* handle = NULL;
699 if (os::dll_build_name(path, sizeof(path), Arguments::get_dll_dir(), "zip")) {
700 handle = os::dll_load(path, ebuf, sizeof ebuf);
701 }
702 if (handle == NULL) {
703 vm_exit_during_initialization("Unable to load ZIP library", path);
704 }
705 // Lookup zip entry points
706 ZipOpen = CAST_TO_FN_PTR(ZipOpen_t, os::dll_lookup(handle, "ZIP_Open"));
707 ZipClose = CAST_TO_FN_PTR(ZipClose_t, os::dll_lookup(handle, "ZIP_Close"));
708 FindEntry = CAST_TO_FN_PTR(FindEntry_t, os::dll_lookup(handle, "ZIP_FindEntry"));
709 ReadEntry = CAST_TO_FN_PTR(ReadEntry_t, os::dll_lookup(handle, "ZIP_ReadEntry"));
710 ReadMappedEntry = CAST_TO_FN_PTR(ReadMappedEntry_t, os::dll_lookup(handle, "ZIP_ReadMappedEntry"));
711 GetNextEntry = CAST_TO_FN_PTR(GetNextEntry_t, os::dll_lookup(handle, "ZIP_GetNextEntry"));
712 ZipInflateFully = CAST_TO_FN_PTR(ZipInflateFully_t, os::dll_lookup(handle, "ZIP_InflateFully"));
713 Crc32 = CAST_TO_FN_PTR(Crc32_t, os::dll_lookup(handle, "ZIP_CRC32"));
714
715 // ZIP_Close is not exported on Windows in JDK5.0 so don't abort if ZIP_Close is NULL
716 if (ZipOpen == NULL || FindEntry == NULL || ReadEntry == NULL ||
717 GetNextEntry == NULL || Crc32 == NULL) {
718 vm_exit_during_initialization("Corrupted ZIP library", path);
719 }
720
721 if (ZipInflateFully == NULL) {
722 vm_exit_during_initialization("Corrupted ZIP library ZIP_InflateFully missing", path);
723 }
724
725 // Lookup canonicalize entry in libjava.dll
726 void *javalib_handle = os::native_java_library();
727 CanonicalizeEntry = CAST_TO_FN_PTR(canonicalize_fn_t, os::dll_lookup(javalib_handle, "Canonicalize"));
728 // This lookup only works on 1.3. Do not check for non-null here
729 }
730
731 void ClassLoader::load_jimage_library() {
732 // First make sure native library is loaded
733 os::native_java_library();
734 // Load jimage library
735 char path[JVM_MAXPATHLEN];
736 char ebuf[1024];
737 void* handle = NULL;
738 if (os::dll_build_name(path, sizeof(path), Arguments::get_dll_dir(), "jimage")) {
739 handle = os::dll_load(path, ebuf, sizeof ebuf);
740 }
741 if (handle == NULL) {
742 vm_exit_during_initialization("Unable to load jimage library", path);
743 }
744
745 // Lookup jimage entry points
746 JImageOpen = CAST_TO_FN_PTR(JImageOpen_t, os::dll_lookup(handle, "JIMAGE_Open"));
747 guarantee(JImageOpen != NULL, "function JIMAGE_Open not found");
748 JImageClose = CAST_TO_FN_PTR(JImageClose_t, os::dll_lookup(handle, "JIMAGE_Close"));
749 guarantee(JImageClose != NULL, "function JIMAGE_Close not found");
750 JImagePackageToModule = CAST_TO_FN_PTR(JImagePackageToModule_t, os::dll_lookup(handle, "JIMAGE_PackageToModule"));
751 guarantee(JImagePackageToModule != NULL, "function JIMAGE_PackageToModule not found");
752 JImageFindResource = CAST_TO_FN_PTR(JImageFindResource_t, os::dll_lookup(handle, "JIMAGE_FindResource"));
753 guarantee(JImageFindResource != NULL, "function JIMAGE_FindResource not found");
754 JImageGetResource = CAST_TO_FN_PTR(JImageGetResource_t, os::dll_lookup(handle, "JIMAGE_GetResource"));
755 guarantee(JImageGetResource != NULL, "function JIMAGE_GetResource not found");
756 JImageResourceIterator = CAST_TO_FN_PTR(JImageResourceIterator_t, os::dll_lookup(handle, "JIMAGE_ResourceIterator"));
757 guarantee(JImageResourceIterator != NULL, "function JIMAGE_ResourceIterator not found");
758 }
759
760 jboolean ClassLoader::decompress(void *in, u8 inSize, void *out, u8 outSize, char **pmsg) {
761 return (*ZipInflateFully)(in, inSize, out, outSize, pmsg);
762 }
763
764 int ClassLoader::crc32(int crc, const char* buf, int len) {
765 assert(Crc32 != NULL, "ZIP_CRC32 is not found");
766 return (*Crc32)(crc, (const jbyte*)buf, len);
767 }
768
769 // PackageInfo data exists in order to support the java.lang.Package
770 // class. A Package object provides information about a java package
771 // (version, vendor, etc.) which originates in the manifest of the jar
772 // file supplying the package. For application classes, the ClassLoader
773 // object takes care of this.
774
775 // For system (boot) classes, the Java code in the Package class needs
776 // to be able to identify which source jar file contained the boot
777 // class, so that it can extract the manifest from it. This table
778 // identifies java packages with jar files in the boot classpath.
779
780 // Because the boot classpath cannot change, the classpath index is
781 // sufficient to identify the source jar file or directory. (Since
782 // directories have no manifests, the directory name is not required,
783 // but is available.)
784
785 // When using sharing -- the pathnames of entries in the boot classpath
786 // may not be the same at runtime as they were when the archive was
787 // created (NFS, Samba, etc.). The actual files and directories named
788 // in the classpath must be the same files, in the same order, even
789 // though the exact name is not the same.
790
791 class PackageInfo: public BasicHashtableEntry<mtClass> {
792 public:
793 const char* _pkgname; // Package name
794 int _classpath_index; // Index of directory or JAR file loaded from
795
796 PackageInfo* next() {
797 return (PackageInfo*)BasicHashtableEntry<mtClass>::next();
798 }
799
800 const char* pkgname() { return _pkgname; }
801 void set_pkgname(char* pkgname) { _pkgname = pkgname; }
802
803 const char* filename() {
804 return ClassLoader::classpath_entry(_classpath_index)->name();
805 }
806
807 void set_index(int index) {
808 _classpath_index = index;
809 }
810 };
811
812
813 class PackageHashtable : public BasicHashtable<mtClass> {
814 private:
815 inline unsigned int compute_hash(const char *s, int n) {
816 unsigned int val = 0;
817 while (--n >= 0) {
818 val = *s++ + 31 * val;
819 }
820 return val;
821 }
822
823 PackageInfo* bucket(int index) {
824 return (PackageInfo*)BasicHashtable<mtClass>::bucket(index);
825 }
826
827 PackageInfo* get_entry(int index, unsigned int hash,
828 const char* pkgname, size_t n) {
829 for (PackageInfo* pp = bucket(index); pp != NULL; pp = pp->next()) {
830 if (pp->hash() == hash &&
831 strncmp(pkgname, pp->pkgname(), n) == 0 &&
832 pp->pkgname()[n] == '\0') {
833 return pp;
834 }
835 }
836 return NULL;
837 }
838
839 public:
840 PackageHashtable(int table_size)
841 : BasicHashtable<mtClass>(table_size, sizeof(PackageInfo)) {}
842
843 PackageHashtable(int table_size, HashtableBucket<mtClass>* t, int number_of_entries)
844 : BasicHashtable<mtClass>(table_size, sizeof(PackageInfo), t, number_of_entries) {}
845
846 PackageInfo* get_entry(const char* pkgname, int n) {
847 unsigned int hash = compute_hash(pkgname, n);
848 return get_entry(hash_to_index(hash), hash, pkgname, n);
849 }
850
851 PackageInfo* new_entry(char* pkgname, int n) {
852 unsigned int hash = compute_hash(pkgname, n);
853 PackageInfo* pp;
854 pp = (PackageInfo*)BasicHashtable<mtClass>::new_entry(hash);
855 pp->set_pkgname(pkgname);
856 return pp;
857 }
858
859 void add_entry(PackageInfo* pp) {
860 int index = hash_to_index(pp->hash());
861 BasicHashtable<mtClass>::add_entry(index, pp);
862 }
863
864 void copy_pkgnames(const char** packages) {
865 int n = 0;
866 for (int i = 0; i < table_size(); ++i) {
867 for (PackageInfo* pp = bucket(i); pp != NULL; pp = pp->next()) {
868 packages[n++] = pp->pkgname();
869 }
870 }
871 assert(n == number_of_entries(), "just checking");
872 }
873
874 CDS_ONLY(void copy_table(char** top, char* end, PackageHashtable* table);)
875 };
876
877 #if INCLUDE_CDS
878 void PackageHashtable::copy_table(char** top, char* end,
879 PackageHashtable* table) {
880 // Copy (relocate) the table to the shared space.
881 BasicHashtable<mtClass>::copy_table(top, end);
882
883 // Calculate the space needed for the package name strings.
884 int i;
885 intptr_t* tableSize = (intptr_t*)(*top);
886 *top += sizeof(intptr_t); // For table size
887 char* tableStart = *top;
888
889 for (i = 0; i < table_size(); ++i) {
890 for (PackageInfo* pp = table->bucket(i);
891 pp != NULL;
892 pp = pp->next()) {
893 int n1 = (int)(strlen(pp->pkgname()) + 1);
894 if (*top + n1 >= end) {
895 report_out_of_shared_space(SharedMiscData);
896 }
897 pp->set_pkgname((char*)memcpy(*top, pp->pkgname(), n1));
898 *top += n1;
899 }
900 }
901 *top = (char*)align_size_up((intptr_t)*top, sizeof(HeapWord));
902 if (*top >= end) {
903 report_out_of_shared_space(SharedMiscData);
904 }
905
906 // Write table size
907 intptr_t len = *top - (char*)tableStart;
908 *tableSize = len;
909 }
910
911
912 void ClassLoader::copy_package_info_buckets(char** top, char* end) {
913 _package_hash_table->copy_buckets(top, end);
914 }
915
916 void ClassLoader::copy_package_info_table(char** top, char* end) {
917 _package_hash_table->copy_table(top, end, _package_hash_table);
918 }
919 #endif
920
921 PackageInfo* ClassLoader::lookup_package(const char *pkgname) {
922 const char *cp = strrchr(pkgname, '/');
923 if (cp != NULL) {
924 // Package prefix found
925 int n = cp - pkgname + 1;
926 return _package_hash_table->get_entry(pkgname, n);
927 }
928 return NULL;
929 }
930
931
932 bool ClassLoader::add_package(const char *pkgname, int classpath_index, TRAPS) {
933 assert(pkgname != NULL, "just checking");
934 // Bootstrap loader no longer holds system loader lock obj serializing
935 // load_instance_class and thereby add_package
936 {
937 MutexLocker ml(PackageTable_lock, THREAD);
938 // First check for previously loaded entry
939 PackageInfo* pp = lookup_package(pkgname);
940 if (pp != NULL) {
941 // Existing entry found, check source of package
942 pp->set_index(classpath_index);
943 return true;
944 }
945
946 const char *cp = strrchr(pkgname, '/');
947 if (cp != NULL) {
948 // Package prefix found
949 int n = cp - pkgname + 1;
950
951 char* new_pkgname = NEW_C_HEAP_ARRAY(char, n + 1, mtClass);
952 if (new_pkgname == NULL) {
953 return false;
954 }
955
956 memcpy(new_pkgname, pkgname, n);
957 new_pkgname[n] = '\0';
958 pp = _package_hash_table->new_entry(new_pkgname, n);
959 pp->set_index(classpath_index);
960
961 // Insert into hash table
962 _package_hash_table->add_entry(pp);
963 }
964 return true;
965 }
966 }
967
968
969 oop ClassLoader::get_system_package(const char* name, TRAPS) {
970 PackageInfo* pp;
971 {
972 MutexLocker ml(PackageTable_lock, THREAD);
973 pp = lookup_package(name);
974 }
975 if (pp == NULL) {
976 return NULL;
977 } else {
978 Handle p = java_lang_String::create_from_str(pp->filename(), THREAD);
979 return p();
980 }
981 }
982
983
984 objArrayOop ClassLoader::get_system_packages(TRAPS) {
985 ResourceMark rm(THREAD);
986 int nof_entries;
987 const char** packages;
988 {
989 MutexLocker ml(PackageTable_lock, THREAD);
990 // Allocate resource char* array containing package names
991 nof_entries = _package_hash_table->number_of_entries();
992 if ((packages = NEW_RESOURCE_ARRAY(const char*, nof_entries)) == NULL) {
993 return NULL;
994 }
995 _package_hash_table->copy_pkgnames(packages);
996 }
997 // Allocate objArray and fill with java.lang.String
998 objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
999 nof_entries, CHECK_0);
1000 objArrayHandle result(THREAD, r);
1001 for (int i = 0; i < nof_entries; i++) {
1002 Handle str = java_lang_String::create_from_str(packages[i], CHECK_0);
1003 result->obj_at_put(i, str());
1004 }
1005
1006 return result();
1007 }
1008
1009 // caller needs ResourceMark
1010 const char* ClassLoader::file_name_for_class_name(const char* class_name,
1011 int class_name_len) {
1012 assert(class_name != NULL, "invariant");
1013 assert((int)strlen(class_name) == class_name_len, "invariant");
1014
1015 static const char class_suffix[] = ".class";
1016
1017 char* const file_name = NEW_RESOURCE_ARRAY(char,
1018 class_name_len +
1019 sizeof(class_suffix)); // includes term NULL
1020
1021 strncpy(file_name, class_name, class_name_len);
1022 strncpy(&file_name[class_name_len], class_suffix, sizeof(class_suffix));
1023
1024 return file_name;
1025 }
1026
1027 instanceKlassHandle ClassLoader::load_class(Symbol* name, TRAPS) {
1028
1029 assert(name != NULL, "invariant");
1030 assert(THREAD->is_Java_thread(), "must be a JavaThread");
1031
1032 ResourceMark rm;
1033 HandleMark hm;
1034
1035 const char* const class_name = name->as_C_string();
1036
1037 EventMark m("loading class %s", class_name);
1038 ThreadProfilerMark tpm(ThreadProfilerMark::classLoaderRegion);
1039
1040 const char* const file_name = file_name_for_class_name(class_name,
1041 name->utf8_length());
1042 assert(file_name != NULL, "invariant");
1043
1044 ClassLoaderExt::Context context(class_name, file_name, THREAD);
1045
1046 // Lookup stream
1047 ClassFileStream* stream = NULL;
1048 int classpath_index = 0;
1049 ClassPathEntry* e = _first_entry;
1050 {
1051 PerfClassTraceTime vmtimer(perf_sys_class_lookup_time(),
1052 ((JavaThread*)THREAD)->get_thread_stat()->perf_timers_addr(),
1053 PerfClassTraceTime::CLASS_LOAD);
1054
1055 for (; e != NULL; e = e->next(), ++classpath_index) {
1056 stream = e->open_stream(file_name, CHECK_NULL);
1057 if (NULL == stream) {
1058 continue;
1059 }
1060 if (!context.check(stream, classpath_index)) {
1061 return NULL;
1062 }
1063 break;
1064 }
1065 }
1066
1067 if (NULL == stream) {
1068 if (DumpSharedSpaces) {
1069 tty->print_cr("Preload Warning: Cannot find %s", class_name);
1070 }
1071 return NULL;
1072 }
1073
1074 stream->set_verify(context.should_verify(classpath_index));
1075
1076 ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data();
1077 Handle protection_domain;
1078
1079 instanceKlassHandle result = KlassFactory::create_from_stream(stream,
1080 name,
1081 loader_data,
1082 protection_domain,
1083 NULL, // host_klass
1084 NULL, // cp_patches
1085 NULL, // parsed_name
1086 THREAD);
1087 if (HAS_PENDING_EXCEPTION) {
1088 if (DumpSharedSpaces) {
1089 tty->print_cr("Preload Error: Failed to load %s", class_name);
1090 }
1091 return NULL;
1092 }
1093
1094 return context.record_result(classpath_index, e, result, THREAD);
1095 }
1096
1097 void ClassLoader::create_package_info_table(HashtableBucket<mtClass> *t, int length,
1098 int number_of_entries) {
1099 assert(_package_hash_table == NULL, "One package info table allowed.");
1100 assert(length == package_hash_table_size * sizeof(HashtableBucket<mtClass>),
1101 "bad shared package info size.");
1102 _package_hash_table = new PackageHashtable(package_hash_table_size, t,
1103 number_of_entries);
1104 }
1105
1106
1107 void ClassLoader::create_package_info_table() {
1108 assert(_package_hash_table == NULL, "shouldn't have one yet");
1109 _package_hash_table = new PackageHashtable(package_hash_table_size);
1110 }
1111
1112
1113 // Initialize the class loader's access to methods in libzip. Parse and
1114 // process the boot classpath into a list ClassPathEntry objects. Once
1115 // this list has been created, it must not change order (see class PackageInfo)
1116 // it can be appended to and is by jvmti and the kernel vm.
1117
1118 void ClassLoader::initialize() {
1119 assert(_package_hash_table == NULL, "should have been initialized by now.");
1120 EXCEPTION_MARK;
1121
1122 if (UsePerfData) {
1123 // jvmstat performance counters
1124 NEWPERFTICKCOUNTER(_perf_accumulated_time, SUN_CLS, "time");
1125 NEWPERFTICKCOUNTER(_perf_class_init_time, SUN_CLS, "classInitTime");
1126 NEWPERFTICKCOUNTER(_perf_class_init_selftime, SUN_CLS, "classInitTime.self");
1127 NEWPERFTICKCOUNTER(_perf_class_verify_time, SUN_CLS, "classVerifyTime");
1128 NEWPERFTICKCOUNTER(_perf_class_verify_selftime, SUN_CLS, "classVerifyTime.self");
1129 NEWPERFTICKCOUNTER(_perf_class_link_time, SUN_CLS, "classLinkedTime");
1130 NEWPERFTICKCOUNTER(_perf_class_link_selftime, SUN_CLS, "classLinkedTime.self");
1131 NEWPERFEVENTCOUNTER(_perf_classes_inited, SUN_CLS, "initializedClasses");
1132 NEWPERFEVENTCOUNTER(_perf_classes_linked, SUN_CLS, "linkedClasses");
1133 NEWPERFEVENTCOUNTER(_perf_classes_verified, SUN_CLS, "verifiedClasses");
1134
1135 NEWPERFTICKCOUNTER(_perf_class_parse_time, SUN_CLS, "parseClassTime");
1136 NEWPERFTICKCOUNTER(_perf_class_parse_selftime, SUN_CLS, "parseClassTime.self");
1137 NEWPERFTICKCOUNTER(_perf_sys_class_lookup_time, SUN_CLS, "lookupSysClassTime");
1138 NEWPERFTICKCOUNTER(_perf_shared_classload_time, SUN_CLS, "sharedClassLoadTime");
1139 NEWPERFTICKCOUNTER(_perf_sys_classload_time, SUN_CLS, "sysClassLoadTime");
1140 NEWPERFTICKCOUNTER(_perf_app_classload_time, SUN_CLS, "appClassLoadTime");
1141 NEWPERFTICKCOUNTER(_perf_app_classload_selftime, SUN_CLS, "appClassLoadTime.self");
1142 NEWPERFEVENTCOUNTER(_perf_app_classload_count, SUN_CLS, "appClassLoadCount");
1143 NEWPERFTICKCOUNTER(_perf_define_appclasses, SUN_CLS, "defineAppClasses");
1144 NEWPERFTICKCOUNTER(_perf_define_appclass_time, SUN_CLS, "defineAppClassTime");
1145 NEWPERFTICKCOUNTER(_perf_define_appclass_selftime, SUN_CLS, "defineAppClassTime.self");
1146 NEWPERFBYTECOUNTER(_perf_app_classfile_bytes_read, SUN_CLS, "appClassBytes");
1147 NEWPERFBYTECOUNTER(_perf_sys_classfile_bytes_read, SUN_CLS, "sysClassBytes");
1148
1149
1150 // The following performance counters are added for measuring the impact
1151 // of the bug fix of 6365597. They are mainly focused on finding out
1152 // the behavior of system & user-defined classloader lock, whether
1153 // ClassLoader.loadClass/findClass is being called synchronized or not.
1154 // Also two additional counters are created to see whether 'UnsyncloadClass'
1155 // flag is being set or not and how many times load_instance_class call
1156 // fails with linkageError etc.
1157 NEWPERFEVENTCOUNTER(_sync_systemLoaderLockContentionRate, SUN_CLS,
1158 "systemLoaderLockContentionRate");
1159 NEWPERFEVENTCOUNTER(_sync_nonSystemLoaderLockContentionRate, SUN_CLS,
1160 "nonSystemLoaderLockContentionRate");
1161 NEWPERFEVENTCOUNTER(_sync_JVMFindLoadedClassLockFreeCounter, SUN_CLS,
1162 "jvmFindLoadedClassNoLockCalls");
1163 NEWPERFEVENTCOUNTER(_sync_JVMDefineClassLockFreeCounter, SUN_CLS,
1164 "jvmDefineClassNoLockCalls");
1165
1166 NEWPERFEVENTCOUNTER(_sync_JNIDefineClassLockFreeCounter, SUN_CLS,
1167 "jniDefineClassNoLockCalls");
1168
1169 NEWPERFEVENTCOUNTER(_unsafe_defineClassCallCounter, SUN_CLS,
1170 "unsafeDefineClassCalls");
1171
1172 NEWPERFEVENTCOUNTER(_isUnsyncloadClass, SUN_CLS, "isUnsyncloadClassSet");
1173 NEWPERFEVENTCOUNTER(_load_instance_class_failCounter, SUN_CLS,
1174 "loadInstanceClassFailRate");
1175
1176 // increment the isUnsyncloadClass counter if UnsyncloadClass is set.
1177 if (UnsyncloadClass) {
1178 _isUnsyncloadClass->inc();
1179 }
1180 }
1181
1182 // lookup zip library entry points
1183 load_zip_library();
1184 // lookup jimage library entry points
1185 load_jimage_library();
1186 #if INCLUDE_CDS
1187 // initialize search path
1188 if (DumpSharedSpaces) {
1189 _shared_paths_misc_info = SharedClassUtil::allocate_shared_paths_misc_info();
1190 }
1191 #endif
1192 setup_bootstrap_search_path();
1193 }
1194
1195 #if INCLUDE_CDS
1196 void ClassLoader::initialize_shared_path() {
1197 if (DumpSharedSpaces) {
1198 ClassLoaderExt::setup_search_paths();
1199 _shared_paths_misc_info->write_jint(0); // see comments in SharedPathsMiscInfo::check()
1200 }
1201 }
1202 #endif
1203
1204 jlong ClassLoader::classloader_time_ms() {
1205 return UsePerfData ?
1206 Management::ticks_to_ms(_perf_accumulated_time->get_value()) : -1;
1207 }
1208
1209 jlong ClassLoader::class_init_count() {
1210 return UsePerfData ? _perf_classes_inited->get_value() : -1;
1211 }
1212
1213 jlong ClassLoader::class_init_time_ms() {
1214 return UsePerfData ?
1215 Management::ticks_to_ms(_perf_class_init_time->get_value()) : -1;
1216 }
1217
1218 jlong ClassLoader::class_verify_time_ms() {
1219 return UsePerfData ?
1220 Management::ticks_to_ms(_perf_class_verify_time->get_value()) : -1;
1221 }
1222
1223 jlong ClassLoader::class_link_count() {
1224 return UsePerfData ? _perf_classes_linked->get_value() : -1;
1225 }
1226
1227 jlong ClassLoader::class_link_time_ms() {
1228 return UsePerfData ?
1229 Management::ticks_to_ms(_perf_class_link_time->get_value()) : -1;
1230 }
1231
1232 int ClassLoader::compute_Object_vtable() {
1233 // hardwired for JDK1.2 -- would need to duplicate class file parsing
1234 // code to determine actual value from file
1235 // Would be value '11' if finals were in vtable
1236 int JDK_1_2_Object_vtable_size = 5;
1237 return JDK_1_2_Object_vtable_size * vtableEntry::size();
1238 }
1239
1240
1241 void classLoader_init() {
1242 ClassLoader::initialize();
1243 }
1244
1245
1246 bool ClassLoader::get_canonical_path(const char* orig, char* out, int len) {
1247 assert(orig != NULL && out != NULL && len > 0, "bad arguments");
1248 if (CanonicalizeEntry != NULL) {
1249 JavaThread* THREAD = JavaThread::current();
1250 JNIEnv* env = THREAD->jni_environment();
1251 ResourceMark rm(THREAD);
1252
1253 // os::native_path writes into orig_copy
1254 char* orig_copy = NEW_RESOURCE_ARRAY_IN_THREAD(THREAD, char, strlen(orig)+1);
1255 strcpy(orig_copy, orig);
1256 if ((CanonicalizeEntry)(env, os::native_path(orig_copy), out, len) < 0) {
1257 return false;
1258 }
1259 } else {
1260 // On JDK 1.2.2 the Canonicalize does not exist, so just do nothing
1261 strncpy(out, orig, len);
1262 out[len - 1] = '\0';
1263 }
1264 return true;
1265 }
1266
1267 #ifndef PRODUCT
1268
1269 void ClassLoader::verify() {
1270 _package_hash_table->verify();
1271 }
1272
1273
1274 // CompileTheWorld
1275 //
1276 // Iterates over all class path entries and forces compilation of all methods
1277 // in all classes found. Currently, only zip/jar archives are searched.
1278 //
1279 // The classes are loaded by the Java level bootstrap class loader, and the
1280 // initializer is called. If DelayCompilationDuringStartup is true (default),
1281 // the interpreter will run the initialization code. Note that forcing
1282 // initialization in this way could potentially lead to initialization order
1283 // problems, in which case we could just force the initialization bit to be set.
1284
1285
1286 // We need to iterate over the contents of a zip/jar file, so we replicate the
1287 // jzcell and jzfile definitions from zip_util.h but rename jzfile to real_jzfile,
1288 // since jzfile already has a void* definition.
1289 //
1290 // Note that this is only used in debug mode.
1291 //
1292 // HotSpot integration note:
1293 // Matches zip_util.h 1.14 99/06/01 from jdk1.3 beta H build
1294
1295
1296 // JDK 1.3 version
1297 typedef struct real_jzentry { /* Zip file entry */
1298 char *name; /* entry name */
1299 jint time; /* modification time */
1300 jint size; /* size of uncompressed data */
1301 jint csize; /* size of compressed data (zero if uncompressed) */
1302 jint crc; /* crc of uncompressed data */
1303 char *comment; /* optional zip file comment */
1304 jbyte *extra; /* optional extra data */
1305 jint pos; /* position of LOC header (if negative) or data */
1306 } real_jzentry;
1307
1308 typedef struct real_jzfile { /* Zip file */
1309 char *name; /* zip file name */
1310 jint refs; /* number of active references */
1311 jint fd; /* open file descriptor */
1312 void *lock; /* read lock */
1313 char *comment; /* zip file comment */
1314 char *msg; /* zip error message */
1315 void *entries; /* array of hash cells */
1316 jint total; /* total number of entries */
1317 unsigned short *table; /* Hash chain heads: indexes into entries */
1318 jint tablelen; /* number of hash eads */
1319 real_jzfile *next; /* next zip file in search list */
1320 jzentry *cache; /* we cache the most recently freed jzentry */
1321 /* Information on metadata names in META-INF directory */
1322 char **metanames; /* array of meta names (may have null names) */
1323 jint metacount; /* number of slots in metanames array */
1324 /* If there are any per-entry comments, they are in the comments array */
1325 char **comments;
1326 } real_jzfile;
1327
1328 void ClassPathDirEntry::compile_the_world(Handle loader, TRAPS) {
1329 // For now we only compile all methods in all classes in zip/jar files
1330 tty->print_cr("CompileTheWorld : Skipped classes in %s", _dir);
1331 tty->cr();
1332 }
1333
1334 bool ClassPathDirEntry::is_jrt() {
1335 return false;
1336 }
1337
1338 void ClassPathZipEntry::compile_the_world(Handle loader, TRAPS) {
1339 real_jzfile* zip = (real_jzfile*) _zip;
1340 tty->print_cr("CompileTheWorld : Compiling all classes in %s", zip->name);
1341 tty->cr();
1342 // Iterate over all entries in zip file
1343 for (int n = 0; ; n++) {
1344 real_jzentry * ze = (real_jzentry *)((*GetNextEntry)(_zip, n));
1345 if (ze == NULL) break;
1346 ClassLoader::compile_the_world_in(ze->name, loader, CHECK);
1347 }
1348 if (HAS_PENDING_EXCEPTION) {
1349 if (PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())) {
1350 CLEAR_PENDING_EXCEPTION;
1351 tty->print_cr("\nCompileTheWorld : Ran out of memory\n");
1352 tty->print_cr("Increase class metadata storage if a limit was set");
1353 } else {
1354 tty->print_cr("\nCompileTheWorld : Unexpected exception occurred\n");
1355 }
1356 }
1357 }
1358
1359 bool ClassPathZipEntry::is_jrt() {
1360 return false;
1361 }
1362
1363 void ClassLoader::compile_the_world() {
1364 EXCEPTION_MARK;
1365 HandleMark hm(THREAD);
1366 ResourceMark rm(THREAD);
1367 // Make sure we don't run with background compilation
1368 BackgroundCompilation = false;
1369 // Find bootstrap loader
1370 Handle system_class_loader (THREAD, SystemDictionary::java_system_loader());
1371 // Iterate over all bootstrap class path entries
1372 ClassPathEntry* e = _first_entry;
1373 jlong start = os::javaTimeMillis();
1374 while (e != NULL) {
1375 // We stop at bootmodules.jimage, unless it is the first bootstrap path entry
1376 if (e->is_jrt() && e != _first_entry) break;
1377 e->compile_the_world(system_class_loader, CATCH);
1378 e = e->next();
1379 }
1380 jlong end = os::javaTimeMillis();
1381 tty->print_cr("CompileTheWorld : Done (%d classes, %d methods, " JLONG_FORMAT " ms)",
1382 _compile_the_world_class_counter, _compile_the_world_method_counter, (end - start));
1383 {
1384 // Print statistics as if before normal exit:
1385 extern void print_statistics();
1386 print_statistics();
1387 }
1388 vm_exit(0);
1389 }
1390
1391 int ClassLoader::_compile_the_world_class_counter = 0;
1392 int ClassLoader::_compile_the_world_method_counter = 0;
1393 static int _codecache_sweep_counter = 0;
1394
1395 // Filter out all exceptions except OOMs
1396 static void clear_pending_exception_if_not_oom(TRAPS) {
1397 if (HAS_PENDING_EXCEPTION &&
1398 !PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())) {
1399 CLEAR_PENDING_EXCEPTION;
1400 }
1401 // The CHECK at the caller will propagate the exception out
1402 }
1403
1404 /**
1405 * Returns if the given method should be compiled when doing compile-the-world.
1406 *
1407 * TODO: This should be a private method in a CompileTheWorld class.
1408 */
1409 static bool can_be_compiled(methodHandle m, int comp_level) {
1410 assert(CompileTheWorld, "must be");
1411
1412 // It's not valid to compile a native wrapper for MethodHandle methods
1413 // that take a MemberName appendix since the bytecode signature is not
1414 // correct.
1415 vmIntrinsics::ID iid = m->intrinsic_id();
1416 if (MethodHandles::is_signature_polymorphic(iid) && MethodHandles::has_member_arg(iid)) {
1417 return false;
1418 }
1419
1420 return CompilationPolicy::can_be_compiled(m, comp_level);
1421 }
1422
1423 void ClassLoader::compile_the_world_in(char* name, Handle loader, TRAPS) {
1424 if (string_ends_with(name, ".class")) {
1425 // We have a .class file
1426 int len = (int)strlen(name);
1427 char buffer[2048];
1428 strncpy(buffer, name, len - 6);
1429 buffer[len-6] = 0;
1430 // If the file has a period after removing .class, it's not really a
1431 // valid class file. The class loader will check everything else.
1432 if (strchr(buffer, '.') == NULL) {
1433 _compile_the_world_class_counter++;
1434 if (_compile_the_world_class_counter > CompileTheWorldStopAt) return;
1435
1436 // Construct name without extension
1437 TempNewSymbol sym = SymbolTable::new_symbol(buffer, CHECK);
1438 // Use loader to load and initialize class
1439 Klass* ik = SystemDictionary::resolve_or_null(sym, loader, Handle(), THREAD);
1440 instanceKlassHandle k (THREAD, ik);
1441 if (k.not_null() && !HAS_PENDING_EXCEPTION) {
1442 k->initialize(THREAD);
1443 }
1444 bool exception_occurred = HAS_PENDING_EXCEPTION;
1445 clear_pending_exception_if_not_oom(CHECK);
1446 if (CompileTheWorldPreloadClasses && k.not_null()) {
1447 ConstantPool::preload_and_initialize_all_classes(k->constants(), THREAD);
1448 if (HAS_PENDING_EXCEPTION) {
1449 // If something went wrong in preloading we just ignore it
1450 clear_pending_exception_if_not_oom(CHECK);
1451 tty->print_cr("Preloading failed for (%d) %s", _compile_the_world_class_counter, buffer);
1452 }
1453 }
1454
1455 if (_compile_the_world_class_counter >= CompileTheWorldStartAt) {
1456 if (k.is_null() || exception_occurred) {
1457 // If something went wrong (e.g. ExceptionInInitializerError) we skip this class
1458 tty->print_cr("CompileTheWorld (%d) : Skipping %s", _compile_the_world_class_counter, buffer);
1459 } else {
1460 tty->print_cr("CompileTheWorld (%d) : %s", _compile_the_world_class_counter, buffer);
1461 // Preload all classes to get around uncommon traps
1462 // Iterate over all methods in class
1463 int comp_level = CompilationPolicy::policy()->initial_compile_level();
1464 for (int n = 0; n < k->methods()->length(); n++) {
1465 methodHandle m (THREAD, k->methods()->at(n));
1466 if (can_be_compiled(m, comp_level)) {
1467 if (++_codecache_sweep_counter == CompileTheWorldSafepointInterval) {
1468 // Give sweeper a chance to keep up with CTW
1469 VM_ForceSafepoint op;
1470 VMThread::execute(&op);
1471 _codecache_sweep_counter = 0;
1472 }
1473 // Force compilation
1474 CompileBroker::compile_method(m, InvocationEntryBci, comp_level,
1475 methodHandle(), 0, "CTW", THREAD);
1476 if (HAS_PENDING_EXCEPTION) {
1477 clear_pending_exception_if_not_oom(CHECK);
1478 tty->print_cr("CompileTheWorld (%d) : Skipping method: %s", _compile_the_world_class_counter, m->name_and_sig_as_C_string());
1479 } else {
1480 _compile_the_world_method_counter++;
1481 }
1482 if (TieredCompilation && TieredStopAtLevel >= CompLevel_full_optimization) {
1483 // Clobber the first compile and force second tier compilation
1484 nmethod* nm = m->code();
1485 if (nm != NULL && !m->is_method_handle_intrinsic()) {
1486 // Throw out the code so that the code cache doesn't fill up
1487 nm->make_not_entrant();
1488 m->clear_code();
1489 }
1490 CompileBroker::compile_method(m, InvocationEntryBci, CompLevel_full_optimization,
1491 methodHandle(), 0, "CTW", THREAD);
1492 if (HAS_PENDING_EXCEPTION) {
1493 clear_pending_exception_if_not_oom(CHECK);
1494 tty->print_cr("CompileTheWorld (%d) : Skipping method: %s", _compile_the_world_class_counter, m->name_and_sig_as_C_string());
1495 } else {
1496 _compile_the_world_method_counter++;
1497 }
1498 }
1499 } else {
1500 tty->print_cr("CompileTheWorld (%d) : Skipping method: %s", _compile_the_world_class_counter, m->name_and_sig_as_C_string());
1501 }
1502
1503 nmethod* nm = m->code();
1504 if (nm != NULL && !m->is_method_handle_intrinsic()) {
1505 // Throw out the code so that the code cache doesn't fill up
1506 nm->make_not_entrant();
1507 m->clear_code();
1508 }
1509 }
1510 }
1511 }
1512 }
1513 }
1514 }
1515
1516 #endif //PRODUCT
1517
1518 // Please keep following two functions at end of this file. With them placed at top or in middle of the file,
1519 // they could get inlined by agressive compiler, an unknown trick, see bug 6966589.
1520 void PerfClassTraceTime::initialize() {
1521 if (!UsePerfData) return;
1522
1523 if (_eventp != NULL) {
1524 // increment the event counter
1525 _eventp->inc();
1526 }
1527
1528 // stop the current active thread-local timer to measure inclusive time
1529 _prev_active_event = -1;
1530 for (int i=0; i < EVENT_TYPE_COUNT; i++) {
1531 if (_timers[i].is_active()) {
1532 assert(_prev_active_event == -1, "should have only one active timer");
1533 _prev_active_event = i;
1534 _timers[i].stop();
1535 }
1536 }
1537
1538 if (_recursion_counters == NULL || (_recursion_counters[_event_type])++ == 0) {
1539 // start the inclusive timer if not recursively called
1540 _t.start();
1541 }
1542
1543 // start thread-local timer of the given event type
1544 if (!_timers[_event_type].is_active()) {
1545 _timers[_event_type].start();
1546 }
1547 }
1548
1549 PerfClassTraceTime::~PerfClassTraceTime() {
1550 if (!UsePerfData) return;
1551
1552 // stop the thread-local timer as the event completes
1553 // and resume the thread-local timer of the event next on the stack
1554 _timers[_event_type].stop();
1555 jlong selftime = _timers[_event_type].ticks();
1556
1557 if (_prev_active_event >= 0) {
1558 _timers[_prev_active_event].start();
1559 }
1560
1561 if (_recursion_counters != NULL && --(_recursion_counters[_event_type]) > 0) return;
1562
1563 // increment the counters only on the leaf call
1564 _t.stop();
1565 _timep->inc(_t.ticks());
1566 if (_selftimep != NULL) {
1567 _selftimep->inc(selftime);
1568 }
1569 // add all class loading related event selftime to the accumulated time counter
1570 ClassLoader::perf_accumulated_time()->inc(selftime);
1571
1572 // reset the timer
1573 _timers[_event_type].reset();
1574 }