1 /*

     2  * Copyright 1997-2007 Sun Microsystems, Inc.  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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    24 

    25 // The VM class loader.

    26 #include <sys/stat.h>

    27 

    28 

    29 // Meta-index (optional, to be able to skip opening boot classpath jar files)

    30 class MetaIndex: public CHeapObj {

    31  private:

    32   char** _meta_package_names;

    33   int    _num_meta_package_names;

    34  public:

    35   MetaIndex(char** meta_package_names, int num_meta_package_names);

    36   ~MetaIndex();

    37   bool may_contain(const char* class_name);

    38 };

    39 

    40 

    41 // Class path entry (directory or zip file)

    42 

    43 class ClassPathEntry: public CHeapObj {

    44  private:

    45   ClassPathEntry* _next;

    46  public:

    47   // Next entry in class path

    48   ClassPathEntry* next()              { return _next; }

    49   void set_next(ClassPathEntry* next) {

    50     // may have unlocked readers, so write atomically.

    51     OrderAccess::release_store_ptr(&_next, next);

    52   }

    53   virtual bool is_jar_file() = 0;

    54   virtual const char* name() = 0;

    55   virtual bool is_lazy();

    56   // Constructor

    57   ClassPathEntry();

    58   // Attempt to locate file_name through this class path entry.

    59   // Returns a class file parsing stream if successfull.

    60   virtual ClassFileStream* open_stream(const char* name) = 0;

    61   // Debugging

    62   NOT_PRODUCT(virtual void compile_the_world(Handle loader, TRAPS) = 0;)

    63   NOT_PRODUCT(virtual bool is_rt_jar() = 0;)

    64 };

    65 

    66 

    67 class ClassPathDirEntry: public ClassPathEntry {

    68  private:

    69   char* _dir;           // Name of directory

    70  public:

    71   bool is_jar_file()  { return false;  }

    72   const char* name()  { return _dir; }

    73   ClassPathDirEntry(char* dir);

    74   ClassFileStream* open_stream(const char* name);

    75   // Debugging

    76   NOT_PRODUCT(void compile_the_world(Handle loader, TRAPS);)

    77   NOT_PRODUCT(bool is_rt_jar();)

    78 };

    79 

    80 

    81 // Type definitions for zip file and zip file entry

    82 typedef void* jzfile;

    83 typedef struct {

    84   char *name;                   /* entry name */

    85   jlong time;                   /* modification time */

    86   jlong size;                   /* size of uncompressed data */

    87   jlong csize;                  /* size of compressed data (zero if uncompressed) */

    88   jint crc;                     /* crc of uncompressed data */

    89   char *comment;                /* optional zip file comment */

    90   jbyte *extra;                 /* optional extra data */

    91   jlong pos;                    /* position of LOC header (if negative) or data */

    92 } jzentry;

    93 

    94 

    95 class ClassPathZipEntry: public ClassPathEntry {

    96  private:

    97   jzfile* _zip;        // The zip archive

    98   char*   _zip_name;   // Name of zip archive

    99  public:

   100   bool is_jar_file()  { return true;  }

   101   const char* name()  { return _zip_name; }

   102   ClassPathZipEntry(jzfile* zip, const char* zip_name);

   103   ~ClassPathZipEntry();

   104   ClassFileStream* open_stream(const char* name);

   105   void contents_do(void f(const char* name, void* context), void* context);

   106   // Debugging

   107   NOT_PRODUCT(void compile_the_world(Handle loader, TRAPS);)

   108   NOT_PRODUCT(void compile_the_world12(Handle loader, TRAPS);) // JDK 1.2 version

   109   NOT_PRODUCT(void compile_the_world13(Handle loader, TRAPS);) // JDK 1.3 version

   110   NOT_PRODUCT(bool is_rt_jar();)

   111   NOT_PRODUCT(bool is_rt_jar12();)

   112   NOT_PRODUCT(bool is_rt_jar13();)

   113 };

   114 

   115 

   116 // For lazier loading of boot class path entries

   117 class LazyClassPathEntry: public ClassPathEntry {

   118  private:

   119   char* _path; // dir or file

   120   struct stat _st;

   121   MetaIndex* _meta_index;

   122   volatile ClassPathEntry* _resolved_entry;

   123   ClassPathEntry* resolve_entry();

   124  public:

   125   bool is_jar_file();

   126   const char* name()  { return _path; }

   127   LazyClassPathEntry(char* path, struct stat st);

   128   ClassFileStream* open_stream(const char* name);

   129   void set_meta_index(MetaIndex* meta_index) { _meta_index = meta_index; }

   130   virtual bool is_lazy();

   131   // Debugging

   132   NOT_PRODUCT(void compile_the_world(Handle loader, TRAPS);)

   133   NOT_PRODUCT(bool is_rt_jar();)

   134 };

   135 

   136 class PackageHashtable;

   137 class PackageInfo;

   138 class HashtableBucket;

   139 

   140 class ClassLoader: AllStatic {

   141  public:

   142   enum SomeConstants {

   143     package_hash_table_size = 31  // Number of buckets

   144   };

   145  private:

   146   friend class LazyClassPathEntry;

   147 

   148   // Performance counters

   149   static PerfCounter* _perf_accumulated_time;

   150   static PerfCounter* _perf_classes_inited;

   151   static PerfCounter* _perf_class_init_time;

   152   static PerfCounter* _perf_class_verify_time;

   153   static PerfCounter* _perf_classes_linked;

   154   static PerfCounter* _perf_class_link_time;

   155 

   156   static PerfCounter* _sync_systemLoaderLockContentionRate;

   157   static PerfCounter* _sync_nonSystemLoaderLockContentionRate;

   158   static PerfCounter* _sync_JVMFindLoadedClassLockFreeCounter;

   159   static PerfCounter* _sync_JVMDefineClassLockFreeCounter;

   160   static PerfCounter* _sync_JNIDefineClassLockFreeCounter;

   161 

   162   static PerfCounter* _unsafe_defineClassCallCounter;

   163   static PerfCounter* _isUnsyncloadClass;

   164   static PerfCounter* _load_instance_class_failCounter;

   165 

   166   // First entry in linked list of ClassPathEntry instances

   167   static ClassPathEntry* _first_entry;

   168   // Last entry in linked list of ClassPathEntry instances

   169   static ClassPathEntry* _last_entry;

   170   // Hash table used to keep track of loaded packages

   171   static PackageHashtable* _package_hash_table;

   172   static const char* _shared_archive;

   173 

   174   // Hash function

   175   static unsigned int hash(const char *s, int n);

   176   // Returns the package file name corresponding to the specified package

   177   // or class name, or null if not found.

   178   static PackageInfo* lookup_package(const char *pkgname);

   179   // Adds a new package entry for the specified class or package name and

   180   // corresponding directory or jar file name.

   181   static bool add_package(const char *pkgname, int classpath_index, TRAPS);

   182 

   183   // Initialization

   184   static void setup_meta_index();

   185   static void setup_bootstrap_search_path();

   186   static void load_zip_library();

   187   static void create_class_path_entry(char *path, struct stat st, ClassPathEntry **new_entry, bool lazy);

   188 

   189   // Canonicalizes path names, so strcmp will work properly. This is mainly

   190   // to avoid confusing the zip library

   191   static bool get_canonical_path(char* orig, char* out, int len);

   192  public:

   193   // Used by the kernel jvm.

   194   static void update_class_path_entry_list(const char *path,

   195                                            bool check_for_duplicates);

   196   static void print_bootclasspath();

   197 

   198   // Timing

   199   static PerfCounter* perf_accumulated_time()  { return _perf_accumulated_time; }

   200   static PerfCounter* perf_classes_inited()    { return _perf_classes_inited; }

   201   static PerfCounter* perf_class_init_time()   { return _perf_class_init_time; }

   202   static PerfCounter* perf_class_verify_time() { return _perf_class_verify_time; }

   203   static PerfCounter* perf_classes_linked()    { return _perf_classes_linked; }

   204   static PerfCounter* perf_class_link_time() { return _perf_class_link_time; }

   205 

   206   // Record how often system loader lock object is contended

   207   static PerfCounter* sync_systemLoaderLockContentionRate() {

   208     return _sync_systemLoaderLockContentionRate;

   209   }

   210 

   211   // Record how often non system loader lock object is contended

   212   static PerfCounter* sync_nonSystemLoaderLockContentionRate() {

   213     return _sync_nonSystemLoaderLockContentionRate;

   214   }

   215 

   216   // Record how many calls to JVM_FindLoadedClass w/o holding a lock

   217   static PerfCounter* sync_JVMFindLoadedClassLockFreeCounter() {

   218     return _sync_JVMFindLoadedClassLockFreeCounter;

   219   }

   220 

   221   // Record how many calls to JVM_DefineClass w/o holding a lock

   222   static PerfCounter* sync_JVMDefineClassLockFreeCounter() {

   223     return _sync_JVMDefineClassLockFreeCounter;

   224   }

   225 

   226   // Record how many calls to jni_DefineClass w/o holding a lock

   227   static PerfCounter* sync_JNIDefineClassLockFreeCounter() {

   228     return _sync_JNIDefineClassLockFreeCounter;

   229   }

   230 

   231   // Record how many calls to Unsafe_DefineClass

   232   static PerfCounter* unsafe_defineClassCallCounter() {

   233     return _unsafe_defineClassCallCounter;

   234   }

   235 

   236   // Record how many times SystemDictionary::load_instance_class call

   237   // fails with linkageError when Unsyncloadclass flag is set.

   238   static PerfCounter* load_instance_class_failCounter() {

   239     return _load_instance_class_failCounter;

   240   }

   241 

   242   // Load individual .class file

   243   static instanceKlassHandle load_classfile(symbolHandle h_name, TRAPS);

   244 

   245   // If the specified package has been loaded by the system, then returns

   246   // the name of the directory or ZIP file that the package was loaded from.

   247   // Returns null if the package was not loaded.

   248   // Note: The specified name can either be the name of a class or package.

   249   // If a package name is specified, then it must be "/"-separator and also

   250   // end with a trailing "/".

   251   static oop get_system_package(const char* name, TRAPS);

   252 

   253   // Returns an array of Java strings representing all of the currently

   254   // loaded system packages.

   255   // Note: The package names returned are "/"-separated and end with a

   256   // trailing "/".

   257   static objArrayOop get_system_packages(TRAPS);

   258 

   259   // Initialization

   260   static void initialize();

   261   static void create_package_info_table();

   262   static void create_package_info_table(HashtableBucket *t, int length,

   263                                         int number_of_entries);

   264   static int compute_Object_vtable();

   265 

   266   static ClassPathEntry* classpath_entry(int n) {

   267     ClassPathEntry* e = ClassLoader::_first_entry;

   268     while (--n >= 0) {

   269       assert(e != NULL, "Not that many classpath entries.");

   270       e = e->next();

   271     }

   272     return e;

   273   }

   274 

   275   // Sharing dump and restore

   276   static void copy_package_info_buckets(char** top, char* end);

   277   static void copy_package_info_table(char** top, char* end);

   278 

   279   // VM monitoring and management support

   280   static jlong classloader_time_ms();

   281   static jlong class_method_total_size();

   282   static jlong class_init_count();

   283   static jlong class_init_time_ms();

   284   static jlong class_verify_time_ms();

   285   static jlong class_link_count();

   286   static jlong class_link_time_ms();

   287 

   288   // indicates if class path already contains a entry (exact match by name)

   289   static bool contains_entry(ClassPathEntry* entry);

   290 

   291   // adds a class path list

   292   static void add_to_list(ClassPathEntry* new_entry);

   293 

   294   // creates a class path zip entry (returns NULL if JAR file cannot be opened)

   295   static ClassPathZipEntry* create_class_path_zip_entry(const char *apath);

   296 

   297   // Debugging

   298   static void verify()              PRODUCT_RETURN;

   299 

   300   // Force compilation of all methods in all classes in bootstrap class path (stress test)

   301 #ifndef PRODUCT

   302  private:

   303   static int _compile_the_world_counter;

   304  public:

   305   static void compile_the_world();

   306   static void compile_the_world_in(char* name, Handle loader, TRAPS);

   307   static int  compile_the_world_counter() { return _compile_the_world_counter; }

   308 #endif //PRODUCT

   309 };