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