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_MUTEXLOCKER_HPP
26#define SHARE_RUNTIME_MUTEXLOCKER_HPP
27
28#include "memory/allocation.hpp"
29#include "runtime/flags/flagSetting.hpp"
30#include "runtime/mutex.hpp"
31
32// Mutexes used in the VM.
33
34extern Mutex* Patching_lock; // a lock used to guard code patching of compiled code
35extern Monitor* SystemDictionary_lock; // a lock on the system dictionary
36extern Mutex* ProtectionDomainSet_lock; // a lock on the pd_set list in the system dictionary
37extern Mutex* SharedDictionary_lock; // a lock on the CDS shared dictionary
38extern Mutex* Module_lock; // a lock on module and package related data structures
39extern Mutex* CompiledIC_lock; // a lock used to guard compiled IC patching and access
40extern Mutex* InlineCacheBuffer_lock; // a lock used to guard the InlineCacheBuffer
41extern Mutex* VMStatistic_lock; // a lock used to guard statistics count increment
42extern Mutex* JNIGlobalAlloc_lock; // JNI global storage allocate list lock
43extern Mutex* JNIGlobalActive_lock; // JNI global storage active list lock
44extern Mutex* JNIWeakAlloc_lock; // JNI weak storage allocate list lock
45extern Mutex* JNIWeakActive_lock; // JNI weak storage active list lock
46extern Mutex* StringTableWeakAlloc_lock; // StringTable weak storage allocate list lock
47extern Mutex* StringTableWeakActive_lock; // STringTable weak storage active list lock
48extern Mutex* JNIHandleBlockFreeList_lock; // a lock on the JNI handle block free list
49extern Mutex* VMWeakAlloc_lock; // VM Weak Handles storage allocate list lock
50extern Mutex* VMWeakActive_lock; // VM Weak Handles storage active list lock
51extern Mutex* ResolvedMethodTableWeakAlloc_lock; // ResolvedMethodTable weak storage allocate list
52extern Mutex* ResolvedMethodTableWeakActive_lock; // ResolvedMethodTable weak storage active list
53extern Mutex* JmethodIdCreation_lock; // a lock on creating JNI method identifiers
54extern Mutex* JfieldIdCreation_lock; // a lock on creating JNI static field identifiers
55extern Monitor* JNICritical_lock; // a lock used while entering and exiting JNI critical regions, allows GC to sometimes get in
56extern Mutex* JvmtiThreadState_lock; // a lock on modification of JVMTI thread data
57extern Monitor* Heap_lock; // a lock on the heap
58extern Mutex* ExpandHeap_lock; // a lock on expanding the heap
59extern Mutex* AdapterHandlerLibrary_lock; // a lock on the AdapterHandlerLibrary
60extern Mutex* SignatureHandlerLibrary_lock; // a lock on the SignatureHandlerLibrary
61extern Mutex* VtableStubs_lock; // a lock on the VtableStubs
62extern Mutex* SymbolArena_lock; // a lock on the symbol table arena
63extern Monitor* StringDedupQueue_lock; // a lock on the string deduplication queue
64extern Mutex* StringDedupTable_lock; // a lock on the string deduplication table
65extern Monitor* CodeCache_lock; // a lock on the CodeCache, rank is special
66extern Mutex* MethodData_lock; // a lock on installation of method data
67extern Mutex* TouchedMethodLog_lock; // a lock on allocation of LogExecutedMethods info
68extern Mutex* RetData_lock; // a lock on installation of RetData inside method data
69extern Monitor* CGCPhaseManager_lock; // a lock to protect a concurrent GC's phase management
70extern Monitor* VMOperationQueue_lock; // a lock on queue of vm_operations waiting to execute
71extern Monitor* VMOperationRequest_lock; // a lock on Threads waiting for a vm_operation to terminate
72extern Monitor* Threads_lock; // a lock on the Threads table of active Java threads
73 // (also used by Safepoints too to block threads creation/destruction)
74extern Mutex* NonJavaThreadsList_lock; // a lock on the NonJavaThreads list
75extern Mutex* NonJavaThreadsListSync_lock; // a lock for NonJavaThreads list synchronization
76extern Monitor* CGC_lock; // used for coordination between
77 // fore- & background GC threads.
78extern Monitor* STS_lock; // used for joining/leaving SuspendibleThreadSet.
79extern Monitor* FullGCCount_lock; // in support of "concurrent" full gc
80extern Monitor* SATB_Q_CBL_mon; // Protects SATB Q
81 // completed buffer queue.
82extern Monitor* DirtyCardQ_CBL_mon; // Protects dirty card Q
83 // completed buffer queue.
84extern Mutex* Shared_DirtyCardQ_lock; // Lock protecting dirty card
85 // queue shared by
86 // non-Java threads.
87extern Mutex* MarkStackFreeList_lock; // Protects access to the global mark stack free list.
88extern Mutex* MarkStackChunkList_lock; // Protects access to the global mark stack chunk list.
89extern Mutex* MonitoringSupport_lock; // Protects updates to the serviceability memory pools.
90extern Mutex* ParGCRareEvent_lock; // Synchronizes various (rare) parallel GC ops.
91extern Mutex* Compile_lock; // a lock held when Compilation is updating code (used to block CodeCache traversal, CHA updates, etc)
92extern Monitor* MethodCompileQueue_lock; // a lock held when method compilations are enqueued, dequeued
93extern Monitor* CompileThread_lock; // a lock held by compile threads during compilation system initialization
94extern Monitor* Compilation_lock; // a lock used to pause compilation
95extern Mutex* CompileTaskAlloc_lock; // a lock held when CompileTasks are allocated
96extern Mutex* CompileStatistics_lock; // a lock held when updating compilation statistics
97extern Mutex* DirectivesStack_lock; // a lock held when mutating the dirstack and ref counting directives
98extern Mutex* MultiArray_lock; // a lock used to guard allocation of multi-dim arrays
99extern Monitor* Terminator_lock; // a lock used to guard termination of the vm
100extern Monitor* InitCompleted_lock; // a lock used to signal threads waiting on init completed
101extern Monitor* BeforeExit_lock; // a lock used to guard cleanups and shutdown hooks
102extern Monitor* Notify_lock; // a lock used to synchronize the start-up of the vm
103extern Mutex* ProfilePrint_lock; // a lock used to serialize the printing of profiles
104extern Mutex* ExceptionCache_lock; // a lock used to synchronize exception cache updates
105extern Mutex* OsrList_lock; // a lock used to serialize access to OSR queues
106extern Mutex* NMethodSweeperStats_lock; // a lock used to serialize access to sweeper statistics
107
108#ifndef PRODUCT
109extern Mutex* FullGCALot_lock; // a lock to make FullGCALot MT safe
110#endif // PRODUCT
111extern Mutex* Debug1_lock; // A bunch of pre-allocated locks that can be used for tracing
112extern Mutex* Debug2_lock; // down synchronization related bugs!
113extern Mutex* Debug3_lock;
114
115extern Mutex* RawMonitor_lock;
116extern Mutex* PerfDataMemAlloc_lock; // a lock on the allocator for PerfData memory for performance data
117extern Mutex* PerfDataManager_lock; // a long on access to PerfDataManager resources
118extern Mutex* ParkerFreeList_lock;
119extern Mutex* OopMapCacheAlloc_lock; // protects allocation of oop_map caches
120
121extern Mutex* FreeList_lock; // protects the free region list during safepoints
122extern Mutex* OldSets_lock; // protects the old region sets
123extern Monitor* RootRegionScan_lock; // used to notify that the CM threads have finished scanning the IM snapshot regions
124
125extern Mutex* Management_lock; // a lock used to serialize JVM management
126extern Monitor* Service_lock; // a lock used for service thread operation
127extern Monitor* PeriodicTask_lock; // protects the periodic task structure
128extern Monitor* RedefineClasses_lock; // locks classes from parallel redefinition
129extern Monitor* ThreadsSMRDelete_lock; // Used by ThreadsSMRSupport to take pressure off the Threads_lock
130extern Mutex* SharedDecoder_lock; // serializes access to the decoder during normal (not error reporting) use
131extern Mutex* DCmdFactory_lock; // serialize access to DCmdFactory information
132#if INCLUDE_NMT
133extern Mutex* NMTQuery_lock; // serialize NMT Dcmd queries
134#endif
135#if INCLUDE_CDS
136#if INCLUDE_JVMTI
137extern Mutex* CDSClassFileStream_lock; // FileMapInfo::open_stream_for_jvmti
138#endif
139extern Mutex* DumpTimeTable_lock; // SystemDictionaryShared::find_or_allocate_info_for
140#endif // INCLUDE_CDS
141#if INCLUDE_JFR
142extern Mutex* JfrStacktrace_lock; // used to guard access to the JFR stacktrace table
143extern Monitor* JfrMsg_lock; // protects JFR messaging
144extern Mutex* JfrBuffer_lock; // protects JFR buffer operations
145extern Mutex* JfrStream_lock; // protects JFR stream access
146extern Monitor* JfrThreadSampler_lock; // used to suspend/resume JFR thread sampler
147#endif
148
149#ifndef SUPPORTS_NATIVE_CX8
150extern Mutex* UnsafeJlong_lock; // provides Unsafe atomic updates to jlongs on platforms that don't support cx8
151#endif
152
153extern Mutex* MetaspaceExpand_lock; // protects Metaspace virtualspace and chunk expansions
154extern Mutex* ClassLoaderDataGraph_lock; // protects CLDG list, needed for concurrent unloading
155
156
157extern Monitor* CodeHeapStateAnalytics_lock; // lock print functions against concurrent analyze functions.
158 // Only used locally in PrintCodeCacheLayout processing.
159
160#if INCLUDE_JVMCI
161extern Monitor* JVMCI_lock; // Monitor to control initialization of JVMCI
162extern Mutex* JVMCIGlobalAlloc_lock; // JVMCI global storage allocate list lock
163extern Mutex* JVMCIGlobalActive_lock; // JVMCI global storage active list lock
164#endif
165
166// A MutexLocker provides mutual exclusion with respect to a given mutex
167// for the scope which contains the locker. The lock is an OS lock, not
168// an object lock, and the two do not interoperate. Do not use Mutex-based
169// locks to lock on Java objects, because they will not be respected if a
170// that object is locked using the Java locking mechanism.
171//
172// NOTE WELL!!
173//
174// See orderAccess.hpp. We assume throughout the VM that MutexLocker's
175// and friends constructors do a fence, a lock and an acquire *in that
176// order*. And that their destructors do a release and unlock, in *that*
177// order. If their implementations change such that these assumptions
178// are violated, a whole lot of code will break.
179
180// Print all mutexes/monitors that are currently owned by a thread; called
181// by fatal error handler.
182void print_owned_locks_on_error(outputStream* st);
183
184char *lock_name(Mutex *mutex);
185
186// for debugging: check that we're already owning this lock (or are at a safepoint)
187#ifdef ASSERT
188void assert_locked_or_safepoint(const Monitor * lock);
189void assert_locked_or_safepoint_weak(const Monitor * lock);
190void assert_lock_strong(const Monitor * lock);
191#else
192#define assert_locked_or_safepoint(lock)
193#define assert_locked_or_safepoint_weak(lock)
194#define assert_lock_strong(lock)
195#endif
196
197class MutexLocker: public StackObj {
198 protected:
199 Monitor* _mutex;
200 private:
201 public:
202 MutexLocker(Monitor* mutex, Mutex::SafepointCheckFlag flag = Mutex::_safepoint_check_flag) :
203 _mutex(mutex) {
204 bool no_safepoint_check = flag == Mutex::_no_safepoint_check_flag;
205 if (_mutex != NULL) {
206 assert(_mutex->rank() > Mutex::special || no_safepoint_check,
207 "Mutexes with rank special or lower should not do safepoint checks");
208 if (no_safepoint_check) {
209 _mutex->lock_without_safepoint_check();
210 } else {
211 _mutex->lock();
212 }
213 }
214 }
215
216 MutexLocker(Monitor* mutex, Thread* thread, Mutex::SafepointCheckFlag flag = Mutex::_safepoint_check_flag) :
217 _mutex(mutex) {
218 bool no_safepoint_check = flag == Mutex::_no_safepoint_check_flag;
219 if (_mutex != NULL) {
220 assert(_mutex->rank() > Mutex::special || no_safepoint_check,
221 "Mutexes with rank special or lower should not do safepoint checks");
222 if (no_safepoint_check) {
223 _mutex->lock_without_safepoint_check(thread);
224 } else {
225 _mutex->lock(thread);
226 }
227 }
228 }
229
230 ~MutexLocker() {
231 if (_mutex != NULL) {
232 assert_lock_strong(_mutex);
233 _mutex->unlock();
234 }
235 }
236};
237
238// A MonitorLocker is like a MutexLocker above, except it allows
239// wait/notify as well which are delegated to the underlying Monitor.
240// It also disallows NULL.
241
242class MonitorLocker: public MutexLocker {
243 Mutex::SafepointCheckFlag _flag;
244 public:
245 MonitorLocker(Monitor* monitor, Mutex::SafepointCheckFlag flag = Mutex::_safepoint_check_flag) :
246 MutexLocker(monitor, flag), _flag(flag) {
247 // Superclass constructor did locking
248 assert(_mutex != NULL, "NULL monitor not allowed");
249 }
250
251 MonitorLocker(Monitor* monitor, Thread* thread, Mutex::SafepointCheckFlag flag = Mutex::_safepoint_check_flag) :
252 MutexLocker(monitor, thread, flag), _flag(flag) {
253 // Superclass constructor did locking
254 assert(_mutex != NULL, "NULL monitor not allowed");
255 }
256
257 bool wait(long timeout = 0,
258 bool as_suspend_equivalent = !Mutex::_as_suspend_equivalent_flag) {
259 if (_flag == Mutex::_safepoint_check_flag) {
260 return _mutex->wait(timeout, as_suspend_equivalent);
261 } else {
262 return _mutex->wait_without_safepoint_check(timeout);
263 }
264 return false;
265 }
266
267 void notify_all() {
268 _mutex->notify_all();
269 }
270
271 void notify() {
272 _mutex->notify();
273 }
274};
275
276
277// A GCMutexLocker is usually initialized with a mutex that is
278// automatically acquired in order to do GC. The function that
279// synchronizes using a GCMutexLocker may be called both during and between
280// GC's. Thus, it must acquire the mutex if GC is not in progress, but not
281// if GC is in progress (since the mutex is already held on its behalf.)
282
283class GCMutexLocker: public StackObj {
284private:
285 Monitor* _mutex;
286 bool _locked;
287public:
288 GCMutexLocker(Monitor* mutex);
289 ~GCMutexLocker() { if (_locked) _mutex->unlock(); }
290};
291
292// A MutexUnlocker temporarily exits a previously
293// entered mutex for the scope which contains the unlocker.
294
295class MutexUnlocker: StackObj {
296 private:
297 Monitor* _mutex;
298 bool _no_safepoint_check;
299
300 public:
301 MutexUnlocker(Monitor* mutex, Mutex::SafepointCheckFlag flag = Mutex::_safepoint_check_flag) :
302 _mutex(mutex),
303 _no_safepoint_check(flag) {
304 _mutex->unlock();
305 }
306
307 ~MutexUnlocker() {
308 if (_no_safepoint_check) {
309 _mutex->lock_without_safepoint_check();
310 } else {
311 _mutex->lock();
312 }
313 }
314};
315
316#endif // SHARE_RUNTIME_MUTEXLOCKER_HPP
317