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