1 /*
2 * Copyright (c) 2022, 2023, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 #include "precompiled.hpp"
26 #include "cds/archiveBuilder.hpp"
27 #include "cds/cdsHeapVerifier.hpp"
28 #include "classfile/classLoaderDataGraph.hpp"
29 #include "classfile/javaClasses.inline.hpp"
30 #include "logging/log.hpp"
31 #include "logging/logStream.hpp"
32 #include "memory/resourceArea.hpp"
33 #include "oops/fieldStreams.inline.hpp"
34 #include "oops/klass.inline.hpp"
35 #include "oops/oop.inline.hpp"
36 #include "runtime/fieldDescriptor.inline.hpp"
37
38 #if INCLUDE_CDS_JAVA_HEAP
39
40 // CDSHeapVerifier is used to check for problems where an archived object references a
41 // static field that may be reinitialized at runtime. In the following example,
42 // Foo.get.test()
43 // correctly returns true when CDS disabled, but incorrectly returns false when CDS is enabled.
44 //
45 // class Foo {
46 // final Foo archivedFoo; // this field is archived by CDS
47 // Bar bar;
48 // static {
49 // CDS.initializeFromArchive(Foo.class);
50 // if (archivedFoo == null) {
51 // archivedFoo = new Foo();
52 // archivedFoo.bar = Bar.bar;
53 // }
54 // }
55 // static Foo get() { return archivedFoo; }
56 // boolean test() {
57 // return bar == Bar.bar;
58 // }
59 // }
60 //
61 // class Bar {
62 // // this field is initialized in both CDS dump time and runtime.
63 // static final Bar bar = new Bar();
64 // }
65 //
66 // The check itself is simple:
67 // [1] CDSHeapVerifier::do_klass() collects all static fields
68 // [2] CDSHeapVerifier::do_entry() checks all the archived objects. None of them
69 // should be in [1]
70 //
71 // However, it's legal for *some* static fields to be references. This leads to the
72 // table of ADD_EXCL below.
73 //
74 // [A] In most of the cases, the module bootstrap code will update the static field
75 // to point to part of the archived module graph. E.g.,
76 // - java/lang/System::bootLayer
77 // - jdk/internal/loader/ClassLoaders::BOOT_LOADER
78 // [B] A final static String that's explicitly initialized inside <clinit>, but
79 // its value is deterministic and is always the same string literal.
80 // [C] A non-final static string that is assigned a string literal during class
81 // initialization; this string is never changed during -Xshare:dump.
82 // [D] Simple caches whose value doesn't matter.
83 // [E] Other cases (see comments in-line below).
84
85 CDSHeapVerifier::CDSHeapVerifier() : _archived_objs(0), _problems(0)
86 {
87 # define ADD_EXCL(...) { static const char* e[] = {__VA_ARGS__, nullptr}; add_exclusion(e); }
88
89 // Unfortunately this needs to be manually maintained. If
90 // test/hotspot/jtreg/runtime/cds/appcds/cacheObject/ArchivedEnumTest.java fails,
91 // you might need to fix the core library code, or fix the ADD_EXCL entries below.
92 //
93 // class field type
94 ADD_EXCL("java/lang/ClassLoader", "scl"); // A
95 ADD_EXCL("java/lang/Module", "ALL_UNNAMED_MODULE", // A
96 "ALL_UNNAMED_MODULE_SET", // A
97 "EVERYONE_MODULE", // A
98 "EVERYONE_SET"); // A
99
100 // This is the same as java/util/ImmutableCollections::EMPTY_SET, which is archived
101 ADD_EXCL("java/lang/reflect/AccessFlag$Location", "EMPTY_SET"); // E
102
103 ADD_EXCL("java/lang/System", "bootLayer"); // A
104
105 // A dummy object used by HashSet. The value doesn't matter and it's never
106 // tested for equality.
107 ADD_EXCL("java/util/HashSet", "PRESENT"); // E
108 ADD_EXCL("jdk/internal/loader/BuiltinClassLoader", "packageToModule"); // A
109 ADD_EXCL("jdk/internal/loader/ClassLoaders", "BOOT_LOADER", // A
110 "APP_LOADER", // A
111 "PLATFORM_LOADER"); // A
112 ADD_EXCL("jdk/internal/module/Builder", "cachedVersion"); // D
113 ADD_EXCL("jdk/internal/module/ModuleLoaderMap$Mapper", "APP_CLASSLOADER", // A
114 "APP_LOADER_INDEX", // A
115 "PLATFORM_CLASSLOADER", // A
116 "PLATFORM_LOADER_INDEX"); // A
117 ADD_EXCL("jdk/internal/module/ServicesCatalog", "CLV"); // A
118
119 // This just points to an empty Map
120 ADD_EXCL("jdk/internal/reflect/Reflection", "methodFilterMap"); // E
121
122 // Integer for 0 and 1 are in java/lang/Integer$IntegerCache and are archived
123 ADD_EXCL("sun/invoke/util/ValueConversions", "ONE_INT", // E
124 "ZERO_INT"); // E
125
126 // Leyden-specific-begin
127 ADD_EXCL("java/lang/invoke/DirectMethodHandle", "LONG_OBJ_TYPE", // TEMP archive MethodTypes
128 "OBJ_OBJ_TYPE"); // TEMP archive MethodTypes
129
130 ADD_EXCL("sun/invoke/util/Wrapper", "FLOAT_ZERO", // ? there is a cache??
131 "DOUBLE_ZERO"); // ? there is a cache??
132
133 ADD_EXCL("java/lang/invoke/BoundMethodHandle$Specializer", "BMH_TRANSFORMS",
134 "SPECIES_DATA_ACCESSOR");
135 ADD_EXCL("java/lang/invoke/BoundMethodHandle", "SPECIALIZER");
136 ADD_EXCL("java/lang/invoke/DelegatingMethodHandle", "NF_getTarget");
137 ADD_EXCL("java/lang/invoke/MethodHandleImpl$ArrayAccessor", "OBJECT_ARRAY_GETTER",
138 "OBJECT_ARRAY_SETTER");
139 ADD_EXCL("java/lang/invoke/SimpleMethodHandle", "BMH_SPECIES");
140
141 ADD_EXCL("java/lang/invoke/StringConcatFactory", "NEW_ARRAY");
142 // Leyden-specific-end
143
144 # undef ADD_EXCL
145
146 ClassLoaderDataGraph::classes_do(this);
147 }
148
149 CDSHeapVerifier::~CDSHeapVerifier() {
150 if (_problems > 0) {
151 log_warning(cds, heap)("Scanned %d objects. Found %d case(s) where "
152 "an object points to a static field that may be "
153 "reinitialized at runtime.", _archived_objs, _problems);
154 }
155 }
156
157 class CDSHeapVerifier::CheckStaticFields : public FieldClosure {
158 CDSHeapVerifier* _verifier;
159 InstanceKlass* _ik;
160 const char** _exclusions;
161 public:
162 CheckStaticFields(CDSHeapVerifier* verifier, InstanceKlass* ik)
163 : _verifier(verifier), _ik(ik) {
164 _exclusions = _verifier->find_exclusion(_ik);
165 }
166
167 void do_field(fieldDescriptor* fd) {
168 if (fd->field_type() != T_OBJECT) {
169 return;
170 }
171
172 oop static_obj_field = _ik->java_mirror()->obj_field(fd->offset());
173 if (static_obj_field != nullptr) {
174 Klass* klass = static_obj_field->klass();
175 if (_exclusions != nullptr) {
176 for (const char** p = _exclusions; *p != nullptr; p++) {
177 if (fd->name()->equals(*p)) {
178 return;
179 }
180 }
181 }
182
183 if (fd->is_final() && java_lang_String::is_instance(static_obj_field) && fd->has_initial_value()) {
184 // This field looks like like this in the Java source:
185 // static final SOME_STRING = "a string literal";
186 // This string literal has been stored in the shared string table, so it's OK
187 // for the archived objects to refer to it.
188 return;
189 }
190 if (fd->is_final() && java_lang_Class::is_instance(static_obj_field)) {
191 // This field points to an archived mirror.
192 return;
193 }
194 if (klass->has_archived_enum_objs()) {
195 // This klass is a subclass of java.lang.Enum. If any instance of this klass
196 // has been archived, we will archive all static fields of this klass.
197 // See HeapShared::initialize_enum_klass().
198 return;
199 }
200
201 // This field *may* be initialized to a different value at runtime. Remember it
202 // and check later if it appears in the archived object graph.
203 _verifier->add_static_obj_field(_ik, static_obj_field, fd->name());
204 }
205 }
206 };
207
208 // Remember all the static object fields of every class that are currently
209 // loaded.
210 void CDSHeapVerifier::do_klass(Klass* k) {
211 if (k->is_instance_klass()) {
212 InstanceKlass* ik = InstanceKlass::cast(k);
213
214 if (HeapShared::is_subgraph_root_class(ik)) {
215 // ik is inside one of the ArchivableStaticFieldInfo tables
216 // in heapShared.cpp. We assume such classes are programmed to
217 // update their static fields correctly at runtime.
218 return;
219 }
220
221 if (HeapShared::is_lambda_form_klass(ik)) {
222 // Archived lambda forms have preinitialized mirrors, so <clinit> won't run.
223 return;
224 }
225
226 CheckStaticFields csf(this, ik);
227 ik->do_local_static_fields(&csf);
228 }
229 }
230
231 void CDSHeapVerifier::add_static_obj_field(InstanceKlass* ik, oop field, Symbol* name) {
232 if (field->klass() == vmClasses::MethodType_klass() ||
233 field->klass() == vmClasses::LambdaForm_klass()) {
234 // LambdaForm and MethodType are non-modifiable and are not tested for object equality, so
235 // it's OK if the static fields are reinitialized at runtime with alternative instances.
236 // (TODO: double check is this is correct)
237 return;
238 }
239 StaticFieldInfo info = {ik, name};
240 _table.put(field, info);
241 }
242
243 inline bool CDSHeapVerifier::do_entry(oop& orig_obj, HeapShared::CachedOopInfo& value) {
244 _archived_objs++;
245
246 StaticFieldInfo* info = _table.get(orig_obj);
247 if (info != nullptr) {
248 if (value.orig_referrer() == nullptr && java_lang_String::is_instance(orig_obj)) {
249 // This string object is not referenced by any of the archived object graphs. It's archived
250 // only because it's in the interned string table. So we are not in a condition that
251 // should be flagged by CDSHeapVerifier.
252 return true; /* keep on iterating */
253 }
254 ResourceMark rm;
255
256 char* class_name = info->_holder->name()->as_C_string();
257 char* field_name = info->_name->as_C_string();
258 if (strstr(class_name, "java/lang/invoke/BoundMethodHandle$Species_") == class_name &&
259 strcmp(field_name, "BMH_SPECIES") == 0) {
260 // FIXME: is this really OK??
261 return true;
262 }
263 LogStream ls(Log(cds, heap)::warning());
264 ls.print_cr("Archive heap points to a static field that may be reinitialized at runtime:");
265 ls.print_cr("Field: %s::%s", class_name, field_name);
266 ls.print("Value: ");
267 orig_obj->print_on(&ls);
268 ls.print_cr("--- trace begin ---");
269 trace_to_root(&ls, orig_obj, nullptr, &value);
270 ls.print_cr("--- trace end ---");
271 ls.cr();
272 _problems ++;
273 }
274
275 return true; /* keep on iterating */
276 }
277
278 class CDSHeapVerifier::TraceFields : public FieldClosure {
279 oop _orig_obj;
280 oop _orig_field;
281 outputStream* _st;
282
283 public:
284 TraceFields(oop orig_obj, oop orig_field, outputStream* st)
285 : _orig_obj(orig_obj), _orig_field(orig_field), _st(st) {}
286
287 void do_field(fieldDescriptor* fd) {
288 if (fd->field_type() == T_OBJECT || fd->field_type() == T_ARRAY) {
289 oop obj_field = _orig_obj->obj_field(fd->offset());
290 if (obj_field == _orig_field) {
291 _st->print("::%s (offset = %d)", fd->name()->as_C_string(), fd->offset());
292 }
293 }
294 }
295 };
296
297 // Call this function (from gdb, etc) if you want to know why an object is archived.
298 void CDSHeapVerifier::trace_to_root(outputStream* st, oop orig_obj) {
299 HeapShared::CachedOopInfo* info = HeapShared::archived_object_cache()->get(orig_obj);
300 if (info != nullptr) {
301 trace_to_root(st, orig_obj, nullptr, info);
302 } else {
303 st->print_cr("Not an archived object??");
304 }
305 }
306
307 int CDSHeapVerifier::trace_to_root(outputStream* st, oop orig_obj, oop orig_field, HeapShared::CachedOopInfo* info) {
308 int level = 0;
309 if (info->orig_referrer() != nullptr) {
310 HeapShared::CachedOopInfo* ref = HeapShared::archived_object_cache()->get(info->orig_referrer());
311 assert(ref != nullptr, "sanity");
312 level = trace_to_root(st, info->orig_referrer(), orig_obj, ref) + 1;
313 } else if (java_lang_String::is_instance(orig_obj)) {
314 st->print_cr("[%2d] (shared string table)", level++);
315 }
316 Klass* k = orig_obj->klass();
317 ResourceMark rm;
318 st->print("[%2d] ", level);
319 orig_obj->print_address_on(st);
320 st->print(" %s", k->internal_name());
321 if (orig_field != nullptr) {
322 if (k->is_instance_klass()) {
323 TraceFields clo(orig_obj, orig_field, st);
324 InstanceKlass::cast(k)->do_nonstatic_fields(&clo);
325 } else {
326 assert(orig_obj->is_objArray(), "must be");
327 objArrayOop array = (objArrayOop)orig_obj;
328 for (int i = 0; i < array->length(); i++) {
329 if (array->obj_at(i) == orig_field) {
330 st->print(" @[%d]", i);
331 break;
332 }
333 }
334 }
335 }
336 st->cr();
337
338 return level;
339 }
340
341 void CDSHeapVerifier::verify() {
342 CDSHeapVerifier verf;
343 HeapShared::archived_object_cache()->iterate(&verf);
344 }
345
346 #endif // INCLUDE_CDS_JAVA_HEAP