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