jdk

1
 /*
2
 * Copyright (c) 2012, 2024, 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
// A ClassLoaderData identifies the full set of class types that a class
26
// loader's name resolution strategy produces for a given configuration of the
27
// class loader.
28
// Class types in the ClassLoaderData may be defined by from class file binaries
29
// provided by the class loader, or from other class loader it interacts with
30
// according to its name resolution strategy.
31
//
32
// Class loaders that implement a deterministic name resolution strategy
33
// (including with respect to their delegation behavior), such as the boot, the
34
// platform, and the system loaders of the JDK's built-in class loader
35
// hierarchy, always produce the same linkset for a given configuration.
36
//
37
// ClassLoaderData carries information related to a linkset (e.g.,
38
// metaspace holding its klass definitions).
39
// The System Dictionary and related data structures (e.g., placeholder table,
40
// loader constraints table) as well as the runtime representation of classes
41
// only reference ClassLoaderData.
42
//
43
// Instances of java.lang.ClassLoader holds a pointer to a ClassLoaderData that
44
// that represent the loader's "linking domain" in the JVM.
45
//
46
// The bootstrap loader (represented by null) also has a ClassLoaderData,
47
// the singleton class the_null_class_loader_data().
48

49
#include "precompiled.hpp"
50
#include "classfile/classLoaderData.inline.hpp"
51
#include "classfile/classLoaderDataGraph.inline.hpp"
52
#include "classfile/dictionary.hpp"
53
#include "classfile/javaClasses.inline.hpp"
54
#include "classfile/moduleEntry.hpp"
55
#include "classfile/packageEntry.hpp"
56
#include "classfile/symbolTable.hpp"
57
#include "classfile/systemDictionary.hpp"
58
#include "classfile/systemDictionaryShared.hpp"
59
#include "classfile/vmClasses.hpp"
60
#include "logging/log.hpp"
61
#include "logging/logStream.hpp"
62
#include "memory/allocation.inline.hpp"
63
#include "memory/classLoaderMetaspace.hpp"
64
#include "memory/metadataFactory.hpp"
65
#include "memory/metaspace.hpp"
66
#include "memory/resourceArea.hpp"
67
#include "memory/universe.hpp"
68
#include "oops/access.inline.hpp"
69
#include "oops/klass.inline.hpp"
70
#include "oops/oop.inline.hpp"
71
#include "oops/oopHandle.inline.hpp"
72
#include "oops/verifyOopClosure.hpp"
73
#include "oops/weakHandle.inline.hpp"
74
#include "runtime/arguments.hpp"
75
#include "runtime/atomic.hpp"
76
#include "runtime/handles.inline.hpp"
77
#include "runtime/mutex.hpp"
78
#include "runtime/safepoint.hpp"
79
#include "utilities/growableArray.hpp"
80
#include "utilities/macros.hpp"
81
#include "utilities/ostream.hpp"
82

83
ClassLoaderData * ClassLoaderData::_the_null_class_loader_data = nullptr;
84

85
void ClassLoaderData::init_null_class_loader_data() {
86
  assert(_the_null_class_loader_data == nullptr, "cannot initialize twice");
87
  assert(ClassLoaderDataGraph::_head == nullptr, "cannot initialize twice");
88

89
  _the_null_class_loader_data = new ClassLoaderData(Handle(), false);
90
  ClassLoaderDataGraph::_head = _the_null_class_loader_data;
91
  assert(_the_null_class_loader_data->is_the_null_class_loader_data(), "Must be");
92

93
  LogTarget(Trace, class, loader, data) lt;
94
  if (lt.is_enabled()) {
95
    ResourceMark rm;
96
    LogStream ls(lt);
97
    ls.print("create ");
98
    _the_null_class_loader_data->print_value_on(&ls);
99
    ls.cr();
100
  }
101
}
102

103
// Obtain and set the class loader's name within the ClassLoaderData so
104
// it will be available for error messages, logging, JFR, etc.  The name
105
// and klass are available after the class_loader oop is no longer alive,
106
// during unloading.
107
void ClassLoaderData::initialize_name(Handle class_loader) {
108
  ResourceMark rm;
109

110
  // Obtain the class loader's name.  If the class loader's name was not
111
  // explicitly set during construction, the CLD's _name field will be null.
112
  oop cl_name = java_lang_ClassLoader::name(class_loader());
113
  if (cl_name != nullptr) {
114
    const char* cl_instance_name = java_lang_String::as_utf8_string(cl_name);
115

116
    if (cl_instance_name != nullptr && cl_instance_name[0] != '\0') {
117
      _name = SymbolTable::new_symbol(cl_instance_name);
118
    }
119
  }
120

121
  // Obtain the class loader's name and identity hash.  If the class loader's
122
  // name was not explicitly set during construction, the class loader's name and id
123
  // will be set to the qualified class name of the class loader along with its
124
  // identity hash.
125
  // If for some reason the ClassLoader's constructor has not been run, instead of
126
  // leaving the _name_and_id field null, fall back to the external qualified class
127
  // name.  Thus CLD's _name_and_id field should never have a null value.
128
  oop cl_name_and_id = java_lang_ClassLoader::nameAndId(class_loader());
129
  const char* cl_instance_name_and_id =
130
                  (cl_name_and_id == nullptr) ? _class_loader_klass->external_name() :
131
                                             java_lang_String::as_utf8_string(cl_name_and_id);
132
  assert(cl_instance_name_and_id != nullptr && cl_instance_name_and_id[0] != '\0', "class loader has no name and id");
133
  _name_and_id = SymbolTable::new_symbol(cl_instance_name_and_id);
134
}
135

136
ClassLoaderData::ClassLoaderData(Handle h_class_loader, bool has_class_mirror_holder) :
137
  _metaspace(nullptr),
138
  _metaspace_lock(new Mutex(Mutex::nosafepoint-2, "MetaspaceAllocation_lock")),
139
  _unloading(false), _has_class_mirror_holder(has_class_mirror_holder),
140
  _modified_oops(true),
141
  // A non-strong hidden class loader data doesn't have anything to keep
142
  // it from being unloaded during parsing of the non-strong hidden class.
143
  // The null-class-loader should always be kept alive.
144
  _keep_alive((has_class_mirror_holder || h_class_loader.is_null()) ? 1 : 0),
145
  _claim(0),
146
  _handles(),
147
  _klasses(nullptr), _packages(nullptr), _modules(nullptr), _unnamed_module(nullptr), _dictionary(nullptr),
148
  _jmethod_ids(nullptr),
149
  _deallocate_list(nullptr),
150
  _next(nullptr),
151
  _unloading_next(nullptr),
152
  _class_loader_klass(nullptr), _name(nullptr), _name_and_id(nullptr) {
153

154
  if (!h_class_loader.is_null()) {
155
    _class_loader = _handles.add(h_class_loader());
156
    _class_loader_klass = h_class_loader->klass();
157
    initialize_name(h_class_loader);
158
  }
159

160
  if (!has_class_mirror_holder) {
161
    // The holder is initialized later for non-strong hidden classes,
162
    // and before calling anything that call class_loader().
163
    initialize_holder(h_class_loader);
164

165
    // A ClassLoaderData created solely for a non-strong hidden class should never
166
    // have a ModuleEntryTable or PackageEntryTable created for it.
167
    _packages = new PackageEntryTable();
168
    if (h_class_loader.is_null()) {
169
      // Create unnamed module for boot loader
170
      _unnamed_module = ModuleEntry::create_boot_unnamed_module(this);
171
    } else {
172
      // Create unnamed module for all other loaders
173
      _unnamed_module = ModuleEntry::create_unnamed_module(this);
174
    }
175
    _dictionary = create_dictionary();
176
  }
177

178
  NOT_PRODUCT(_dependency_count = 0); // number of class loader dependencies
179

180
  JFR_ONLY(INIT_ID(this);)
181
}
182

183
ClassLoaderData::ChunkedHandleList::~ChunkedHandleList() {
184
  Chunk* c = _head;
185
  while (c != nullptr) {
186
    Chunk* next = c->_next;
187
    delete c;
188
    c = next;
189
  }
190
}
191

192
OopHandle ClassLoaderData::ChunkedHandleList::add(oop o) {
193
  if (_head == nullptr || _head->_size == Chunk::CAPACITY) {
194
    Chunk* next = new Chunk(_head);
195
    Atomic::release_store(&_head, next);
196
  }
197
  oop* handle = &_head->_data[_head->_size];
198
  NativeAccess<IS_DEST_UNINITIALIZED>::oop_store(handle, o);
199
  Atomic::release_store(&_head->_size, _head->_size + 1);
200
  return OopHandle(handle);
201
}
202

203
int ClassLoaderData::ChunkedHandleList::count() const {
204
  int count = 0;
205
  Chunk* chunk = Atomic::load_acquire(&_head);
206
  while (chunk != nullptr) {
207
    count += Atomic::load(&chunk->_size);
208
    chunk = chunk->_next;
209
  }
210
  return count;
211
}
212

213
inline void ClassLoaderData::ChunkedHandleList::oops_do_chunk(OopClosure* f, Chunk* c, const juint size) {
214
  for (juint i = 0; i < size; i++) {
215
    f->do_oop(&c->_data[i]);
216
  }
217
}
218

219
void ClassLoaderData::ChunkedHandleList::oops_do(OopClosure* f) {
220
  Chunk* head = Atomic::load_acquire(&_head);
221
  if (head != nullptr) {
222
    // Must be careful when reading size of head
223
    oops_do_chunk(f, head, Atomic::load_acquire(&head->_size));
224
    for (Chunk* c = head->_next; c != nullptr; c = c->_next) {
225
      oops_do_chunk(f, c, c->_size);
226
    }
227
  }
228
}
229

230
class VerifyContainsOopClosure : public OopClosure {
231
  oop  _target;
232
  bool _found;
233

234
 public:
235
  VerifyContainsOopClosure(oop target) : _target(target), _found(false) {}
236

237
  void do_oop(oop* p) {
238
    if (p != nullptr && NativeAccess<AS_NO_KEEPALIVE>::oop_load(p) == _target) {
239
      _found = true;
240
    }
241
  }
242

243
  void do_oop(narrowOop* p) {
244
    // The ChunkedHandleList should not contain any narrowOop
245
    ShouldNotReachHere();
246
  }
247

248
  bool found() const {
249
    return _found;
250
  }
251
};
252

253
bool ClassLoaderData::ChunkedHandleList::contains(oop p) {
254
  VerifyContainsOopClosure cl(p);
255
  oops_do(&cl);
256
  return cl.found();
257
}
258

259
#ifndef PRODUCT
260
bool ClassLoaderData::ChunkedHandleList::owner_of(oop* oop_handle) {
261
  Chunk* chunk = Atomic::load_acquire(&_head);
262
  while (chunk != nullptr) {
263
    if (&(chunk->_data[0]) <= oop_handle && oop_handle < &(chunk->_data[Atomic::load(&chunk->_size)])) {
264
      return true;
265
    }
266
    chunk = chunk->_next;
267
  }
268
  return false;
269
}
270
#endif // PRODUCT
271

272
void ClassLoaderData::clear_claim(int claim) {
273
  for (;;) {
274
    int old_claim = Atomic::load(&_claim);
275
    if ((old_claim & claim) == 0) {
276
      return;
277
    }
278
    int new_claim = old_claim & ~claim;
279
    if (Atomic::cmpxchg(&_claim, old_claim, new_claim) == old_claim) {
280
      return;
281
    }
282
  }
283
}
284

285
#ifdef ASSERT
286
void ClassLoaderData::verify_not_claimed(int claim) {
287
  assert((_claim & claim) == 0, "Found claim: %d bits in _claim: %d", claim, _claim);
288
}
289
#endif
290

291
bool ClassLoaderData::try_claim(int claim) {
292
  for (;;) {
293
    int old_claim = Atomic::load(&_claim);
294
    if ((old_claim & claim) == claim) {
295
      return false;
296
    }
297
    int new_claim = old_claim | claim;
298
    if (Atomic::cmpxchg(&_claim, old_claim, new_claim) == old_claim) {
299
      return true;
300
    }
301
  }
302
}
303

304
void ClassLoaderData::demote_strong_roots() {
305
  // The oop handle area contains strong roots that the GC traces from. We are about
306
  // to demote them to strong native oops that the GC does *not* trace from. Conceptually,
307
  // we are retiring a rather normal strong root, and creating a strong non-root handle,
308
  // which happens to reuse the same address as the normal strong root had.
309
  // Unless we invoke the right barriers, the GC might not notice that a strong root
310
  // has been pulled from the system, and is left unprocessed by the GC. There can be
311
  // several consequences:
312
  // 1. A concurrently marking snapshot-at-the-beginning GC might assume that the contents
313
  //    of all strong roots get processed by the GC in order to keep them alive. Without
314
  //    barriers, some objects might not be kept alive.
315
  // 2. A concurrently relocating GC might assume that after moving an object, a subsequent
316
  //    tracing from all roots can fix all the pointers in the system, which doesn't play
317
  //    well with roots racingly being pulled.
318
  // 3. A concurrent GC using colored pointers, might assume that tracing the object graph
319
  //    from roots results in all pointers getting some particular color, which also doesn't
320
  //    play well with roots being pulled out from the system concurrently.
321

322
  class TransitionRootsOopClosure : public OopClosure {
323
  public:
324
    virtual void do_oop(oop* p) {
325
      // By loading the strong root with the access API, we can use the right barriers to
326
      // store the oop as a strong non-root handle, that happens to reuse the same memory
327
      // address as the strong root. The barriered store ensures that:
328
      // 1. The concurrent SATB marking properties are satisfied as the store will keep
329
      //    the oop alive.
330
      // 2. The concurrent object movement properties are satisfied as we store the address
331
      //    of the new location of the object, if any.
332
      // 3. The colors if any will be stored as the new good colors.
333
      oop obj = NativeAccess<>::oop_load(p); // Load the strong root
334
      NativeAccess<>::oop_store(p, obj); // Store the strong non-root
335
    }
336

337
    virtual void do_oop(narrowOop* p) {
338
      ShouldNotReachHere();
339
    }
340
  } cl;
341
  oops_do(&cl, ClassLoaderData::_claim_none, false /* clear_mod_oops */);
342
}
343

344
// Non-strong hidden classes have their own ClassLoaderData that is marked to keep alive
345
// while the class is being parsed, and if the class appears on the module fixup list.
346
// Due to the uniqueness that no other class shares the hidden class' name or
347
// ClassLoaderData, no other non-GC thread has knowledge of the hidden class while
348
// it is being defined, therefore _keep_alive is not volatile or atomic.
349
void ClassLoaderData::inc_keep_alive() {
350
  if (has_class_mirror_holder()) {
351
    assert(_keep_alive > 0, "Invalid keep alive increment count");
352
    _keep_alive++;
353
  }
354
}
355

356
void ClassLoaderData::dec_keep_alive() {
357
  if (has_class_mirror_holder()) {
358
    assert(_keep_alive > 0, "Invalid keep alive decrement count");
359
    if (_keep_alive == 1) {
360
      // When the keep_alive counter is 1, the oop handle area is a strong root,
361
      // acting as input to the GC tracing. Such strong roots are part of the
362
      // snapshot-at-the-beginning, and can not just be pulled out from the
363
      // system when concurrent GCs are running at the same time, without
364
      // invoking the right barriers.
365
      demote_strong_roots();
366
    }
367
    _keep_alive--;
368
  }
369
}
370

371
void ClassLoaderData::oops_do(OopClosure* f, int claim_value, bool clear_mod_oops) {
372
  if (claim_value != ClassLoaderData::_claim_none && !try_claim(claim_value)) {
373
    return;
374
  }
375

376
  // Only clear modified_oops after the ClassLoaderData is claimed.
377
  if (clear_mod_oops) {
378
    clear_modified_oops();
379
  }
380

381
  _handles.oops_do(f);
382
}
383

384
void ClassLoaderData::classes_do(KlassClosure* klass_closure) {
385
  // Lock-free access requires load_acquire
386
  for (Klass* k = Atomic::load_acquire(&_klasses); k != nullptr; k = k->next_link()) {
387
    klass_closure->do_klass(k);
388
    assert(k != k->next_link(), "no loops!");
389
  }
390
}
391

392
void ClassLoaderData::classes_do(void f(Klass * const)) {
393
  // Lock-free access requires load_acquire
394
  for (Klass* k = Atomic::load_acquire(&_klasses); k != nullptr; k = k->next_link()) {
395
    f(k);
396
    assert(k != k->next_link(), "no loops!");
397
  }
398
}
399

400
void ClassLoaderData::methods_do(void f(Method*)) {
401
  // Lock-free access requires load_acquire
402
  for (Klass* k = Atomic::load_acquire(&_klasses); k != nullptr; k = k->next_link()) {
403
    if (k->is_instance_klass() && InstanceKlass::cast(k)->is_loaded()) {
404
      InstanceKlass::cast(k)->methods_do(f);
405
    }
406
  }
407
}
408

409
void ClassLoaderData::loaded_classes_do(KlassClosure* klass_closure) {
410
  // Lock-free access requires load_acquire
411
  for (Klass* k = Atomic::load_acquire(&_klasses); k != nullptr; k = k->next_link()) {
412
    // Filter out InstanceKlasses (or their ObjArrayKlasses) that have not entered the
413
    // loaded state.
414
    if (k->is_instance_klass()) {
415
      if (!InstanceKlass::cast(k)->is_loaded()) {
416
        continue;
417
      }
418
    } else if (k->is_shared() && k->is_objArray_klass()) {
419
      Klass* bottom = ObjArrayKlass::cast(k)->bottom_klass();
420
      if (bottom->is_instance_klass() && !InstanceKlass::cast(bottom)->is_loaded()) {
421
        // This could happen if <bottom> is a shared class that has been restored
422
        // but is not yet marked as loaded. All archived array classes of the
423
        // bottom class are already restored and placed in the _klasses list.
424
        continue;
425
      }
426
    }
427

428
#ifdef ASSERT
429
    oop m = k->java_mirror();
430
    assert(m != nullptr, "nullptr mirror");
431
    assert(m->is_a(vmClasses::Class_klass()), "invalid mirror");
432
#endif
433
    klass_closure->do_klass(k);
434
  }
435
}
436

437
void ClassLoaderData::classes_do(void f(InstanceKlass*)) {
438
  // Lock-free access requires load_acquire
439
  for (Klass* k = Atomic::load_acquire(&_klasses); k != nullptr; k = k->next_link()) {
440
    if (k->is_instance_klass()) {
441
      f(InstanceKlass::cast(k));
442
    }
443
    assert(k != k->next_link(), "no loops!");
444
  }
445
}
446

447
void ClassLoaderData::modules_do(void f(ModuleEntry*)) {
448
  assert_locked_or_safepoint(Module_lock);
449
  if (_unnamed_module != nullptr) {
450
    f(_unnamed_module);
451
  }
452
  if (_modules != nullptr) {
453
    _modules->modules_do(f);
454
  }
455
}
456

457
void ClassLoaderData::packages_do(void f(PackageEntry*)) {
458
  assert_locked_or_safepoint(Module_lock);
459
  if (_packages != nullptr) {
460
    _packages->packages_do(f);
461
  }
462
}
463

464
void ClassLoaderData::record_dependency(const Klass* k) {
465
  assert(k != nullptr, "invariant");
466

467
  ClassLoaderData * const from_cld = this;
468
  ClassLoaderData * const to_cld = k->class_loader_data();
469

470
  // Do not need to record dependency if the dependency is to a class whose
471
  // class loader data is never freed.  (i.e. the dependency's class loader
472
  // is one of the three builtin class loaders and the dependency's class
473
  // loader data has a ClassLoader holder, not a Class holder.)
474
  if (to_cld->is_permanent_class_loader_data()) {
475
    return;
476
  }
477

478
  oop to;
479
  if (to_cld->has_class_mirror_holder()) {
480
    // Just return if a non-strong hidden class class is attempting to record a dependency
481
    // to itself.  (Note that every non-strong hidden class has its own unique class
482
    // loader data.)
483
    if (to_cld == from_cld) {
484
      return;
485
    }
486
    // Hidden class dependencies are through the mirror.
487
    to = k->java_mirror();
488
  } else {
489
    to = to_cld->class_loader();
490
    oop from = from_cld->class_loader();
491

492
    // Just return if this dependency is to a class with the same or a parent
493
    // class_loader.
494
    if (from == to || java_lang_ClassLoader::isAncestor(from, to)) {
495
      return; // this class loader is in the parent list, no need to add it.
496
    }
497
  }
498

499
  // It's a dependency we won't find through GC, add it.
500
  if (!_handles.contains(to)) {
501
    NOT_PRODUCT(Atomic::inc(&_dependency_count));
502
    LogTarget(Trace, class, loader, data) lt;
503
    if (lt.is_enabled()) {
504
      ResourceMark rm;
505
      LogStream ls(lt);
506
      ls.print("adding dependency from ");
507
      print_value_on(&ls);
508
      ls.print(" to ");
509
      to_cld->print_value_on(&ls);
510
      ls.cr();
511
    }
512
    Handle dependency(Thread::current(), to);
513
    add_handle(dependency);
514
    // Added a potentially young gen oop to the ClassLoaderData
515
    record_modified_oops();
516
  }
517
}
518

519
void ClassLoaderData::add_class(Klass* k, bool publicize /* true */) {
520
  {
521
    MutexLocker ml(metaspace_lock(), Mutex::_no_safepoint_check_flag);
522
    Klass* old_value = _klasses;
523
    k->set_next_link(old_value);
524
    // Link the new item into the list, making sure the linked class is stable
525
    // since the list can be walked without a lock
526
    Atomic::release_store(&_klasses, k);
527
    if (k->is_array_klass()) {
528
      ClassLoaderDataGraph::inc_array_classes(1);
529
    } else {
530
      ClassLoaderDataGraph::inc_instance_classes(1);
531
    }
532
  }
533

534
  if (publicize) {
535
    LogTarget(Trace, class, loader, data) lt;
536
    if (lt.is_enabled()) {
537
      ResourceMark rm;
538
      LogStream ls(lt);
539
      ls.print("Adding k: " PTR_FORMAT " %s to ", p2i(k), k->external_name());
540
      print_value_on(&ls);
541
      ls.cr();
542
    }
543
  }
544
}
545

546
void ClassLoaderData::initialize_holder(Handle loader_or_mirror) {
547
  if (loader_or_mirror() != nullptr) {
548
    assert(_holder.is_null(), "never replace holders");
549
    _holder = WeakHandle(Universe::vm_weak(), loader_or_mirror);
550
  }
551
}
552

553
// Remove a klass from the _klasses list for scratch_class during redefinition
554
// or parsed class in the case of an error.
555
void ClassLoaderData::remove_class(Klass* scratch_class) {
556
  assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
557

558
  Klass* prev = nullptr;
559
  for (Klass* k = _klasses; k != nullptr; k = k->next_link()) {
560
    if (k == scratch_class) {
561
      if (prev == nullptr) {
562
        _klasses = k->next_link();
563
      } else {
564
        Klass* next = k->next_link();
565
        prev->set_next_link(next);
566
      }
567

568
      if (k->is_array_klass()) {
569
        ClassLoaderDataGraph::dec_array_classes(1);
570
      } else {
571
        ClassLoaderDataGraph::dec_instance_classes(1);
572
      }
573

574
      return;
575
    }
576
    prev = k;
577
    assert(k != k->next_link(), "no loops!");
578
  }
579
  ShouldNotReachHere();   // should have found this class!!
580
}
581

582
void ClassLoaderData::unload() {
583
  _unloading = true;
584

585
  LogTarget(Trace, class, loader, data) lt;
586
  if (lt.is_enabled()) {
587
    ResourceMark rm;
588
    LogStream ls(lt);
589
    ls.print("unload");
590
    print_value_on(&ls);
591
    ls.cr();
592
  }
593

594
  // Some items on the _deallocate_list need to free their C heap structures
595
  // if they are not already on the _klasses list.
596
  free_deallocate_list_C_heap_structures();
597

598
  // Clean up class dependencies and tell serviceability tools
599
  // these classes are unloading.  This must be called
600
  // after erroneous classes are released.
601
  classes_do(InstanceKlass::unload_class);
602

603
  // Method::clear_jmethod_ids only sets the jmethod_ids to null without
604
  // releasing the memory for related JNIMethodBlocks and JNIMethodBlockNodes.
605
  // This is done intentionally because native code (e.g. JVMTI agent) holding
606
  // jmethod_ids may access them after the associated classes and class loader
607
  // are unloaded. The Java Native Interface Specification says "method ID
608
  // does not prevent the VM from unloading the class from which the ID has
609
  // been derived. After the class is unloaded, the method or field ID becomes
610
  // invalid". In real world usages, the native code may rely on jmethod_ids
611
  // being null after class unloading. Hence, it is unsafe to free the memory
612
  // from the VM side without knowing when native code is going to stop using
613
  // them.
614
  if (_jmethod_ids != nullptr) {
615
    Method::clear_jmethod_ids(this);
616
  }
617
}
618

619
ModuleEntryTable* ClassLoaderData::modules() {
620
  // Lazily create the module entry table at first request.
621
  // Lock-free access requires load_acquire.
622
  ModuleEntryTable* modules = Atomic::load_acquire(&_modules);
623
  if (modules == nullptr) {
624
    MutexLocker m1(Module_lock);
625
    // Check if _modules got allocated while we were waiting for this lock.
626
    if ((modules = _modules) == nullptr) {
627
      modules = new ModuleEntryTable();
628

629
      {
630
        MutexLocker m1(metaspace_lock(), Mutex::_no_safepoint_check_flag);
631
        // Ensure _modules is stable, since it is examined without a lock
632
        Atomic::release_store(&_modules, modules);
633
      }
634
    }
635
  }
636
  return modules;
637
}
638

639
const int _boot_loader_dictionary_size    = 1009;
640
const int _default_loader_dictionary_size = 107;
641

642
Dictionary* ClassLoaderData::create_dictionary() {
643
  assert(!has_class_mirror_holder(), "class mirror holder cld does not have a dictionary");
644
  int size;
645
  if (_the_null_class_loader_data == nullptr) {
646
    size = _boot_loader_dictionary_size;
647
  } else if (class_loader()->is_a(vmClasses::reflect_DelegatingClassLoader_klass())) {
648
    size = 1;  // there's only one class in relection class loader and no initiated classes
649
  } else if (is_system_class_loader_data()) {
650
    size = _boot_loader_dictionary_size;
651
  } else {
652
    size = _default_loader_dictionary_size;
653
  }
654
  return new Dictionary(this, size);
655
}
656

657
// Tell the GC to keep this klass alive. Needed while iterating ClassLoaderDataGraph,
658
// and any runtime code that uses klasses.
659
oop ClassLoaderData::holder() const {
660
  // A klass that was previously considered dead can be looked up in the
661
  // CLD/SD, and its _java_mirror or _class_loader can be stored in a root
662
  // or a reachable object making it alive again. The SATB part of G1 needs
663
  // to get notified about this potential resurrection, otherwise the marking
664
  // might not find the object.
665
  if (!_holder.is_null()) {  // null class_loader
666
    return _holder.resolve();
667
  } else {
668
    return nullptr;
669
  }
670
}
671

672
// Let the GC read the holder without keeping it alive.
673
oop ClassLoaderData::holder_no_keepalive() const {
674
  if (!_holder.is_null()) {  // null class_loader
675
    return _holder.peek();
676
  } else {
677
    return nullptr;
678
  }
679
}
680

681
// Unloading support
682
bool ClassLoaderData::is_alive() const {
683
  bool alive = keep_alive()         // null class loader and incomplete non-strong hidden class.
684
      || (_holder.peek() != nullptr);  // and not cleaned by the GC weak handle processing.
685

686
  return alive;
687
}
688

689
class ReleaseKlassClosure: public KlassClosure {
690
private:
691
  size_t  _instance_class_released;
692
  size_t  _array_class_released;
693
public:
694
  ReleaseKlassClosure() : _instance_class_released(0), _array_class_released(0) { }
695

696
  size_t instance_class_released() const { return _instance_class_released; }
697
  size_t array_class_released()    const { return _array_class_released;    }
698

699
  void do_klass(Klass* k) {
700
    if (k->is_array_klass()) {
701
      _array_class_released ++;
702
    } else {
703
      assert(k->is_instance_klass(), "Must be");
704
      _instance_class_released ++;
705
    }
706
    k->release_C_heap_structures();
707
  }
708
};
709

710
ClassLoaderData::~ClassLoaderData() {
711
  // Release C heap structures for all the classes.
712
  ReleaseKlassClosure cl;
713
  classes_do(&cl);
714

715
  ClassLoaderDataGraph::dec_array_classes(cl.array_class_released());
716
  ClassLoaderDataGraph::dec_instance_classes(cl.instance_class_released());
717

718
  // Release the WeakHandle
719
  _holder.release(Universe::vm_weak());
720

721
  // Release C heap allocated hashtable for all the packages.
722
  if (_packages != nullptr) {
723
    // Destroy the table itself
724
    delete _packages;
725
    _packages = nullptr;
726
  }
727

728
  // Release C heap allocated hashtable for all the modules.
729
  if (_modules != nullptr) {
730
    // Destroy the table itself
731
    delete _modules;
732
    _modules = nullptr;
733
  }
734

735
  // Release C heap allocated hashtable for the dictionary
736
  if (_dictionary != nullptr) {
737
    // Destroy the table itself
738
    delete _dictionary;
739
    _dictionary = nullptr;
740
  }
741

742
  if (_unnamed_module != nullptr) {
743
    delete _unnamed_module;
744
    _unnamed_module = nullptr;
745
  }
746

747
  // release the metaspace
748
  ClassLoaderMetaspace *m = _metaspace;
749
  if (m != nullptr) {
750
    _metaspace = nullptr;
751
    delete m;
752
  }
753

754
  // Delete lock
755
  delete _metaspace_lock;
756

757
  // Delete free list
758
  if (_deallocate_list != nullptr) {
759
    delete _deallocate_list;
760
  }
761

762
  // Decrement refcounts of Symbols if created.
763
  if (_name != nullptr) {
764
    _name->decrement_refcount();
765
  }
766
  if (_name_and_id != nullptr) {
767
    _name_and_id->decrement_refcount();
768
  }
769
}
770

771
// Returns true if this class loader data is for the app class loader
772
// or a user defined system class loader.  (Note that the class loader
773
// data may have a Class holder.)
774
bool ClassLoaderData::is_system_class_loader_data() const {
775
  return SystemDictionary::is_system_class_loader(class_loader());
776
}
777

778
// Returns true if this class loader data is for the platform class loader.
779
// (Note that the class loader data may have a Class holder.)
780
bool ClassLoaderData::is_platform_class_loader_data() const {
781
  return SystemDictionary::is_platform_class_loader(class_loader());
782
}
783

784
// Returns true if the class loader for this class loader data is one of
785
// the 3 builtin (boot application/system or platform) class loaders,
786
// including a user-defined system class loader.  Note that if the class
787
// loader data is for a non-strong hidden class then it may
788
// get freed by a GC even if its class loader is one of these loaders.
789
bool ClassLoaderData::is_builtin_class_loader_data() const {
790
  return (is_boot_class_loader_data() ||
791
          SystemDictionary::is_system_class_loader(class_loader()) ||
792
          SystemDictionary::is_platform_class_loader(class_loader()));
793
}
794

795
// Returns true if this class loader data is a class loader data
796
// that is not ever freed by a GC.  It must be the CLD for one of the builtin
797
// class loaders and not the CLD for a non-strong hidden class.
798
bool ClassLoaderData::is_permanent_class_loader_data() const {
799
  return is_builtin_class_loader_data() && !has_class_mirror_holder();
800
}
801

802
ClassLoaderMetaspace* ClassLoaderData::metaspace_non_null() {
803
  // If the metaspace has not been allocated, create a new one.  Might want
804
  // to create smaller arena for Reflection class loaders also.
805
  // The reason for the delayed allocation is because some class loaders are
806
  // simply for delegating with no metadata of their own.
807
  // Lock-free access requires load_acquire.
808
  ClassLoaderMetaspace* metaspace = Atomic::load_acquire(&_metaspace);
809
  if (metaspace == nullptr) {
810
    MutexLocker ml(_metaspace_lock,  Mutex::_no_safepoint_check_flag);
811
    // Check if _metaspace got allocated while we were waiting for this lock.
812
    if ((metaspace = _metaspace) == nullptr) {
813
      if (this == the_null_class_loader_data()) {
814
        assert (class_loader() == nullptr, "Must be");
815
        metaspace = new ClassLoaderMetaspace(_metaspace_lock, Metaspace::BootMetaspaceType);
816
      } else if (has_class_mirror_holder()) {
817
        metaspace = new ClassLoaderMetaspace(_metaspace_lock, Metaspace::ClassMirrorHolderMetaspaceType);
818
      } else if (class_loader()->is_a(vmClasses::reflect_DelegatingClassLoader_klass())) {
819
        metaspace = new ClassLoaderMetaspace(_metaspace_lock, Metaspace::ReflectionMetaspaceType);
820
      } else {
821
        metaspace = new ClassLoaderMetaspace(_metaspace_lock, Metaspace::StandardMetaspaceType);
822
      }
823
      // Ensure _metaspace is stable, since it is examined without a lock
824
      Atomic::release_store(&_metaspace, metaspace);
825
    }
826
  }
827
  return metaspace;
828
}
829

830
OopHandle ClassLoaderData::add_handle(Handle h) {
831
  MutexLocker ml(metaspace_lock(),  Mutex::_no_safepoint_check_flag);
832
  record_modified_oops();
833
  return _handles.add(h());
834
}
835

836
void ClassLoaderData::remove_handle(OopHandle h) {
837
  assert(!is_unloading(), "Do not remove a handle for a CLD that is unloading");
838
  if (!h.is_empty()) {
839
    assert(_handles.owner_of(h.ptr_raw()),
840
           "Got unexpected handle " PTR_FORMAT, p2i(h.ptr_raw()));
841
    h.replace(oop(nullptr));
842
  }
843
}
844

845
void ClassLoaderData::init_handle_locked(OopHandle& dest, Handle h) {
846
  MutexLocker ml(metaspace_lock(),  Mutex::_no_safepoint_check_flag);
847
  if (dest.resolve() != nullptr) {
848
    return;
849
  } else {
850
    record_modified_oops();
851
    dest = _handles.add(h());
852
  }
853
}
854

855
// Add this metadata pointer to be freed when it's safe.  This is only during
856
// a safepoint which checks if handles point to this metadata field.
857
void ClassLoaderData::add_to_deallocate_list(Metadata* m) {
858
  // Metadata in shared region isn't deleted.
859
  if (!m->is_shared()) {
860
    MutexLocker ml(metaspace_lock(),  Mutex::_no_safepoint_check_flag);
861
    if (_deallocate_list == nullptr) {
862
      _deallocate_list = new (mtClass) GrowableArray<Metadata*>(100, mtClass);
863
    }
864
    _deallocate_list->append_if_missing(m);
865
    ResourceMark rm;
866
    log_debug(class, loader, data)("deallocate added for %s", m->print_value_string());
867
    ClassLoaderDataGraph::set_should_clean_deallocate_lists();
868
  }
869
}
870

871
// Deallocate free metadata on the free list.  How useful the PermGen was!
872
void ClassLoaderData::free_deallocate_list() {
873
  // This must be called at a safepoint because it depends on metadata walking at
874
  // safepoint cleanup time.
875
  assert(SafepointSynchronize::is_at_safepoint(), "only called at safepoint");
876
  assert(!is_unloading(), "only called for ClassLoaderData that are not unloading");
877
  if (_deallocate_list == nullptr) {
878
    return;
879
  }
880
  // Go backwards because this removes entries that are freed.
881
  for (int i = _deallocate_list->length() - 1; i >= 0; i--) {
882
    Metadata* m = _deallocate_list->at(i);
883
    if (!m->on_stack()) {
884
      _deallocate_list->remove_at(i);
885
      // There are only three types of metadata that we deallocate directly.
886
      // Cast them so they can be used by the template function.
887
      if (m->is_method()) {
888
        MetadataFactory::free_metadata(this, (Method*)m);
889
      } else if (m->is_constantPool()) {
890
        MetadataFactory::free_metadata(this, (ConstantPool*)m);
891
      } else if (m->is_klass()) {
892
        MetadataFactory::free_metadata(this, (InstanceKlass*)m);
893
      } else {
894
        ShouldNotReachHere();
895
      }
896
    } else {
897
      // Metadata is alive.
898
      // If scratch_class is on stack then it shouldn't be on this list!
899
      assert(!m->is_klass() || !((InstanceKlass*)m)->is_scratch_class(),
900
             "scratch classes on this list should be dead");
901
      // Also should assert that other metadata on the list was found in handles.
902
      // Some cleaning remains.
903
      ClassLoaderDataGraph::set_should_clean_deallocate_lists();
904
    }
905
  }
906
}
907

908
// This is distinct from free_deallocate_list.  For class loader data that are
909
// unloading, this frees the C heap memory for items on the list, and unlinks
910
// scratch or error classes so that unloading events aren't triggered for these
911
// classes. The metadata is removed with the unloading metaspace.
912
// There isn't C heap memory allocated for methods, so nothing is done for them.
913
void ClassLoaderData::free_deallocate_list_C_heap_structures() {
914
  assert_locked_or_safepoint(ClassLoaderDataGraph_lock);
915
  assert(is_unloading(), "only called for ClassLoaderData that are unloading");
916
  if (_deallocate_list == nullptr) {
917
    return;
918
  }
919
  // Go backwards because this removes entries that are freed.
920
  for (int i = _deallocate_list->length() - 1; i >= 0; i--) {
921
    Metadata* m = _deallocate_list->at(i);
922
    _deallocate_list->remove_at(i);
923
    if (m->is_constantPool()) {
924
      ((ConstantPool*)m)->release_C_heap_structures();
925
    } else if (m->is_klass()) {
926
      InstanceKlass* ik = (InstanceKlass*)m;
927
      // also releases ik->constants() C heap memory
928
      ik->release_C_heap_structures();
929
      // Remove the class so unloading events aren't triggered for
930
      // this class (scratch or error class) in do_unloading().
931
      remove_class(ik);
932
      // But still have to remove it from the dumptime_table.
933
      SystemDictionaryShared::handle_class_unloading(ik);
934
    }
935
  }
936
}
937

938
// Caller needs ResourceMark
939
// If the class loader's _name has not been explicitly set, the class loader's
940
// qualified class name is returned.
941
const char* ClassLoaderData::loader_name() const {
942
   if (_class_loader_klass == nullptr) {
943
     return BOOTSTRAP_LOADER_NAME;
944
   } else if (_name != nullptr) {
945
     return _name->as_C_string();
946
   } else {
947
     return _class_loader_klass->external_name();
948
   }
949
}
950

951
// Caller needs ResourceMark
952
// Format of the _name_and_id is as follows:
953
//   If the defining loader has a name explicitly set then '<loader-name>' @<id>
954
//   If the defining loader has no name then <qualified-class-name> @<id>
955
//   If built-in loader, then omit '@<id>' as there is only one instance.
956
const char* ClassLoaderData::loader_name_and_id() const {
957
  if (_class_loader_klass == nullptr) {
958
    return "'" BOOTSTRAP_LOADER_NAME "'";
959
  } else if (_name_and_id != nullptr) {
960
    return _name_and_id->as_C_string();
961
  } else {
962
    // May be called in a race before _name_and_id is initialized.
963
    return _class_loader_klass->external_name();
964
  }
965
}
966

967
void ClassLoaderData::print_value_on(outputStream* out) const {
968
  if (!is_unloading() && class_loader() != nullptr) {
969
    out->print("loader data: " INTPTR_FORMAT " for instance ", p2i(this));
970
    class_loader()->print_value_on(out);  // includes loader_name_and_id() and address of class loader instance
971
  } else {
972
    // loader data: 0xsomeaddr of 'bootstrap'
973
    out->print("loader data: " INTPTR_FORMAT " of %s", p2i(this), loader_name_and_id());
974
  }
975
  if (_has_class_mirror_holder) {
976
    out->print(" has a class holder");
977
  }
978
}
979

980
void ClassLoaderData::print_value() const { print_value_on(tty); }
981

982
#ifndef PRODUCT
983
class PrintKlassClosure: public KlassClosure {
984
  outputStream* _out;
985
public:
986
  PrintKlassClosure(outputStream* out): _out(out) { }
987

988
  void do_klass(Klass* k) {
989
    ResourceMark rm;
990
    _out->print("%s,", k->external_name());
991
  }
992
};
993

994
void ClassLoaderData::print_on(outputStream* out) const {
995
  ResourceMark rm;
996
  out->print_cr("ClassLoaderData(" INTPTR_FORMAT ")", p2i(this));
997
  out->print_cr(" - name                %s", loader_name_and_id());
998
  if (!_holder.is_null()) {
999
    out->print   (" - holder              ");
1000
    _holder.print_on(out);
1001
    out->print_cr("");
1002
  }
1003
  if (!_unloading) {
1004
    out->print_cr(" - class loader        " INTPTR_FORMAT, p2i(_class_loader.peek()));
1005
  } else {
1006
    out->print_cr(" - class loader        <unloading, oop is bad>");
1007
  }
1008
  out->print_cr(" - metaspace           " INTPTR_FORMAT, p2i(_metaspace));
1009
  out->print_cr(" - unloading           %s", _unloading ? "true" : "false");
1010
  out->print_cr(" - class mirror holder %s", _has_class_mirror_holder ? "true" : "false");
1011
  out->print_cr(" - modified oops       %s", _modified_oops ? "true" : "false");
1012
  out->print_cr(" - keep alive          %d", _keep_alive);
1013
  out->print   (" - claim               ");
1014
  switch(_claim) {
1015
    case _claim_none:                       out->print_cr("none"); break;
1016
    case _claim_finalizable:                out->print_cr("finalizable"); break;
1017
    case _claim_strong:                     out->print_cr("strong"); break;
1018
    case _claim_stw_fullgc_mark:            out->print_cr("stw full gc mark"); break;
1019
    case _claim_stw_fullgc_adjust:          out->print_cr("stw full gc adjust"); break;
1020
    case _claim_other:                      out->print_cr("other"); break;
1021
    case _claim_other | _claim_finalizable: out->print_cr("other and finalizable"); break;
1022
    case _claim_other | _claim_strong:      out->print_cr("other and strong"); break;
1023
    default:                                ShouldNotReachHere();
1024
  }
1025
  out->print_cr(" - handles             %d", _handles.count());
1026
  out->print_cr(" - dependency count    %d", _dependency_count);
1027
  out->print   (" - klasses             { ");
1028
  if (Verbose) {
1029
    PrintKlassClosure closure(out);
1030
    ((ClassLoaderData*)this)->classes_do(&closure);
1031
  } else {
1032
     out->print("...");
1033
  }
1034
  out->print_cr(" }");
1035
  out->print_cr(" - packages            " INTPTR_FORMAT, p2i(_packages));
1036
  out->print_cr(" - module              " INTPTR_FORMAT, p2i(_modules));
1037
  out->print_cr(" - unnamed module      " INTPTR_FORMAT, p2i(_unnamed_module));
1038
  if (_dictionary != nullptr) {
1039
    out->print   (" - dictionary          " INTPTR_FORMAT " ", p2i(_dictionary));
1040
    _dictionary->print_size(out);
1041
  } else {
1042
    out->print_cr(" - dictionary          " INTPTR_FORMAT, p2i(_dictionary));
1043
  }
1044
  if (_jmethod_ids != nullptr) {
1045
    out->print   (" - jmethod count       ");
1046
    Method::print_jmethod_ids_count(this, out);
1047
    out->print_cr("");
1048
  }
1049
  out->print_cr(" - deallocate list     " INTPTR_FORMAT, p2i(_deallocate_list));
1050
  out->print_cr(" - next CLD            " INTPTR_FORMAT, p2i(_next));
1051
}
1052
#endif // PRODUCT
1053

1054
void ClassLoaderData::print() const { print_on(tty); }
1055

1056
class VerifyHandleOops : public OopClosure {
1057
  VerifyOopClosure vc;
1058
 public:
1059
  virtual void do_oop(oop* p) {
1060
    if (p != nullptr && *p != nullptr) {
1061
      oop o = *p;
1062
      if (!java_lang_Class::is_instance(o)) {
1063
        // is_instance will assert for an invalid oop.
1064
        // Walk the resolved_references array and other assorted oops in the
1065
        // CLD::_handles field.  The mirror oops are followed by other heap roots.
1066
        o->oop_iterate(&vc);
1067
      }
1068
    }
1069
  }
1070
  virtual void do_oop(narrowOop* o) { ShouldNotReachHere(); }
1071
};
1072

1073
void ClassLoaderData::verify() {
1074
  assert_locked_or_safepoint(_metaspace_lock);
1075
  oop cl = class_loader();
1076

1077
  guarantee(this == class_loader_data(cl) || has_class_mirror_holder(), "Must be the same");
1078
  guarantee(cl != nullptr || this == ClassLoaderData::the_null_class_loader_data() || has_class_mirror_holder(), "must be");
1079

1080
  // Verify the integrity of the allocated space.
1081
#ifdef ASSERT
1082
  if (metaspace_or_null() != nullptr) {
1083
    metaspace_or_null()->verify();
1084
  }
1085
#endif
1086

1087
  for (Klass* k = _klasses; k != nullptr; k = k->next_link()) {
1088
    guarantee(k->class_loader_data() == this, "Must be the same");
1089
    k->verify();
1090
    assert(k != k->next_link(), "no loops!");
1091
  }
1092

1093
  if (_modules != nullptr) {
1094
    _modules->verify();
1095
  }
1096

1097
  if (_deallocate_list != nullptr) {
1098
    for (int i = _deallocate_list->length() - 1; i >= 0; i--) {
1099
      Metadata* m = _deallocate_list->at(i);
1100
      if (m->is_klass()) {
1101
        ((Klass*)m)->verify();
1102
      }
1103
    }
1104
  }
1105

1106
  // Check the oops in the handles area
1107
  VerifyHandleOops vho;
1108
  oops_do(&vho, _claim_none, false);
1109
}
1110

1111
bool ClassLoaderData::contains_klass(Klass* klass) {
1112
  // Lock-free access requires load_acquire
1113
  for (Klass* k = Atomic::load_acquire(&_klasses); k != nullptr; k = k->next_link()) {
1114
    if (k == klass) return true;
1115
  }
1116
  return false;
1117
}
1118