1 /*
2 * Copyright (c) 2016, 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 "jni.h"
27 #include "classfile/javaClasses.inline.hpp"
28 #include "classfile/modules.hpp"
29 #include "classfile/symbolTable.hpp"
30 #include "classfile/systemDictionary.hpp"
31 #include "classfile/vmSymbols.hpp"
32 #include "jfr/jni/jfrJavaCall.hpp"
33 #include "jfr/jni/jfrJavaSupport.hpp"
34 #include "jfr/support/jfrThreadId.hpp"
35 #include "logging/log.hpp"
36 #include "memory/resourceArea.hpp"
37 #include "oops/instanceOop.hpp"
38 #include "oops/oop.inline.hpp"
39 #include "oops/objArrayKlass.hpp"
40 #include "oops/objArrayOop.inline.hpp"
41 #include "runtime/handles.inline.hpp"
42 #include "runtime/fieldDescriptor.inline.hpp"
43 #include "runtime/java.hpp"
44 #include "runtime/jniHandles.inline.hpp"
45 #include "runtime/synchronizer.hpp"
46 #include "runtime/thread.inline.hpp"
47 #include "runtime/threadSMR.hpp"
48
49 #ifdef ASSERT
check_java_thread_in_vm(Thread * t)50 void JfrJavaSupport::check_java_thread_in_vm(Thread* t) {
51 assert(t != NULL, "invariant");
52 assert(t->is_Java_thread(), "invariant");
53 assert(((JavaThread*)t)->thread_state() == _thread_in_vm, "invariant");
54 }
55
check_java_thread_in_native(Thread * t)56 void JfrJavaSupport::check_java_thread_in_native(Thread* t) {
57 assert(t != NULL, "invariant");
58 assert(t->is_Java_thread(), "invariant");
59 assert(((JavaThread*)t)->thread_state() == _thread_in_native, "invariant");
60 }
61 #endif
62
63 /*
64 * Handles and references
65 */
local_jni_handle(const oop obj,Thread * t)66 jobject JfrJavaSupport::local_jni_handle(const oop obj, Thread* t) {
67 DEBUG_ONLY(check_java_thread_in_vm(t));
68 return t->active_handles()->allocate_handle(obj);
69 }
70
local_jni_handle(const jobject handle,Thread * t)71 jobject JfrJavaSupport::local_jni_handle(const jobject handle, Thread* t) {
72 DEBUG_ONLY(check_java_thread_in_vm(t));
73 const oop obj = JNIHandles::resolve(handle);
74 return obj == NULL ? NULL : local_jni_handle(obj, t);
75 }
76
destroy_local_jni_handle(jobject handle)77 void JfrJavaSupport::destroy_local_jni_handle(jobject handle) {
78 JNIHandles::destroy_local(handle);
79 }
80
global_jni_handle(const oop obj,Thread * t)81 jobject JfrJavaSupport::global_jni_handle(const oop obj, Thread* t) {
82 DEBUG_ONLY(check_java_thread_in_vm(t));
83 HandleMark hm(t);
84 return JNIHandles::make_global(Handle(t, obj));
85 }
86
global_jni_handle(const jobject handle,Thread * t)87 jobject JfrJavaSupport::global_jni_handle(const jobject handle, Thread* t) {
88 const oop obj = JNIHandles::resolve(handle);
89 return obj == NULL ? NULL : global_jni_handle(obj, t);
90 }
91
destroy_global_jni_handle(jobject handle)92 void JfrJavaSupport::destroy_global_jni_handle(jobject handle) {
93 JNIHandles::destroy_global(handle);
94 }
95
resolve_non_null(jobject obj)96 oop JfrJavaSupport::resolve_non_null(jobject obj) {
97 return JNIHandles::resolve_non_null(obj);
98 }
99
100 /*
101 * Method invocation
102 */
call_static(JfrJavaArguments * args,TRAPS)103 void JfrJavaSupport::call_static(JfrJavaArguments* args, TRAPS) {
104 JfrJavaCall::call_static(args, THREAD);
105 }
106
call_special(JfrJavaArguments * args,TRAPS)107 void JfrJavaSupport::call_special(JfrJavaArguments* args, TRAPS) {
108 JfrJavaCall::call_special(args, THREAD);
109 }
110
call_virtual(JfrJavaArguments * args,TRAPS)111 void JfrJavaSupport::call_virtual(JfrJavaArguments* args, TRAPS) {
112 JfrJavaCall::call_virtual(args, THREAD);
113 }
114
notify_all(jobject object,TRAPS)115 void JfrJavaSupport::notify_all(jobject object, TRAPS) {
116 assert(object != NULL, "invariant");
117 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
118 HandleMark hm(THREAD);
119 Handle h_obj(THREAD, resolve_non_null(object));
120 assert(h_obj.not_null(), "invariant");
121 ObjectSynchronizer::jni_enter(h_obj, THREAD);
122 ObjectSynchronizer::notifyall(h_obj, THREAD);
123 ObjectSynchronizer::jni_exit(h_obj(), THREAD);
124 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
125 }
126
127 /*
128 * Object construction
129 */
object_construction(JfrJavaArguments * args,JavaValue * result,InstanceKlass * klass,TRAPS)130 static void object_construction(JfrJavaArguments* args, JavaValue* result, InstanceKlass* klass, TRAPS) {
131 assert(args != NULL, "invariant");
132 assert(result != NULL, "invariant");
133 assert(klass != NULL, "invariant");
134 assert(klass->is_initialized(), "invariant");
135
136 HandleMark hm(THREAD);
137 instanceOop obj = klass->allocate_instance(CHECK);
138 instanceHandle h_obj(THREAD, obj);
139 assert(h_obj.not_null(), "invariant");
140 args->set_receiver(h_obj);
141 result->set_type(T_VOID); // constructor result type
142 JfrJavaSupport::call_special(args, CHECK);
143 result->set_type(T_OBJECT); // set back to original result type
144 result->set_jobject((jobject)h_obj());
145 }
146
array_construction(JfrJavaArguments * args,JavaValue * result,InstanceKlass * klass,int array_length,TRAPS)147 static void array_construction(JfrJavaArguments* args, JavaValue* result, InstanceKlass* klass, int array_length, TRAPS) {
148 assert(args != NULL, "invariant");
149 assert(result != NULL, "invariant");
150 assert(klass != NULL, "invariant");
151 assert(klass->is_initialized(), "invariant");
152
153 Klass* const ak = klass->array_klass(THREAD);
154 ObjArrayKlass::cast(ak)->initialize(THREAD);
155 HandleMark hm(THREAD);
156 objArrayOop arr = ObjArrayKlass::cast(ak)->allocate(array_length, CHECK);
157 result->set_jobject((jobject)arr);
158 }
159
create_object(JfrJavaArguments * args,JavaValue * result,TRAPS)160 static void create_object(JfrJavaArguments* args, JavaValue* result, TRAPS) {
161 assert(args != NULL, "invariant");
162 assert(result != NULL, "invariant");
163 assert(result->get_type() == T_OBJECT, "invariant");
164 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(THREAD));
165
166 InstanceKlass* const klass = static_cast<InstanceKlass*>(args->klass());
167 klass->initialize(CHECK);
168
169 const int array_length = args->array_length();
170
171 if (array_length >= 0) {
172 array_construction(args, result, klass, array_length, CHECK);
173 } else {
174 object_construction(args, result, klass, THREAD);
175 }
176 }
177
handle_result(JavaValue * result,bool global_ref,Thread * t)178 static void handle_result(JavaValue* result, bool global_ref, Thread* t) {
179 assert(result != NULL, "invariant");
180 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(t));
181 const oop result_oop = (const oop)result->get_jobject();
182 if (result_oop == NULL) {
183 return;
184 }
185 result->set_jobject(global_ref ?
186 JfrJavaSupport::global_jni_handle(result_oop, t) :
187 JfrJavaSupport::local_jni_handle(result_oop, t));
188 }
189
new_object(JfrJavaArguments * args,TRAPS)190 void JfrJavaSupport::new_object(JfrJavaArguments* args, TRAPS) {
191 assert(args != NULL, "invariant");
192 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
193 create_object(args, args->result(), THREAD);
194 }
195
new_object_local_ref(JfrJavaArguments * args,TRAPS)196 void JfrJavaSupport::new_object_local_ref(JfrJavaArguments* args, TRAPS) {
197 assert(args != NULL, "invariant");
198 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
199 JavaValue* const result = args->result();
200 assert(result != NULL, "invariant");
201 create_object(args, result, CHECK);
202 handle_result(result, false, THREAD);
203 }
204
new_object_global_ref(JfrJavaArguments * args,TRAPS)205 void JfrJavaSupport::new_object_global_ref(JfrJavaArguments* args, TRAPS) {
206 assert(args != NULL, "invariant");
207 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
208 JavaValue* const result = args->result();
209 assert(result != NULL, "invariant");
210 create_object(args, result, CHECK);
211 handle_result(result, true, THREAD);
212 }
213
new_string(const char * c_str,TRAPS)214 jstring JfrJavaSupport::new_string(const char* c_str, TRAPS) {
215 assert(c_str != NULL, "invariant");
216 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
217 const oop result = java_lang_String::create_oop_from_str(c_str, THREAD);
218 return (jstring)local_jni_handle(result, THREAD);
219 }
220
new_string_array(int length,TRAPS)221 jobjectArray JfrJavaSupport::new_string_array(int length, TRAPS) {
222 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
223 JavaValue result(T_OBJECT);
224 JfrJavaArguments args(&result, "java/lang/String", "<init>", "()V", CHECK_NULL);
225 args.set_array_length(length);
226 new_object_local_ref(&args, THREAD);
227 return (jobjectArray)args.result()->get_jobject();
228 }
229
new_java_lang_Boolean(bool value,TRAPS)230 jobject JfrJavaSupport::new_java_lang_Boolean(bool value, TRAPS) {
231 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
232 JavaValue result(T_OBJECT);
233 JfrJavaArguments args(&result, "java/lang/Boolean", "<init>", "(Z)V", CHECK_NULL);
234 args.push_int(value ? (jint)JNI_TRUE : (jint)JNI_FALSE);
235 new_object_local_ref(&args, THREAD);
236 return args.result()->get_jobject();
237 }
238
new_java_lang_Integer(jint value,TRAPS)239 jobject JfrJavaSupport::new_java_lang_Integer(jint value, TRAPS) {
240 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
241 JavaValue result(T_OBJECT);
242 JfrJavaArguments args(&result, "java/lang/Integer", "<init>", "(I)V", CHECK_NULL);
243 args.push_int(value);
244 new_object_local_ref(&args, THREAD);
245 return args.result()->get_jobject();
246 }
247
new_java_lang_Long(jlong value,TRAPS)248 jobject JfrJavaSupport::new_java_lang_Long(jlong value, TRAPS) {
249 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
250 JavaValue result(T_OBJECT);
251 JfrJavaArguments args(&result, "java/lang/Long", "<init>", "(J)V", CHECK_NULL);
252 args.push_long(value);
253 new_object_local_ref(&args, THREAD);
254 return args.result()->get_jobject();
255 }
256
set_array_element(jobjectArray arr,jobject element,int index,Thread * t)257 void JfrJavaSupport::set_array_element(jobjectArray arr, jobject element, int index, Thread* t) {
258 assert(arr != NULL, "invariant");
259 DEBUG_ONLY(check_java_thread_in_vm(t));
260 HandleMark hm(t);
261 objArrayHandle a(t, (objArrayOop)resolve_non_null(arr));
262 a->obj_at_put(index, resolve_non_null(element));
263 }
264
265 /*
266 * Field access
267 */
write_int_field(const Handle & h_oop,fieldDescriptor * fd,jint value)268 static void write_int_field(const Handle& h_oop, fieldDescriptor* fd, jint value) {
269 assert(h_oop.not_null(), "invariant");
270 assert(fd != NULL, "invariant");
271 h_oop->int_field_put(fd->offset(), value);
272 }
273
write_float_field(const Handle & h_oop,fieldDescriptor * fd,jfloat value)274 static void write_float_field(const Handle& h_oop, fieldDescriptor* fd, jfloat value) {
275 assert(h_oop.not_null(), "invariant");
276 assert(fd != NULL, "invariant");
277 h_oop->float_field_put(fd->offset(), value);
278 }
279
write_double_field(const Handle & h_oop,fieldDescriptor * fd,jdouble value)280 static void write_double_field(const Handle& h_oop, fieldDescriptor* fd, jdouble value) {
281 assert(h_oop.not_null(), "invariant");
282 assert(fd != NULL, "invariant");
283 h_oop->double_field_put(fd->offset(), value);
284 }
285
write_long_field(const Handle & h_oop,fieldDescriptor * fd,jlong value)286 static void write_long_field(const Handle& h_oop, fieldDescriptor* fd, jlong value) {
287 assert(h_oop.not_null(), "invariant");
288 assert(fd != NULL, "invariant");
289 h_oop->long_field_put(fd->offset(), value);
290 }
291
write_oop_field(const Handle & h_oop,fieldDescriptor * fd,const oop value)292 static void write_oop_field(const Handle& h_oop, fieldDescriptor* fd, const oop value) {
293 assert(h_oop.not_null(), "invariant");
294 assert(fd != NULL, "invariant");
295 h_oop->obj_field_put(fd->offset(), value);
296 }
297
write_specialized_field(JfrJavaArguments * args,const Handle & h_oop,fieldDescriptor * fd,bool static_field)298 static void write_specialized_field(JfrJavaArguments* args, const Handle& h_oop, fieldDescriptor* fd, bool static_field) {
299 assert(args != NULL, "invariant");
300 assert(h_oop.not_null(), "invariant");
301 assert(fd != NULL, "invariant");
302 assert(fd->offset() > 0, "invariant");
303 assert(args->length() >= 1, "invariant");
304
305 // attempt must set a real value
306 assert(args->param(1).get_type() != T_VOID, "invariant");
307
308 switch(fd->field_type()) {
309 case T_BOOLEAN:
310 case T_CHAR:
311 case T_SHORT:
312 case T_INT:
313 write_int_field(h_oop, fd, args->param(1).get_jint());
314 break;
315 case T_FLOAT:
316 write_float_field(h_oop, fd, args->param(1).get_jfloat());
317 break;
318 case T_DOUBLE:
319 write_double_field(h_oop, fd, args->param(1).get_jdouble());
320 break;
321 case T_LONG:
322 write_long_field(h_oop, fd, args->param(1).get_jlong());
323 break;
324 case T_OBJECT:
325 write_oop_field(h_oop, fd, (oop)args->param(1).get_jobject());
326 break;
327 case T_ADDRESS:
328 write_oop_field(h_oop, fd, JfrJavaSupport::resolve_non_null(args->param(1).get_jobject()));
329 break;
330 default:
331 ShouldNotReachHere();
332 }
333 }
334
read_specialized_field(JavaValue * result,const Handle & h_oop,fieldDescriptor * fd)335 static void read_specialized_field(JavaValue* result, const Handle& h_oop, fieldDescriptor* fd) {
336 assert(result != NULL, "invariant");
337 assert(h_oop.not_null(), "invariant");
338 assert(fd != NULL, "invariant");
339 assert(fd->offset() > 0, "invariant");
340
341 switch(fd->field_type()) {
342 case T_BOOLEAN:
343 case T_CHAR:
344 case T_SHORT:
345 case T_INT:
346 result->set_jint(h_oop->int_field(fd->offset()));
347 break;
348 case T_FLOAT:
349 result->set_jfloat(h_oop->float_field(fd->offset()));
350 break;
351 case T_DOUBLE:
352 result->set_jdouble(h_oop->double_field(fd->offset()));
353 break;
354 case T_LONG:
355 result->set_jlong(h_oop->long_field(fd->offset()));
356 break;
357 case T_OBJECT:
358 result->set_jobject((jobject)h_oop->obj_field(fd->offset()));
359 break;
360 default:
361 ShouldNotReachHere();
362 }
363 }
364
find_field(InstanceKlass * ik,Symbol * name_symbol,Symbol * signature_symbol,fieldDescriptor * fd,bool is_static=false,bool allow_super=false)365 static bool find_field(InstanceKlass* ik,
366 Symbol* name_symbol,
367 Symbol* signature_symbol,
368 fieldDescriptor* fd,
369 bool is_static = false,
370 bool allow_super = false) {
371 if (allow_super || is_static) {
372 return ik->find_field(name_symbol, signature_symbol, is_static, fd) != NULL;
373 }
374 return ik->find_local_field(name_symbol, signature_symbol, fd);
375 }
376
lookup_field(JfrJavaArguments * args,InstanceKlass * klass,fieldDescriptor * fd,bool static_field)377 static void lookup_field(JfrJavaArguments* args, InstanceKlass* klass, fieldDescriptor* fd, bool static_field) {
378 assert(args != NULL, "invariant");
379 assert(klass != NULL, "invariant");
380 assert(klass->is_initialized(), "invariant");
381 assert(fd != NULL, "invariant");
382 find_field(klass, args->name(), args->signature(), fd, static_field, true);
383 }
384
read_field(JfrJavaArguments * args,JavaValue * result,TRAPS)385 static void read_field(JfrJavaArguments* args, JavaValue* result, TRAPS) {
386 assert(args != NULL, "invariant");
387 assert(result != NULL, "invariant");
388 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(THREAD));
389
390 InstanceKlass* const klass = static_cast<InstanceKlass*>(args->klass());
391 klass->initialize(CHECK);
392 const bool static_field = !args->has_receiver();
393 fieldDescriptor fd;
394 lookup_field(args, klass, &fd, static_field);
395 assert(fd.offset() > 0, "invariant");
396
397 HandleMark hm(THREAD);
398 Handle h_oop(static_field ? Handle(THREAD, klass->java_mirror()) : Handle(THREAD, args->receiver()));
399 read_specialized_field(result, h_oop, &fd);
400 }
401
write_field(JfrJavaArguments * args,JavaValue * result,TRAPS)402 static void write_field(JfrJavaArguments* args, JavaValue* result, TRAPS) {
403 assert(args != NULL, "invariant");
404 assert(result != NULL, "invariant");
405 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(THREAD));
406
407 InstanceKlass* const klass = static_cast<InstanceKlass*>(args->klass());
408 klass->initialize(CHECK);
409
410 const bool static_field = !args->has_receiver();
411 fieldDescriptor fd;
412 lookup_field(args, klass, &fd, static_field);
413 assert(fd.offset() > 0, "invariant");
414
415 HandleMark hm(THREAD);
416 Handle h_oop(static_field ? Handle(THREAD, klass->java_mirror()) : Handle(THREAD, args->receiver()));
417 write_specialized_field(args, h_oop, &fd, static_field);
418 }
419
set_field(JfrJavaArguments * args,TRAPS)420 void JfrJavaSupport::set_field(JfrJavaArguments* args, TRAPS) {
421 assert(args != NULL, "invariant");
422 write_field(args, args->result(), THREAD);
423 }
424
get_field(JfrJavaArguments * args,TRAPS)425 void JfrJavaSupport::get_field(JfrJavaArguments* args, TRAPS) {
426 assert(args != NULL, "invariant");
427 read_field(args, args->result(), THREAD);
428 }
429
get_field_local_ref(JfrJavaArguments * args,TRAPS)430 void JfrJavaSupport::get_field_local_ref(JfrJavaArguments* args, TRAPS) {
431 assert(args != NULL, "invariant");
432 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
433
434 JavaValue* const result = args->result();
435 assert(result != NULL, "invariant");
436 assert(result->get_type() == T_OBJECT, "invariant");
437
438 read_field(args, result, CHECK);
439 const oop obj = (const oop)result->get_jobject();
440
441 if (obj != NULL) {
442 result->set_jobject(local_jni_handle(obj, THREAD));
443 }
444 }
445
get_field_global_ref(JfrJavaArguments * args,TRAPS)446 void JfrJavaSupport::get_field_global_ref(JfrJavaArguments* args, TRAPS) {
447 assert(args != NULL, "invariant");
448 DEBUG_ONLY(check_java_thread_in_vm(THREAD));
449
450 JavaValue* const result = args->result();
451 assert(result != NULL, "invariant");
452 assert(result->get_type() == T_OBJECT, "invariant");
453 read_field(args, result, CHECK);
454 const oop obj = (const oop)result->get_jobject();
455 if (obj != NULL) {
456 result->set_jobject(global_jni_handle(obj, THREAD));
457 }
458 }
459
460 /*
461 * Misc
462 */
klass(const jobject handle)463 Klass* JfrJavaSupport::klass(const jobject handle) {
464 const oop obj = resolve_non_null(handle);
465 assert(obj != NULL, "invariant");
466 return obj->klass();
467 }
468
469 // caller needs ResourceMark
c_str(jstring string,Thread * t)470 const char* JfrJavaSupport::c_str(jstring string, Thread* t) {
471 DEBUG_ONLY(check_java_thread_in_vm(t));
472 if (string == NULL) {
473 return NULL;
474 }
475 const char* temp = NULL;
476 const oop java_string = resolve_non_null(string);
477 const typeArrayOop value = java_lang_String::value(java_string);
478 if (value != NULL) {
479 const size_t length = java_lang_String::utf8_length(java_string, value);
480 temp = NEW_RESOURCE_ARRAY_IN_THREAD(t, const char, (length + 1));
481 if (temp == NULL) {
482 JfrJavaSupport::throw_out_of_memory_error("Unable to allocate thread local native memory", t);
483 return NULL;
484 }
485 assert(temp != NULL, "invariant");
486 java_lang_String::as_utf8_string(java_string, value, const_cast<char*>(temp), (int) length + 1);
487 }
488 return temp;
489 }
490
491 /*
492 * Exceptions and errors
493 */
create_and_throw(Symbol * name,const char * message,TRAPS)494 static void create_and_throw(Symbol* name, const char* message, TRAPS) {
495 assert(name != NULL, "invariant");
496 DEBUG_ONLY(JfrJavaSupport::check_java_thread_in_vm(THREAD));
497 assert(!HAS_PENDING_EXCEPTION, "invariant");
498 THROW_MSG(name, message);
499 }
500
throw_illegal_state_exception(const char * message,TRAPS)501 void JfrJavaSupport::throw_illegal_state_exception(const char* message, TRAPS) {
502 create_and_throw(vmSymbols::java_lang_IllegalStateException(), message, THREAD);
503 }
504
throw_internal_error(const char * message,TRAPS)505 void JfrJavaSupport::throw_internal_error(const char* message, TRAPS) {
506 create_and_throw(vmSymbols::java_lang_InternalError(), message, THREAD);
507 }
508
throw_illegal_argument_exception(const char * message,TRAPS)509 void JfrJavaSupport::throw_illegal_argument_exception(const char* message, TRAPS) {
510 create_and_throw(vmSymbols::java_lang_IllegalArgumentException(), message, THREAD);
511 }
512
throw_out_of_memory_error(const char * message,TRAPS)513 void JfrJavaSupport::throw_out_of_memory_error(const char* message, TRAPS) {
514 create_and_throw(vmSymbols::java_lang_OutOfMemoryError(), message, THREAD);
515 }
516
throw_class_format_error(const char * message,TRAPS)517 void JfrJavaSupport::throw_class_format_error(const char* message, TRAPS) {
518 create_and_throw(vmSymbols::java_lang_ClassFormatError(), message, THREAD);
519 }
520
throw_runtime_exception(const char * message,TRAPS)521 void JfrJavaSupport::throw_runtime_exception(const char* message, TRAPS) {
522 create_and_throw(vmSymbols::java_lang_RuntimeException(), message, THREAD);
523 }
524
abort(jstring errorMsg,Thread * t)525 void JfrJavaSupport::abort(jstring errorMsg, Thread* t) {
526 DEBUG_ONLY(check_java_thread_in_vm(t));
527
528 ResourceMark rm(t);
529 const char* const error_msg = c_str(errorMsg, t);
530 if (error_msg != NULL) {
531 log_error(jfr, system)("%s",error_msg);
532 }
533 log_error(jfr, system)("%s", "An irrecoverable error in Jfr. Shutting down VM...");
534 vm_abort();
535 }
536
537 JfrJavaSupport::CAUSE JfrJavaSupport::_cause = JfrJavaSupport::VM_ERROR;
set_cause(jthrowable throwable,Thread * t)538 void JfrJavaSupport::set_cause(jthrowable throwable, Thread* t) {
539 DEBUG_ONLY(check_java_thread_in_vm(t));
540
541 HandleMark hm(t);
542 Handle ex(t, JNIHandles::resolve_external_guard(throwable));
543
544 if (ex.is_null()) {
545 return;
546 }
547
548 if (ex->is_a(SystemDictionary::OutOfMemoryError_klass())) {
549 _cause = OUT_OF_MEMORY;
550 return;
551 }
552 if (ex->is_a(SystemDictionary::StackOverflowError_klass())) {
553 _cause = STACK_OVERFLOW;
554 return;
555 }
556 if (ex->is_a(SystemDictionary::Error_klass())) {
557 _cause = VM_ERROR;
558 return;
559 }
560 if (ex->is_a(SystemDictionary::RuntimeException_klass())) {
561 _cause = RUNTIME_EXCEPTION;
562 return;
563 }
564 if (ex->is_a(SystemDictionary::Exception_klass())) {
565 _cause = UNKNOWN;
566 return;
567 }
568 }
569
uncaught_exception(jthrowable throwable,Thread * t)570 void JfrJavaSupport::uncaught_exception(jthrowable throwable, Thread* t) {
571 DEBUG_ONLY(check_java_thread_in_vm(t));
572 assert(throwable != NULL, "invariant");
573 set_cause(throwable, t);
574 }
575
cause()576 JfrJavaSupport::CAUSE JfrJavaSupport::cause() {
577 return _cause;
578 }
579
580 const char* const JDK_JFR_MODULE_NAME = "jdk.jfr";
581 const char* const JDK_JFR_PACKAGE_NAME = "jdk/jfr";
582
is_jdk_jfr_module_in_readability_graph()583 static bool is_jdk_jfr_module_in_readability_graph() {
584 Thread* const t = Thread::current();
585 // take one of the packages in the module to be located and query for its definition.
586 TempNewSymbol pkg_sym = SymbolTable::new_symbol(JDK_JFR_PACKAGE_NAME);
587 return Modules::is_package_defined(pkg_sym, Handle(), t);
588 }
589
print_module_resolution_error(outputStream * stream)590 static void print_module_resolution_error(outputStream* stream) {
591 assert(stream != NULL, "invariant");
592 stream->print_cr("Module %s not found.", JDK_JFR_MODULE_NAME);
593 stream->print_cr("Flight Recorder can not be enabled.");
594 }
595
is_jdk_jfr_module_available()596 bool JfrJavaSupport::is_jdk_jfr_module_available() {
597 return is_jdk_jfr_module_in_readability_graph();
598 }
599
is_jdk_jfr_module_available(outputStream * stream,TRAPS)600 bool JfrJavaSupport::is_jdk_jfr_module_available(outputStream* stream, TRAPS) {
601 if (!JfrJavaSupport::is_jdk_jfr_module_available()) {
602 if (stream != NULL) {
603 print_module_resolution_error(stream);
604 }
605 return false;
606 }
607 return true;
608 }
609
jfr_thread_id(jobject target_thread)610 jlong JfrJavaSupport::jfr_thread_id(jobject target_thread) {
611 ThreadsListHandle tlh;
612 JavaThread* native_thread = NULL;
613 (void)tlh.cv_internal_thread_to_JavaThread(target_thread, &native_thread, NULL);
614 return native_thread != NULL ? JFR_THREAD_ID(native_thread) : 0;
615 }
616