src/share/vm/classfile/classLoader.cpp

Print this page
rev 6853 : 8046070: Class Data Sharing clean up and refactoring
Summary: Cleaned up CDS to be more configurable, maintainable and extensible
Reviewed-by: dholmes, coleenp, acorn, mchung


   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/classFileParser.hpp"
  27 #include "classfile/classFileStream.hpp"
  28 #include "classfile/classLoader.hpp"

  29 #include "classfile/classLoaderData.inline.hpp"
  30 #include "classfile/javaClasses.hpp"




  31 #include "classfile/systemDictionary.hpp"
  32 #include "classfile/vmSymbols.hpp"
  33 #include "compiler/compileBroker.hpp"
  34 #include "gc_interface/collectedHeap.inline.hpp"
  35 #include "interpreter/bytecodeStream.hpp"
  36 #include "interpreter/oopMapCache.hpp"
  37 #include "memory/allocation.inline.hpp"

  38 #include "memory/generation.hpp"
  39 #include "memory/oopFactory.hpp"
  40 #include "memory/universe.inline.hpp"
  41 #include "oops/instanceKlass.hpp"
  42 #include "oops/instanceRefKlass.hpp"
  43 #include "oops/oop.inline.hpp"
  44 #include "oops/symbol.hpp"
  45 #include "prims/jvm_misc.hpp"
  46 #include "runtime/arguments.hpp"
  47 #include "runtime/compilationPolicy.hpp"
  48 #include "runtime/fprofiler.hpp"
  49 #include "runtime/handles.hpp"
  50 #include "runtime/handles.inline.hpp"
  51 #include "runtime/init.hpp"
  52 #include "runtime/interfaceSupport.hpp"
  53 #include "runtime/java.hpp"
  54 #include "runtime/javaCalls.hpp"
  55 #include "runtime/os.hpp"
  56 #include "runtime/threadCritical.hpp"
  57 #include "runtime/timer.hpp"


  97 PerfCounter*    ClassLoader::_perf_sys_classload_time = NULL;
  98 PerfCounter*    ClassLoader::_perf_app_classload_time = NULL;
  99 PerfCounter*    ClassLoader::_perf_app_classload_selftime = NULL;
 100 PerfCounter*    ClassLoader::_perf_app_classload_count = NULL;
 101 PerfCounter*    ClassLoader::_perf_define_appclasses = NULL;
 102 PerfCounter*    ClassLoader::_perf_define_appclass_time = NULL;
 103 PerfCounter*    ClassLoader::_perf_define_appclass_selftime = NULL;
 104 PerfCounter*    ClassLoader::_perf_app_classfile_bytes_read = NULL;
 105 PerfCounter*    ClassLoader::_perf_sys_classfile_bytes_read = NULL;
 106 PerfCounter*    ClassLoader::_sync_systemLoaderLockContentionRate = NULL;
 107 PerfCounter*    ClassLoader::_sync_nonSystemLoaderLockContentionRate = NULL;
 108 PerfCounter*    ClassLoader::_sync_JVMFindLoadedClassLockFreeCounter = NULL;
 109 PerfCounter*    ClassLoader::_sync_JVMDefineClassLockFreeCounter = NULL;
 110 PerfCounter*    ClassLoader::_sync_JNIDefineClassLockFreeCounter = NULL;
 111 PerfCounter*    ClassLoader::_unsafe_defineClassCallCounter = NULL;
 112 PerfCounter*    ClassLoader::_isUnsyncloadClass = NULL;
 113 PerfCounter*    ClassLoader::_load_instance_class_failCounter = NULL;
 114 
 115 ClassPathEntry* ClassLoader::_first_entry         = NULL;
 116 ClassPathEntry* ClassLoader::_last_entry          = NULL;

 117 PackageHashtable* ClassLoader::_package_hash_table = NULL;
 118 



 119 // helper routines
 120 bool string_starts_with(const char* str, const char* str_to_find) {
 121   size_t str_len = strlen(str);
 122   size_t str_to_find_len = strlen(str_to_find);
 123   if (str_to_find_len > str_len) {
 124     return false;
 125   }
 126   return (strncmp(str, str_to_find, str_to_find_len) == 0);
 127 }
 128 
 129 bool string_ends_with(const char* str, const char* str_to_find) {
 130   size_t str_len = strlen(str);
 131   size_t str_to_find_len = strlen(str_to_find);
 132   if (str_to_find_len > str_len) {
 133     return false;
 134   }
 135   return (strncmp(str + (str_len - str_to_find_len), str_to_find, str_to_find_len) == 0);
 136 }
 137 
 138 


 177 
 178 bool ClassPathEntry::is_lazy() {
 179   return false;
 180 }
 181 
 182 ClassPathDirEntry::ClassPathDirEntry(char* dir) : ClassPathEntry() {
 183   _dir = NEW_C_HEAP_ARRAY(char, strlen(dir)+1, mtClass);
 184   strcpy(_dir, dir);
 185 }
 186 
 187 
 188 ClassFileStream* ClassPathDirEntry::open_stream(const char* name, TRAPS) {
 189   // construct full path name
 190   char path[JVM_MAXPATHLEN];
 191   if (jio_snprintf(path, sizeof(path), "%s%s%s", _dir, os::file_separator(), name) == -1) {
 192     return NULL;
 193   }
 194   // check if file exists
 195   struct stat st;
 196   if (os::stat(path, &st) == 0) {









 197     // found file, open it
 198     int file_handle = os::open(path, 0, 0);
 199     if (file_handle != -1) {
 200       // read contents into resource array
 201       u1* buffer = NEW_RESOURCE_ARRAY(u1, st.st_size);
 202       size_t num_read = os::read(file_handle, (char*) buffer, st.st_size);
 203       // close file
 204       os::close(file_handle);
 205       // construct ClassFileStream
 206       if (num_read == (size_t)st.st_size) {
 207         if (UsePerfData) {
 208           ClassLoader::perf_sys_classfile_bytes_read()->inc(num_read);
 209         }
 210         return new ClassFileStream(buffer, st.st_size, _dir);    // Resource allocated
 211       }
 212     }
 213   }
 214   return NULL;
 215 }
 216 
 217 
 218 ClassPathZipEntry::ClassPathZipEntry(jzfile* zip, const char* zip_name) : ClassPathEntry() {
 219   _zip = zip;
 220   _zip_name = NEW_C_HEAP_ARRAY(char, strlen(zip_name)+1, mtClass);
 221   strcpy(_zip_name, zip_name);
 222 }
 223 
 224 ClassPathZipEntry::~ClassPathZipEntry() {
 225   if (ZipClose != NULL) {
 226     (*ZipClose)(_zip);
 227   }
 228   FREE_C_HEAP_ARRAY(char, _zip_name, mtClass);
 229 }
 230 
 231 ClassFileStream* ClassPathZipEntry::open_stream(const char* name, TRAPS) {
 232   // enable call to C land
 233   JavaThread* thread = JavaThread::current();
 234   ThreadToNativeFromVM ttn(thread);
 235   // check whether zip archive contains name
 236   jint filesize, name_len;
 237   jzentry* entry = (*FindEntry)(_zip, name, &filesize, &name_len);
 238   if (entry == NULL) return NULL;
 239   u1* buffer;
 240   char name_buf[128];
 241   char* filename;
 242   if (name_len < 128) {
 243     filename = name_buf;
 244   } else {
 245     filename = NEW_RESOURCE_ARRAY(char, name_len + 1);
 246   }
 247 
 248   // file found, get pointer to class in mmaped jar file.
 249   if (ReadMappedEntry == NULL ||
 250       !(*ReadMappedEntry)(_zip, entry, &buffer, filename)) {
 251       // mmaped access not available, perhaps due to compression,
 252       // read contents into resource array
 253       buffer     = NEW_RESOURCE_ARRAY(u1, filesize);

 254       if (!(*ReadEntry)(_zip, entry, buffer, filename)) return NULL;
 255   }














 256   if (UsePerfData) {
 257     ClassLoader::perf_sys_classfile_bytes_read()->inc(filesize);
 258   }
 259   // return result
 260   return new ClassFileStream(buffer, filesize, _zip_name);    // Resource allocated
 261 }
 262 
 263 // invoke function for each entry in the zip file
 264 void ClassPathZipEntry::contents_do(void f(const char* name, void* context), void* context) {
 265   JavaThread* thread = JavaThread::current();
 266   HandleMark  handle_mark(thread);
 267   ThreadToNativeFromVM ttn(thread);
 268   for (int n = 0; ; n++) {
 269     jzentry * ze = ((*GetNextEntry)(_zip, n));
 270     if (ze == NULL) break;
 271     (*f)(ze->name, context);
 272   }
 273 }
 274 
 275 LazyClassPathEntry::LazyClassPathEntry(char* path, const struct stat* st) : ClassPathEntry() {
 276   _path = os::strdup_check_oom(path);
 277   _st = *st;
 278   _meta_index = NULL;
 279   _resolved_entry = NULL;
 280   _has_error = false;

 281 }
 282 
 283 LazyClassPathEntry::~LazyClassPathEntry() {
 284   os::free(_path);
 285 }
 286 
 287 bool LazyClassPathEntry::is_jar_file() {
 288   return ((_st.st_mode & S_IFREG) == S_IFREG);
 289 }
 290 
 291 ClassPathEntry* LazyClassPathEntry::resolve_entry(TRAPS) {
 292   if (_resolved_entry != NULL) {
 293     return (ClassPathEntry*) _resolved_entry;
 294   }
 295   ClassPathEntry* new_entry = NULL;
 296   new_entry = ClassLoader::create_class_path_entry(_path, &_st, false, CHECK_NULL);




 297   {
 298     ThreadCritical tc;
 299     if (_resolved_entry == NULL) {
 300       _resolved_entry = new_entry;
 301       return new_entry;
 302     }
 303   }
 304   assert(_resolved_entry != NULL, "bug in MT-safe resolution logic");
 305   delete new_entry;
 306   return (ClassPathEntry*) _resolved_entry;
 307 }
 308 
 309 ClassFileStream* LazyClassPathEntry::open_stream(const char* name, TRAPS) {
 310   if (_meta_index != NULL &&
 311       !_meta_index->may_contain(name)) {
 312     return NULL;
 313   }
 314   if (_has_error) {
 315     return NULL;
 316   }
 317   ClassPathEntry* cpe = resolve_entry(THREAD);
 318   if (cpe == NULL) {
 319     _has_error = true;
 320     return NULL;
 321   } else {
 322     return cpe->open_stream(name, THREAD);
 323   }
 324 }
 325 
 326 bool LazyClassPathEntry::is_lazy() {
 327   return true;
 328 }
 329 

















 330 static void print_meta_index(LazyClassPathEntry* entry,
 331                              GrowableArray<char*>& meta_packages) {
 332   tty->print("[Meta index for %s=", entry->name());
 333   for (int i = 0; i < meta_packages.length(); i++) {
 334     if (i > 0) tty->print(" ");
 335     tty->print("%s", meta_packages.at(i));
 336   }
 337   tty->print_cr("]");
 338 }
 339 












 340 
 341 void ClassLoader::setup_meta_index() {






















 342   // Set up meta index which allows us to open boot jars lazily if
 343   // class data sharing is enabled






 344   const char* known_version = "% VERSION 2";
 345   char* meta_index_path = Arguments::get_meta_index_path();
 346   char* meta_index_dir  = Arguments::get_meta_index_dir();
 347   FILE* file = fopen(meta_index_path, "r");
 348   int line_no = 0;









 349   if (file != NULL) {
 350     ResourceMark rm;
 351     LazyClassPathEntry* cur_entry = NULL;
 352     GrowableArray<char*> boot_class_path_packages(10);
 353     char package_name[256];
 354     bool skipCurrentJar = false;
 355     while (fgets(package_name, sizeof(package_name), file) != NULL) {
 356       ++line_no;
 357       // Remove trailing newline
 358       package_name[strlen(package_name) - 1] = '\0';
 359       switch(package_name[0]) {
 360         case '%':
 361         {
 362           if ((line_no == 1) && (strcmp(package_name, known_version) != 0)) {
 363             if (TraceClassLoading && Verbose) {
 364               tty->print("[Unsupported meta index version]");
 365             }
 366             fclose(file);
 367             return;
 368           }
 369         }
 370 
 371         // These directives indicate jar files which contain only
 372         // classes, only non-classfile resources, or a combination of
 373         // the two. See src/share/classes/sun/misc/MetaIndex.java and
 374         // make/tools/MetaIndex/BuildMetaIndex.java in the J2SE
 375         // workspace.
 376         case '#':
 377         case '!':
 378         case '@':
 379         {
 380           // Hand off current packages to current lazy entry (if any)
 381           if ((cur_entry != NULL) &&
 382               (boot_class_path_packages.length() > 0)) {
 383             if (TraceClassLoading && Verbose) {
 384               print_meta_index(cur_entry, boot_class_path_packages);
 385             }
 386             MetaIndex* index = new MetaIndex(boot_class_path_packages.adr_at(0),
 387                                              boot_class_path_packages.length());
 388             cur_entry->set_meta_index(index);
 389           }
 390           cur_entry = NULL;
 391           boot_class_path_packages.clear();
 392 
 393           // Find lazy entry corresponding to this jar file
 394           for (ClassPathEntry* entry = _first_entry; entry != NULL; entry = entry->next()) {
 395             if (entry->is_lazy() &&


 396                 string_starts_with(entry->name(), meta_index_dir) &&
 397                 string_ends_with(entry->name(), &package_name[2])) {
 398               cur_entry = (LazyClassPathEntry*) entry;
 399               break;
 400             }
 401           }
 402 
 403           // If the first character is '@', it indicates the following jar
 404           // file is a resource only jar file in which case, we should skip
 405           // reading the subsequent entries since the resource loading is
 406           // totally handled by J2SE side.
 407           if (package_name[0] == '@') {
 408             if (cur_entry != NULL) {
 409               cur_entry->set_meta_index(new MetaIndex(NULL, 0));
 410             }
 411             cur_entry = NULL;
 412             skipCurrentJar = true;
 413           } else {
 414             skipCurrentJar = false;
 415           }
 416 
 417           break;
 418         }
 419 
 420         default:
 421         {
 422           if (!skipCurrentJar && cur_entry != NULL) {
 423             char* new_name = os::strdup_check_oom(package_name);
 424             boot_class_path_packages.append(new_name);
 425           }
 426         }
 427       }
 428     }
 429     // Hand off current packages to current lazy entry (if any)
 430     if ((cur_entry != NULL) &&
 431         (boot_class_path_packages.length() > 0)) {
 432       if (TraceClassLoading && Verbose) {
 433         print_meta_index(cur_entry, boot_class_path_packages);
 434       }
 435       MetaIndex* index = new MetaIndex(boot_class_path_packages.adr_at(0),
 436                                        boot_class_path_packages.length());
 437       cur_entry->set_meta_index(index);
 438     }
 439     fclose(file);
 440   }
 441 }
 442 


















 443 void ClassLoader::setup_bootstrap_search_path() {
 444   assert(_first_entry == NULL, "should not setup bootstrap class search path twice");
 445   char* sys_class_path = os::strdup_check_oom(Arguments::get_sysclasspath());
 446   if (TraceClassLoading && Verbose) {
 447     tty->print_cr("[Bootstrap loader class path=%s]", sys_class_path);
 448   }

















 449 
 450   int len = (int)strlen(sys_class_path);










 451   int end = 0;
 452 
 453   // Iterate over class path entries
 454   for (int start = 0; start < len; start = end) {
 455     while (sys_class_path[end] && sys_class_path[end] != os::path_separator()[0]) {
 456       end++;
 457     }
 458     char* path = NEW_C_HEAP_ARRAY(char, end-start+1, mtClass);
 459     strncpy(path, &sys_class_path[start], end-start);
 460     path[end-start] = '\0';


 461     update_class_path_entry_list(path, false);
 462     FREE_C_HEAP_ARRAY(char, path, mtClass);
 463     while (sys_class_path[end] == os::path_separator()[0]) {




 464       end++;
 465     }
 466   }
 467   os::free(sys_class_path);
 468 }
 469 
 470 ClassPathEntry* ClassLoader::create_class_path_entry(char *path, const struct stat* st, bool lazy, TRAPS) {

 471   JavaThread* thread = JavaThread::current();
 472   if (lazy) {
 473     return new LazyClassPathEntry(path, st);
 474   }
 475   ClassPathEntry* new_entry = NULL;
 476   if ((st->st_mode & S_IFREG) == S_IFREG) {
 477     // Regular file, should be a zip file
 478     // Canonicalized filename
 479     char canonical_path[JVM_MAXPATHLEN];
 480     if (!get_canonical_path(path, canonical_path, JVM_MAXPATHLEN)) {
 481       // This matches the classic VM

 482       THROW_MSG_(vmSymbols::java_io_IOException(), "Bad pathname", NULL);



 483     }
 484     char* error_msg = NULL;
 485     jzfile* zip;
 486     {
 487       // enable call to C land
 488       ThreadToNativeFromVM ttn(thread);
 489       HandleMark hm(thread);
 490       zip = (*ZipOpen)(canonical_path, &error_msg);
 491     }
 492     if (zip != NULL && error_msg == NULL) {
 493       new_entry = new ClassPathZipEntry(zip, path);
 494       if (TraceClassLoading) {
 495         tty->print_cr("[Opened %s]", path);
 496       }
 497     } else {
 498       ResourceMark rm(thread);
 499       char *msg;
 500       if (error_msg == NULL) {
 501         msg = NEW_RESOURCE_ARRAY(char, strlen(path) + 128); ;
 502         jio_snprintf(msg, strlen(path) + 127, "error in opening JAR file %s", path);
 503       } else {
 504         int len = (int)(strlen(path) + strlen(error_msg) + 128);
 505         msg = NEW_RESOURCE_ARRAY(char, len); ;
 506         jio_snprintf(msg, len - 1, "error in opening JAR file <%s> %s", error_msg, path);
 507       }

 508       THROW_MSG_(vmSymbols::java_lang_ClassNotFoundException(), msg, NULL);



 509     }
 510   } else {
 511     // Directory
 512     new_entry = new ClassPathDirEntry(path);
 513     if (TraceClassLoading) {
 514       tty->print_cr("[Path %s]", path);
 515     }
 516   }
 517   return new_entry;
 518 }
 519 
 520 
 521 // Create a class path zip entry for a given path (return NULL if not found
 522 // or zip/JAR file cannot be opened)
 523 ClassPathZipEntry* ClassLoader::create_class_path_zip_entry(const char *path) {
 524   // check for a regular file
 525   struct stat st;
 526   if (os::stat(path, &st) == 0) {
 527     if ((st.st_mode & S_IFREG) == S_IFREG) {
 528       char orig_path[JVM_MAXPATHLEN];
 529       char canonical_path[JVM_MAXPATHLEN];
 530 
 531       strcpy(orig_path, path);
 532       if (get_canonical_path(orig_path, canonical_path, JVM_MAXPATHLEN)) {
 533         char* error_msg = NULL;


 554   ClassPathEntry* e = _first_entry;
 555   while (e != NULL) {
 556     // assume zip entries have been canonicalized
 557     if (strcmp(entry->name(), e->name()) == 0) {
 558       return true;
 559     }
 560     e = e->next();
 561   }
 562   return false;
 563 }
 564 
 565 void ClassLoader::add_to_list(ClassPathEntry *new_entry) {
 566   if (new_entry != NULL) {
 567     if (_last_entry == NULL) {
 568       _first_entry = _last_entry = new_entry;
 569     } else {
 570       _last_entry->set_next(new_entry);
 571       _last_entry = new_entry;
 572     }
 573   }

 574 }
 575 
 576 void ClassLoader::update_class_path_entry_list(char *path,
 577                                                bool check_for_duplicates) {


 578   struct stat st;
 579   if (os::stat(path, &st) == 0) {
 580     // File or directory found
 581     ClassPathEntry* new_entry = NULL;
 582     Thread* THREAD = Thread::current();
 583     new_entry = create_class_path_entry(path, &st, LazyBootClassLoader, CHECK);



 584     // The kernel VM adds dynamically to the end of the classloader path and
 585     // doesn't reorder the bootclasspath which would break java.lang.Package
 586     // (see PackageInfo).
 587     // Add new entry to linked list
 588     if (!check_for_duplicates || !contains_entry(new_entry)) {
 589       add_to_list(new_entry);
 590     }








 591   }
 592 }
 593 
 594 void ClassLoader::print_bootclasspath() {
 595   ClassPathEntry* e = _first_entry;
 596   tty->print("[bootclasspath= ");
 597   while (e != NULL) {
 598     tty->print("%s ;", e->name());
 599     e = e->next();
 600   }
 601   tty->print_cr("]");
 602 }
 603 
 604 void ClassLoader::load_zip_library() {
 605   assert(ZipOpen == NULL, "should not load zip library twice");
 606   // First make sure native library is loaded
 607   os::native_java_library();
 608   // Load zip library
 609   char path[JVM_MAXPATHLEN];
 610   char ebuf[1024];


 722     pp = (PackageInfo*)BasicHashtable<mtClass>::new_entry(hash);
 723     pp->set_pkgname(pkgname);
 724     return pp;
 725   }
 726 
 727   void add_entry(PackageInfo* pp) {
 728     int index = hash_to_index(pp->hash());
 729     BasicHashtable<mtClass>::add_entry(index, pp);
 730   }
 731 
 732   void copy_pkgnames(const char** packages) {
 733     int n = 0;
 734     for (int i = 0; i < table_size(); ++i) {
 735       for (PackageInfo* pp = bucket(i); pp != NULL; pp = pp->next()) {
 736         packages[n++] = pp->pkgname();
 737       }
 738     }
 739     assert(n == number_of_entries(), "just checking");
 740   }
 741 
 742   void copy_table(char** top, char* end, PackageHashtable* table);
 743 };
 744 
 745 
 746 void PackageHashtable::copy_table(char** top, char* end,
 747                                   PackageHashtable* table) {
 748   // Copy (relocate) the table to the shared space.
 749   BasicHashtable<mtClass>::copy_table(top, end);
 750 
 751   // Calculate the space needed for the package name strings.
 752   int i;
 753   int n = 0;
 754   for (i = 0; i < table_size(); ++i) {
 755     for (PackageInfo* pp = table->bucket(i);
 756                       pp != NULL;
 757                       pp = pp->next()) {
 758       n += (int)(strlen(pp->pkgname()) + 1);
 759     }
 760   }
 761   if (*top + n + sizeof(intptr_t) >= end) {
 762     report_out_of_shared_space(SharedMiscData);
 763   }
 764 
 765   // Copy the table data (the strings) to the shared space.
 766   n = align_size_up(n, sizeof(HeapWord));
 767   *(intptr_t*)(*top) = n;
 768   *top += sizeof(intptr_t);
 769 
 770   for (i = 0; i < table_size(); ++i) {
 771     for (PackageInfo* pp = table->bucket(i);
 772                       pp != NULL;
 773                       pp = pp->next()) {
 774       int n1 = (int)(strlen(pp->pkgname()) + 1);



 775       pp->set_pkgname((char*)memcpy(*top, pp->pkgname(), n1));
 776       *top += n1;
 777     }
 778   }
 779   *top = (char*)align_size_up((intptr_t)*top, sizeof(HeapWord));







 780 }
 781 
 782 
 783 void ClassLoader::copy_package_info_buckets(char** top, char* end) {
 784   _package_hash_table->copy_buckets(top, end);
 785 }
 786 
 787 void ClassLoader::copy_package_info_table(char** top, char* end) {
 788   _package_hash_table->copy_table(top, end, _package_hash_table);
 789 }
 790 
 791 
 792 PackageInfo* ClassLoader::lookup_package(const char *pkgname) {
 793   const char *cp = strrchr(pkgname, '/');
 794   if (cp != NULL) {
 795     // Package prefix found
 796     int n = cp - pkgname + 1;
 797     return _package_hash_table->get_entry(pkgname, n);
 798   }
 799   return NULL;
 800 }
 801 
 802 
 803 bool ClassLoader::add_package(const char *pkgname, int classpath_index, TRAPS) {
 804   assert(pkgname != NULL, "just checking");
 805   // Bootstrap loader no longer holds system loader lock obj serializing
 806   // load_instance_class and thereby add_package
 807   {
 808     MutexLocker ml(PackageTable_lock, THREAD);
 809     // First check for previously loaded entry
 810     PackageInfo* pp = lookup_package(pkgname);


 863     if ((packages = NEW_RESOURCE_ARRAY(const char*, nof_entries)) == NULL) {
 864       return NULL;
 865     }
 866     _package_hash_table->copy_pkgnames(packages);
 867   }
 868   // Allocate objArray and fill with java.lang.String
 869   objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
 870                                            nof_entries, CHECK_0);
 871   objArrayHandle result(THREAD, r);
 872   for (int i = 0; i < nof_entries; i++) {
 873     Handle str = java_lang_String::create_from_str(packages[i], CHECK_0);
 874     result->obj_at_put(i, str());
 875   }
 876 
 877   return result();
 878 }
 879 
 880 
 881 instanceKlassHandle ClassLoader::load_classfile(Symbol* h_name, TRAPS) {
 882   ResourceMark rm(THREAD);
 883   EventMark m("loading class %s", h_name->as_C_string());

 884   ThreadProfilerMark tpm(ThreadProfilerMark::classLoaderRegion);
 885 
 886   stringStream st;
 887   // st.print() uses too much stack space while handling a StackOverflowError
 888   // st.print("%s.class", h_name->as_utf8());
 889   st.print_raw(h_name->as_utf8());
 890   st.print_raw(".class");
 891   char* name = st.as_string();

 892 
 893   // Lookup stream for parsing .class file
 894   ClassFileStream* stream = NULL;
 895   int classpath_index = 0;


 896   {
 897     PerfClassTraceTime vmtimer(perf_sys_class_lookup_time(),
 898                                ((JavaThread*) THREAD)->get_thread_stat()->perf_timers_addr(),
 899                                PerfClassTraceTime::CLASS_LOAD);
 900     ClassPathEntry* e = _first_entry;
 901     while (e != NULL) {
 902       stream = e->open_stream(name, CHECK_NULL);



 903       if (stream != NULL) {
 904         break;
 905       }
 906       e = e->next();
 907       ++classpath_index;
 908     }
 909   }
 910 
 911   instanceKlassHandle h;
 912   if (stream != NULL) {
 913 
 914     // class file found, parse it
 915     ClassFileParser parser(stream);
 916     ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data();
 917     Handle protection_domain;
 918     TempNewSymbol parsed_name = NULL;
 919     instanceKlassHandle result = parser.parseClassFile(h_name,
 920                                                        loader_data,
 921                                                        protection_domain,
 922                                                        parsed_name,
 923                                                        false,
 924                                                        CHECK_(h));
 925 
 926     // add to package table
 927     if (add_package(name, classpath_index, THREAD)) {
 928       h = result;







 929     }
 930   }
 931 
 932   return h;
 933 }
 934 
 935 
 936 void ClassLoader::create_package_info_table(HashtableBucket<mtClass> *t, int length,
 937                                             int number_of_entries) {
 938   assert(_package_hash_table == NULL, "One package info table allowed.");
 939   assert(length == package_hash_table_size * sizeof(HashtableBucket<mtClass>),
 940          "bad shared package info size.");
 941   _package_hash_table = new PackageHashtable(package_hash_table_size, t,
 942                                              number_of_entries);
 943 }
 944 
 945 
 946 void ClassLoader::create_package_info_table() {
 947     assert(_package_hash_table == NULL, "shouldn't have one yet");
 948     _package_hash_table = new PackageHashtable(package_hash_table_size);


1003                         "jvmDefineClassNoLockCalls");
1004 
1005     NEWPERFEVENTCOUNTER(_sync_JNIDefineClassLockFreeCounter, SUN_CLS,
1006                         "jniDefineClassNoLockCalls");
1007 
1008     NEWPERFEVENTCOUNTER(_unsafe_defineClassCallCounter, SUN_CLS,
1009                         "unsafeDefineClassCalls");
1010 
1011     NEWPERFEVENTCOUNTER(_isUnsyncloadClass, SUN_CLS, "isUnsyncloadClassSet");
1012     NEWPERFEVENTCOUNTER(_load_instance_class_failCounter, SUN_CLS,
1013                         "loadInstanceClassFailRate");
1014 
1015     // increment the isUnsyncloadClass counter if UnsyncloadClass is set.
1016     if (UnsyncloadClass) {
1017       _isUnsyncloadClass->inc();
1018     }
1019   }
1020 
1021   // lookup zip library entry points
1022   load_zip_library();

1023   // initialize search path




1024   setup_bootstrap_search_path();
1025   if (LazyBootClassLoader) {
1026     // set up meta index which makes boot classpath initialization lazier
1027     setup_meta_index();
1028   }
1029 }
1030 








1031 
1032 jlong ClassLoader::classloader_time_ms() {
1033   return UsePerfData ?
1034     Management::ticks_to_ms(_perf_accumulated_time->get_value()) : -1;
1035 }
1036 
1037 jlong ClassLoader::class_init_count() {
1038   return UsePerfData ? _perf_classes_inited->get_value() : -1;
1039 }
1040 
1041 jlong ClassLoader::class_init_time_ms() {
1042   return UsePerfData ?
1043     Management::ticks_to_ms(_perf_class_init_time->get_value()) : -1;
1044 }
1045 
1046 jlong ClassLoader::class_verify_time_ms() {
1047   return UsePerfData ?
1048     Management::ticks_to_ms(_perf_class_verify_time->get_value()) : -1;
1049 }
1050 




   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/classFileParser.hpp"
  27 #include "classfile/classFileStream.hpp"
  28 #include "classfile/classLoader.hpp"
  29 #include "classfile/classLoaderExt.hpp"
  30 #include "classfile/classLoaderData.inline.hpp"
  31 #include "classfile/javaClasses.hpp"
  32 #if INCLUDE_CDS
  33 #include "classfile/sharedPathsMiscInfo.hpp"
  34 #include "classfile/sharedClassUtil.hpp"
  35 #endif
  36 #include "classfile/systemDictionary.hpp"
  37 #include "classfile/vmSymbols.hpp"
  38 #include "compiler/compileBroker.hpp"
  39 #include "gc_interface/collectedHeap.inline.hpp"
  40 #include "interpreter/bytecodeStream.hpp"
  41 #include "interpreter/oopMapCache.hpp"
  42 #include "memory/allocation.inline.hpp"
  43 #include "memory/filemap.hpp"
  44 #include "memory/generation.hpp"
  45 #include "memory/oopFactory.hpp"
  46 #include "memory/universe.inline.hpp"
  47 #include "oops/instanceKlass.hpp"
  48 #include "oops/instanceRefKlass.hpp"
  49 #include "oops/oop.inline.hpp"
  50 #include "oops/symbol.hpp"
  51 #include "prims/jvm_misc.hpp"
  52 #include "runtime/arguments.hpp"
  53 #include "runtime/compilationPolicy.hpp"
  54 #include "runtime/fprofiler.hpp"
  55 #include "runtime/handles.hpp"
  56 #include "runtime/handles.inline.hpp"
  57 #include "runtime/init.hpp"
  58 #include "runtime/interfaceSupport.hpp"
  59 #include "runtime/java.hpp"
  60 #include "runtime/javaCalls.hpp"
  61 #include "runtime/os.hpp"
  62 #include "runtime/threadCritical.hpp"
  63 #include "runtime/timer.hpp"


 103 PerfCounter*    ClassLoader::_perf_sys_classload_time = NULL;
 104 PerfCounter*    ClassLoader::_perf_app_classload_time = NULL;
 105 PerfCounter*    ClassLoader::_perf_app_classload_selftime = NULL;
 106 PerfCounter*    ClassLoader::_perf_app_classload_count = NULL;
 107 PerfCounter*    ClassLoader::_perf_define_appclasses = NULL;
 108 PerfCounter*    ClassLoader::_perf_define_appclass_time = NULL;
 109 PerfCounter*    ClassLoader::_perf_define_appclass_selftime = NULL;
 110 PerfCounter*    ClassLoader::_perf_app_classfile_bytes_read = NULL;
 111 PerfCounter*    ClassLoader::_perf_sys_classfile_bytes_read = NULL;
 112 PerfCounter*    ClassLoader::_sync_systemLoaderLockContentionRate = NULL;
 113 PerfCounter*    ClassLoader::_sync_nonSystemLoaderLockContentionRate = NULL;
 114 PerfCounter*    ClassLoader::_sync_JVMFindLoadedClassLockFreeCounter = NULL;
 115 PerfCounter*    ClassLoader::_sync_JVMDefineClassLockFreeCounter = NULL;
 116 PerfCounter*    ClassLoader::_sync_JNIDefineClassLockFreeCounter = NULL;
 117 PerfCounter*    ClassLoader::_unsafe_defineClassCallCounter = NULL;
 118 PerfCounter*    ClassLoader::_isUnsyncloadClass = NULL;
 119 PerfCounter*    ClassLoader::_load_instance_class_failCounter = NULL;
 120 
 121 ClassPathEntry* ClassLoader::_first_entry         = NULL;
 122 ClassPathEntry* ClassLoader::_last_entry          = NULL;
 123 int             ClassLoader::_num_entries         = 0;
 124 PackageHashtable* ClassLoader::_package_hash_table = NULL;
 125 
 126 #if INCLUDE_CDS
 127 SharedPathsMiscInfo* ClassLoader::_shared_paths_misc_info = NULL;
 128 #endif
 129 // helper routines
 130 bool string_starts_with(const char* str, const char* str_to_find) {
 131   size_t str_len = strlen(str);
 132   size_t str_to_find_len = strlen(str_to_find);
 133   if (str_to_find_len > str_len) {
 134     return false;
 135   }
 136   return (strncmp(str, str_to_find, str_to_find_len) == 0);
 137 }
 138 
 139 bool string_ends_with(const char* str, const char* str_to_find) {
 140   size_t str_len = strlen(str);
 141   size_t str_to_find_len = strlen(str_to_find);
 142   if (str_to_find_len > str_len) {
 143     return false;
 144   }
 145   return (strncmp(str + (str_len - str_to_find_len), str_to_find, str_to_find_len) == 0);
 146 }
 147 
 148 


 187 
 188 bool ClassPathEntry::is_lazy() {
 189   return false;
 190 }
 191 
 192 ClassPathDirEntry::ClassPathDirEntry(char* dir) : ClassPathEntry() {
 193   _dir = NEW_C_HEAP_ARRAY(char, strlen(dir)+1, mtClass);
 194   strcpy(_dir, dir);
 195 }
 196 
 197 
 198 ClassFileStream* ClassPathDirEntry::open_stream(const char* name, TRAPS) {
 199   // construct full path name
 200   char path[JVM_MAXPATHLEN];
 201   if (jio_snprintf(path, sizeof(path), "%s%s%s", _dir, os::file_separator(), name) == -1) {
 202     return NULL;
 203   }
 204   // check if file exists
 205   struct stat st;
 206   if (os::stat(path, &st) == 0) {
 207 #if INCLUDE_CDS
 208     if (DumpSharedSpaces) {
 209       // We have already check in ClassLoader::check_shared_classpath() that the directory is empty, so
 210       // we should never find a file underneath it -- unless user has added a new file while we are running
 211       // the dump, in which case let's quit!
 212       ShouldNotReachHere();
 213       ClassLoader::exit_with_path_failure("VM internal error. Classes can be loaded only from JAR files during dump time: %s", path);
 214     }
 215 #endif
 216     // found file, open it
 217     int file_handle = os::open(path, 0, 0);
 218     if (file_handle != -1) {
 219       // read contents into resource array
 220       u1* buffer = NEW_RESOURCE_ARRAY(u1, st.st_size);
 221       size_t num_read = os::read(file_handle, (char*) buffer, st.st_size);
 222       // close file
 223       os::close(file_handle);
 224       // construct ClassFileStream
 225       if (num_read == (size_t)st.st_size) {
 226         if (UsePerfData) {
 227           ClassLoader::perf_sys_classfile_bytes_read()->inc(num_read);
 228         }
 229         return new ClassFileStream(buffer, st.st_size, _dir);    // Resource allocated
 230       }
 231     }
 232   }
 233   return NULL;
 234 }
 235 
 236 
 237 ClassPathZipEntry::ClassPathZipEntry(jzfile* zip, const char* zip_name) : ClassPathEntry() {
 238   _zip = zip;
 239   _zip_name = NEW_C_HEAP_ARRAY(char, strlen(zip_name)+1, mtClass);
 240   strcpy(_zip_name, zip_name);
 241 }
 242 
 243 ClassPathZipEntry::~ClassPathZipEntry() {
 244   if (ZipClose != NULL) {
 245     (*ZipClose)(_zip);
 246   }
 247   FREE_C_HEAP_ARRAY(char, _zip_name, mtClass);
 248 }
 249 
 250 u1* ClassPathZipEntry::open_entry(const char* name, jint* filesize, bool nul_terminate, TRAPS) {
 251     // enable call to C land
 252   JavaThread* thread = JavaThread::current();
 253   ThreadToNativeFromVM ttn(thread);
 254   // check whether zip archive contains name
 255   jint name_len;
 256   jzentry* entry = (*FindEntry)(_zip, name, filesize, &name_len);
 257   if (entry == NULL) return NULL;
 258   u1* buffer;
 259   char name_buf[128];
 260   char* filename;
 261   if (name_len < 128) {
 262     filename = name_buf;
 263   } else {
 264     filename = NEW_RESOURCE_ARRAY(char, name_len + 1);
 265   }
 266 
 267   // file found, get pointer to the entry in mmapped jar file.
 268   if (ReadMappedEntry == NULL ||
 269       !(*ReadMappedEntry)(_zip, entry, &buffer, filename)) {
 270       // mmapped access not available, perhaps due to compression,
 271       // read contents into resource array
 272       int size = (*filesize) + ((nul_terminate) ? 1 : 0);
 273       buffer = NEW_RESOURCE_ARRAY(u1, size);
 274       if (!(*ReadEntry)(_zip, entry, buffer, filename)) return NULL;
 275   }
 276 
 277   // return result
 278   if (nul_terminate) {
 279     buffer[*filesize] = 0;
 280   }
 281   return buffer;
 282 }
 283 
 284 ClassFileStream* ClassPathZipEntry::open_stream(const char* name, TRAPS) {
 285   jint filesize;
 286   u1* buffer = open_entry(name, &filesize, false, CHECK_NULL);
 287   if (buffer == NULL) {
 288     return NULL;
 289   }
 290   if (UsePerfData) {
 291     ClassLoader::perf_sys_classfile_bytes_read()->inc(filesize);
 292   }

 293   return new ClassFileStream(buffer, filesize, _zip_name); // Resource allocated
 294 }
 295 
 296 // invoke function for each entry in the zip file
 297 void ClassPathZipEntry::contents_do(void f(const char* name, void* context), void* context) {
 298   JavaThread* thread = JavaThread::current();
 299   HandleMark  handle_mark(thread);
 300   ThreadToNativeFromVM ttn(thread);
 301   for (int n = 0; ; n++) {
 302     jzentry * ze = ((*GetNextEntry)(_zip, n));
 303     if (ze == NULL) break;
 304     (*f)(ze->name, context);
 305   }
 306 }
 307 
 308 LazyClassPathEntry::LazyClassPathEntry(char* path, const struct stat* st, bool throw_exception) : ClassPathEntry() {
 309   _path = os::strdup_check_oom(path);
 310   _st = *st;
 311   _meta_index = NULL;
 312   _resolved_entry = NULL;
 313   _has_error = false;
 314   _throw_exception = throw_exception;
 315 }
 316 
 317 LazyClassPathEntry::~LazyClassPathEntry() {
 318   os::free(_path);
 319 }
 320 
 321 bool LazyClassPathEntry::is_jar_file() {
 322   return ((_st.st_mode & S_IFREG) == S_IFREG);
 323 }
 324 
 325 ClassPathEntry* LazyClassPathEntry::resolve_entry(TRAPS) {
 326   if (_resolved_entry != NULL) {
 327     return (ClassPathEntry*) _resolved_entry;
 328   }
 329   ClassPathEntry* new_entry = NULL;
 330   new_entry = ClassLoader::create_class_path_entry(_path, &_st, false, _throw_exception, CHECK_NULL);
 331   if (!_throw_exception && new_entry == NULL) {
 332     assert(!HAS_PENDING_EXCEPTION, "must be");
 333     return NULL;
 334   }
 335   {
 336     ThreadCritical tc;
 337     if (_resolved_entry == NULL) {
 338       _resolved_entry = new_entry;
 339       return new_entry;
 340     }
 341   }
 342   assert(_resolved_entry != NULL, "bug in MT-safe resolution logic");
 343   delete new_entry;
 344   return (ClassPathEntry*) _resolved_entry;
 345 }
 346 
 347 ClassFileStream* LazyClassPathEntry::open_stream(const char* name, TRAPS) {
 348   if (_meta_index != NULL &&
 349       !_meta_index->may_contain(name)) {
 350     return NULL;
 351   }
 352   if (_has_error) {
 353     return NULL;
 354   }
 355   ClassPathEntry* cpe = resolve_entry(THREAD);
 356   if (cpe == NULL) {
 357     _has_error = true;
 358     return NULL;
 359   } else {
 360     return cpe->open_stream(name, THREAD);
 361   }
 362 }
 363 
 364 bool LazyClassPathEntry::is_lazy() {
 365   return true;
 366 }
 367 
 368 u1* LazyClassPathEntry::open_entry(const char* name, jint* filesize, bool nul_terminate, TRAPS) {
 369   if (_has_error) {
 370     return NULL;
 371   }
 372   ClassPathEntry* cpe = resolve_entry(THREAD);
 373   if (cpe == NULL) {
 374     _has_error = true;
 375     return NULL;
 376   } else if (cpe->is_jar_file()) {
 377     return ((ClassPathZipEntry*)cpe)->open_entry(name, filesize, nul_terminate,THREAD);
 378   } else {
 379     ShouldNotReachHere();
 380     *filesize = 0;
 381     return NULL;
 382   }
 383 }
 384 
 385 static void print_meta_index(LazyClassPathEntry* entry,
 386                              GrowableArray<char*>& meta_packages) {
 387   tty->print("[Meta index for %s=", entry->name());
 388   for (int i = 0; i < meta_packages.length(); i++) {
 389     if (i > 0) tty->print(" ");
 390     tty->print("%s", meta_packages.at(i));
 391   }
 392   tty->print_cr("]");
 393 }
 394 
 395 #if INCLUDE_CDS
 396 void ClassLoader::exit_with_path_failure(const char* error, const char* message) {
 397   assert(DumpSharedSpaces, "only called at dump time");
 398   tty->print_cr("Hint: enable -XX:+TraceClassPaths to diagnose the failure");
 399   vm_exit_during_initialization(error, message);
 400 }
 401 #endif
 402 
 403 void ClassLoader::trace_class_path(const char* msg, const char* name) {
 404   if (!TraceClassPaths) {
 405     return;
 406   }
 407 
 408   if (msg) {
 409     tty->print("%s", msg);
 410   }
 411   if (name) {
 412     if (strlen(name) < 256) {
 413       tty->print("%s", name);
 414     } else {
 415       // For very long paths, we need to print each character separately,
 416       // as print_cr() has a length limit
 417       while (name[0] != '\0') {
 418         tty->print("%c", name[0]);
 419         name++;
 420       }
 421     }
 422   }
 423   if (msg && msg[0] == '[') {
 424     tty->print_cr("]");
 425   } else {
 426     tty->cr();
 427   }
 428 }
 429 
 430 void ClassLoader::setup_bootstrap_meta_index() {
 431   // Set up meta index which allows us to open boot jars lazily if
 432   // class data sharing is enabled
 433   const char* meta_index_path = Arguments::get_meta_index_path();
 434   const char* meta_index_dir  = Arguments::get_meta_index_dir();
 435   setup_meta_index(meta_index_path, meta_index_dir, 0);
 436 }
 437 
 438 void ClassLoader::setup_meta_index(const char* meta_index_path, const char* meta_index_dir, int start_index) {
 439   const char* known_version = "% VERSION 2";


 440   FILE* file = fopen(meta_index_path, "r");
 441   int line_no = 0;
 442 #if INCLUDE_CDS
 443   if (DumpSharedSpaces) {
 444     if (file != NULL) {
 445       _shared_paths_misc_info->add_required_file(meta_index_path);
 446     } else {
 447       _shared_paths_misc_info->add_nonexist_path(meta_index_path);
 448     }
 449   }
 450 #endif
 451   if (file != NULL) {
 452     ResourceMark rm;
 453     LazyClassPathEntry* cur_entry = NULL;
 454     GrowableArray<char*> boot_class_path_packages(10);
 455     char package_name[256];
 456     bool skipCurrentJar = false;
 457     while (fgets(package_name, sizeof(package_name), file) != NULL) {
 458       ++line_no;
 459       // Remove trailing newline
 460       package_name[strlen(package_name) - 1] = '\0';
 461       switch(package_name[0]) {
 462         case '%':
 463         {
 464           if ((line_no == 1) && (strcmp(package_name, known_version) != 0)) {
 465             if (TraceClassLoading && Verbose) {
 466               tty->print("[Unsupported meta index version]");
 467             }
 468             fclose(file);
 469             return;
 470           }
 471         }
 472 
 473         // These directives indicate jar files which contain only
 474         // classes, only non-classfile resources, or a combination of
 475         // the two. See src/share/classes/sun/misc/MetaIndex.java and
 476         // make/tools/MetaIndex/BuildMetaIndex.java in the J2SE
 477         // workspace.
 478         case '#':
 479         case '!':
 480         case '@':
 481         {
 482           // Hand off current packages to current lazy entry (if any)
 483           if ((cur_entry != NULL) &&
 484               (boot_class_path_packages.length() > 0)) {
 485             if ((TraceClassLoading || TraceClassPaths) && Verbose) {
 486               print_meta_index(cur_entry, boot_class_path_packages);
 487             }
 488             MetaIndex* index = new MetaIndex(boot_class_path_packages.adr_at(0),
 489                                              boot_class_path_packages.length());
 490             cur_entry->set_meta_index(index);
 491           }
 492           cur_entry = NULL;
 493           boot_class_path_packages.clear();
 494 
 495           // Find lazy entry corresponding to this jar file
 496           int count = 0;
 497           for (ClassPathEntry* entry = _first_entry; entry != NULL; entry = entry->next(), count++) {
 498             if (count >= start_index &&
 499                 entry->is_lazy() &&
 500                 string_starts_with(entry->name(), meta_index_dir) &&
 501                 string_ends_with(entry->name(), &package_name[2])) {
 502               cur_entry = (LazyClassPathEntry*) entry;
 503               break;
 504             }
 505           }
 506 
 507           // If the first character is '@', it indicates the following jar
 508           // file is a resource only jar file in which case, we should skip
 509           // reading the subsequent entries since the resource loading is
 510           // totally handled by J2SE side.
 511           if (package_name[0] == '@') {
 512             if (cur_entry != NULL) {
 513               cur_entry->set_meta_index(new MetaIndex(NULL, 0));
 514             }
 515             cur_entry = NULL;
 516             skipCurrentJar = true;
 517           } else {
 518             skipCurrentJar = false;
 519           }
 520 
 521           break;
 522         }
 523 
 524         default:
 525         {
 526           if (!skipCurrentJar && cur_entry != NULL) {
 527             char* new_name = os::strdup_check_oom(package_name);
 528             boot_class_path_packages.append(new_name);
 529           }
 530         }
 531       }
 532     }
 533     // Hand off current packages to current lazy entry (if any)
 534     if ((cur_entry != NULL) &&
 535         (boot_class_path_packages.length() > 0)) {
 536       if ((TraceClassLoading || TraceClassPaths) && Verbose) {
 537         print_meta_index(cur_entry, boot_class_path_packages);
 538       }
 539       MetaIndex* index = new MetaIndex(boot_class_path_packages.adr_at(0),
 540                                        boot_class_path_packages.length());
 541       cur_entry->set_meta_index(index);
 542     }
 543     fclose(file);
 544   }
 545 }
 546 
 547 #if INCLUDE_CDS
 548 void ClassLoader::check_shared_classpath(const char *path) {
 549   if (strcmp(path, "") == 0) {
 550     exit_with_path_failure("Cannot have empty path in archived classpaths", NULL);
 551   }
 552 
 553   struct stat st;
 554   if (os::stat(path, &st) == 0) {
 555     if ((st.st_mode & S_IFREG) != S_IFREG) { // is directory
 556       if (!os::dir_is_empty(path)) {
 557         tty->print_cr("Error: non-empty directory '%s'", path);
 558         exit_with_path_failure("CDS allows only empty directories in archived classpaths", NULL);
 559       }
 560     }
 561   }
 562 }
 563 #endif
 564 
 565 void ClassLoader::setup_bootstrap_search_path() {
 566   assert(_first_entry == NULL, "should not setup bootstrap class search path twice");
 567   char* sys_class_path = os::strdup_check_oom(Arguments::get_sysclasspath());
 568   if (!PrintSharedArchiveAndExit) {
 569     trace_class_path("[Bootstrap loader class path=", sys_class_path);
 570   }
 571 #if INCLUDE_CDS
 572   if (DumpSharedSpaces) {
 573     _shared_paths_misc_info->add_boot_classpath(Arguments::get_sysclasspath());
 574   }
 575 #endif
 576   setup_search_path(sys_class_path);
 577   os::free(sys_class_path);
 578 }
 579 
 580 #if INCLUDE_CDS
 581 int ClassLoader::get_shared_paths_misc_info_size() {
 582   return _shared_paths_misc_info->get_used_bytes();
 583 }
 584 
 585 void* ClassLoader::get_shared_paths_misc_info() {
 586   return _shared_paths_misc_info->buffer();
 587 }
 588 
 589 bool ClassLoader::check_shared_paths_misc_info(void *buf, int size) {
 590   SharedPathsMiscInfo* checker = SharedClassUtil::allocate_shared_paths_misc_info((char*)buf, size);
 591   bool result = checker->check();
 592   delete checker;
 593   return result;
 594 }
 595 #endif
 596 
 597 void ClassLoader::setup_search_path(char *class_path) {
 598   int offset = 0;
 599   int len = (int)strlen(class_path);
 600   int end = 0;
 601 
 602   // Iterate over class path entries
 603   for (int start = 0; start < len; start = end) {
 604     while (class_path[end] && class_path[end] != os::path_separator()[0]) {
 605       end++;
 606     }
 607     EXCEPTION_MARK;
 608     ResourceMark rm(THREAD);
 609     char* path = NEW_RESOURCE_ARRAY(char, end - start + 1);
 610     strncpy(path, &class_path[start], end - start);
 611     path[end - start] = '\0';
 612     update_class_path_entry_list(path, false);
 613 #if INCLUDE_CDS
 614     if (DumpSharedSpaces) {
 615       check_shared_classpath(path);
 616     }
 617 #endif
 618     while (class_path[end] == os::path_separator()[0]) {
 619       end++;
 620     }
 621   }

 622 }
 623 
 624 ClassPathEntry* ClassLoader::create_class_path_entry(char *path, const struct stat* st,
 625                                                      bool lazy, bool throw_exception, TRAPS) {
 626   JavaThread* thread = JavaThread::current();
 627   if (lazy) {
 628     return new LazyClassPathEntry(path, st, throw_exception);
 629   }
 630   ClassPathEntry* new_entry = NULL;
 631   if ((st->st_mode & S_IFREG) == S_IFREG) {
 632     // Regular file, should be a zip file
 633     // Canonicalized filename
 634     char canonical_path[JVM_MAXPATHLEN];
 635     if (!get_canonical_path(path, canonical_path, JVM_MAXPATHLEN)) {
 636       // This matches the classic VM
 637       if (throw_exception) {
 638         THROW_MSG_(vmSymbols::java_io_IOException(), "Bad pathname", NULL);
 639       } else {
 640         return NULL;
 641       }
 642     }
 643     char* error_msg = NULL;
 644     jzfile* zip;
 645     {
 646       // enable call to C land
 647       ThreadToNativeFromVM ttn(thread);
 648       HandleMark hm(thread);
 649       zip = (*ZipOpen)(canonical_path, &error_msg);
 650     }
 651     if (zip != NULL && error_msg == NULL) {
 652       new_entry = new ClassPathZipEntry(zip, path);
 653       if (TraceClassLoading || TraceClassPaths) {
 654         tty->print_cr("[Opened %s]", path);
 655       }
 656     } else {
 657       ResourceMark rm(thread);
 658       char *msg;
 659       if (error_msg == NULL) {
 660         msg = NEW_RESOURCE_ARRAY(char, strlen(path) + 128); ;
 661         jio_snprintf(msg, strlen(path) + 127, "error in opening JAR file %s", path);
 662       } else {
 663         int len = (int)(strlen(path) + strlen(error_msg) + 128);
 664         msg = NEW_RESOURCE_ARRAY(char, len); ;
 665         jio_snprintf(msg, len - 1, "error in opening JAR file <%s> %s", error_msg, path);
 666       }
 667       if (throw_exception) {
 668         THROW_MSG_(vmSymbols::java_lang_ClassNotFoundException(), msg, NULL);
 669       } else {
 670         return NULL;
 671       }
 672     }
 673   } else {
 674     // Directory
 675     new_entry = new ClassPathDirEntry(path);
 676     if (TraceClassLoading || TraceClassPaths) {
 677       tty->print_cr("[Path %s]", path);
 678     }
 679   }
 680   return new_entry;
 681 }
 682 
 683 
 684 // Create a class path zip entry for a given path (return NULL if not found
 685 // or zip/JAR file cannot be opened)
 686 ClassPathZipEntry* ClassLoader::create_class_path_zip_entry(const char *path) {
 687   // check for a regular file
 688   struct stat st;
 689   if (os::stat(path, &st) == 0) {
 690     if ((st.st_mode & S_IFREG) == S_IFREG) {
 691       char orig_path[JVM_MAXPATHLEN];
 692       char canonical_path[JVM_MAXPATHLEN];
 693 
 694       strcpy(orig_path, path);
 695       if (get_canonical_path(orig_path, canonical_path, JVM_MAXPATHLEN)) {
 696         char* error_msg = NULL;


 717   ClassPathEntry* e = _first_entry;
 718   while (e != NULL) {
 719     // assume zip entries have been canonicalized
 720     if (strcmp(entry->name(), e->name()) == 0) {
 721       return true;
 722     }
 723     e = e->next();
 724   }
 725   return false;
 726 }
 727 
 728 void ClassLoader::add_to_list(ClassPathEntry *new_entry) {
 729   if (new_entry != NULL) {
 730     if (_last_entry == NULL) {
 731       _first_entry = _last_entry = new_entry;
 732     } else {
 733       _last_entry->set_next(new_entry);
 734       _last_entry = new_entry;
 735     }
 736   }
 737   _num_entries ++;
 738 }
 739 
 740 // Returns true IFF the file/dir exists and the entry was successfully created.
 741 bool ClassLoader::update_class_path_entry_list(char *path,
 742                                                bool check_for_duplicates,
 743                                                bool throw_exception) {
 744   struct stat st;
 745   if (os::stat(path, &st) == 0) {
 746     // File or directory found
 747     ClassPathEntry* new_entry = NULL;
 748     Thread* THREAD = Thread::current();
 749     new_entry = create_class_path_entry(path, &st, LazyBootClassLoader, throw_exception, CHECK_(false));
 750     if (new_entry == NULL) {
 751       return false;
 752     }
 753     // The kernel VM adds dynamically to the end of the classloader path and
 754     // doesn't reorder the bootclasspath which would break java.lang.Package
 755     // (see PackageInfo).
 756     // Add new entry to linked list
 757     if (!check_for_duplicates || !contains_entry(new_entry)) {
 758       ClassLoaderExt::add_class_path_entry(path, check_for_duplicates, new_entry);
 759     }
 760     return true;
 761   } else {
 762 #if INCLUDE_CDS
 763     if (DumpSharedSpaces) {
 764       _shared_paths_misc_info->add_nonexist_path(path);
 765     }
 766     return false;
 767 #endif
 768   }
 769 }
 770 
 771 void ClassLoader::print_bootclasspath() {
 772   ClassPathEntry* e = _first_entry;
 773   tty->print("[bootclasspath= ");
 774   while (e != NULL) {
 775     tty->print("%s ;", e->name());
 776     e = e->next();
 777   }
 778   tty->print_cr("]");
 779 }
 780 
 781 void ClassLoader::load_zip_library() {
 782   assert(ZipOpen == NULL, "should not load zip library twice");
 783   // First make sure native library is loaded
 784   os::native_java_library();
 785   // Load zip library
 786   char path[JVM_MAXPATHLEN];
 787   char ebuf[1024];


 899     pp = (PackageInfo*)BasicHashtable<mtClass>::new_entry(hash);
 900     pp->set_pkgname(pkgname);
 901     return pp;
 902   }
 903 
 904   void add_entry(PackageInfo* pp) {
 905     int index = hash_to_index(pp->hash());
 906     BasicHashtable<mtClass>::add_entry(index, pp);
 907   }
 908 
 909   void copy_pkgnames(const char** packages) {
 910     int n = 0;
 911     for (int i = 0; i < table_size(); ++i) {
 912       for (PackageInfo* pp = bucket(i); pp != NULL; pp = pp->next()) {
 913         packages[n++] = pp->pkgname();
 914       }
 915     }
 916     assert(n == number_of_entries(), "just checking");
 917   }
 918 
 919   CDS_ONLY(void copy_table(char** top, char* end, PackageHashtable* table);)
 920 };
 921 
 922 #if INCLUDE_CDS
 923 void PackageHashtable::copy_table(char** top, char* end,
 924                                   PackageHashtable* table) {
 925   // Copy (relocate) the table to the shared space.
 926   BasicHashtable<mtClass>::copy_table(top, end);
 927 
 928   // Calculate the space needed for the package name strings.
 929   int i;
 930   intptr_t* tableSize = (intptr_t*)(*top);
 931   *top += sizeof(intptr_t);  // For table size
 932   char* tableStart = *top;













 933 
 934   for (i = 0; i < table_size(); ++i) {
 935     for (PackageInfo* pp = table->bucket(i);
 936                       pp != NULL;
 937                       pp = pp->next()) {
 938       int n1 = (int)(strlen(pp->pkgname()) + 1);
 939       if (*top + n1 >= end) {
 940         report_out_of_shared_space(SharedMiscData);
 941       }
 942       pp->set_pkgname((char*)memcpy(*top, pp->pkgname(), n1));
 943       *top += n1;
 944     }
 945   }
 946   *top = (char*)align_size_up((intptr_t)*top, sizeof(HeapWord));
 947   if (*top >= end) {
 948     report_out_of_shared_space(SharedMiscData);
 949   }
 950 
 951   // Write table size
 952   intptr_t len = *top - (char*)tableStart;
 953   *tableSize = len;
 954 }
 955 
 956 
 957 void ClassLoader::copy_package_info_buckets(char** top, char* end) {
 958   _package_hash_table->copy_buckets(top, end);
 959 }
 960 
 961 void ClassLoader::copy_package_info_table(char** top, char* end) {
 962   _package_hash_table->copy_table(top, end, _package_hash_table);
 963 }
 964 #endif
 965 
 966 PackageInfo* ClassLoader::lookup_package(const char *pkgname) {
 967   const char *cp = strrchr(pkgname, '/');
 968   if (cp != NULL) {
 969     // Package prefix found
 970     int n = cp - pkgname + 1;
 971     return _package_hash_table->get_entry(pkgname, n);
 972   }
 973   return NULL;
 974 }
 975 
 976 
 977 bool ClassLoader::add_package(const char *pkgname, int classpath_index, TRAPS) {
 978   assert(pkgname != NULL, "just checking");
 979   // Bootstrap loader no longer holds system loader lock obj serializing
 980   // load_instance_class and thereby add_package
 981   {
 982     MutexLocker ml(PackageTable_lock, THREAD);
 983     // First check for previously loaded entry
 984     PackageInfo* pp = lookup_package(pkgname);


1037     if ((packages = NEW_RESOURCE_ARRAY(const char*, nof_entries)) == NULL) {
1038       return NULL;
1039     }
1040     _package_hash_table->copy_pkgnames(packages);
1041   }
1042   // Allocate objArray and fill with java.lang.String
1043   objArrayOop r = oopFactory::new_objArray(SystemDictionary::String_klass(),
1044                                            nof_entries, CHECK_0);
1045   objArrayHandle result(THREAD, r);
1046   for (int i = 0; i < nof_entries; i++) {
1047     Handle str = java_lang_String::create_from_str(packages[i], CHECK_0);
1048     result->obj_at_put(i, str());
1049   }
1050 
1051   return result();
1052 }
1053 
1054 
1055 instanceKlassHandle ClassLoader::load_classfile(Symbol* h_name, TRAPS) {
1056   ResourceMark rm(THREAD);
1057   const char* class_name = h_name->as_C_string();
1058   EventMark m("loading class %s", class_name);
1059   ThreadProfilerMark tpm(ThreadProfilerMark::classLoaderRegion);
1060 
1061   stringStream st;
1062   // st.print() uses too much stack space while handling a StackOverflowError
1063   // st.print("%s.class", h_name->as_utf8());
1064   st.print_raw(h_name->as_utf8());
1065   st.print_raw(".class");
1066   const char* file_name = st.as_string();
1067   ClassLoaderExt::Context context(class_name, file_name, THREAD);
1068 
1069   // Lookup stream for parsing .class file
1070   ClassFileStream* stream = NULL;
1071   int classpath_index = 0;
1072   ClassPathEntry* e = NULL;
1073   instanceKlassHandle h;
1074   {
1075     PerfClassTraceTime vmtimer(perf_sys_class_lookup_time(),
1076                                ((JavaThread*) THREAD)->get_thread_stat()->perf_timers_addr(),
1077                                PerfClassTraceTime::CLASS_LOAD);
1078     e = _first_entry;
1079     while (e != NULL) {
1080       stream = e->open_stream(file_name, CHECK_NULL);
1081       if (!context.check(stream, classpath_index)) {
1082         return h; // NULL
1083       }
1084       if (stream != NULL) {
1085         break;
1086       }
1087       e = e->next();
1088       ++classpath_index;
1089     }
1090   }
1091 

1092   if (stream != NULL) {

1093     // class file found, parse it
1094     ClassFileParser parser(stream);
1095     ClassLoaderData* loader_data = ClassLoaderData::the_null_class_loader_data();
1096     Handle protection_domain;
1097     TempNewSymbol parsed_name = NULL;
1098     instanceKlassHandle result = parser.parseClassFile(h_name,
1099                                                        loader_data,
1100                                                        protection_domain,
1101                                                        parsed_name,
1102                                                        context.should_verify(classpath_index),
1103                                                        THREAD);
1104     if (HAS_PENDING_EXCEPTION) {
1105       ResourceMark rm;
1106       if (DumpSharedSpaces) {
1107         tty->print_cr("Preload Error: Failed to load %s", class_name);
1108       }
1109       return h;
1110     }
1111     h = context.record_result(classpath_index, e, result, THREAD);
1112   } else {
1113     if (DumpSharedSpaces) {
1114       tty->print_cr("Preload Error: Cannot find %s", class_name);
1115     }
1116   }
1117 
1118   return h;
1119 }
1120 
1121 
1122 void ClassLoader::create_package_info_table(HashtableBucket<mtClass> *t, int length,
1123                                             int number_of_entries) {
1124   assert(_package_hash_table == NULL, "One package info table allowed.");
1125   assert(length == package_hash_table_size * sizeof(HashtableBucket<mtClass>),
1126          "bad shared package info size.");
1127   _package_hash_table = new PackageHashtable(package_hash_table_size, t,
1128                                              number_of_entries);
1129 }
1130 
1131 
1132 void ClassLoader::create_package_info_table() {
1133     assert(_package_hash_table == NULL, "shouldn't have one yet");
1134     _package_hash_table = new PackageHashtable(package_hash_table_size);


1189                         "jvmDefineClassNoLockCalls");
1190 
1191     NEWPERFEVENTCOUNTER(_sync_JNIDefineClassLockFreeCounter, SUN_CLS,
1192                         "jniDefineClassNoLockCalls");
1193 
1194     NEWPERFEVENTCOUNTER(_unsafe_defineClassCallCounter, SUN_CLS,
1195                         "unsafeDefineClassCalls");
1196 
1197     NEWPERFEVENTCOUNTER(_isUnsyncloadClass, SUN_CLS, "isUnsyncloadClassSet");
1198     NEWPERFEVENTCOUNTER(_load_instance_class_failCounter, SUN_CLS,
1199                         "loadInstanceClassFailRate");
1200 
1201     // increment the isUnsyncloadClass counter if UnsyncloadClass is set.
1202     if (UnsyncloadClass) {
1203       _isUnsyncloadClass->inc();
1204     }
1205   }
1206 
1207   // lookup zip library entry points
1208   load_zip_library();
1209 #if INCLUDE_CDS
1210   // initialize search path
1211   if (DumpSharedSpaces) {
1212     _shared_paths_misc_info = SharedClassUtil::allocate_shared_paths_misc_info();
1213   }
1214 #endif
1215   setup_bootstrap_search_path();
1216   if (LazyBootClassLoader) {
1217     // set up meta index which makes boot classpath initialization lazier
1218     setup_bootstrap_meta_index();
1219   }
1220 }
1221 
1222 #if INCLUDE_CDS
1223 void ClassLoader::initialize_shared_path() {
1224   if (DumpSharedSpaces) {
1225     ClassLoaderExt::setup_search_paths();
1226     _shared_paths_misc_info->write_jint(0); // see comments in SharedPathsMiscInfo::check()
1227   }
1228 }
1229 #endif
1230 
1231 jlong ClassLoader::classloader_time_ms() {
1232   return UsePerfData ?
1233     Management::ticks_to_ms(_perf_accumulated_time->get_value()) : -1;
1234 }
1235 
1236 jlong ClassLoader::class_init_count() {
1237   return UsePerfData ? _perf_classes_inited->get_value() : -1;
1238 }
1239 
1240 jlong ClassLoader::class_init_time_ms() {
1241   return UsePerfData ?
1242     Management::ticks_to_ms(_perf_class_init_time->get_value()) : -1;
1243 }
1244 
1245 jlong ClassLoader::class_verify_time_ms() {
1246   return UsePerfData ?
1247     Management::ticks_to_ms(_perf_class_verify_time->get_value()) : -1;
1248 }
1249