1 /*
2 * Copyright (c) 2003, 2019, 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/dictionary.hpp"
27 #include "classfile/classLoaderData.inline.hpp"
28 #include "classfile/loaderConstraints.hpp"
29 #include "logging/log.hpp"
30 #include "memory/resourceArea.hpp"
31 #include "oops/oop.inline.hpp"
32 #include "runtime/handles.inline.hpp"
33 #include "runtime/safepoint.hpp"
34 #include "utilities/hashtable.inline.hpp"
35
set_loader(int i,oop p)36 void LoaderConstraintEntry::set_loader(int i, oop p) {
37 set_loader_data(i, ClassLoaderData::class_loader_data(p));
38 }
39
LoaderConstraintTable(int table_size)40 LoaderConstraintTable::LoaderConstraintTable(int table_size)
41 : Hashtable<InstanceKlass*, mtClass>(table_size, sizeof(LoaderConstraintEntry)) {};
42
43
new_entry(unsigned int hash,Symbol * name,InstanceKlass * klass,int num_loaders,int max_loaders)44 LoaderConstraintEntry* LoaderConstraintTable::new_entry(
45 unsigned int hash, Symbol* name,
46 InstanceKlass* klass, int num_loaders,
47 int max_loaders) {
48 LoaderConstraintEntry* entry;
49 entry = (LoaderConstraintEntry*)Hashtable<InstanceKlass*, mtClass>::new_entry(hash, klass);
50 entry->set_name(name);
51 entry->set_num_loaders(num_loaders);
52 entry->set_max_loaders(max_loaders);
53 return entry;
54 }
55
free_entry(LoaderConstraintEntry * entry)56 void LoaderConstraintTable::free_entry(LoaderConstraintEntry *entry) {
57 // decrement name refcount before freeing
58 entry->name()->decrement_refcount();
59 Hashtable<InstanceKlass*, mtClass>::free_entry(entry);
60 }
61
62 // The loaderConstraintTable must always be accessed with the
63 // SystemDictionary lock held. This is true even for readers as
64 // entries in the table could be being dynamically resized.
65
find_loader_constraint(Symbol * name,Handle loader)66 LoaderConstraintEntry** LoaderConstraintTable::find_loader_constraint(
67 Symbol* name, Handle loader) {
68
69 unsigned int hash = compute_hash(name);
70 int index = hash_to_index(hash);
71 LoaderConstraintEntry** pp = bucket_addr(index);
72 ClassLoaderData* loader_data = ClassLoaderData::class_loader_data(loader());
73
74 while (*pp) {
75 LoaderConstraintEntry* p = *pp;
76 if (p->hash() == hash) {
77 if (p->name() == name) {
78 for (int i = p->num_loaders() - 1; i >= 0; i--) {
79 if (p->loader_data(i) == loader_data &&
80 // skip unloaded klasses
81 (p->klass() == NULL ||
82 p->klass()->is_loader_alive())) {
83 return pp;
84 }
85 }
86 }
87 }
88 pp = p->next_addr();
89 }
90 return pp;
91 }
92
93
purge_loader_constraints()94 void LoaderConstraintTable::purge_loader_constraints() {
95 assert(SafepointSynchronize::is_at_safepoint(), "must be at safepoint");
96 LogTarget(Info, class, loader, constraints) lt;
97 // Remove unloaded entries from constraint table
98 for (int index = 0; index < table_size(); index++) {
99 LoaderConstraintEntry** p = bucket_addr(index);
100 while(*p) {
101 LoaderConstraintEntry* probe = *p;
102 InstanceKlass* klass = probe->klass();
103 // Remove klass that is no longer alive
104 if (klass != NULL &&
105 !klass->is_loader_alive()) {
106 probe->set_klass(NULL);
107 if (lt.is_enabled()) {
108 ResourceMark rm;
109 lt.print("purging class object from constraint for name %s,"
110 " loader list:",
111 probe->name()->as_C_string());
112 for (int i = 0; i < probe->num_loaders(); i++) {
113 lt.print(" [%d]: %s", i,
114 probe->loader_data(i)->loader_name_and_id());
115 }
116 }
117 }
118 // Remove entries no longer alive from loader array
119 int n = 0;
120 while (n < probe->num_loaders()) {
121 if (probe->loader_data(n)->is_unloading()) {
122 if (lt.is_enabled()) {
123 ResourceMark rm;
124 lt.print("purging loader %s from constraint for name %s",
125 probe->loader_data(n)->loader_name_and_id(),
126 probe->name()->as_C_string()
127 );
128 }
129
130 // Compact array
131 int num = probe->num_loaders() - 1;
132 probe->set_num_loaders(num);
133 probe->set_loader_data(n, probe->loader_data(num));
134 probe->set_loader_data(num, NULL);
135
136 if (lt.is_enabled()) {
137 ResourceMark rm;
138 lt.print("new loader list:");
139 for (int i = 0; i < probe->num_loaders(); i++) {
140 lt.print(" [%d]: %s", i,
141 probe->loader_data(i)->loader_name_and_id());
142 }
143 }
144
145 continue; // current element replaced, so restart without
146 // incrementing n
147 }
148 n++;
149 }
150 // Check whether entry should be purged
151 if (probe->num_loaders() < 2) {
152 if (lt.is_enabled()) {
153 ResourceMark rm;
154 lt.print("purging complete constraint for name %s",
155 probe->name()->as_C_string());
156 }
157
158 // Purge entry
159 *p = probe->next();
160 FREE_C_HEAP_ARRAY(oop, probe->loaders());
161 free_entry(probe);
162 } else {
163 #ifdef ASSERT
164 if (probe->klass() != NULL) {
165 assert(probe->klass()->is_loader_alive(), "klass should be live");
166 }
167 #endif
168 // Go to next entry
169 p = probe->next_addr();
170 }
171 }
172 }
173 }
174
log_ldr_constraint_msg(Symbol * class_name,const char * reason,Handle class_loader1,Handle class_loader2)175 void log_ldr_constraint_msg(Symbol* class_name, const char* reason,
176 Handle class_loader1, Handle class_loader2) {
177 LogTarget(Info, class, loader, constraints) lt;
178 if (lt.is_enabled()) {
179 ResourceMark rm;
180 lt.print("Failed to add constraint for name: %s, loader[0]: %s,"
181 " loader[1]: %s, Reason: %s",
182 class_name->as_C_string(),
183 ClassLoaderData::class_loader_data(class_loader1())->loader_name_and_id(),
184 ClassLoaderData::class_loader_data(class_loader2())->loader_name_and_id(),
185 reason);
186 }
187 }
188
add_entry(Symbol * class_name,InstanceKlass * klass1,Handle class_loader1,InstanceKlass * klass2,Handle class_loader2)189 bool LoaderConstraintTable::add_entry(Symbol* class_name,
190 InstanceKlass* klass1, Handle class_loader1,
191 InstanceKlass* klass2, Handle class_loader2) {
192 LogTarget(Info, class, loader, constraints) lt;
193 if (klass1 != NULL && klass2 != NULL) {
194 if (klass1 == klass2) {
195 // Same type already loaded in both places. There is no need for any constraint.
196 return true;
197 } else {
198 log_ldr_constraint_msg(class_name,
199 "The class objects presented by loader[0] and loader[1] "
200 "are different",
201 class_loader1, class_loader2);
202 return false;
203 }
204 }
205
206 InstanceKlass* klass = klass1 != NULL ? klass1 : klass2;
207 LoaderConstraintEntry** pp1 = find_loader_constraint(class_name, class_loader1);
208 if (*pp1 != NULL && (*pp1)->klass() != NULL) {
209 if (klass != NULL) {
210 if (klass != (*pp1)->klass()) {
211 log_ldr_constraint_msg(class_name,
212 "The class object presented by loader[0] does not match "
213 "the stored class object in the constraint",
214 class_loader1, class_loader2);
215 return false;
216 }
217 } else {
218 klass = (*pp1)->klass();
219 }
220 }
221
222 LoaderConstraintEntry** pp2 = find_loader_constraint(class_name, class_loader2);
223 if (*pp2 != NULL && (*pp2)->klass() != NULL) {
224 if (klass != NULL) {
225 if (klass != (*pp2)->klass()) {
226 log_ldr_constraint_msg(class_name,
227 "The class object presented by loader[1] does not match "
228 "the stored class object in the constraint",
229 class_loader1, class_loader2);
230 return false;
231 }
232 } else {
233 klass = (*pp2)->klass();
234 }
235 }
236
237 if (*pp1 == NULL && *pp2 == NULL) {
238 unsigned int hash = compute_hash(class_name);
239 int index = hash_to_index(hash);
240 LoaderConstraintEntry* p;
241 p = new_entry(hash, class_name, klass, 2, 2);
242 p->set_loaders(NEW_C_HEAP_ARRAY(ClassLoaderData*, 2, mtClass));
243 p->set_loader(0, class_loader1());
244 p->set_loader(1, class_loader2());
245 p->set_klass(klass);
246 p->set_next(bucket(index));
247 set_entry(index, p);
248 if (lt.is_enabled()) {
249 ResourceMark rm;
250 lt.print("adding new constraint for name: %s, loader[0]: %s,"
251 " loader[1]: %s",
252 class_name->as_C_string(),
253 ClassLoaderData::class_loader_data(class_loader1())->loader_name_and_id(),
254 ClassLoaderData::class_loader_data(class_loader2())->loader_name_and_id()
255 );
256 }
257 } else if (*pp1 == *pp2) {
258 /* constraint already imposed */
259 if ((*pp1)->klass() == NULL) {
260 (*pp1)->set_klass(klass);
261 if (lt.is_enabled()) {
262 ResourceMark rm;
263 lt.print("setting class object in existing constraint for"
264 " name: %s and loader %s",
265 class_name->as_C_string(),
266 ClassLoaderData::class_loader_data(class_loader1())->loader_name_and_id()
267 );
268 }
269 } else {
270 assert((*pp1)->klass() == klass, "loader constraints corrupted");
271 }
272 } else if (*pp1 == NULL) {
273 extend_loader_constraint(*pp2, class_loader1, klass);
274 } else if (*pp2 == NULL) {
275 extend_loader_constraint(*pp1, class_loader2, klass);
276 } else {
277 merge_loader_constraints(pp1, pp2, klass);
278 }
279
280 return true;
281 }
282
283
284 // return true if the constraint was updated, false if the constraint is
285 // violated
check_or_update(InstanceKlass * k,Handle loader,Symbol * name)286 bool LoaderConstraintTable::check_or_update(InstanceKlass* k,
287 Handle loader,
288 Symbol* name) {
289 LogTarget(Info, class, loader, constraints) lt;
290 LoaderConstraintEntry* p = *(find_loader_constraint(name, loader));
291 if (p && p->klass() != NULL && p->klass() != k) {
292 if (lt.is_enabled()) {
293 ResourceMark rm;
294 lt.print("constraint check failed for name %s, loader %s: "
295 "the presented class object differs from that stored",
296 name->as_C_string(),
297 ClassLoaderData::class_loader_data(loader())->loader_name_and_id());
298 }
299 return false;
300 } else {
301 if (p && p->klass() == NULL) {
302 p->set_klass(k);
303 if (lt.is_enabled()) {
304 ResourceMark rm;
305 lt.print("updating constraint for name %s, loader %s, "
306 "by setting class object",
307 name->as_C_string(),
308 ClassLoaderData::class_loader_data(loader())->loader_name_and_id());
309 }
310 }
311 return true;
312 }
313 }
314
find_constrained_klass(Symbol * name,Handle loader)315 InstanceKlass* LoaderConstraintTable::find_constrained_klass(Symbol* name,
316 Handle loader) {
317 LoaderConstraintEntry *p = *(find_loader_constraint(name, loader));
318 if (p != NULL && p->klass() != NULL) {
319 assert(p->klass()->is_instance_klass(), "sanity");
320 if (!p->klass()->is_loaded()) {
321 // Only return fully loaded classes. Classes found through the
322 // constraints might still be in the process of loading.
323 return NULL;
324 }
325 return p->klass();
326 }
327
328 // No constraints, or else no klass loaded yet.
329 return NULL;
330 }
331
ensure_loader_constraint_capacity(LoaderConstraintEntry * p,int nfree)332 void LoaderConstraintTable::ensure_loader_constraint_capacity(
333 LoaderConstraintEntry *p,
334 int nfree) {
335 if (p->max_loaders() - p->num_loaders() < nfree) {
336 int n = nfree + p->num_loaders();
337 ClassLoaderData** new_loaders = NEW_C_HEAP_ARRAY(ClassLoaderData*, n, mtClass);
338 memcpy(new_loaders, p->loaders(), sizeof(ClassLoaderData*) * p->num_loaders());
339 p->set_max_loaders(n);
340 FREE_C_HEAP_ARRAY(ClassLoaderData*, p->loaders());
341 p->set_loaders(new_loaders);
342 }
343 }
344
345
extend_loader_constraint(LoaderConstraintEntry * p,Handle loader,InstanceKlass * klass)346 void LoaderConstraintTable::extend_loader_constraint(LoaderConstraintEntry* p,
347 Handle loader,
348 InstanceKlass* klass) {
349 ensure_loader_constraint_capacity(p, 1);
350 int num = p->num_loaders();
351 p->set_loader(num, loader());
352 p->set_num_loaders(num + 1);
353 LogTarget(Info, class, loader, constraints) lt;
354 if (lt.is_enabled()) {
355 ResourceMark rm;
356 lt.print("extending constraint for name %s by adding loader[%d]: %s %s",
357 p->name()->as_C_string(),
358 num,
359 ClassLoaderData::class_loader_data(loader())->loader_name_and_id(),
360 (p->klass() == NULL ? " and setting class object" : "")
361 );
362 }
363 if (p->klass() == NULL) {
364 p->set_klass(klass);
365 } else {
366 assert(klass == NULL || p->klass() == klass, "constraints corrupted");
367 }
368 }
369
370
merge_loader_constraints(LoaderConstraintEntry ** pp1,LoaderConstraintEntry ** pp2,InstanceKlass * klass)371 void LoaderConstraintTable::merge_loader_constraints(
372 LoaderConstraintEntry** pp1,
373 LoaderConstraintEntry** pp2,
374 InstanceKlass* klass) {
375 // make sure *pp1 has higher capacity
376 if ((*pp1)->max_loaders() < (*pp2)->max_loaders()) {
377 LoaderConstraintEntry** tmp = pp2;
378 pp2 = pp1;
379 pp1 = tmp;
380 }
381
382 LoaderConstraintEntry* p1 = *pp1;
383 LoaderConstraintEntry* p2 = *pp2;
384
385 ensure_loader_constraint_capacity(p1, p2->num_loaders());
386
387 for (int i = 0; i < p2->num_loaders(); i++) {
388 int num = p1->num_loaders();
389 p1->set_loader_data(num, p2->loader_data(i));
390 p1->set_num_loaders(num + 1);
391 }
392
393 LogTarget(Info, class, loader, constraints) lt;
394 if (lt.is_enabled()) {
395 ResourceMark rm;
396 lt.print("merged constraints for name %s, new loader list:",
397 p1->name()->as_C_string()
398 );
399
400 for (int i = 0; i < p1->num_loaders(); i++) {
401 lt.print(" [%d]: %s", i,
402 p1->loader_data(i)->loader_name_and_id());
403 }
404 if (p1->klass() == NULL) {
405 lt.print("... and setting class object");
406 }
407 }
408
409 // p1->klass() will hold NULL if klass, p2->klass(), and old
410 // p1->klass() are all NULL. In addition, all three must have
411 // matching non-NULL values, otherwise either the constraints would
412 // have been violated, or the constraints had been corrupted (and an
413 // assertion would fail).
414 if (p2->klass() != NULL) {
415 assert(p2->klass() == klass, "constraints corrupted");
416 }
417 if (p1->klass() == NULL) {
418 p1->set_klass(klass);
419 } else {
420 assert(p1->klass() == klass, "constraints corrupted");
421 }
422
423 *pp2 = p2->next();
424 FREE_C_HEAP_ARRAY(oop, p2->loaders());
425 free_entry(p2);
426 return;
427 }
428
429
verify(PlaceholderTable * placeholders)430 void LoaderConstraintTable::verify(PlaceholderTable* placeholders) {
431 Thread *thread = Thread::current();
432 for (int cindex = 0; cindex < table_size(); cindex++) {
433 for (LoaderConstraintEntry* probe = bucket(cindex);
434 probe != NULL;
435 probe = probe->next()) {
436 if (probe->klass() != NULL) {
437 InstanceKlass* ik = probe->klass();
438 guarantee(ik->name() == probe->name(), "name should match");
439 Symbol* name = ik->name();
440 ClassLoaderData* loader_data = ik->class_loader_data();
441 Dictionary* dictionary = loader_data->dictionary();
442 unsigned int d_hash = dictionary->compute_hash(name);
443 int d_index = dictionary->hash_to_index(d_hash);
444 InstanceKlass* k = dictionary->find_class(d_index, d_hash, name);
445 if (k != NULL) {
446 // We found the class in the dictionary, so we should
447 // make sure that the Klass* matches what we already have.
448 guarantee(k == probe->klass(), "klass should be in dictionary");
449 } else {
450 // If we don't find the class in the dictionary, it
451 // has to be in the placeholders table.
452 unsigned int p_hash = placeholders->compute_hash(name);
453 int p_index = placeholders->hash_to_index(p_hash);
454 PlaceholderEntry* entry = placeholders->get_entry(p_index, p_hash,
455 name, loader_data);
456
457 // The InstanceKlass might not be on the entry, so the only
458 // thing we can check here is whether we were successful in
459 // finding the class in the placeholders table.
460 guarantee(entry != NULL, "klass should be in the placeholders");
461 }
462 }
463 for (int n = 0; n< probe->num_loaders(); n++) {
464 assert(ClassLoaderDataGraph::contains_loader_data(probe->loader_data(n)), "The loader is missing");
465 }
466 }
467 }
468 }
469
470 // Called with the system dictionary lock held
print_on(outputStream * st) const471 void LoaderConstraintTable::print_on(outputStream* st) const {
472 ResourceMark rm;
473 assert_locked_or_safepoint(SystemDictionary_lock);
474 st->print_cr("Java loader constraints (table_size=%d, constraints=%d)",
475 table_size(), number_of_entries());
476 for (int cindex = 0; cindex < table_size(); cindex++) {
477 for (LoaderConstraintEntry* probe = bucket(cindex);
478 probe != NULL;
479 probe = probe->next()) {
480 st->print("%4d: ", cindex);
481 probe->name()->print_on(st);
482 st->print(" , loaders:");
483 for (int n = 0; n < probe->num_loaders(); n++) {
484 probe->loader_data(n)->print_value_on(st);
485 st->print(", ");
486 }
487 st->cr();
488 }
489 }
490 }
491