1/*
2 * Copyright (c) 1997, 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#ifndef SHARE_RUNTIME_INTERFACESUPPORT_INLINE_HPP
26#define SHARE_RUNTIME_INTERFACESUPPORT_INLINE_HPP
27
28#include "runtime/handles.inline.hpp"
29#include "runtime/mutexLocker.hpp"
30#include "runtime/orderAccess.hpp"
31#include "runtime/os.hpp"
32#include "runtime/safepointMechanism.inline.hpp"
33#include "runtime/safepointVerifiers.hpp"
34#include "runtime/thread.hpp"
35#include "runtime/vmOperations.hpp"
36#include "utilities/globalDefinitions.hpp"
37#include "utilities/histogram.hpp"
38#include "utilities/macros.hpp"
39#include "utilities/preserveException.hpp"
40
41// Wrapper for all entry points to the virtual machine.
42
43// InterfaceSupport provides functionality used by the VM_LEAF_BASE and
44// VM_ENTRY_BASE macros. These macros are used to guard entry points into
45// the VM and perform checks upon leave of the VM.
46
47
48class InterfaceSupport: AllStatic {
49# ifdef ASSERT
50 public:
51 static long _scavenge_alot_counter;
52 static long _fullgc_alot_counter;
53 static long _number_of_calls;
54 static long _fullgc_alot_invocation;
55
56 // Helper methods used to implement +ScavengeALot and +FullGCALot
57 static void check_gc_alot() { if (ScavengeALot || FullGCALot) gc_alot(); }
58 static void gc_alot();
59
60 static void walk_stack_from(vframe* start_vf);
61 static void walk_stack();
62
63 static void zombieAll();
64 static void deoptimizeAll();
65 static void stress_derived_pointers();
66 static void verify_stack();
67 static void verify_last_frame();
68# endif
69};
70
71
72// Basic class for all thread transition classes.
73
74class ThreadStateTransition : public StackObj {
75 protected:
76 JavaThread* _thread;
77 public:
78 ThreadStateTransition(JavaThread *thread) {
79 _thread = thread;
80 assert(thread != NULL && thread->is_Java_thread(), "must be Java thread");
81 }
82
83 // Change threadstate in a manner, so safepoint can detect changes.
84 // Time-critical: called on exit from every runtime routine
85 static inline void transition(JavaThread *thread, JavaThreadState from, JavaThreadState to) {
86 assert(from != _thread_in_Java, "use transition_from_java");
87 assert(from != _thread_in_native, "use transition_from_native");
88 assert((from & 1) == 0 && (to & 1) == 0, "odd numbers are transitions states");
89 assert(thread->thread_state() == from, "coming from wrong thread state");
90 // Change to transition state and ensure it is seen by the VM thread.
91 thread->set_thread_state_fence((JavaThreadState)(from + 1));
92
93 SafepointMechanism::block_if_requested(thread);
94 thread->set_thread_state(to);
95
96 CHECK_UNHANDLED_OOPS_ONLY(thread->clear_unhandled_oops();)
97 }
98
99 // Same as above, but assumes from = _thread_in_Java. This is simpler, since we
100 // never block on entry to the VM. This will break the code, since e.g. preserve arguments
101 // have not been setup.
102 static inline void transition_from_java(JavaThread *thread, JavaThreadState to) {
103 assert(thread->thread_state() == _thread_in_Java, "coming from wrong thread state");
104 thread->set_thread_state(to);
105 }
106
107 static inline void transition_from_native(JavaThread *thread, JavaThreadState to) {
108 assert((to & 1) == 0, "odd numbers are transitions states");
109 assert(thread->thread_state() == _thread_in_native, "coming from wrong thread state");
110 // Change to transition state and ensure it is seen by the VM thread.
111 thread->set_thread_state_fence(_thread_in_native_trans);
112
113 // We never install asynchronous exceptions when coming (back) in
114 // to the runtime from native code because the runtime is not set
115 // up to handle exceptions floating around at arbitrary points.
116 if (SafepointMechanism::should_block(thread) || thread->is_suspend_after_native()) {
117 JavaThread::check_safepoint_and_suspend_for_native_trans(thread);
118 }
119
120 thread->set_thread_state(to);
121 }
122 protected:
123 void trans(JavaThreadState from, JavaThreadState to) { transition(_thread, from, to); }
124 void trans_from_java(JavaThreadState to) { transition_from_java(_thread, to); }
125 void trans_from_native(JavaThreadState to) { transition_from_native(_thread, to); }
126};
127
128class ThreadInVMForHandshake : public ThreadStateTransition {
129 const JavaThreadState _original_state;
130
131 void transition_back() {
132 // This can be invoked from transition states and must return to the original state properly
133 assert(_thread->thread_state() == _thread_in_vm, "should only call when leaving VM after handshake");
134 // Change to transition state and ensure it is seen by the VM thread.
135 _thread->set_thread_state_fence(_thread_in_vm_trans);
136
137 SafepointMechanism::block_if_requested(_thread);
138
139 _thread->set_thread_state(_original_state);
140
141 if (_original_state != _thread_blocked_trans && _original_state != _thread_in_vm_trans &&
142 _thread->has_special_runtime_exit_condition()) {
143 _thread->handle_special_runtime_exit_condition(
144 !_thread->is_at_poll_safepoint() && (_original_state != _thread_in_native_trans));
145 }
146 }
147
148 public:
149
150 ThreadInVMForHandshake(JavaThread* thread) : ThreadStateTransition(thread),
151 _original_state(thread->thread_state()) {
152
153 if (thread->has_last_Java_frame()) {
154 thread->frame_anchor()->make_walkable(thread);
155 }
156
157 thread->set_thread_state(_thread_in_vm);
158 }
159
160 ~ThreadInVMForHandshake() {
161 transition_back();
162 }
163
164};
165
166class ThreadInVMfromJava : public ThreadStateTransition {
167 public:
168 ThreadInVMfromJava(JavaThread* thread) : ThreadStateTransition(thread) {
169 trans_from_java(_thread_in_vm);
170 }
171 ~ThreadInVMfromJava() {
172 if (_thread->stack_yellow_reserved_zone_disabled()) {
173 _thread->enable_stack_yellow_reserved_zone();
174 }
175 trans(_thread_in_vm, _thread_in_Java);
176 // Check for pending. async. exceptions or suspends.
177 if (_thread->has_special_runtime_exit_condition()) _thread->handle_special_runtime_exit_condition();
178 }
179};
180
181
182class ThreadInVMfromUnknown {
183 JavaThread* _thread;
184 public:
185 ThreadInVMfromUnknown() : _thread(NULL) {
186 Thread* t = Thread::current();
187 if (t->is_Java_thread()) {
188 JavaThread* t2 = (JavaThread*) t;
189 if (t2->thread_state() == _thread_in_native) {
190 _thread = t2;
191 ThreadStateTransition::transition_from_native(t2, _thread_in_vm);
192 // Used to have a HandleMarkCleaner but that is dangerous as
193 // it could free a handle in our (indirect, nested) caller.
194 // We expect any handles will be short lived and figure we
195 // don't need an actual HandleMark.
196 }
197 }
198 }
199 ~ThreadInVMfromUnknown() {
200 if (_thread) {
201 ThreadStateTransition::transition(_thread, _thread_in_vm, _thread_in_native);
202 }
203 }
204};
205
206
207class ThreadInVMfromNative : public ThreadStateTransition {
208 public:
209 ThreadInVMfromNative(JavaThread* thread) : ThreadStateTransition(thread) {
210 trans_from_native(_thread_in_vm);
211 }
212 ~ThreadInVMfromNative() {
213 trans(_thread_in_vm, _thread_in_native);
214 }
215};
216
217
218class ThreadToNativeFromVM : public ThreadStateTransition {
219 public:
220 ThreadToNativeFromVM(JavaThread *thread) : ThreadStateTransition(thread) {
221 // We are leaving the VM at this point and going directly to native code.
222 // Block, if we are in the middle of a safepoint synchronization.
223 assert(!thread->owns_locks(), "must release all locks when leaving VM");
224 thread->frame_anchor()->make_walkable(thread);
225 trans(_thread_in_vm, _thread_in_native);
226 // Check for pending. async. exceptions or suspends.
227 if (_thread->has_special_runtime_exit_condition()) _thread->handle_special_runtime_exit_condition(false);
228 }
229
230 ~ThreadToNativeFromVM() {
231 trans_from_native(_thread_in_vm);
232 assert(!_thread->is_pending_jni_exception_check(), "Pending JNI Exception Check");
233 // We don't need to clear_walkable because it will happen automagically when we return to java
234 }
235};
236
237
238class ThreadBlockInVM : public ThreadStateTransition {
239 public:
240 ThreadBlockInVM(JavaThread *thread)
241 : ThreadStateTransition(thread) {
242 // Once we are blocked vm expects stack to be walkable
243 thread->frame_anchor()->make_walkable(thread);
244 trans(_thread_in_vm, _thread_blocked);
245 }
246 ~ThreadBlockInVM() {
247 trans(_thread_blocked, _thread_in_vm);
248 OrderAccess::cross_modify_fence();
249 // We don't need to clear_walkable because it will happen automagically when we return to java
250 }
251};
252
253// Unlike ThreadBlockInVM, this class is designed to avoid certain deadlock scenarios while making
254// transitions inside class Monitor in cases where we need to block for a safepoint or handshake. It
255// receives an extra argument compared to ThreadBlockInVM, the address of a pointer to the monitor we
256// are trying to acquire. This will be used to access and release the monitor if needed to avoid
257// said deadlocks.
258// It works like ThreadBlockInVM but differs from it in two ways:
259// - When transitioning in (constructor), it checks for safepoints without blocking, i.e., calls
260// back if needed to allow a pending safepoint to continue but does not block in it.
261// - When transitioning back (destructor), if there is a pending safepoint or handshake it releases
262// the monitor that is only partially acquired.
263class ThreadBlockInVMWithDeadlockCheck : public ThreadStateTransition {
264 private:
265 Monitor** _in_flight_monitor_adr;
266
267 void release_monitor() {
268 assert(_in_flight_monitor_adr != NULL, "_in_flight_monitor_adr should have been set on constructor");
269 Monitor* in_flight_monitor = *_in_flight_monitor_adr;
270 if (in_flight_monitor != NULL) {
271 in_flight_monitor->release_for_safepoint();
272 *_in_flight_monitor_adr = NULL;
273 }
274 }
275 public:
276 ThreadBlockInVMWithDeadlockCheck(JavaThread* thread, Monitor** in_flight_monitor_adr)
277 : ThreadStateTransition(thread), _in_flight_monitor_adr(in_flight_monitor_adr) {
278 // Once we are blocked vm expects stack to be walkable
279 thread->frame_anchor()->make_walkable(thread);
280
281 // All unsafe states are treated the same by the VMThread
282 // so we can skip the _thread_in_vm_trans state here. Since
283 // we don't read poll, it's enough to order the stores.
284 OrderAccess::storestore();
285
286 thread->set_thread_state(_thread_blocked);
287 }
288 ~ThreadBlockInVMWithDeadlockCheck() {
289 // Change to transition state and ensure it is seen by the VM thread.
290 _thread->set_thread_state_fence((JavaThreadState)(_thread_blocked_trans));
291
292 if (SafepointMechanism::should_block(_thread)) {
293 release_monitor();
294 SafepointMechanism::block_if_requested(_thread);
295 }
296
297 _thread->set_thread_state(_thread_in_vm);
298 OrderAccess::cross_modify_fence();
299 }
300};
301
302
303// This special transition class is only used to prevent asynchronous exceptions
304// from being installed on vm exit in situations where we can't tolerate them.
305// See bugs: 4324348, 4854693, 4998314, 5040492, 5050705.
306class ThreadInVMfromJavaNoAsyncException : public ThreadStateTransition {
307 public:
308 ThreadInVMfromJavaNoAsyncException(JavaThread* thread) : ThreadStateTransition(thread) {
309 trans_from_java(_thread_in_vm);
310 }
311 ~ThreadInVMfromJavaNoAsyncException() {
312 if (_thread->stack_yellow_reserved_zone_disabled()) {
313 _thread->enable_stack_yellow_reserved_zone();
314 }
315 trans(_thread_in_vm, _thread_in_Java);
316 // NOTE: We do not check for pending. async. exceptions.
317 // If we did and moved the pending async exception over into the
318 // pending exception field, we would need to deopt (currently C2
319 // only). However, to do so would require that we transition back
320 // to the _thread_in_vm state. Instead we postpone the handling of
321 // the async exception.
322
323
324 // Check for pending. suspends only.
325 if (_thread->has_special_runtime_exit_condition())
326 _thread->handle_special_runtime_exit_condition(false);
327 }
328};
329
330// Debug class instantiated in JRT_ENTRY and ITR_ENTRY macro.
331// Can be used to verify properties on enter/exit of the VM.
332
333#ifdef ASSERT
334class VMEntryWrapper {
335 public:
336 VMEntryWrapper();
337 ~VMEntryWrapper();
338};
339
340
341class VMNativeEntryWrapper {
342 public:
343 VMNativeEntryWrapper() {
344 if (GCALotAtAllSafepoints) InterfaceSupport::check_gc_alot();
345 }
346
347 ~VMNativeEntryWrapper() {
348 if (GCALotAtAllSafepoints) InterfaceSupport::check_gc_alot();
349 }
350};
351
352#endif
353
354
355// VM-internal runtime interface support
356
357// Definitions for JRT (Java (Compiler/Shared) Runtime)
358
359// JRT_LEAF currently can be called from either _thread_in_Java or
360// _thread_in_native mode. In _thread_in_native, it is ok
361// for another thread to trigger GC. The rest of the JRT_LEAF
362// rules apply.
363class JRTLeafVerifier : public NoSafepointVerifier {
364 static bool should_verify_GC();
365 public:
366#ifdef ASSERT
367 JRTLeafVerifier();
368 ~JRTLeafVerifier();
369#else
370 JRTLeafVerifier() {}
371 ~JRTLeafVerifier() {}
372#endif
373};
374
375#ifdef ASSERT
376
377class RuntimeHistogramElement : public HistogramElement {
378 public:
379 RuntimeHistogramElement(const char* name);
380};
381
382#define TRACE_CALL(result_type, header) \
383 InterfaceSupport::_number_of_calls++; \
384 if (CountRuntimeCalls) { \
385 static RuntimeHistogramElement* e = new RuntimeHistogramElement(#header); \
386 if (e != NULL) e->increment_count(); \
387 }
388#else
389#define TRACE_CALL(result_type, header) \
390 /* do nothing */
391#endif
392
393
394// LEAF routines do not lock, GC or throw exceptions
395
396#define VM_LEAF_BASE(result_type, header) \
397 TRACE_CALL(result_type, header) \
398 debug_only(NoHandleMark __hm;) \
399 os::verify_stack_alignment(); \
400 /* begin of body */
401
402#define VM_ENTRY_BASE_FROM_LEAF(result_type, header, thread) \
403 TRACE_CALL(result_type, header) \
404 debug_only(ResetNoHandleMark __rnhm;) \
405 HandleMarkCleaner __hm(thread); \
406 Thread* THREAD = thread; \
407 os::verify_stack_alignment(); \
408 /* begin of body */
409
410
411// ENTRY routines may lock, GC and throw exceptions
412
413#define VM_ENTRY_BASE(result_type, header, thread) \
414 TRACE_CALL(result_type, header) \
415 HandleMarkCleaner __hm(thread); \
416 Thread* THREAD = thread; \
417 os::verify_stack_alignment(); \
418 /* begin of body */
419
420
421// QUICK_ENTRY routines behave like ENTRY but without a handle mark
422
423#define VM_QUICK_ENTRY_BASE(result_type, header, thread) \
424 TRACE_CALL(result_type, header) \
425 debug_only(NoHandleMark __hm;) \
426 Thread* THREAD = thread; \
427 os::verify_stack_alignment(); \
428 /* begin of body */
429
430
431#define JRT_ENTRY(result_type, header) \
432 result_type header { \
433 ThreadInVMfromJava __tiv(thread); \
434 VM_ENTRY_BASE(result_type, header, thread) \
435 debug_only(VMEntryWrapper __vew;)
436
437
438#define JRT_LEAF(result_type, header) \
439 result_type header { \
440 VM_LEAF_BASE(result_type, header) \
441 debug_only(JRTLeafVerifier __jlv;)
442
443
444#define JRT_ENTRY_NO_ASYNC(result_type, header) \
445 result_type header { \
446 ThreadInVMfromJavaNoAsyncException __tiv(thread); \
447 VM_ENTRY_BASE(result_type, header, thread) \
448 debug_only(VMEntryWrapper __vew;)
449
450// Same as JRT Entry but allows for return value after the safepoint
451// to get back into Java from the VM
452#define JRT_BLOCK_ENTRY(result_type, header) \
453 result_type header { \
454 TRACE_CALL(result_type, header) \
455 HandleMarkCleaner __hm(thread);
456
457#define JRT_BLOCK \
458 { \
459 ThreadInVMfromJava __tiv(thread); \
460 Thread* THREAD = thread; \
461 debug_only(VMEntryWrapper __vew;)
462
463#define JRT_BLOCK_NO_ASYNC \
464 { \
465 ThreadInVMfromJavaNoAsyncException __tiv(thread); \
466 Thread* THREAD = thread; \
467 debug_only(VMEntryWrapper __vew;)
468
469#define JRT_BLOCK_END }
470
471#define JRT_END }
472
473// Definitions for JNI
474
475#define JNI_ENTRY(result_type, header) \
476 JNI_ENTRY_NO_PRESERVE(result_type, header) \
477 WeakPreserveExceptionMark __wem(thread);
478
479#define JNI_ENTRY_NO_PRESERVE(result_type, header) \
480extern "C" { \
481 result_type JNICALL header { \
482 JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
483 assert( !VerifyJNIEnvThread || (thread == Thread::current()), "JNIEnv is only valid in same thread"); \
484 ThreadInVMfromNative __tiv(thread); \
485 debug_only(VMNativeEntryWrapper __vew;) \
486 VM_ENTRY_BASE(result_type, header, thread)
487
488
489// Ensure that the VMNativeEntryWrapper constructor, which can cause
490// a GC, is called outside the NoHandleMark (set via VM_QUICK_ENTRY_BASE).
491#define JNI_QUICK_ENTRY(result_type, header) \
492extern "C" { \
493 result_type JNICALL header { \
494 JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
495 assert( !VerifyJNIEnvThread || (thread == Thread::current()), "JNIEnv is only valid in same thread"); \
496 ThreadInVMfromNative __tiv(thread); \
497 debug_only(VMNativeEntryWrapper __vew;) \
498 VM_QUICK_ENTRY_BASE(result_type, header, thread)
499
500
501#define JNI_LEAF(result_type, header) \
502extern "C" { \
503 result_type JNICALL header { \
504 JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
505 assert( !VerifyJNIEnvThread || (thread == Thread::current()), "JNIEnv is only valid in same thread"); \
506 VM_LEAF_BASE(result_type, header)
507
508
509// Close the routine and the extern "C"
510#define JNI_END } }
511
512
513
514// Definitions for JVM
515
516#define JVM_ENTRY(result_type, header) \
517extern "C" { \
518 result_type JNICALL header { \
519 JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
520 ThreadInVMfromNative __tiv(thread); \
521 debug_only(VMNativeEntryWrapper __vew;) \
522 VM_ENTRY_BASE(result_type, header, thread)
523
524
525#define JVM_ENTRY_NO_ENV(result_type, header) \
526extern "C" { \
527 result_type JNICALL header { \
528 JavaThread* thread = JavaThread::current(); \
529 ThreadInVMfromNative __tiv(thread); \
530 debug_only(VMNativeEntryWrapper __vew;) \
531 VM_ENTRY_BASE(result_type, header, thread)
532
533
534#define JVM_QUICK_ENTRY(result_type, header) \
535extern "C" { \
536 result_type JNICALL header { \
537 JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
538 ThreadInVMfromNative __tiv(thread); \
539 debug_only(VMNativeEntryWrapper __vew;) \
540 VM_QUICK_ENTRY_BASE(result_type, header, thread)
541
542
543#define JVM_LEAF(result_type, header) \
544extern "C" { \
545 result_type JNICALL header { \
546 VM_Exit::block_if_vm_exited(); \
547 VM_LEAF_BASE(result_type, header)
548
549
550#define JVM_ENTRY_FROM_LEAF(env, result_type, header) \
551 { { \
552 JavaThread* thread=JavaThread::thread_from_jni_environment(env); \
553 ThreadInVMfromNative __tiv(thread); \
554 debug_only(VMNativeEntryWrapper __vew;) \
555 VM_ENTRY_BASE_FROM_LEAF(result_type, header, thread)
556
557
558#define JVM_END } }
559
560#endif // SHARE_RUNTIME_INTERFACESUPPORT_INLINE_HPP
561