jdk

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
# undef ADD_EXCL
127

128
  ClassLoaderDataGraph::classes_do(this);
129
}
130

131
CDSHeapVerifier::~CDSHeapVerifier() {
132
  if (_problems > 0) {
133
    log_warning(cds, heap)("Scanned %d objects. Found %d case(s) where "
134
                           "an object points to a static field that may be "
135
                           "reinitialized at runtime.", _archived_objs, _problems);
136
  }
137
}
138

139
class CDSHeapVerifier::CheckStaticFields : public FieldClosure {
140
  CDSHeapVerifier* _verifier;
141
  InstanceKlass* _ik;
142
  const char** _exclusions;
143
public:
144
  CheckStaticFields(CDSHeapVerifier* verifier, InstanceKlass* ik)
145
    : _verifier(verifier), _ik(ik) {
146
    _exclusions = _verifier->find_exclusion(_ik);
147
  }
148

149
  void do_field(fieldDescriptor* fd) {
150
    if (fd->field_type() != T_OBJECT) {
151
      return;
152
    }
153

154
    oop static_obj_field = _ik->java_mirror()->obj_field(fd->offset());
155
    if (static_obj_field != nullptr) {
156
      Klass* klass = static_obj_field->klass();
157
      if (_exclusions != nullptr) {
158
        for (const char** p = _exclusions; *p != nullptr; p++) {
159
          if (fd->name()->equals(*p)) {
160
            return;
161
          }
162
        }
163
      }
164

165
      if (fd->is_final() && java_lang_String::is_instance(static_obj_field) && fd->has_initial_value()) {
166
        // This field looks like like this in the Java source:
167
        //    static final SOME_STRING = "a string literal";
168
        // This string literal has been stored in the shared string table, so it's OK
169
        // for the archived objects to refer to it.
170
        return;
171
      }
172
      if (fd->is_final() && java_lang_Class::is_instance(static_obj_field)) {
173
        // This field points to an archived mirror.
174
        return;
175
      }
176
      if (klass->has_archived_enum_objs()) {
177
        // This klass is a subclass of java.lang.Enum. If any instance of this klass
178
        // has been archived, we will archive all static fields of this klass.
179
        // See HeapShared::initialize_enum_klass().
180
        return;
181
      }
182

183
      // This field *may* be initialized to a different value at runtime. Remember it
184
      // and check later if it appears in the archived object graph.
185
      _verifier->add_static_obj_field(_ik, static_obj_field, fd->name());
186
    }
187
  }
188
};
189

190
// Remember all the static object fields of every class that are currently
191
// loaded.
192
void CDSHeapVerifier::do_klass(Klass* k) {
193
  if (k->is_instance_klass()) {
194
    InstanceKlass* ik = InstanceKlass::cast(k);
195

196
    if (HeapShared::is_subgraph_root_class(ik)) {
197
      // ik is inside one of the ArchivableStaticFieldInfo tables
198
      // in heapShared.cpp. We assume such classes are programmed to
199
      // update their static fields correctly at runtime.
200
      return;
201
    }
202

203
    CheckStaticFields csf(this, ik);
204
    ik->do_local_static_fields(&csf);
205
  }
206
}
207

208
void CDSHeapVerifier::add_static_obj_field(InstanceKlass* ik, oop field, Symbol* name) {
209
  StaticFieldInfo info = {ik, name};
210
  _table.put(field, info);
211
}
212

213
inline bool CDSHeapVerifier::do_entry(oop& orig_obj, HeapShared::CachedOopInfo& value) {
214
  _archived_objs++;
215

216
  StaticFieldInfo* info = _table.get(orig_obj);
217
  if (info != nullptr) {
218
    if (value.orig_referrer() == nullptr && java_lang_String::is_instance(orig_obj)) {
219
      // This string object is not referenced by any of the archived object graphs. It's archived
220
      // only because it's in the interned string table. So we are not in a condition that
221
      // should be flagged by CDSHeapVerifier.
222
      return true; /* keep on iterating */
223
    }
224
    ResourceMark rm;
225
    LogStream ls(Log(cds, heap)::warning());
226
    ls.print_cr("Archive heap points to a static field that may be reinitialized at runtime:");
227
    ls.print_cr("Field: %s::%s", info->_holder->name()->as_C_string(), info->_name->as_C_string());
228
    ls.print("Value: ");
229
    orig_obj->print_on(&ls);
230
    ls.print_cr("--- trace begin ---");
231
    trace_to_root(&ls, orig_obj, nullptr, &value);
232
    ls.print_cr("--- trace end ---");
233
    ls.cr();
234
    _problems ++;
235
  }
236

237
  return true; /* keep on iterating */
238
}
239

240
class CDSHeapVerifier::TraceFields : public FieldClosure {
241
  oop _orig_obj;
242
  oop _orig_field;
243
  outputStream* _st;
244

245
public:
246
  TraceFields(oop orig_obj, oop orig_field, outputStream* st)
247
    : _orig_obj(orig_obj), _orig_field(orig_field), _st(st) {}
248

249
  void do_field(fieldDescriptor* fd) {
250
    if (fd->field_type() == T_OBJECT || fd->field_type() == T_ARRAY) {
251
      oop obj_field = _orig_obj->obj_field(fd->offset());
252
      if (obj_field == _orig_field) {
253
        _st->print("::%s (offset = %d)", fd->name()->as_C_string(), fd->offset());
254
      }
255
    }
256
  }
257
};
258

259
// Call this function (from gdb, etc) if you want to know why an object is archived.
260
void CDSHeapVerifier::trace_to_root(outputStream* st, oop orig_obj) {
261
  HeapShared::CachedOopInfo* info = HeapShared::archived_object_cache()->get(orig_obj);
262
  if (info != nullptr) {
263
    trace_to_root(st, orig_obj, nullptr, info);
264
  } else {
265
    st->print_cr("Not an archived object??");
266
  }
267
}
268

269
int CDSHeapVerifier::trace_to_root(outputStream* st, oop orig_obj, oop orig_field, HeapShared::CachedOopInfo* info) {
270
  int level = 0;
271
  if (info->orig_referrer() != nullptr) {
272
    HeapShared::CachedOopInfo* ref = HeapShared::archived_object_cache()->get(info->orig_referrer());
273
    assert(ref != nullptr, "sanity");
274
    level = trace_to_root(st, info->orig_referrer(), orig_obj, ref) + 1;
275
  } else if (java_lang_String::is_instance(orig_obj)) {
276
    st->print_cr("[%2d] (shared string table)", level++);
277
  }
278
  Klass* k = orig_obj->klass();
279
  ResourceMark rm;
280
  st->print("[%2d] ", level);
281
  orig_obj->print_address_on(st);
282
  st->print(" %s", k->internal_name());
283
  if (orig_field != nullptr) {
284
    if (k->is_instance_klass()) {
285
      TraceFields clo(orig_obj, orig_field, st);
286
      InstanceKlass::cast(k)->do_nonstatic_fields(&clo);
287
    } else {
288
      assert(orig_obj->is_objArray(), "must be");
289
      objArrayOop array = (objArrayOop)orig_obj;
290
      for (int i = 0; i < array->length(); i++) {
291
        if (array->obj_at(i) == orig_field) {
292
          st->print(" @[%d]", i);
293
          break;
294
        }
295
      }
296
    }
297
  }
298
  st->cr();
299

300
  return level;
301
}
302

303
void CDSHeapVerifier::verify() {
304
  CDSHeapVerifier verf;
305
  HeapShared::archived_object_cache()->iterate(&verf);
306
}
307

308
#endif // INCLUDE_CDS_JAVA_HEAP
309