1 /*
2 * Copyright (c) 2016, 2026, 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 "classfile/javaClasses.inline.hpp"
26 #include "classfile/modules.hpp"
27 #include "classfile/symbolTable.hpp"
28 #include "classfile/vmClasses.hpp"
29 #include "classfile/vmSymbols.hpp"
30 #include "jfr/instrumentation/jfrEventClassTransformer.hpp"
31 #include "jfr/jni/jfrJavaCall.hpp"
32 #include "jfr/jni/jfrJavaSupport.hpp"
33 #include "jfr/recorder/checkpoint/jfrCheckpointManager.hpp"
34 #include "jfr/recorder/checkpoint/types/traceid/jfrOopTraceId.inline.hpp"
35 #include "jfr/recorder/checkpoint/types/traceid/jfrTraceIdEpoch.hpp"
36 #include "jfr/support/jfrThreadId.inline.hpp"
37 #include "logging/log.hpp"
38 #include "memory/oopFactory.hpp"
39 #include "memory/resourceArea.hpp"
40 #include "oops/instanceOop.hpp"
41 #include "oops/klass.inline.hpp"
42 #include "oops/objArrayKlass.hpp"
43 #include "oops/objArrayOop.inline.hpp"
44 #include "oops/oop.inline.hpp"
45 #include "oops/oopCast.inline.hpp"
46 #include "runtime/fieldDescriptor.inline.hpp"
47 #include "runtime/handles.inline.hpp"
48 #include "runtime/java.hpp"
49 #include "runtime/javaCalls.hpp"
50 #include "runtime/javaThread.hpp"
51 #include "runtime/jniHandles.inline.hpp"
52 #include "runtime/semaphore.inline.hpp"
53 #include "runtime/synchronizer.hpp"
54 #include "runtime/threadSMR.hpp"
55 #include "utilities/growableArray.hpp"
56
57 #ifdef ASSERT
58 static void check_java_thread_state(JavaThread* t, JavaThreadState state) {
59 assert(t != nullptr, "invariant");
60 assert(t->is_Java_thread(), "invariant");
61 assert(t->thread_state() == state, "invariant");
62 }
63
64 void JfrJavaSupport::check_java_thread_in_vm(JavaThread* t) {
65 check_java_thread_state(t, _thread_in_vm);
66 }
67
68 void JfrJavaSupport::check_java_thread_in_native(JavaThread* t) {
69 check_java_thread_state(t, _thread_in_native);
70 }
71
72 void JfrJavaSupport::check_java_thread_in_java(JavaThread* t) {
73 check_java_thread_state(t, _thread_in_Java);
74 }
75
76 #endif
77
78 /*
79 * Handles and references
80 */
81 jobject JfrJavaSupport::local_jni_handle(const oop obj, JavaThread* t) {
82 DEBUG_ONLY(check_java_thread_in_vm(t));
83 return t->active_handles()->allocate_handle(t, obj);
84 }
85
86 jobject JfrJavaSupport::local_jni_handle(const jobject handle, JavaThread* t) {
87 DEBUG_ONLY(check_java_thread_in_vm(t));
88 const oop obj = JNIHandles::resolve(handle);
89 return obj == nullptr ? nullptr : local_jni_handle(obj, t);
90 }
91
92 void JfrJavaSupport::destroy_local_jni_handle(jobject handle) {
93 JNIHandles::destroy_local(handle);
94 }
95
96 jobject JfrJavaSupport::global_jni_handle(const oop obj, JavaThread* t) {
97 DEBUG_ONLY(check_java_thread_in_vm(t));
98 HandleMark hm(t);
99 return JNIHandles::make_global(Handle(t, obj));
100 }
101
102 jobject JfrJavaSupport::global_jni_handle(const jobject handle, JavaThread* t) {
103 const oop obj = JNIHandles::resolve(handle);
104 return obj == nullptr ? nullptr : global_jni_handle(obj, t);
105 }
106
107 void JfrJavaSupport::destroy_global_jni_handle(jobject handle) {
108 JNIHandles::destroy_global(handle);
109 }
110
111 jweak JfrJavaSupport::global_weak_jni_handle(const oop obj, JavaThread* t) {
112 DEBUG_ONLY(check_java_thread_in_vm(t));
113 HandleMark hm(t);
114 return JNIHandles::make_weak_global(Handle(t, obj));
115 }
116
117 jweak JfrJavaSupport::global_weak_jni_handle(const jobject handle, JavaThread* t) {
118 const oop obj = JNIHandles::resolve(handle);
119 return obj == nullptr ? nullptr : global_weak_jni_handle(obj, t);
120 }
121
122 void JfrJavaSupport::destroy_global_weak_jni_handle(jweak handle) {
123 JNIHandles::destroy_weak_global(handle);
124 }
125
126 oop JfrJavaSupport::resolve_non_null(jobject obj) {
127 return JNIHandles::resolve_non_null(obj);
128 }
129
130 oop JfrJavaSupport::resolve(jobject obj) {
131 return JNIHandles::resolve(obj);
132 }
133
134 /*
135 * Method invocation
136 */
137 void JfrJavaSupport::call_static(JfrJavaArguments* args, TRAPS) {
138 JfrJavaCall::call_static(args, THREAD);
139 }
140
141 void JfrJavaSupport::call_special(JfrJavaArguments* args, TRAPS) {
142 JfrJavaCall::call_special(args, THREAD);
143 }
144
145 void JfrJavaSupport::call_virtual(JfrJavaArguments* args, TRAPS) {
146 JfrJavaCall::call_virtual(args, THREAD);
147 }
148
149 void JfrJavaSupport::notify_all(jobject object, TRAPS) {
150 assert(object != nullptr, "invariant");
151 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
152 HandleMark hm(THREAD);
153 Handle h_obj(THREAD, resolve_non_null(object));
154 assert(h_obj.not_null(), "invariant");
155 ObjectSynchronizer::jni_enter(h_obj, THREAD);
156 ObjectSynchronizer::notifyall(h_obj, THREAD);
157 ObjectSynchronizer::jni_exit(h_obj(), THREAD);
158 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
159 }
160
161 /*
162 * Object construction
163 */
164 static void object_construction(JfrJavaArguments* args, JavaValue* result, InstanceKlass* klass, TRAPS) {
165 assert(args != nullptr, "invariant");
166 assert(result != nullptr, "invariant");
167 assert(klass != nullptr, "invariant");
168 assert(klass->is_initialized(), "invariant");
169
170 HandleMark hm(THREAD);
171 instanceOop obj = klass->allocate_instance(CHECK);
172 instanceHandle h_obj(THREAD, obj);
173 assert(h_obj.not_null(), "invariant");
174 args->set_receiver(h_obj);
175 result->set_type(T_VOID); // constructor result type
176 JfrJavaSupport::call_special(args, CHECK);
177 result->set_type(T_OBJECT); // set back to original result type
178 result->set_oop(h_obj());
179 }
180
181 static void create_object(JfrJavaArguments* args, JavaValue* result, TRAPS) {
182 assert(args != nullptr, "invariant");
183 assert(result != nullptr, "invariant");
184 assert(result->get_type() == T_OBJECT, "invariant");
185 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(THREAD));
186
187 InstanceKlass* const klass = static_cast<InstanceKlass*>(args->klass());
188 klass->initialize(CHECK);
189
190 object_construction(args, result, klass, THREAD);
191 }
192
193 static void handle_result(JavaValue* result, bool global_ref, JavaThread* t) {
194 assert(result != nullptr, "invariant");
195 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(t));
196 const oop result_oop = result->get_oop();
197 if (result_oop == nullptr) {
198 return;
199 }
200 result->set_jobject(global_ref ?
201 JfrJavaSupport::global_jni_handle(result_oop, t) :
202 JfrJavaSupport::local_jni_handle(result_oop, t));
203 }
204
205 void JfrJavaSupport::new_object(JfrJavaArguments* args, TRAPS) {
206 assert(args != nullptr, "invariant");
207 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
208 create_object(args, args->result(), THREAD);
209 }
210
211 void JfrJavaSupport::new_object_local_ref(JfrJavaArguments* args, TRAPS) {
212 assert(args != nullptr, "invariant");
213 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
214 JavaValue* const result = args->result();
215 assert(result != nullptr, "invariant");
216 create_object(args, result, CHECK);
217 handle_result(result, false, THREAD);
218 }
219
220 void JfrJavaSupport::new_object_global_ref(JfrJavaArguments* args, TRAPS) {
221 assert(args != nullptr, "invariant");
222 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
223 JavaValue* const result = args->result();
224 assert(result != nullptr, "invariant");
225 create_object(args, result, CHECK);
226 handle_result(result, true, THREAD);
227 }
228
229 jstring JfrJavaSupport::new_string(const char* c_str, TRAPS) {
230 assert(c_str != nullptr, "invariant");
231 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
232 const oop result = java_lang_String::create_oop_from_str(c_str, THREAD);
233 return (jstring)local_jni_handle(result, THREAD);
234 }
235
236 jobject JfrJavaSupport::new_java_lang_Boolean(bool value, TRAPS) {
237 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
238 JavaValue result(T_OBJECT);
239 JfrJavaArguments args(&result, "java/lang/Boolean", "<init>", "(Z)V", CHECK_NULL);
240 args.push_int(value ? (jint)JNI_TRUE : (jint)JNI_FALSE);
241 new_object_local_ref(&args, THREAD);
242 return args.result()->get_jobject();
243 }
244
245 jobject JfrJavaSupport::new_java_lang_Integer(jint value, TRAPS) {
246 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
247 JavaValue result(T_OBJECT);
248 JfrJavaArguments args(&result, "java/lang/Integer", "<init>", "(I)V", CHECK_NULL);
249 args.push_int(value);
250 new_object_local_ref(&args, THREAD);
251 return args.result()->get_jobject();
252 }
253
254 jobject JfrJavaSupport::new_java_lang_Long(jlong value, TRAPS) {
255 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
256 JavaValue result(T_OBJECT);
257 JfrJavaArguments args(&result, "java/lang/Long", "<init>", "(J)V", CHECK_NULL);
258 args.push_long(value);
259 new_object_local_ref(&args, THREAD);
260 return args.result()->get_jobject();
261 }
262
263 void JfrJavaSupport::set_array_element(jobjectArray arr, jobject element, int index, JavaThread* t) {
264 assert(arr != nullptr, "invariant");
265 DEBUG_ONLY(check_java_thread_in_vm(t));
266 HandleMark hm(t);
267 objArrayHandle a(t, (objArrayOop)resolve_non_null(arr));
268 a->obj_at_put(index, resolve_non_null(element));
269 }
270
271 /*
272 * Field access
273 */
274 static void write_bool_field(const Handle& h_oop, fieldDescriptor* fd, jboolean value) {
275 assert(h_oop.not_null(), "invariant");
276 assert(fd != nullptr, "invariant");
277 h_oop->bool_field_put(fd->offset(), value);
278 }
279
280 static void write_char_field(const Handle& h_oop, fieldDescriptor* fd, jchar value) {
281 assert(h_oop.not_null(), "invariant");
282 assert(fd != nullptr, "invariant");
283 h_oop->char_field_put(fd->offset(), value);
284 }
285
286 static void write_short_field(const Handle& h_oop, fieldDescriptor* fd, jshort value) {
287 assert(h_oop.not_null(), "invariant");
288 assert(fd != nullptr, "invariant");
289 h_oop->short_field_put(fd->offset(), value);
290 }
291
292 static void write_int_field(const Handle& h_oop, fieldDescriptor* fd, jint value) {
293 assert(h_oop.not_null(), "invariant");
294 assert(fd != nullptr, "invariant");
295 h_oop->int_field_put(fd->offset(), value);
296 }
297
298 static void write_float_field(const Handle& h_oop, fieldDescriptor* fd, jfloat value) {
299 assert(h_oop.not_null(), "invariant");
300 assert(fd != nullptr, "invariant");
301 h_oop->float_field_put(fd->offset(), value);
302 }
303
304 static void write_double_field(const Handle& h_oop, fieldDescriptor* fd, jdouble value) {
305 assert(h_oop.not_null(), "invariant");
306 assert(fd != nullptr, "invariant");
307 h_oop->double_field_put(fd->offset(), value);
308 }
309
310 static void write_long_field(const Handle& h_oop, fieldDescriptor* fd, jlong value) {
311 assert(h_oop.not_null(), "invariant");
312 assert(fd != nullptr, "invariant");
313 h_oop->long_field_put(fd->offset(), value);
314 }
315
316 static void write_oop_field(const Handle& h_oop, fieldDescriptor* fd, const oop value) {
317 assert(h_oop.not_null(), "invariant");
318 assert(fd != nullptr, "invariant");
319 h_oop->obj_field_put(fd->offset(), value);
320 }
321
322 static void write_specialized_field(JfrJavaArguments* args, const Handle& h_oop, fieldDescriptor* fd, bool static_field) {
323 assert(args != nullptr, "invariant");
324 assert(h_oop.not_null(), "invariant");
325 assert(fd != nullptr, "invariant");
326 assert(fd->offset() > 0, "invariant");
327 assert(args->length() >= 1, "invariant");
328
329 // attempt must set a real value
330 assert(args->param(1).get_type() != T_VOID, "invariant");
331
332 switch(fd->field_type()) {
333 case T_BOOLEAN:
334 write_bool_field(h_oop, fd, args->param(1).get_jboolean());
335 break;
336 case T_CHAR:
337 write_char_field(h_oop, fd, args->param(1).get_jchar());
338 break;
339 case T_SHORT:
340 write_short_field(h_oop, fd, args->param(1).get_jshort());
341 break;
342 case T_INT:
343 write_int_field(h_oop, fd, args->param(1).get_jint());
344 break;
345 case T_FLOAT:
346 write_float_field(h_oop, fd, args->param(1).get_jfloat());
347 break;
348 case T_DOUBLE:
349 write_double_field(h_oop, fd, args->param(1).get_jdouble());
350 break;
351 case T_LONG:
352 write_long_field(h_oop, fd, args->param(1).get_jlong());
353 break;
354 case T_OBJECT:
355 write_oop_field(h_oop, fd, args->param(1).get_oop());
356 break;
357 case T_ADDRESS:
358 write_oop_field(h_oop, fd, JfrJavaSupport::resolve_non_null(args->param(1).get_jobject()));
359 break;
360 default:
361 ShouldNotReachHere();
362 }
363 }
364
365 static void read_specialized_field(JavaValue* result, const Handle& h_oop, fieldDescriptor* fd) {
366 assert(result != nullptr, "invariant");
367 assert(h_oop.not_null(), "invariant");
368 assert(fd != nullptr, "invariant");
369 assert(fd->offset() > 0, "invariant");
370
371 switch(fd->field_type()) {
372 case T_BOOLEAN:
373 result->set_jint(h_oop->bool_field(fd->offset()));
374 break;
375 case T_CHAR:
376 result->set_jint(h_oop->char_field(fd->offset()));
377 break;
378 case T_SHORT:
379 result->set_jint(h_oop->short_field(fd->offset()));
380 break;
381 case T_INT:
382 result->set_jint(h_oop->int_field(fd->offset()));
383 break;
384 case T_FLOAT:
385 result->set_jfloat(h_oop->float_field(fd->offset()));
386 break;
387 case T_DOUBLE:
388 result->set_jdouble(h_oop->double_field(fd->offset()));
389 break;
390 case T_LONG:
391 result->set_jlong(h_oop->long_field(fd->offset()));
392 break;
393 case T_OBJECT:
394 result->set_oop(h_oop->obj_field(fd->offset()));
395 break;
396 default:
397 ShouldNotReachHere();
398 }
399 }
400
401 static bool find_field(const InstanceKlass* ik,
402 Symbol* name_symbol,
403 Symbol* signature_symbol,
404 fieldDescriptor* fd,
405 bool is_static = false,
406 bool allow_super = false) {
407 assert(ik != nullptr, "invariant");
408 if (allow_super || is_static) {
409 return ik->find_field(name_symbol, signature_symbol, is_static, fd) != nullptr;
410 }
411 return ik->find_local_field(name_symbol, signature_symbol, fd);
412 }
413
414 static void lookup_field(JfrJavaArguments* args, const InstanceKlass* ik, fieldDescriptor* fd, bool static_field) {
415 assert(args != nullptr, "invariant");
416 assert(ik != nullptr, "invariant");
417 assert(ik->is_initialized(), "invariant");
418 assert(fd != nullptr, "invariant");
419 find_field(ik, args->name(), args->signature(), fd, static_field, true);
420 }
421
422 static void read_field(JfrJavaArguments* args, JavaValue* result, Thread* thread) {
423 assert(result != nullptr, "invariant");
424 assert(result->get_oop() == nullptr, "result not initialized");
425 const bool static_field = !args->has_receiver();
426 fieldDescriptor fd;
427 const InstanceKlass* const ik = static_cast<InstanceKlass*>(args->klass());
428 lookup_field(args, ik, &fd, static_field);
429 assert(fd.offset() > 0, "invariant");
430 HandleMark hm(thread);
431 Handle h_oop(static_field ? Handle(thread, ik->java_mirror()) : Handle(thread, args->receiver()));
432 read_specialized_field(result, h_oop, &fd);
433 }
434
435 static void read_field(JfrJavaArguments* args, JavaValue* result, TRAPS) {
436 assert(args != nullptr, "invariant");
437 assert(result != nullptr, "invariant");
438 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(THREAD));
439 result->set_oop(nullptr); // Initialize result in case klass initialize throws.
440 InstanceKlass* const klass = static_cast<InstanceKlass*>(args->klass());
441 klass->initialize(CHECK);
442 read_field(args, result, static_cast<Thread*>(THREAD));
443 }
444
445 static void write_field(JfrJavaArguments* args, TRAPS) {
446 assert(args != nullptr, "invariant");
447 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(THREAD));
448
449 InstanceKlass* const klass = static_cast<InstanceKlass*>(args->klass());
450 klass->initialize(CHECK);
451
452 const bool static_field = !args->has_receiver();
453 fieldDescriptor fd;
454 lookup_field(args, klass, &fd, static_field);
455 assert(fd.offset() > 0, "invariant");
456
457 HandleMark hm(THREAD);
458 Handle h_oop(static_field ? Handle(THREAD, klass->java_mirror()) : Handle(THREAD, args->receiver()));
459 write_specialized_field(args, h_oop, &fd, static_field);
460 }
461
462 void JfrJavaSupport::set_field(JfrJavaArguments* args, TRAPS) {
463 assert(args != nullptr, "invariant");
464 write_field(args, THREAD);
465 }
466
467 void JfrJavaSupport::get_field(JfrJavaArguments* args, TRAPS) {
468 assert(args != nullptr, "invariant");
469 read_field(args, args->result(), THREAD);
470 }
471
472 static void get_field_ref(JfrJavaArguments* args, bool local_ref, TRAPS) {
473 assert(args != nullptr, "invariant");
474 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(THREAD));
475 JavaValue* const result = args->result();
476 assert(result != nullptr, "invariant");
477 assert(result->get_type() == T_OBJECT, "invariant");
478 read_field(args, result, CHECK);
479 const oop obj = result->get_oop();
480 if (obj == nullptr) {
481 return;
482 }
483 if (local_ref) {
484 result->set_jobject(JfrJavaSupport::local_jni_handle(obj, THREAD));
485 } else {
486 result->set_jobject(JfrJavaSupport::global_jni_handle(obj, THREAD));
487 }
488 }
489
490 void JfrJavaSupport::get_field_local_ref(JfrJavaArguments* args, TRAPS) {
491 get_field_ref(args, true /* local_ref */, THREAD);
492 }
493
494 void JfrJavaSupport::get_field_global_ref(JfrJavaArguments* args, TRAPS) {
495 get_field_ref(args, false /* local_ref */, THREAD);
496 }
497
498 /*
499 * Misc
500 */
501 Klass* JfrJavaSupport::klass(const jobject handle) {
502 const oop obj = resolve_non_null(handle);
503 assert(obj != nullptr, "invariant");
504 return obj->klass();
505 }
506
507 static char* allocate_string(bool c_heap, size_t length, Thread* thread) {
508 return c_heap ? NEW_C_HEAP_ARRAY(char, length, mtTracing) :
509 NEW_RESOURCE_ARRAY_IN_THREAD(thread, char, length);
510 }
511
512 const char* JfrJavaSupport::c_str(oop string, Thread* thread, bool c_heap /* false */) {
513 char* str = nullptr;
514 const typeArrayOop value = java_lang_String::value(string);
515 if (value != nullptr) {
516 const size_t length = java_lang_String::utf8_length(string, value);
517 str = allocate_string(c_heap, length + 1, thread);
518 if (str == nullptr) {
519 return nullptr;
520 }
521 java_lang_String::as_utf8_string(string, value, str, length + 1);
522 }
523 return str;
524 }
525
526 const char* JfrJavaSupport::c_str(jstring string, Thread* thread, bool c_heap /* false */) {
527 return string != nullptr ? c_str(resolve_non_null(string), thread, c_heap) : nullptr;
528 }
529
530 void JfrJavaSupport::free_c_str(const char* str, bool c_heap) {
531 if (c_heap) {
532 FREE_C_HEAP_ARRAY(char, str);
533 }
534 }
535
536 static Symbol** allocate_symbol_array(bool c_heap, int length, Thread* thread) {
537 return c_heap ?
538 NEW_C_HEAP_ARRAY(Symbol*, length, mtTracing) :
539 NEW_RESOURCE_ARRAY_IN_THREAD(thread, Symbol*, length);
540 }
541
542 Symbol** JfrJavaSupport::symbol_array(jobjectArray string_array, JavaThread* thread, intptr_t* result_array_size, bool c_heap /* false */) {
543 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(thread));
544 assert(string_array != nullptr, "invariant");
545 assert(result_array_size != nullptr, "invariant");
546 refArrayOop arrayOop = oop_cast<refArrayOop>(resolve_non_null(string_array));
547 const int length = arrayOop->length();
548 *result_array_size = length;
549 Symbol** result_array = allocate_symbol_array(c_heap, length, thread);
550 assert(result_array != nullptr, "invariant");
551 for (int i = 0; i < length; i++) {
552 oop object = arrayOop->obj_at(i);
553 Symbol* symbol = nullptr;
554 if (object != nullptr) {
555 const char* text = c_str(arrayOop->obj_at(i), thread, c_heap);
556 symbol = SymbolTable::new_symbol(text);
557 free_c_str(text, c_heap);
558 }
559 result_array[i] = symbol;
560 }
561 return result_array;
562 }
563
564 /*
565 * Exceptions and errors
566 */
567 static void create_and_throw(Symbol* name, const char* message, TRAPS) {
568 assert(name != nullptr, "invariant");
569 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(THREAD));
570 assert(!HAS_PENDING_EXCEPTION, "invariant");
571 THROW_MSG(name, message);
572 }
573
574 void JfrJavaSupport::throw_illegal_state_exception(const char* message, TRAPS) {
575 create_and_throw(vmSymbols::java_lang_IllegalStateException(), message, THREAD);
576 }
577
578 void JfrJavaSupport::throw_internal_error(const char* message, TRAPS) {
579 create_and_throw(vmSymbols::java_lang_InternalError(), message, THREAD);
580 }
581
582 void JfrJavaSupport::throw_illegal_argument_exception(const char* message, TRAPS) {
583 create_and_throw(vmSymbols::java_lang_IllegalArgumentException(), message, THREAD);
584 }
585
586 void JfrJavaSupport::throw_out_of_memory_error(const char* message, TRAPS) {
587 create_and_throw(vmSymbols::java_lang_OutOfMemoryError(), message, THREAD);
588 }
589
590 void JfrJavaSupport::throw_class_format_error(const char* message, TRAPS) {
591 create_and_throw(vmSymbols::java_lang_ClassFormatError(), message, THREAD);
592 }
593
594 void JfrJavaSupport::throw_runtime_exception(const char* message, TRAPS) {
595 create_and_throw(vmSymbols::java_lang_RuntimeException(), message, THREAD);
596 }
597
598 void JfrJavaSupport::abort(jstring errorMsg, JavaThread* t) {
599 DEBUG_ONLY(check_java_thread_in_vm(t));
600 ResourceMark rm(t);
601 abort(c_str(errorMsg, t));
602 }
603
604 void JfrJavaSupport::abort(const char* error_msg, bool dump_core /* true */) {
605 if (error_msg != nullptr) {
606 log_error(jfr, system)("%s", error_msg);
607 }
608 log_error(jfr, system)("%s", "An irrecoverable error in Jfr. Shutting down VM...");
609 vm_abort(dump_core);
610 }
611
612 JfrJavaSupport::CAUSE JfrJavaSupport::_cause = JfrJavaSupport::VM_ERROR;
613 void JfrJavaSupport::set_cause(jthrowable throwable, JavaThread* t) {
614 DEBUG_ONLY(check_java_thread_in_vm(t));
615
616 HandleMark hm(t);
617 Handle ex(t, JNIHandles::resolve_external_guard(throwable));
618
619 if (ex.is_null()) {
620 return;
621 }
622
623 if (ex->is_a(vmClasses::OutOfMemoryError_klass())) {
624 _cause = OUT_OF_MEMORY;
625 return;
626 }
627 if (ex->is_a(vmClasses::StackOverflowError_klass())) {
628 _cause = STACK_OVERFLOW;
629 return;
630 }
631 if (ex->is_a(vmClasses::Error_klass())) {
632 _cause = VM_ERROR;
633 return;
634 }
635 if (ex->is_a(vmClasses::RuntimeException_klass())) {
636 _cause = RUNTIME_EXCEPTION;
637 return;
638 }
639 if (ex->is_a(vmClasses::Exception_klass())) {
640 _cause = UNKNOWN;
641 return;
642 }
643 }
644
645 void JfrJavaSupport::uncaught_exception(jthrowable throwable, JavaThread* t) {
646 DEBUG_ONLY(check_java_thread_in_vm(t));
647 assert(throwable != nullptr, "invariant");
648 set_cause(throwable, t);
649 }
650
651 JfrJavaSupport::CAUSE JfrJavaSupport::cause() {
652 return _cause;
653 }
654
655 const char* const JDK_JFR_MODULE_NAME = "jdk.jfr";
656 const char* const JDK_JFR_PACKAGE_NAME = "jdk/jfr";
657
658
659
660 void JfrJavaSupport::load_jdk_jfr_module(TRAPS) {
661 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(THREAD));
662 ResourceMark rm(THREAD);
663 HandleMark hm(THREAD);
664 Handle h_module_name = java_lang_String::create_from_str(JDK_JFR_MODULE_NAME, CHECK);
665 JavaValue result(T_OBJECT);
666 JavaCalls::call_static(&result,
667 vmClasses::module_Modules_klass(),
668 vmSymbols::loadModule_name(),
669 vmSymbols::loadModule_signature(),
670 h_module_name,
671 CHECK
672 );
673 }
674
675 static bool is_jdk_jfr_module_in_readability_graph() {
676 // take one of the packages in the module to be located and query for its definition.
677 TempNewSymbol pkg_sym = SymbolTable::new_symbol(JDK_JFR_PACKAGE_NAME);
678 return Modules::is_package_defined(pkg_sym, Handle());
679 }
680
681 static void print_module_resolution_error(outputStream* stream) {
682 assert(stream != nullptr, "invariant");
683 stream->print_cr("Module %s not found.", JDK_JFR_MODULE_NAME);
684 stream->print_cr("Flight Recorder can not be enabled.");
685 }
686
687 bool JfrJavaSupport::is_jdk_jfr_module_available() {
688 return is_jdk_jfr_module_in_readability_graph();
689 }
690
691 bool JfrJavaSupport::is_jdk_jfr_module_available(outputStream* stream, TRAPS) {
692 if (!JfrJavaSupport::is_jdk_jfr_module_available()) {
693 if (stream != nullptr) {
694 print_module_resolution_error(stream);
695 }
696 return false;
697 }
698 return true;
699 }
700
701 typedef JfrOopTraceId<ThreadIdAccess> AccessThreadTraceId;
702
703
704 static JavaThread* get_native(ThreadsListHandle& tlh, jobject thread) {
705 JavaThread* native_thread = nullptr;
706 (void)tlh.cv_internal_thread_to_JavaThread(thread, &native_thread, nullptr);
707 return native_thread;
708 }
709
710 static bool is_virtual_thread(oop ref) {
711 const Klass* const k = ref->klass();
712 assert(k != nullptr, "invariant");
713 return k->is_subclass_of(vmClasses::VirtualThread_klass());
714 }
715
716 jlong JfrJavaSupport::jfr_thread_id(JavaThread* jt, jobject thread) {
717 assert(jt != nullptr, "invariant");
718 oop ref = resolve(thread);
719 if (ref == nullptr) {
720 return 0;
721 }
722 const traceid tid = AccessThreadTraceId::id(ref);
723 if (is_virtual_thread(ref)) {
724 const u2 epoch = JfrTraceIdEpoch::epoch_generation();
725 if (AccessThreadTraceId::epoch(ref) != epoch) {
726 AccessThreadTraceId::set_epoch(ref, epoch);
727 JfrCheckpointManager::write_checkpoint(jt, tid, ref);
728 }
729 }
730 return static_cast<jlong>(tid);
731 }
732
733 void JfrJavaSupport::exclude(JavaThread* jt, oop ref, jobject thread) {
734 if (ref != nullptr) {
735 AccessThreadTraceId::exclude(ref);
736 if (is_virtual_thread(ref)) {
737 if (ref == jt->vthread()) {
738 JfrThreadLocal::exclude_vthread(jt);
739 }
740 return;
741 }
742 }
743 ThreadsListHandle tlh;
744 jt = get_native(tlh, thread);
745 if (jt != nullptr) {
746 JfrThreadLocal::exclude_jvm_thread(jt);
747 }
748 }
749
750 void JfrJavaSupport::include(JavaThread* jt, oop ref, jobject thread) {
751 if (ref != nullptr) {
752 AccessThreadTraceId::include(ref);
753 if (is_virtual_thread(ref)) {
754 if (ref == jt->vthread()) {
755 JfrThreadLocal::include_vthread(jt);
756 }
757 return;
758 }
759 }
760 ThreadsListHandle tlh;
761 jt = get_native(tlh, thread);
762 if (jt != nullptr) {
763 JfrThreadLocal::include_jvm_thread(jt);
764 }
765 }
766
767 void JfrJavaSupport::exclude(Thread* thread) {
768 assert(thread != nullptr, "invariant");
769 if (thread->is_Java_thread()) {
770 JavaThread* const jt = JavaThread::cast(thread);
771 exclude(jt, jt->threadObj(), nullptr);
772 return;
773 }
774 JfrThreadLocal::exclude_jvm_thread(thread);
775 }
776
777 void JfrJavaSupport::include(Thread* thread) {
778 assert(thread != nullptr, "invariant");
779 if (thread->is_Java_thread()) {
780 JavaThread* const jt = JavaThread::cast(thread);
781 include(jt, jt->threadObj(), nullptr);
782 return;
783 }
784 JfrThreadLocal::include_jvm_thread(thread);
785 }
786
787 void JfrJavaSupport::exclude(JavaThread* jt, jobject thread) {
788 oop ref = resolve(thread);
789 assert(ref != nullptr, "invariant");
790 exclude(jt, ref, thread);
791 }
792
793 void JfrJavaSupport::include(JavaThread* jt, jobject thread) {
794 oop ref = resolve(thread);
795 assert(ref != nullptr, "invariant");
796 include(jt, ref, thread);
797 }
798
799 bool JfrJavaSupport::is_excluded(jobject thread) {
800 oop ref = resolve(thread);
801 assert(ref != nullptr, "invariant");
802 return AccessThreadTraceId::is_excluded(ref);
803 }
804
805 bool JfrJavaSupport::is_excluded(Thread* thread) {
806 assert(thread != nullptr, "invariant");
807 if (thread->is_Java_thread()) {
808 JavaThread* const jt = JavaThread::cast(thread);
809 oop ref = jt->threadObj();
810 return ref != nullptr ? AccessThreadTraceId::is_excluded(ref) : false;
811 }
812 return JfrThreadLocal::is_jvm_thread_excluded(thread);
813 }
814
815 static const Klass* get_configuration_field_descriptor(const Handle& h_mirror, fieldDescriptor* descriptor, TRAPS) {
816 assert(h_mirror.not_null(), "invariant");
817 assert(descriptor != nullptr, "invariant");
818 Klass* const k = java_lang_Class::as_Klass(h_mirror());
819 assert(k->is_instance_klass(), "invariant");
820 InstanceKlass* const ik = InstanceKlass::cast(k);
821 if (ik->is_not_initialized()) {
822 ik->initialize(CHECK_NULL);
823 }
824 assert(ik->is_being_initialized() || ik->is_initialized(), "invariant");
825 const Klass* const typed_field_holder = ik->find_field(vmSymbols::eventConfiguration_name(),
826 vmSymbols::jdk_jfr_internal_event_EventConfiguration_signature(),
827 true,
828 descriptor);
829 return typed_field_holder != nullptr ? typed_field_holder : ik->find_field(vmSymbols::eventConfiguration_name(),
830 vmSymbols::object_signature(), // untyped
831 true,
832 descriptor);
833 }
834
835 jobject JfrJavaSupport::get_configuration(jobject clazz, TRAPS) {
836 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(THREAD));
837 HandleMark hm(THREAD);
838 const Handle h_mirror(Handle(THREAD, JNIHandles::resolve(clazz)));
839 assert(h_mirror.not_null(), "invariant");
840 fieldDescriptor configuration_field_descriptor;
841 const Klass* const field_holder = get_configuration_field_descriptor(h_mirror, &configuration_field_descriptor, THREAD);
842 if (field_holder == nullptr) {
843 // The only reason should be that klass initialization failed.
844 return nullptr;
845 }
846 assert(java_lang_Class::as_Klass(h_mirror()) == field_holder, "invariant");
847 oop configuration_oop = h_mirror->obj_field(configuration_field_descriptor.offset());
848 return configuration_oop != nullptr ? JfrJavaSupport::local_jni_handle(configuration_oop, THREAD) : nullptr;
849 }
850
851 bool JfrJavaSupport::set_configuration(jobject clazz, jobject configuration, TRAPS) {
852 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(THREAD));
853 HandleMark hm(THREAD);
854 const Handle h_mirror(Handle(THREAD, JNIHandles::resolve(clazz)));
855 assert(h_mirror.not_null(), "invariant");
856 fieldDescriptor configuration_field_descriptor;
857 const Klass* const field_holder = get_configuration_field_descriptor(h_mirror, &configuration_field_descriptor, THREAD);
858 if (field_holder == nullptr) {
859 // The only reason should be that klass initialization failed.
860 return false;
861 }
862 assert(java_lang_Class::as_Klass(h_mirror()) == field_holder, "invariant");
863 const oop configuration_oop = JNIHandles::resolve(configuration);
864 assert(configuration_oop != nullptr, "invariant");
865 h_mirror->obj_field_put(configuration_field_descriptor.offset(), configuration_oop);
866 return true;
867 }
868
869 bool JfrJavaSupport::is_instrumented(jobject clazz, TRAPS) {
870 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(THREAD));
871 const Klass* const k = java_lang_Class::as_Klass(resolve_non_null(clazz));
872 assert(k->is_instance_klass(), "invariant");
873 return JfrEventClassTransformer::is_instrumented(InstanceKlass::cast(k));
874 }
875
876 bool JfrJavaSupport::on_thread_start(Thread* t) {
877 assert(t != nullptr, "invariant");
878 assert(Thread::current() == t, "invariant");
879 if (!t->is_Java_thread()) {
880 return true;
881 }
882 JavaThread* const jt = JavaThread::cast(t);
883 assert(!JfrThreadLocal::is_vthread(jt), "invariant");
884 if (is_excluded(jt)) {
885 JfrThreadLocal::exclude_jvm_thread(jt);
886 return false;
887 }
888 return true;
889 }
890
891 bool JfrJavaSupport::compute_field_offset(int &dest_offset,
892 Klass* klass,
893 Symbol* name_symbol,
894 Symbol* signature_symbol,
895 bool is_static,
896 bool allow_super) {
897 fieldDescriptor fd;
898 const InstanceKlass* const ik = InstanceKlass::cast(klass);
899 if (!find_field(ik, name_symbol, signature_symbol, &fd, is_static, allow_super)) {
900 return false;
901 }
902 dest_offset = fd.offset();
903 return true;
904 }
905
906 jlongArray JfrJavaSupport::create_long_array(GrowableArray<jlong>* array, TRAPS) {
907 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(THREAD));
908 assert(array != nullptr, "invariant");
909 assert(array->is_nonempty(), "invariant");
910 const int length = array->length();
911 assert(length > 0, "invariant");
912 typeArrayOop obj = oopFactory::new_typeArray(T_LONG, length, CHECK_NULL);
913 ArrayAccess<>::arraycopy_from_native(&array->first(), obj, typeArrayOopDesc::element_offset<jlong>(0), length);
914 return static_cast<jlongArray>(JfrJavaSupport::local_jni_handle(obj, THREAD));
915 }