1 /*
2 * Copyright (c) 2003, 2017, 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 "classfile/classLoaderData.inline.hpp"
27 #include "classfile/sharedClassUtil.hpp"
28 #include "classfile/dictionary.hpp"
29 #include "classfile/protectionDomainCache.hpp"
30 #include "classfile/systemDictionary.hpp"
31 #include "classfile/systemDictionaryShared.hpp"
32 #include "memory/iterator.hpp"
33 #include "memory/resourceArea.hpp"
34 #include "oops/oop.inline.hpp"
35 #include "runtime/atomic.hpp"
36 #include "runtime/orderAccess.inline.hpp"
37 #include "utilities/hashtable.inline.hpp"
38
39 size_t Dictionary::entry_size() {
40 if (DumpSharedSpaces) {
41 return SystemDictionaryShared::dictionary_entry_size();
42 } else {
43 return sizeof(DictionaryEntry);
44 }
45 }
46
47 Dictionary::Dictionary(ClassLoaderData* loader_data, int table_size)
48 : _loader_data(loader_data), Hashtable<InstanceKlass*, mtClass>(table_size, (int)entry_size()) {
49 };
50
51
52 Dictionary::Dictionary(ClassLoaderData* loader_data,
53 int table_size, HashtableBucket<mtClass>* t,
54 int number_of_entries)
55 : _loader_data(loader_data), Hashtable<InstanceKlass*, mtClass>(table_size, (int)entry_size(), t, number_of_entries) {
56 };
57
58 Dictionary::~Dictionary() {
59 DictionaryEntry* probe = NULL;
60 for (int index = 0; index < table_size(); index++) {
61 for (DictionaryEntry** p = bucket_addr(index); *p != NULL; ) {
62 probe = *p;
63 *p = probe->next();
64 free_entry(probe);
65 }
66 }
67 assert(number_of_entries() == 0, "should have removed all entries");
68 assert(new_entry_free_list() == NULL, "entry present on Dictionary's free list");
69 free_buckets();
70 }
71
72 DictionaryEntry* Dictionary::new_entry(unsigned int hash, InstanceKlass* klass) {
73 DictionaryEntry* entry = (DictionaryEntry*)Hashtable<InstanceKlass*, mtClass>::allocate_new_entry(hash, klass);
74 entry->set_pd_set(NULL);
75 assert(klass->is_instance_klass(), "Must be");
76 if (DumpSharedSpaces) {
77 SystemDictionaryShared::init_shared_dictionary_entry(klass, entry);
78 }
79 return entry;
80 }
81
82
83 void Dictionary::free_entry(DictionaryEntry* entry) {
84 // avoid recursion when deleting linked list
85 while (entry->pd_set() != NULL) {
86 ProtectionDomainEntry* to_delete = entry->pd_set();
87 entry->set_pd_set(to_delete->next());
88 delete to_delete;
89 }
90 // Unlink from the Hashtable prior to freeing
91 unlink_entry(entry);
92 FREE_C_HEAP_ARRAY(char, entry);
93 }
94
95
96 bool DictionaryEntry::contains_protection_domain(oop protection_domain) const {
97 #ifdef ASSERT
98 if (protection_domain == instance_klass()->protection_domain()) {
99 // Ensure this doesn't show up in the pd_set (invariant)
100 bool in_pd_set = false;
101 for (ProtectionDomainEntry* current = _pd_set;
102 current != NULL;
103 current = current->next()) {
104 if (current->protection_domain() == protection_domain) {
105 in_pd_set = true;
106 break;
107 }
108 }
109 if (in_pd_set) {
110 assert(false, "A klass's protection domain should not show up "
111 "in its sys. dict. PD set");
112 }
113 }
114 #endif /* ASSERT */
115
116 if (protection_domain == instance_klass()->protection_domain()) {
117 // Succeeds trivially
118 return true;
119 }
120
121 for (ProtectionDomainEntry* current = _pd_set;
122 current != NULL;
123 current = current->next()) {
124 if (current->protection_domain() == protection_domain) return true;
125 }
126 return false;
127 }
128
129
130 void DictionaryEntry::add_protection_domain(Dictionary* dict, Handle protection_domain) {
131 assert_locked_or_safepoint(SystemDictionary_lock);
132 if (!contains_protection_domain(protection_domain())) {
133 ProtectionDomainCacheEntry* entry = SystemDictionary::cache_get(protection_domain);
134 ProtectionDomainEntry* new_head =
135 new ProtectionDomainEntry(entry, _pd_set);
136 // Warning: Preserve store ordering. The SystemDictionary is read
137 // without locks. The new ProtectionDomainEntry must be
138 // complete before other threads can be allowed to see it
139 // via a store to _pd_set.
140 OrderAccess::release_store_ptr(&_pd_set, new_head);
141 }
142 if (log_is_enabled(Trace, protectiondomain)) {
143 ResourceMark rm;
144 outputStream* log = Log(protectiondomain)::trace_stream();
145 print_count(log);
146 }
147 }
148
149
150 void Dictionary::do_unloading() {
151 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
152
153 // The NULL class loader doesn't initiate loading classes from other class loaders
154 if (loader_data() == ClassLoaderData::the_null_class_loader_data()) {
155 return;
156 }
157
158 // Remove unloaded entries and classes from this dictionary
159 DictionaryEntry* probe = NULL;
160 for (int index = 0; index < table_size(); index++) {
161 for (DictionaryEntry** p = bucket_addr(index); *p != NULL; ) {
162 probe = *p;
163 InstanceKlass* ik = probe->instance_klass();
164 ClassLoaderData* k_def_class_loader_data = ik->class_loader_data();
165
166 // If the klass that this loader initiated is dead,
167 // (determined by checking the defining class loader)
168 // remove this entry.
169 if (k_def_class_loader_data->is_unloading()) {
170 assert(k_def_class_loader_data != loader_data(),
171 "cannot have live defining loader and unreachable klass");
172 *p = probe->next();
173 free_entry(probe);
174 continue;
175 }
176 p = probe->next_addr();
177 }
178 }
179 }
180
181 void Dictionary::remove_classes_in_error_state() {
182 assert(DumpSharedSpaces, "supported only when dumping");
183 DictionaryEntry* probe = NULL;
184 for (int index = 0; index < table_size(); index++) {
185 for (DictionaryEntry** p = bucket_addr(index); *p != NULL; ) {
186 probe = *p;
187 InstanceKlass* ik = probe->instance_klass();
188 if (ik->is_in_error_state()) { // purge this entry
189 *p = probe->next();
190 free_entry(probe);
191 ResourceMark rm;
192 tty->print_cr("Preload Warning: Removed error class: %s", ik->external_name());
193 continue;
194 }
195
196 p = probe->next_addr();
197 }
198 }
199 }
200
201 // Just the classes from defining class loaders
202 void Dictionary::classes_do(void f(InstanceKlass*)) {
203 for (int index = 0; index < table_size(); index++) {
204 for (DictionaryEntry* probe = bucket(index);
205 probe != NULL;
206 probe = probe->next()) {
207 InstanceKlass* k = probe->instance_klass();
208 if (loader_data() == k->class_loader_data()) {
209 f(k);
210 }
211 }
212 }
213 }
214
215 // Added for initialize_itable_for_klass to handle exceptions
216 // Just the classes from defining class loaders
217 void Dictionary::classes_do(void f(InstanceKlass*, TRAPS), TRAPS) {
218 for (int index = 0; index < table_size(); index++) {
219 for (DictionaryEntry* probe = bucket(index);
220 probe != NULL;
221 probe = probe->next()) {
222 InstanceKlass* k = probe->instance_klass();
223 if (loader_data() == k->class_loader_data()) {
224 f(k, CHECK);
225 }
226 }
227 }
228 }
229
230 // All classes, and their class loaders, including initiating class loaders
231 void Dictionary::all_entries_do(void f(InstanceKlass*, ClassLoaderData*)) {
232 for (int index = 0; index < table_size(); index++) {
233 for (DictionaryEntry* probe = bucket(index);
234 probe != NULL;
235 probe = probe->next()) {
236 InstanceKlass* k = probe->instance_klass();
237 f(k, loader_data());
238 }
239 }
240 }
241
242
243 // Add a loaded class to the dictionary.
244 // Readers of the SystemDictionary aren't always locked, so _buckets
245 // is volatile. The store of the next field in the constructor is
246 // also cast to volatile; we do this to ensure store order is maintained
247 // by the compilers.
248
249 void Dictionary::add_klass(int index, unsigned int hash, Symbol* class_name,
250 InstanceKlass* obj) {
251 assert_locked_or_safepoint(SystemDictionary_lock);
252 assert(obj != NULL, "adding NULL obj");
253 assert(obj->name() == class_name, "sanity check on name");
254
255 DictionaryEntry* entry = new_entry(hash, obj);
256 add_entry(index, entry);
257 }
258
259
260 // This routine does not lock the dictionary.
261 //
262 // Since readers don't hold a lock, we must make sure that system
263 // dictionary entries are only removed at a safepoint (when only one
264 // thread is running), and are added to in a safe way (all links must
265 // be updated in an MT-safe manner).
266 //
267 // Callers should be aware that an entry could be added just after
268 // _buckets[index] is read here, so the caller will not see the new entry.
269 DictionaryEntry* Dictionary::get_entry(int index, unsigned int hash,
270 Symbol* class_name) {
271 for (DictionaryEntry* entry = bucket(index);
272 entry != NULL;
273 entry = entry->next()) {
274 if (entry->hash() == hash && entry->equals(class_name)) {
275 if (!DumpSharedSpaces || SystemDictionaryShared::is_builtin(entry)) {
276 return entry;
277 }
278 }
279 }
280 return NULL;
281 }
282
283
284 InstanceKlass* Dictionary::find(int index, unsigned int hash, Symbol* name,
285 Handle protection_domain) {
286 DictionaryEntry* entry = get_entry(index, hash, name);
287 if (entry != NULL && entry->is_valid_protection_domain(protection_domain)) {
288 return entry->instance_klass();
289 } else {
290 return NULL;
291 }
292 }
293
294
295 InstanceKlass* Dictionary::find_class(int index, unsigned int hash,
296 Symbol* name) {
297 assert_locked_or_safepoint(SystemDictionary_lock);
298 assert (index == index_for(name), "incorrect index?");
299
300 DictionaryEntry* entry = get_entry(index, hash, name);
301 return (entry != NULL) ? entry->instance_klass() : NULL;
302 }
303
304
305 // Variant of find_class for shared classes. No locking required, as
306 // that table is static.
307
308 InstanceKlass* Dictionary::find_shared_class(int index, unsigned int hash,
309 Symbol* name) {
310 assert (index == index_for(name), "incorrect index?");
311
312 DictionaryEntry* entry = get_entry(index, hash, name);
313 return (entry != NULL) ? entry->instance_klass() : NULL;
314 }
315
316
317 void Dictionary::add_protection_domain(int index, unsigned int hash,
318 InstanceKlass* klass,
319 Handle protection_domain,
320 TRAPS) {
321 Symbol* klass_name = klass->name();
322 DictionaryEntry* entry = get_entry(index, hash, klass_name);
323
324 assert(entry != NULL,"entry must be present, we just created it");
325 assert(protection_domain() != NULL,
326 "real protection domain should be present");
327
328 entry->add_protection_domain(this, protection_domain);
329
330 assert(entry->contains_protection_domain(protection_domain()),
331 "now protection domain should be present");
332 }
333
334
335 bool Dictionary::is_valid_protection_domain(int index, unsigned int hash,
336 Symbol* name,
337 Handle protection_domain) {
338 DictionaryEntry* entry = get_entry(index, hash, name);
339 return entry->is_valid_protection_domain(protection_domain);
340 }
341
342
343 void Dictionary::reorder_dictionary() {
344
345 // Copy all the dictionary entries into a single master list.
346
347 DictionaryEntry* master_list = NULL;
348 for (int i = 0; i < table_size(); ++i) {
349 DictionaryEntry* p = bucket(i);
350 while (p != NULL) {
351 DictionaryEntry* tmp;
352 tmp = p->next();
353 p->set_next(master_list);
354 master_list = p;
355 p = tmp;
356 }
357 set_entry(i, NULL);
358 }
359
360 // Add the dictionary entries back to the list in the correct buckets.
361 while (master_list != NULL) {
362 DictionaryEntry* p = master_list;
363 master_list = master_list->next();
364 p->set_next(NULL);
365 Symbol* class_name = p->instance_klass()->name();
366 // Since the null class loader data isn't copied to the CDS archive,
367 // compute the hash with NULL for loader data.
368 unsigned int hash = compute_hash(class_name);
369 int index = hash_to_index(hash);
370 p->set_hash(hash);
371 p->set_next(bucket(index));
372 set_entry(index, p);
373 }
374 }
375
376
377 SymbolPropertyTable::SymbolPropertyTable(int table_size)
378 : Hashtable<Symbol*, mtSymbol>(table_size, sizeof(SymbolPropertyEntry))
379 {
380 }
381 SymbolPropertyTable::SymbolPropertyTable(int table_size, HashtableBucket<mtSymbol>* t,
382 int number_of_entries)
383 : Hashtable<Symbol*, mtSymbol>(table_size, sizeof(SymbolPropertyEntry), t, number_of_entries)
384 {
385 }
386
387
388 SymbolPropertyEntry* SymbolPropertyTable::find_entry(int index, unsigned int hash,
389 Symbol* sym,
390 intptr_t sym_mode) {
391 assert(index == index_for(sym, sym_mode), "incorrect index?");
392 for (SymbolPropertyEntry* p = bucket(index); p != NULL; p = p->next()) {
393 if (p->hash() == hash && p->symbol() == sym && p->symbol_mode() == sym_mode) {
394 return p;
395 }
396 }
397 return NULL;
398 }
399
400
401 SymbolPropertyEntry* SymbolPropertyTable::add_entry(int index, unsigned int hash,
402 Symbol* sym, intptr_t sym_mode) {
403 assert_locked_or_safepoint(SystemDictionary_lock);
404 assert(index == index_for(sym, sym_mode), "incorrect index?");
405 assert(find_entry(index, hash, sym, sym_mode) == NULL, "no double entry");
406
407 SymbolPropertyEntry* p = new_entry(hash, sym, sym_mode);
408 Hashtable<Symbol*, mtSymbol>::add_entry(index, p);
409 return p;
410 }
411
412 void SymbolPropertyTable::oops_do(OopClosure* f) {
413 for (int index = 0; index < table_size(); index++) {
414 for (SymbolPropertyEntry* p = bucket(index); p != NULL; p = p->next()) {
415 if (p->method_type() != NULL) {
416 f->do_oop(p->method_type_addr());
417 }
418 }
419 }
420 }
421
422 void SymbolPropertyTable::methods_do(void f(Method*)) {
423 for (int index = 0; index < table_size(); index++) {
424 for (SymbolPropertyEntry* p = bucket(index); p != NULL; p = p->next()) {
425 Method* prop = p->method();
426 if (prop != NULL) {
427 f((Method*)prop);
428 }
429 }
430 }
431 }
432
433
434 // ----------------------------------------------------------------------------
435
436 void Dictionary::print(bool details) {
437 ResourceMark rm;
438
439 assert(loader_data() != NULL, "loader data should not be null");
440 if (details) {
441 tty->print_cr("Java dictionary (table_size=%d, classes=%d)",
442 table_size(), number_of_entries());
443 tty->print_cr("^ indicates that initiating loader is different from "
444 "defining loader");
445 }
446
447 for (int index = 0; index < table_size(); index++) {
448 for (DictionaryEntry* probe = bucket(index);
449 probe != NULL;
450 probe = probe->next()) {
451 Klass* e = probe->instance_klass();
452 bool is_defining_class =
453 (loader_data() == e->class_loader_data());
454 if (details) {
455 tty->print("%4d: ", index);
456 }
457 tty->print("%s%s", ((!details) || is_defining_class) ? " " : "^",
458 e->external_name());
459
460 if (details) {
461 tty->print(", loader ");
462 e->class_loader_data()->print_value();
463 }
464 tty->cr();
465 }
466 }
467 tty->cr();
468 }
469
470 void DictionaryEntry::verify() {
471 Klass* e = instance_klass();
472 guarantee(e->is_instance_klass(),
473 "Verify of dictionary failed");
474 e->verify();
475 verify_protection_domain_set();
476 }
477
478 void Dictionary::verify() {
479 guarantee(number_of_entries() >= 0, "Verify of dictionary failed");
480
481 ClassLoaderData* cld = loader_data();
482 // class loader must be present; a null class loader is the
483 // boostrap loader
484 guarantee(cld != NULL || DumpSharedSpaces ||
485 cld->class_loader() == NULL ||
486 cld->class_loader()->is_instance(),
487 "checking type of class_loader");
488
489 ResourceMark rm;
490
491 stringStream tempst;
492 tempst.print("System Dictionary for %s", cld->loader_name());
493 verify_table<DictionaryEntry>(tempst.as_string());
494 }
495