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 "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/objArrayOop.inline.hpp" 47 #include "oops/oop.inline.hpp" 48 #include "oops/symbol.hpp" 49 #include "prims/jvm_misc.hpp" 50 #include "runtime/arguments.hpp" 51 #include "runtime/compilationPolicy.hpp" 52 #include "runtime/fprofiler.hpp" 53 #include "runtime/handles.hpp" 54 #include "runtime/handles.inline.hpp" 55 #include "runtime/init.hpp" 56 #include "runtime/interfaceSupport.hpp" 57 #include "runtime/java.hpp" 58 #include "runtime/javaCalls.hpp" 59 #include "runtime/os.hpp" 60 #include "runtime/threadCritical.hpp" 61 #include "runtime/timer.hpp" 62 #include "runtime/vm_version.hpp" 63 #include "services/management.hpp" 64 #include "services/threadService.hpp" 65 #include "utilities/events.hpp" 66 #include "utilities/hashtable.inline.hpp" 67 #include "utilities/macros.hpp" 68 #if INCLUDE_CDS 69 #include "classfile/sharedClassUtil.hpp" 70 #include "classfile/sharedPathsMiscInfo.hpp" 71 #endif 72 73 // Entry points in zip.dll for loading zip/jar file entries 74 75 typedef void * * (JNICALL *ZipOpen_t)(const char *name, char **pmsg); 76 typedef void (JNICALL *ZipClose_t)(jzfile *zip); 77 typedef jzentry* (JNICALL *FindEntry_t)(jzfile *zip, const char *name, jint *sizeP, jint *nameLen); 78 typedef jboolean (JNICALL *ReadEntry_t)(jzfile *zip, jzentry *entry, unsigned char *buf, char *namebuf); 79 typedef jboolean (JNICALL *ReadMappedEntry_t)(jzfile *zip, jzentry *entry, unsigned char **buf, char *namebuf); 80 typedef jzentry* (JNICALL *GetNextEntry_t)(jzfile *zip, jint n); 81 typedef jboolean (JNICALL *ZipInflateFully_t)(void *inBuf, jlong inLen, void *outBuf, jlong outLen, char **pmsg); 82 typedef jint (JNICALL *Crc32_t)(jint crc, const jbyte *buf, jint len); 83 84 static ZipOpen_t ZipOpen = NULL; 85 static ZipClose_t ZipClose = NULL; 86 static FindEntry_t FindEntry = NULL; 87 static ReadEntry_t ReadEntry = NULL; 88 static ReadMappedEntry_t ReadMappedEntry = NULL; 89 static GetNextEntry_t GetNextEntry = NULL; 90 static canonicalize_fn_t CanonicalizeEntry = NULL; 91 static ZipInflateFully_t ZipInflateFully = NULL; 92 static Crc32_t Crc32 = NULL; 93 94 // Entry points for jimage.dll for loading jimage file entries 95 96 static JImageOpen_t JImageOpen = NULL; 97 static JImageClose_t JImageClose = NULL; 98 static JImagePackageToModule_t JImagePackageToModule = NULL; 99 static JImageFindResource_t JImageFindResource = NULL; 100 static JImageGetResource_t JImageGetResource = NULL; 101 static JImageResourceIterator_t JImageResourceIterator = NULL; 102 103 // Globals 104 105 PerfCounter* ClassLoader::_perf_accumulated_time = NULL; 106 PerfCounter* ClassLoader::_perf_classes_inited = NULL; 107 PerfCounter* ClassLoader::_perf_class_init_time = NULL; 108 PerfCounter* ClassLoader::_perf_class_init_selftime = NULL; 109 PerfCounter* ClassLoader::_perf_classes_verified = NULL; 110 PerfCounter* ClassLoader::_perf_class_verify_time = NULL; 111 PerfCounter* ClassLoader::_perf_class_verify_selftime = NULL; 112 PerfCounter* ClassLoader::_perf_classes_linked = NULL; 113 PerfCounter* ClassLoader::_perf_class_link_time = NULL; 114 PerfCounter* ClassLoader::_perf_class_link_selftime = NULL; 115 PerfCounter* ClassLoader::_perf_class_parse_time = NULL; 116 PerfCounter* ClassLoader::_perf_class_parse_selftime = NULL; 117 PerfCounter* ClassLoader::_perf_sys_class_lookup_time = NULL; 118 PerfCounter* ClassLoader::_perf_shared_classload_time = NULL; 119 PerfCounter* ClassLoader::_perf_sys_classload_time = NULL; 120 PerfCounter* ClassLoader::_perf_app_classload_time = NULL; 121 PerfCounter* ClassLoader::_perf_app_classload_selftime = NULL; 122 PerfCounter* ClassLoader::_perf_app_classload_count = NULL; 123 PerfCounter* ClassLoader::_perf_define_appclasses = NULL; 124 PerfCounter* ClassLoader::_perf_define_appclass_time = NULL; 125 PerfCounter* ClassLoader::_perf_define_appclass_selftime = NULL; 126 PerfCounter* ClassLoader::_perf_app_classfile_bytes_read = NULL; 127 PerfCounter* ClassLoader::_perf_sys_classfile_bytes_read = NULL; 128 PerfCounter* ClassLoader::_sync_systemLoaderLockContentionRate = NULL; 129 PerfCounter* ClassLoader::_sync_nonSystemLoaderLockContentionRate = NULL; 130 PerfCounter* ClassLoader::_sync_JVMFindLoadedClassLockFreeCounter = NULL; 131 PerfCounter* ClassLoader::_sync_JVMDefineClassLockFreeCounter = NULL; 132 PerfCounter* ClassLoader::_sync_JNIDefineClassLockFreeCounter = NULL; 133 PerfCounter* ClassLoader::_unsafe_defineClassCallCounter = NULL; 134 PerfCounter* ClassLoader::_isUnsyncloadClass = NULL; 135 PerfCounter* ClassLoader::_load_instance_class_failCounter = NULL; 136 137 ClassPathEntry* ClassLoader::_first_entry = NULL; 138 ClassPathEntry* ClassLoader::_last_entry = NULL; 139 int ClassLoader::_num_entries = 0; 140 PackageHashtable* ClassLoader::_package_hash_table = NULL; 141 142 #if INCLUDE_CDS 143 SharedPathsMiscInfo* ClassLoader::_shared_paths_misc_info = NULL; 144 #endif 145 // helper routines 146 bool string_starts_with(const char* str, const char* str_to_find) { 147 size_t str_len = strlen(str); 148 size_t str_to_find_len = strlen(str_to_find); 149 if (str_to_find_len > str_len) { 150 return false; 151 } 152 return (strncmp(str, str_to_find, str_to_find_len) == 0); 153 } 154 155 static const char* get_jimage_version_string() { 156 static char version_string[10] = ""; 157 if (version_string[0] == '\0') { 158 jio_snprintf(version_string, sizeof(version_string), "%d.%d", 159 Abstract_VM_Version::vm_major_version(), Abstract_VM_Version::vm_minor_version()); 160 } 161 return (const char*)version_string; 162 } 163 164 bool string_ends_with(const char* str, const char* str_to_find) { 165 size_t str_len = strlen(str); 166 size_t str_to_find_len = strlen(str_to_find); 167 if (str_to_find_len > str_len) { 168 return false; 169 } 170 return (strncmp(str + (str_len - str_to_find_len), str_to_find, str_to_find_len) == 0); 171 } 172 173 174 ClassPathDirEntry::ClassPathDirEntry(const char* dir) : ClassPathEntry() { 175 char* copy = NEW_C_HEAP_ARRAY(char, strlen(dir)+1, mtClass); 176 strcpy(copy, dir); 177 _dir = copy; 178 } 179 180 181 ClassFileStream* ClassPathDirEntry::open_stream(const char* name, TRAPS) { 182 // construct full path name 183 char path[JVM_MAXPATHLEN]; 184 if (jio_snprintf(path, sizeof(path), "%s%s%s", _dir, os::file_separator(), name) == -1) { 185 return NULL; 186 } 187 // check if file exists 188 struct stat st; 189 if (os::stat(path, &st) == 0) { 190 #if INCLUDE_CDS 191 if (DumpSharedSpaces) { 192 // We have already check in ClassLoader::check_shared_classpath() that the directory is empty, so 193 // we should never find a file underneath it -- unless user has added a new file while we are running 194 // the dump, in which case let's quit! 195 ShouldNotReachHere(); 196 } 197 #endif 198 // found file, open it 199 int file_handle = os::open(path, 0, 0); 200 if (file_handle != -1) { 201 // read contents into resource array 202 u1* buffer = NEW_RESOURCE_ARRAY(u1, st.st_size); 203 size_t num_read = os::read(file_handle, (char*) buffer, st.st_size); 204 // close file 205 os::close(file_handle); 206 // construct ClassFileStream 207 if (num_read == (size_t)st.st_size) { 208 if (UsePerfData) { 209 ClassLoader::perf_sys_classfile_bytes_read()->inc(num_read); 210 } 211 // Resource allocated 212 return new ClassFileStream(buffer, 213 st.st_size, 214 _dir, 215 ClassFileStream::verify); 216 } 217 } 218 } 219 return NULL; 220 } 221 222 ClassPathZipEntry::ClassPathZipEntry(jzfile* zip, const char* zip_name) : ClassPathEntry() { 223 _zip = zip; 224 char *copy = NEW_C_HEAP_ARRAY(char, strlen(zip_name)+1, mtClass); 225 strcpy(copy, zip_name); 226 _zip_name = copy; 227 } 228 229 ClassPathZipEntry::~ClassPathZipEntry() { 230 if (ZipClose != NULL) { 231 (*ZipClose)(_zip); 232 } 233 FREE_C_HEAP_ARRAY(char, _zip_name); 234 } 235 236 u1* ClassPathZipEntry::open_entry(const char* name, jint* filesize, bool nul_terminate, TRAPS) { 237 // enable call to C land 238 JavaThread* thread = JavaThread::current(); 239 ThreadToNativeFromVM ttn(thread); 240 // check whether zip archive contains name 241 jint name_len; 242 jzentry* entry = (*FindEntry)(_zip, name, filesize, &name_len); 243 if (entry == NULL) return NULL; 244 u1* buffer; 245 char name_buf[128]; 246 char* filename; 247 if (name_len < 128) { 248 filename = name_buf; 249 } else { 250 filename = NEW_RESOURCE_ARRAY(char, name_len + 1); 251 } 252 253 // file found, get pointer to the entry in mmapped jar file. 254 if (ReadMappedEntry == NULL || 255 !(*ReadMappedEntry)(_zip, entry, &buffer, filename)) { 256 // mmapped access not available, perhaps due to compression, 257 // read contents into resource array 258 int size = (*filesize) + ((nul_terminate) ? 1 : 0); 259 buffer = NEW_RESOURCE_ARRAY(u1, size); 260 if (!(*ReadEntry)(_zip, entry, buffer, filename)) return NULL; 261 } 262 263 // return result 264 if (nul_terminate) { 265 buffer[*filesize] = 0; 266 } 267 return buffer; 268 } 269 270 ClassFileStream* ClassPathZipEntry::open_stream(const char* name, TRAPS) { 271 jint filesize; 272 const u1* buffer = open_entry(name, &filesize, false, CHECK_NULL); 273 if (buffer == NULL) { 274 return NULL; 275 } 276 if (UsePerfData) { 277 ClassLoader::perf_sys_classfile_bytes_read()->inc(filesize); 278 } 279 // Resource allocated 280 return new ClassFileStream(buffer, 281 filesize, 282 _zip_name, 283 ClassFileStream::verify); 284 } 285 286 // invoke function for each entry in the zip file 287 void ClassPathZipEntry::contents_do(void f(const char* name, void* context), void* context) { 288 JavaThread* thread = JavaThread::current(); 289 HandleMark handle_mark(thread); 290 ThreadToNativeFromVM ttn(thread); 291 for (int n = 0; ; n++) { 292 jzentry * ze = ((*GetNextEntry)(_zip, n)); 293 if (ze == NULL) break; 294 (*f)(ze->name, context); 295 } 296 } 297 298 ClassPathImageEntry::ClassPathImageEntry(JImageFile* jimage, const char* name) : 299 ClassPathEntry(), 300 _jimage(jimage) { 301 guarantee(jimage != NULL, "jimage file is null"); 302 guarantee(name != NULL, "jimage file name is null"); 303 size_t len = strlen(name) + 1; 304 _name = NEW_C_HEAP_ARRAY(const char, len, mtClass); 305 strncpy((char *)_name, name, len); 306 } 307 308 ClassPathImageEntry::~ClassPathImageEntry() { 309 if (_name != NULL) { 310 FREE_C_HEAP_ARRAY(const char, _name); 311 _name = NULL; 312 } 313 if (_jimage != NULL) { 314 (*JImageClose)(_jimage); 315 _jimage = NULL; 316 } 317 } 318 319 void ClassPathImageEntry::name_to_package(const char* name, char* buffer, int length) { 320 const char *pslash = strrchr(name, '/'); 321 if (pslash == NULL) { 322 buffer[0] = '\0'; 323 return; 324 } 325 int len = pslash - name; 326 #if INCLUDE_CDS 327 if (len <= 0 && DumpSharedSpaces) { 328 buffer[0] = '\0'; 329 return; 330 } 331 #endif 332 assert(len > 0, "Bad length for package name"); 333 if (len >= length) { 334 buffer[0] = '\0'; 335 return; 336 } 337 // drop name after last slash (including slash) 338 // Ex., "java/lang/String.class" => "java/lang" 339 strncpy(buffer, name, len); 340 // ensure string termination (strncpy does not guarantee) 341 buffer[len] = '\0'; 342 } 343 344 // For a class in a named module, look it up in the jimage file using this syntax: 345 // /<module-name>/<package-name>/<base-class> 346 // 347 // Assumptions: 348 // 1. There are no unnamed modules in the jimage file. 349 // 2. A package is in at most one module in the jimage file. 350 // 351 ClassFileStream* ClassPathImageEntry::open_stream(const char* name, TRAPS) { 352 jlong size; 353 JImageLocationRef location = (*JImageFindResource)(_jimage, "", get_jimage_version_string(), name, &size); 354 355 if (location == 0) { 356 char package[JIMAGE_MAX_PATH]; 357 name_to_package(name, package, JIMAGE_MAX_PATH); 358 if (package[0] != '\0') { 359 const char* module = (*JImagePackageToModule)(_jimage, package); 360 if (module == NULL) { 361 module = "java.base"; 362 } 363 location = (*JImageFindResource)(_jimage, module, get_jimage_version_string(), name, &size); 364 } 365 } 366 367 if (location != 0) { 368 if (UsePerfData) { 369 ClassLoader::perf_sys_classfile_bytes_read()->inc(size); 370 } 371 char* data = NEW_RESOURCE_ARRAY(char, size); 372 (*JImageGetResource)(_jimage, location, data, size); 373 // Resource allocated 374 return new ClassFileStream((u1*)data, 375 (int)size, 376 _name, 377 ClassFileStream::verify); 378 } 379 380 return NULL; 381 } 382 383 #ifndef PRODUCT 384 bool ctw_visitor(JImageFile* jimage, 385 const char* module_name, const char* version, const char* package, 386 const char* name, const char* extension, void* arg) { 387 if (strcmp(extension, "class") == 0) { 388 Thread* THREAD = Thread::current(); 389 char path[JIMAGE_MAX_PATH]; 390 jio_snprintf(path, JIMAGE_MAX_PATH - 1, "%s/%s.class", package, name); 391 ClassLoader::compile_the_world_in(path, *(Handle*)arg, THREAD); 392 return !HAS_PENDING_EXCEPTION; 393 } 394 return true; 395 } 396 397 void ClassPathImageEntry::compile_the_world(Handle loader, TRAPS) { 398 tty->print_cr("CompileTheWorld : Compiling all classes in %s", name()); 399 tty->cr(); 400 (*JImageResourceIterator)(_jimage, (JImageResourceVisitor_t)ctw_visitor, (void *)&loader); 401 if (HAS_PENDING_EXCEPTION) { 402 if (PENDING_EXCEPTION->is_a(SystemDictionary::OutOfMemoryError_klass())) { 403 CLEAR_PENDING_EXCEPTION; 404 tty->print_cr("\nCompileTheWorld : Ran out of memory\n"); 405 tty->print_cr("Increase class metadata storage if a limit was set"); 406 } else { 407 tty->print_cr("\nCompileTheWorld : Unexpected exception occurred\n"); 408 } 409 } 410 } 411 412 bool ClassPathImageEntry::is_jrt() { 413 return string_ends_with(name(), BOOT_IMAGE_NAME); 414 } 415 #endif 416 417 #if INCLUDE_CDS 418 void ClassLoader::exit_with_path_failure(const char* error, const char* message) { 419 assert(DumpSharedSpaces, "only called at dump time"); 420 tty->print_cr("Hint: enable -XX:+TraceClassPaths to diagnose the failure"); 421 vm_exit_during_initialization(error, message); 422 } 423 #endif 424 425 void ClassLoader::trace_class_path(outputStream* out, const char* msg, const char* name) { 426 if (!TraceClassPaths) { 427 return; 428 } 429 430 if (msg) { 431 out->print("%s", msg); 432 } 433 if (name) { 434 if (strlen(name) < 256) { 435 out->print("%s", name); 436 } else { 437 // For very long paths, we need to print each character separately, 438 // as print_cr() has a length limit 439 while (name[0] != '\0') { 440 out->print("%c", name[0]); 441 name++; 442 } 443 } 444 } 445 if (msg && msg[0] == '[') { 446 out->print_cr("]"); 447 } else { 448 out->cr(); 449 } 450 } 451 452 #if INCLUDE_CDS 453 void ClassLoader::check_shared_classpath(const char *path) { 454 if (strcmp(path, "") == 0) { 455 exit_with_path_failure("Cannot have empty path in archived classpaths", NULL); 456 } 457 458 struct stat st; 459 if (os::stat(path, &st) == 0) { 460 if ((st.st_mode & S_IFREG) != S_IFREG) { // is directory 461 if (!os::dir_is_empty(path)) { 462 tty->print_cr("Error: non-empty directory '%s'", path); 463 exit_with_path_failure("CDS allows only empty directories in archived classpaths", NULL); 464 } 465 } 466 } 467 } 468 #endif 469 470 void ClassLoader::setup_bootstrap_search_path() { 471 assert(_first_entry == NULL, "should not setup bootstrap class search path twice"); 472 const char* sys_class_path = Arguments::get_sysclasspath(); 473 if (PrintSharedArchiveAndExit) { 474 // Don't print sys_class_path - this is the bootcp of this current VM process, not necessarily 475 // the same as the bootcp of the shared archive. 476 } else { 477 trace_class_path(tty, "[Bootstrap loader class path=", sys_class_path); 478 } 479 #if INCLUDE_CDS 480 if (DumpSharedSpaces) { 481 _shared_paths_misc_info->add_boot_classpath(sys_class_path); 482 } 483 #endif 484 setup_search_path(sys_class_path); 485 } 486 487 #if INCLUDE_CDS 488 int ClassLoader::get_shared_paths_misc_info_size() { 489 return _shared_paths_misc_info->get_used_bytes(); 490 } 491 492 void* ClassLoader::get_shared_paths_misc_info() { 493 return _shared_paths_misc_info->buffer(); 494 } 495 496 bool ClassLoader::check_shared_paths_misc_info(void *buf, int size) { 497 SharedPathsMiscInfo* checker = SharedClassUtil::allocate_shared_paths_misc_info((char*)buf, size); 498 bool result = checker->check(); 499 delete checker; 500 return result; 501 } 502 #endif 503 504 void ClassLoader::setup_search_path(const char *class_path) { 505 int offset = 0; 506 int len = (int)strlen(class_path); 507 int end = 0; 508 509 // Iterate over class path entries 510 for (int start = 0; start < len; start = end) { 511 while (class_path[end] && class_path[end] != os::path_separator()[0]) { 512 end++; 513 } 514 EXCEPTION_MARK; 515 ResourceMark rm(THREAD); 516 char* path = NEW_RESOURCE_ARRAY(char, end - start + 1); 517 strncpy(path, &class_path[start], end - start); 518 path[end - start] = '\0'; 519 update_class_path_entry_list(path, false); 520 #if INCLUDE_CDS 521 if (DumpSharedSpaces) { 522 check_shared_classpath(path); 523 } 524 #endif 525 while (class_path[end] == os::path_separator()[0]) { 526 end++; 527 } 528 } 529 } 530 531 ClassPathEntry* ClassLoader::create_class_path_entry(const char *path, const struct stat* st, 532 bool throw_exception, TRAPS) { 533 JavaThread* thread = JavaThread::current(); 534 ClassPathEntry* new_entry = NULL; 535 if ((st->st_mode & S_IFREG) == S_IFREG) { 536 // Regular file, should be a zip or jimage file 537 // Canonicalized filename 538 char canonical_path[JVM_MAXPATHLEN]; 539 if (!get_canonical_path(path, canonical_path, JVM_MAXPATHLEN)) { 540 // This matches the classic VM 541 if (throw_exception) { 542 THROW_MSG_(vmSymbols::java_io_IOException(), "Bad pathname", NULL); 543 } else { 544 return NULL; 545 } 546 } 547 jint error; 548 JImageFile* jimage =(*JImageOpen)(canonical_path, &error); 549 if (jimage != NULL) { 550 new_entry = new ClassPathImageEntry(jimage, canonical_path); 551 } else { 552 char* error_msg = NULL; 553 jzfile* zip; 554 { 555 // enable call to C land 556 ThreadToNativeFromVM ttn(thread); 557 HandleMark hm(thread); 558 zip = (*ZipOpen)(canonical_path, &error_msg); 559 } 560 if (zip != NULL && error_msg == NULL) { 561 new_entry = new ClassPathZipEntry(zip, path); 562 } else { 563 ResourceMark rm(thread); 564 char *msg; 565 if (error_msg == NULL) { 566 msg = NEW_RESOURCE_ARRAY(char, strlen(path) + 128); ; 567 jio_snprintf(msg, strlen(path) + 127, "error in opening JAR file %s", path); 568 } else { 569 int len = (int)(strlen(path) + strlen(error_msg) + 128); 570 msg = NEW_RESOURCE_ARRAY(char, len); ; 571 jio_snprintf(msg, len - 1, "error in opening JAR file <%s> %s", error_msg, path); 572 } 573 // Don't complain about bad jar files added via -Xbootclasspath/a:. 574 if (throw_exception && is_init_completed()) { 575 THROW_MSG_(vmSymbols::java_lang_ClassNotFoundException(), msg, NULL); 576 } else { 577 return NULL; 578 } 579 } 580 } 581 if (TraceClassPaths) { 582 tty->print_cr("[Opened %s]", path); 583 } 584 log_info(classload)("opened: %s", path); 585 } else { 586 // Directory 587 new_entry = new ClassPathDirEntry(path); 588 log_info(classload)("path: %s", path); 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 }