|
| 1 | +/* |
| 2 | + * Copyright (c) 2003, 2025, 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_CDS_AOTCLASSLOCATION_HPP |
| 26 | +#define SHARE_CDS_AOTCLASSLOCATION_HPP |
| 27 | + |
| 28 | +#include "memory/allocation.hpp" |
| 29 | +#include "oops/array.hpp" |
| 30 | +#include "utilities/exceptions.hpp" |
| 31 | +#include "utilities/growableArray.hpp" |
| 32 | +#include "utilities/globalDefinitions.hpp" |
| 33 | +#include "utilities/macros.hpp" |
| 34 | + |
| 35 | +class AllClassLocationStreams; |
| 36 | +class ClassLocationStream; |
| 37 | +class LogStream; |
| 38 | + |
| 39 | +// An AOTClassLocation is a location where the application is configured to load Java classes |
| 40 | +// from. It can be: |
| 41 | +// - the location of $JAVA_HOME/lib/modules |
| 42 | +// - an entry in -Xbootclasspath/a |
| 43 | +// - an entry in -classpath |
| 44 | +// - a JAR file specified using --module-path. |
| 45 | +// |
| 46 | +// AOTClassLocation is similar to java.security.CodeSource, except: |
| 47 | +// - Only local files/dirs are allowed. Directories must be empty. Network locations are not allowed. |
| 48 | +// - No code signing information is recorded. |
| 49 | +// |
| 50 | +// We avoid using pointers in AOTClassLocation to avoid runtime pointer relocation. Each AOTClassLocation |
| 51 | +// is a variable-size structure: |
| 52 | +// [ all fields specified below (sizeof(AOTClassLocation) bytes) ] |
| 53 | +// [ path (_path_length bytes, including the terminating zero) ] |
| 54 | +// [ manifest (_manifest_length bytes, including the terminating zero) ] |
| 55 | +class AOTClassLocation { |
| 56 | +public: |
| 57 | + enum class Group : int { |
| 58 | + MODULES_IMAGE, |
| 59 | + BOOT_CLASSPATH, |
| 60 | + APP_CLASSPATH, |
| 61 | + MODULE_PATH |
| 62 | + }; |
| 63 | +private: |
| 64 | + enum class FileType : int { |
| 65 | + NORMAL, |
| 66 | + DIR, |
| 67 | + NOT_EXIST |
| 68 | + }; |
| 69 | + size_t _path_length; // does NOT include terminating zero |
| 70 | + size_t _manifest_length; // does NOT include terminating zero |
| 71 | + bool _check_time; |
| 72 | + bool _from_cpattr; |
| 73 | + bool _is_multi_release_jar; // is this a JAR file that has multi-release classes? |
| 74 | + FileType _file_type; |
| 75 | + Group _group; |
| 76 | + int _index; // index of this AOTClassLocation inside AOTClassLocationConfig::_class_locations |
| 77 | + time_t _timestamp; |
| 78 | + int64_t _filesize; |
| 79 | + |
| 80 | + static size_t header_size() { return sizeof(AOTClassLocation); } // bytes |
| 81 | + size_t path_offset() const { return header_size(); } |
| 82 | + size_t manifest_offset() const { return path_offset() + _path_length + 1; } |
| 83 | + static char* read_manifest(JavaThread* current, const char* path, size_t& manifest_length); |
| 84 | + |
| 85 | +public: |
| 86 | + static AOTClassLocation* allocate(JavaThread* current, const char* path, int index, Group group, |
| 87 | + bool from_cpattr = false, bool is_jrt = false); |
| 88 | + |
| 89 | + size_t total_size() const { return manifest_offset() + _manifest_length + 1; } |
| 90 | + const char* path() const { return ((const char*)this) + path_offset(); } |
| 91 | + size_t manifest_length() const { return _manifest_length; } |
| 92 | + const char* manifest() const { return ((const char*)this) + manifest_offset(); } |
| 93 | + bool must_exist() const { return _file_type != FileType::NOT_EXIST; } |
| 94 | + bool must_not_exist() const { return _file_type == FileType::NOT_EXIST; } |
| 95 | + bool is_dir() const { return _file_type == FileType::DIR; } |
| 96 | + int index() const { return _index; } |
| 97 | + bool is_modules_image() const { return _group == Group::MODULES_IMAGE; } |
| 98 | + bool from_boot_classpath() const { return _group == Group::BOOT_CLASSPATH; } |
| 99 | + bool from_app_classpath() const { return _group == Group::APP_CLASSPATH; } |
| 100 | + bool from_module_path() const { return _group == Group::MODULE_PATH; } |
| 101 | + bool is_multi_release_jar() const { return _is_multi_release_jar; } |
| 102 | + |
| 103 | + // Only boot/app classpaths can contain unnamed module |
| 104 | + bool has_unnamed_module() const { return from_boot_classpath() || from_app_classpath(); } |
| 105 | + |
| 106 | + char* get_cpattr() const; |
| 107 | + AOTClassLocation* write_to_archive() const; |
| 108 | + |
| 109 | + // Returns true IFF this AOTClassLocation is discovered from the -classpath or -Xbootclasspath/a by parsing the |
| 110 | + // "Class-Path" attribute of a JAR file. |
| 111 | + bool from_cpattr() const { return _from_cpattr; } |
| 112 | + const char* file_type_string() const; |
| 113 | + bool check(const char* runtime_path, bool has_aot_linked_classes) const; |
| 114 | +}; |
| 115 | + |
| 116 | +// AOTClassLocationConfig |
| 117 | +// |
| 118 | +// Keep track of the set of AOTClassLocations used when an AOTCache is created. |
| 119 | +// To load the AOTCache in a production run, the JVM must be using a compatible set of |
| 120 | +// AOTClassLocations (subjected to AOTClassLocationConfig::validate()). |
| 121 | +// |
| 122 | +// In general, validation is performed on the AOTClassLocations to ensure the code locations used |
| 123 | +// during AOTCache creation are the same as when the AOTCache is used during runtime. |
| 124 | +// Non-existent entries are recorded during AOTCache creation. Those non-existent entries, |
| 125 | +// if they are specified at runtime, must not exist. |
| 126 | +// |
| 127 | +// Some details on validation: |
| 128 | +// - the boot classpath can be appended to at runtime if there's no app classpath and no |
| 129 | +// module path specified when an AOTCache is created; |
| 130 | +// - the app classpath can be appended to at runtime; |
| 131 | +// - the module path at runtime can be a superset of the one specified during AOTCache creation. |
| 132 | + |
| 133 | +class AOTClassLocationConfig : public CHeapObj<mtClassShared> { |
| 134 | + using Group = AOTClassLocation::Group; |
| 135 | + using GrowableClassLocationArray = GrowableArrayCHeap<AOTClassLocation*, mtClassShared>; |
| 136 | + |
| 137 | + // Note: both of the following are non-null if we are dumping a dynamic archive. |
| 138 | + static AOTClassLocationConfig* _dumptime_instance; |
| 139 | + static const AOTClassLocationConfig* _runtime_instance; |
| 140 | + |
| 141 | + Array<AOTClassLocation*>* _class_locations; // jrt -> -Xbootclasspath/a -> -classpath -> --module_path |
| 142 | + int _boot_classpath_end; |
| 143 | + int _app_classpath_end; |
| 144 | + int _module_end; |
| 145 | + bool _has_non_jar_modules; |
| 146 | + bool _has_platform_classes; |
| 147 | + bool _has_app_classes; |
| 148 | + int _max_used_index; |
| 149 | + size_t _dumptime_lcp_len; |
| 150 | + |
| 151 | + // accessors |
| 152 | + Array<AOTClassLocation*>* class_locations() const { return _class_locations; } |
| 153 | + |
| 154 | + void parse(JavaThread* current, GrowableClassLocationArray& tmp_array, ClassLocationStream& css, |
| 155 | + Group group, bool parse_manifest); |
| 156 | + void add_class_location(JavaThread* current, GrowableClassLocationArray& tmp_array, const char* path, |
| 157 | + Group group, bool parse_manifest, bool from_cpattr); |
| 158 | + void dumptime_init_helper(TRAPS); |
| 159 | + |
| 160 | + bool check_classpaths(bool is_boot_classpath, bool has_aot_linked_classes, |
| 161 | + int index_start, int index_end, ClassLocationStream& runtime_css, |
| 162 | + bool use_lcp_match, const char* runtime_lcp, size_t runtime_lcp_len) const; |
| 163 | + bool check_module_paths(bool has_aot_linked_classes, int index_start, int index_end, ClassLocationStream& runtime_css, |
| 164 | + bool* has_extra_module_paths) const; |
| 165 | + bool file_exists(const char* filename) const; |
| 166 | + bool check_paths_existence(ClassLocationStream& runtime_css) const; |
| 167 | + |
| 168 | + static const char* substitute(const char* path, size_t remove_prefix_len, |
| 169 | + const char* prepend, size_t prepend_len); |
| 170 | + static const char* find_lcp(ClassLocationStream& css, size_t& lcp_len); |
| 171 | + bool need_lcp_match(AllClassLocationStreams& all_css) const; |
| 172 | + bool need_lcp_match_helper(int start, int end, ClassLocationStream& css) const; |
| 173 | + |
| 174 | + template <typename FUNC> void dumptime_iterate_helper(FUNC func) const { |
| 175 | + assert(_class_locations != nullptr, "sanity"); |
| 176 | + int n = _class_locations->length(); |
| 177 | + for (int i = 0; i < n; i++) { |
| 178 | + if (!func(_class_locations->at(i))) { |
| 179 | + break; |
| 180 | + } |
| 181 | + } |
| 182 | + } |
| 183 | + |
| 184 | + template <typename FUNC> void iterate(FUNC func) const { |
| 185 | + int n = class_locations()->length(); |
| 186 | + for (int i = 0; i < n; i++) { |
| 187 | + if (!func(class_locations()->at(i))) { |
| 188 | + break; |
| 189 | + } |
| 190 | + } |
| 191 | + } |
| 192 | + |
| 193 | + void check_nonempty_dirs() const; |
| 194 | + bool need_to_check_app_classpath() const { |
| 195 | + return (num_app_classpaths() > 0) && (_max_used_index >= app_cp_start_index()) && has_platform_or_app_classes(); |
| 196 | + } |
| 197 | + |
| 198 | + void print_dumptime_classpath(LogStream& ls, int index_start, int index_limit, |
| 199 | + bool do_substitute, size_t remove_prefix_len, |
| 200 | + const char* prepend, size_t prepend_len) const; |
| 201 | +public: |
| 202 | + static AOTClassLocationConfig* dumptime() { |
| 203 | + assert(_dumptime_instance != nullptr, "can only be called when dumping an AOT cache"); |
| 204 | + return _dumptime_instance; |
| 205 | + } |
| 206 | + |
| 207 | + static const AOTClassLocationConfig* runtime() { |
| 208 | + assert(_runtime_instance != nullptr, "can only be called when using an AOT cache"); |
| 209 | + return _runtime_instance; |
| 210 | + } |
| 211 | + |
| 212 | + // Common accessors |
| 213 | + int boot_cp_start_index() const { return 1; } |
| 214 | + int boot_cp_end_index() const { return _boot_classpath_end; } |
| 215 | + int app_cp_start_index() const { return boot_cp_end_index(); } |
| 216 | + int app_cp_end_index() const { return _app_classpath_end; } |
| 217 | + int module_path_start_index() const { return app_cp_end_index(); } |
| 218 | + int module_path_end_index() const { return _module_end; } |
| 219 | + bool has_platform_or_app_classes() const { return _has_app_classes || _has_platform_classes; } |
| 220 | + bool has_non_jar_modules() const { return _has_non_jar_modules; } |
| 221 | + int num_boot_classpaths() const { return boot_cp_end_index() - boot_cp_start_index(); } |
| 222 | + int num_app_classpaths() const { return app_cp_end_index() - app_cp_start_index(); } |
| 223 | + int num_module_paths() const { return module_path_end_index() - module_path_start_index(); } |
| 224 | + |
| 225 | + int length() const { |
| 226 | + return _class_locations->length(); |
| 227 | + } |
| 228 | + |
| 229 | + const AOTClassLocation* class_location_at(int index) const; |
| 230 | + int get_module_shared_path_index(Symbol* location) const; |
| 231 | + |
| 232 | + // Functions used only during dumptime |
| 233 | + static void dumptime_init(JavaThread* current); |
| 234 | + |
| 235 | + static void dumptime_set_has_app_classes() { |
| 236 | + _dumptime_instance->_has_app_classes = true; |
| 237 | + } |
| 238 | + |
| 239 | + static void dumptime_set_has_platform_classes() { |
| 240 | + _dumptime_instance->_has_platform_classes = true; |
| 241 | + } |
| 242 | + |
| 243 | + static void dumptime_update_max_used_index(int index) { |
| 244 | + if (_dumptime_instance == nullptr) { |
| 245 | + assert(index == 0, "sanity"); |
| 246 | + } else if (_dumptime_instance->_max_used_index < index) { |
| 247 | + _dumptime_instance->_max_used_index = index; |
| 248 | + } |
| 249 | + } |
| 250 | + |
| 251 | + static void dumptime_check_nonempty_dirs() { |
| 252 | + _dumptime_instance->check_nonempty_dirs(); |
| 253 | + } |
| 254 | + |
| 255 | + static bool dumptime_is_ready() { |
| 256 | + return _dumptime_instance != nullptr; |
| 257 | + } |
| 258 | + template <typename FUNC> static void dumptime_iterate(FUNC func) { |
| 259 | + _dumptime_instance->dumptime_iterate_helper(func); |
| 260 | + } |
| 261 | + |
| 262 | + AOTClassLocationConfig* write_to_archive() const; |
| 263 | + |
| 264 | + // Functions used only during runtime |
| 265 | + bool validate(bool has_aot_linked_classes, bool* has_extra_module_paths) const; |
| 266 | +}; |
| 267 | + |
| 268 | + |
| 269 | +#endif // SHARE_CDS_AOTCLASSLOCATION_HPP |
0 commit comments