1 /*
   2  * Copyright (c) 2014, 2019, 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 #ifndef SHARE_CLASSFILE_SYSTEMDICTIONARYSHARED_HPP
  26 #define SHARE_CLASSFILE_SYSTEMDICTIONARYSHARED_HPP
  27 
  28 #include "oops/klass.hpp"
  29 #include "classfile/dictionary.hpp"
  30 #include "classfile/packageEntry.hpp"
  31 #include "classfile/systemDictionary.hpp"
  32 #include "memory/filemap.hpp"
  33 
  34 
  35 /*===============================================================================
  36 
  37     Handling of the classes in the AppCDS archive
  38 
  39     To ensure safety and to simplify the implementation, archived classes are
  40     "segregated" into 2 types. The following rules describe how they
  41     are stored and looked up.
  42 
  43 [1] Category of archived classes
  44 
  45     There are 2 disjoint groups of classes stored in the AppCDS archive:
  46 
  47     BUILTIN:              These classes may be defined ONLY by the BOOT/PLATFORM/APP
  48                           loaders.
  49 
  50     UNREGISTERED:         These classes may be defined ONLY by a ClassLoader
  51                           instance that's not listed above (using fingerprint matching)
  52 
  53 [2] How classes from different categories are specified in the classlist:
  54 
  55     Starting from JDK9, each class in the classlist may be specified with
  56     these keywords: "id", "super", "interfaces", "loader" and "source".
  57 
  58 
  59     BUILTIN               Only the "id" keyword may be (optionally) specified. All other
  60                           keywords are forbidden.
  61 
  62                           The named class is looked up from the jimage and from
  63                           Xbootclasspath/a and CLASSPATH.
  64 
  65     UNREGISTERED:         The "id", "super", and "source" keywords must all be
  66                           specified.
  67 
  68                           The "interfaces" keyword must be specified if the class implements
  69                           one or more local interfaces. The "interfaces" keyword must not be
  70                           specified if the class does not implement local interfaces.
  71 
  72                           The named class is looked up from the location specified in the
  73                           "source" keyword.
  74 
  75     Example classlist:
  76 
  77     # BUILTIN
  78     java/lang/Object id: 0
  79     java/lang/Cloneable id: 1
  80     java/lang/String
  81 
  82     # UNREGISTERED
  83     Bar id: 3 super: 0 interfaces: 1 source: /foo.jar
  84 
  85 
  86 [3] Identifying the category of archived classes
  87 
  88     BUILTIN:              (C->shared_classpath_index() >= 0)
  89     UNREGISTERED:         (C->shared_classpath_index() == UNREGISTERED_INDEX (-9999))
  90 
  91 [4] Lookup of archived classes at run time:
  92 
  93     (a) BUILTIN loaders:
  94 
  95         search _builtin_dictionary
  96 
  97     (b) UNREGISTERED loaders:
  98 
  99         search _unregistered_dictionary for an entry that matches the
 100         (name, clsfile_len, clsfile_crc32).
 101 
 102 ===============================================================================*/
 103 #define UNREGISTERED_INDEX -9999
 104 
 105 class ClassFileStream;
 106 class DumpTimeSharedClassInfo;
 107 class DumpTimeSharedClassTable;
 108 class RunTimeSharedClassInfo;
 109 class RunTimeSharedDictionary;
 110 
 111 class SystemDictionaryShared: public SystemDictionary {
 112   friend class ExcludeDumpTimeSharedClasses;
 113 public:
 114   enum {
 115     FROM_FIELD_IS_PROTECTED = 1 << 0,
 116     FROM_IS_ARRAY           = 1 << 1,
 117     FROM_IS_OBJECT          = 1 << 2
 118   };
 119 
 120 private:
 121   // These _shared_xxxs arrays are used to initialize the java.lang.Package and
 122   // java.security.ProtectionDomain objects associated with each shared class.
 123   //
 124   // See SystemDictionaryShared::init_security_info for more info.
 125   static objArrayOop _shared_protection_domains;
 126   static objArrayOop _shared_jar_urls;
 127   static objArrayOop _shared_jar_manifests;
 128 
 129   static InstanceKlass* load_shared_class_for_builtin_loader(
 130                                                Symbol* class_name,
 131                                                Handle class_loader,
 132                                                TRAPS);
 133   static Handle get_package_name(Symbol*  class_name, TRAPS);
 134 
 135 
 136   // Package handling:
 137   //
 138   // 1. For named modules in the runtime image
 139   //    BOOT classes: Reuses the existing JVM_GetSystemPackage(s) interfaces
 140   //                  to get packages in named modules for shared classes.
 141   //                  Package for non-shared classes in named module is also
 142   //                  handled using JVM_GetSystemPackage(s).
 143   //
 144   //    APP  classes: VM calls ClassLoaders.AppClassLoader::definePackage(String, Module)
 145   //                  to define package for shared app classes from named
 146   //                  modules.
 147   //
 148   //    PLATFORM  classes: VM calls ClassLoaders.PlatformClassLoader::definePackage(String, Module)
 149   //                  to define package for shared platform classes from named
 150   //                  modules.
 151   //
 152   // 2. For unnamed modules
 153   //    BOOT classes: Reuses the existing JVM_GetSystemPackage(s) interfaces to
 154   //                  get packages for shared boot classes in unnamed modules.
 155   //
 156   //    APP  classes: VM calls ClassLoaders.AppClassLoader::defineOrCheckPackage()
 157   //                  with with the manifest and url from archived data.
 158   //
 159   //    PLATFORM  classes: No package is defined.
 160   //
 161   // The following two define_shared_package() functions are used to define
 162   // package for shared APP and PLATFORM classes.
 163   static void define_shared_package(Symbol*  class_name,
 164                                     Handle class_loader,
 165                                     Handle manifest,
 166                                     Handle url,
 167                                     TRAPS);
 168   static void define_shared_package(Symbol* class_name,
 169                                     Handle class_loader,
 170                                     ModuleEntry* mod_entry,
 171                                     TRAPS);
 172 
 173   static Handle get_shared_jar_manifest(int shared_path_index, TRAPS);
 174   static Handle get_shared_jar_url(int shared_path_index, TRAPS);
 175   static Handle get_protection_domain_from_classloader(Handle class_loader,
 176                                                        Handle url, TRAPS);
 177   static Handle get_shared_protection_domain(Handle class_loader,
 178                                              int shared_path_index,
 179                                              Handle url,
 180                                              TRAPS);
 181   static Handle get_shared_protection_domain(Handle class_loader,
 182                                              ModuleEntry* mod, TRAPS);
 183   static Handle init_security_info(Handle class_loader, InstanceKlass* ik, TRAPS);
 184 
 185   static void atomic_set_array_index(objArrayOop array, int index, oop o) {
 186     // Benign race condition:  array.obj_at(index) may already be filled in.
 187     // The important thing here is that all threads pick up the same result.
 188     // It doesn't matter which racing thread wins, as long as only one
 189     // result is used by all threads, and all future queries.
 190     array->atomic_compare_exchange_oop(index, o, NULL);
 191   }
 192 
 193   static oop shared_protection_domain(int index);
 194   static void atomic_set_shared_protection_domain(int index, oop pd) {
 195     atomic_set_array_index(_shared_protection_domains, index, pd);
 196   }
 197   static void allocate_shared_protection_domain_array(int size, TRAPS);
 198   static oop shared_jar_url(int index);
 199   static void atomic_set_shared_jar_url(int index, oop url) {
 200     atomic_set_array_index(_shared_jar_urls, index, url);
 201   }
 202   static void allocate_shared_jar_url_array(int size, TRAPS);
 203   static oop shared_jar_manifest(int index);
 204   static void atomic_set_shared_jar_manifest(int index, oop man) {
 205     atomic_set_array_index(_shared_jar_manifests, index, man);
 206   }
 207   static void allocate_shared_jar_manifest_array(int size, TRAPS);
 208   static InstanceKlass* acquire_class_for_current_thread(
 209                                  InstanceKlass *ik,
 210                                  Handle class_loader,
 211                                  Handle protection_domain,
 212                                  const ClassFileStream* cfs,
 213                                  TRAPS);
 214   static DumpTimeSharedClassInfo* find_or_allocate_info_for(InstanceKlass* k);
 215   static void write_dictionary(RunTimeSharedDictionary* dictionary,
 216                                bool is_builtin,
 217                                bool is_static_archive = true);
 218   static bool is_jfr_event_class(InstanceKlass *k);
 219   static void warn_excluded(InstanceKlass* k, const char* reason);
 220   static bool should_be_excluded(InstanceKlass* k);
 221 
 222   DEBUG_ONLY(static bool _no_class_loading_should_happen;)
 223 public:
 224   static InstanceKlass* find_builtin_class(Symbol* class_name);
 225 
 226   static const RunTimeSharedClassInfo* find_record(RunTimeSharedDictionary* static_dict,
 227                                                    RunTimeSharedDictionary* dynamic_dict,
 228                                                    Symbol* name);
 229 
 230   static bool has_platform_or_app_classes();
 231 
 232   // Called by PLATFORM/APP loader only
 233   static InstanceKlass* find_or_load_shared_class(Symbol* class_name,
 234                                                Handle class_loader,
 235                                                TRAPS);
 236 
 237 
 238   static void allocate_shared_data_arrays(int size, TRAPS);
 239   static void oops_do(OopClosure* f);
 240 
 241   // Check if sharing is supported for the class loader.
 242   static bool is_sharing_possible(ClassLoaderData* loader_data);
 243   static bool is_shared_class_visible_for_classloader(InstanceKlass* ik,
 244                                                       Handle class_loader,
 245                                                       Symbol* pkg_name,
 246                                                       PackageEntry* pkg_entry,
 247                                                       ModuleEntry* mod_entry,
 248                                                       TRAPS);
 249   static PackageEntry* get_package_entry(Symbol* pkg,
 250                                          ClassLoaderData *loader_data) {
 251     if (loader_data != NULL) {
 252       PackageEntryTable* pkgEntryTable = loader_data->packages();
 253       return pkgEntryTable->lookup_only(pkg);
 254     }
 255     return NULL;
 256   }
 257 
 258   static bool add_unregistered_class(InstanceKlass* k, TRAPS);
 259   static InstanceKlass* dump_time_resolve_super_or_fail(Symbol* child_name,
 260                                                 Symbol* class_name,
 261                                                 Handle class_loader,
 262                                                 Handle protection_domain,
 263                                                 bool is_superclass,
 264                                                 TRAPS);
 265 
 266   static void init_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
 267   static void remove_dumptime_info(InstanceKlass* k) NOT_CDS_RETURN;
 268 
 269   static Dictionary* boot_loader_dictionary() {
 270     return ClassLoaderData::the_null_class_loader_data()->dictionary();
 271   }
 272 
 273   static void update_shared_entry(InstanceKlass* klass, int id);
 274   static void set_shared_class_misc_info(InstanceKlass* k, ClassFileStream* cfs);
 275 
 276   static InstanceKlass* lookup_from_stream(Symbol* class_name,
 277                                            Handle class_loader,
 278                                            Handle protection_domain,
 279                                            const ClassFileStream* st,
 280                                            TRAPS);
 281   // "verification_constraints" are a set of checks performed by
 282   // VerificationType::is_reference_assignable_from when verifying a shared class during
 283   // dump time.
 284   //
 285   // With AppCDS, it is possible to override archived classes by calling
 286   // ClassLoader.defineClass() directly. SystemDictionary::load_shared_class() already
 287   // ensures that you cannot load a shared class if its super type(s) are changed. However,
 288   // we need an additional check to ensure that the verification_constraints did not change
 289   // between dump time and runtime.
 290   static bool add_verification_constraint(InstanceKlass* k, Symbol* name,
 291                   Symbol* from_name, bool from_field_is_protected,
 292                   bool from_is_array, bool from_is_object) NOT_CDS_RETURN_(false);
 293   static void check_verification_constraints(InstanceKlass* klass,
 294                                              TRAPS) NOT_CDS_RETURN;
 295   static bool is_builtin(InstanceKlass* k) {
 296     return (k->shared_classpath_index() != UNREGISTERED_INDEX);
 297   }
 298   static void check_excluded_classes();
 299   static void validate_before_archiving(InstanceKlass* k);
 300   static bool is_excluded_class(InstanceKlass* k);
 301   static void dumptime_classes_do(class MetaspaceClosure* it);
 302   static size_t estimate_size_for_archive();
 303   static void write_to_archive(bool is_static_archive = true);
 304   static void serialize_dictionary_headers(class SerializeClosure* soc,
 305                                            bool is_static_archive = true);
 306   static void print() { return print_on(tty); }
 307   static void print_on(outputStream* st) NOT_CDS_RETURN;
 308   static void print_table_statistics(outputStream* st) NOT_CDS_RETURN;
 309   static bool empty_dumptime_table() NOT_CDS_RETURN_(true);
 310 
 311   DEBUG_ONLY(static bool no_class_loading_should_happen() {return _no_class_loading_should_happen;})
 312 
 313 #ifdef ASSERT
 314   class NoClassLoadingMark: public StackObj {
 315   public:
 316     NoClassLoadingMark() {
 317       assert(!_no_class_loading_should_happen, "must not be nested");
 318       _no_class_loading_should_happen = true;
 319     }
 320     ~NoClassLoadingMark() {
 321       _no_class_loading_should_happen = false;
 322     }
 323   };
 324 #endif
 325 
 326 };
 327 
 328 #endif // SHARE_CLASSFILE_SYSTEMDICTIONARYSHARED_HPP