< prev index next >

src/hotspot/share/runtime/mutexLocker.cpp

Print this page




   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 "memory/universe.hpp"
  27 #include "runtime/mutexLocker.hpp"
  28 #include "runtime/os.inline.hpp"
  29 #include "runtime/safepoint.hpp"
  30 #include "runtime/thread.inline.hpp"
  31 #include "runtime/vmThread.hpp"
  32 
  33 // Mutexes used in the VM (see comment in mutexLocker.hpp):
  34 //
  35 // Note that the following pointers are effectively final -- after having been
  36 // set at JVM startup-time, they should never be subsequently mutated.
  37 // Instead of using pointers to malloc()ed monitors and mutexes we should consider
  38 // eliminating the indirection and using instances instead.
  39 // Consider using GCC's __read_mostly.
  40 
  41 Mutex*   Patching_lock                = NULL;
  42 Mutex*   CompiledMethod_lock          = NULL;
  43 Monitor* SystemDictionary_lock        = NULL;
  44 Mutex*   ProtectionDomainSet_lock     = NULL;
  45 Mutex*   SharedDictionary_lock        = NULL;
  46 Mutex*   Module_lock                  = NULL;
  47 Mutex*   CompiledIC_lock              = NULL;
  48 Mutex*   InlineCacheBuffer_lock       = NULL;
  49 Mutex*   VMStatistic_lock             = NULL;
  50 Mutex*   JNIGlobalAlloc_lock          = NULL;
  51 Mutex*   JNIGlobalActive_lock         = NULL;
  52 Mutex*   JNIWeakAlloc_lock            = NULL;
  53 Mutex*   JNIWeakActive_lock           = NULL;
  54 Mutex*   StringTableWeakAlloc_lock    = NULL;
  55 Mutex*   StringTableWeakActive_lock   = NULL;
  56 Mutex*   JNIHandleBlockFreeList_lock  = NULL;
  57 Mutex*   VMWeakAlloc_lock             = NULL;
  58 Mutex*   VMWeakActive_lock            = NULL;
  59 Mutex*   ResolvedMethodTableWeakAlloc_lock  = NULL;
  60 Mutex*   ResolvedMethodTableWeakActive_lock = NULL;
  61 Mutex*   JmethodIdCreation_lock       = NULL;
  62 Mutex*   JfieldIdCreation_lock        = NULL;
  63 Monitor* JNICritical_lock             = NULL;
  64 Mutex*   JvmtiThreadState_lock        = NULL;
  65 Monitor* Heap_lock                    = NULL;
  66 Mutex*   ExpandHeap_lock              = NULL;
  67 Mutex*   AdapterHandlerLibrary_lock   = NULL;
  68 Mutex*   SignatureHandlerLibrary_lock = NULL;
  69 Mutex*   VtableStubs_lock             = NULL;
  70 Mutex*   SymbolArena_lock             = NULL;
  71 Monitor* StringDedupQueue_lock        = NULL;
  72 Mutex*   StringDedupTable_lock        = NULL;
  73 Monitor* CodeCache_lock               = NULL;
  74 Mutex*   MethodData_lock              = NULL;
  75 Mutex*   TouchedMethodLog_lock        = NULL;
  76 Mutex*   RetData_lock                 = NULL;
  77 Monitor* VMOperationQueue_lock        = NULL;
  78 Monitor* VMOperationRequest_lock      = NULL;
  79 Monitor* SerializePage_lock           = NULL;
  80 Monitor* Threads_lock                 = NULL;
  81 Mutex*   NonJavaThreadsList_lock      = NULL;
  82 Mutex*   NonJavaThreadsListSync_lock  = NULL;
  83 Monitor* CGC_lock                     = NULL;
  84 Monitor* STS_lock                     = NULL;
  85 Monitor* FullGCCount_lock             = NULL;
  86 Monitor* SATB_Q_CBL_mon               = NULL;
  87 Monitor* DirtyCardQ_CBL_mon           = NULL;
  88 Mutex*   Shared_DirtyCardQ_lock       = NULL;
  89 Mutex*   MarkStackFreeList_lock       = NULL;
  90 Mutex*   MarkStackChunkList_lock      = NULL;
  91 Mutex*   MonitoringSupport_lock       = NULL;
  92 Mutex*   ParGCRareEvent_lock          = NULL;

  93 Monitor* CGCPhaseManager_lock         = NULL;
  94 Mutex*   Compile_lock                 = NULL;
  95 Monitor* MethodCompileQueue_lock      = NULL;
  96 Monitor* CompileThread_lock           = NULL;
  97 Monitor* Compilation_lock             = NULL;
  98 Mutex*   CompileTaskAlloc_lock        = NULL;
  99 Mutex*   CompileStatistics_lock       = NULL;
 100 Mutex*   DirectivesStack_lock         = NULL;
 101 Mutex*   MultiArray_lock              = NULL;
 102 Monitor* Terminator_lock              = NULL;
 103 Monitor* InitCompleted_lock           = NULL;
 104 Monitor* BeforeExit_lock              = NULL;
 105 Monitor* Notify_lock                  = NULL;
 106 Mutex*   ProfilePrint_lock            = NULL;
 107 Mutex*   ExceptionCache_lock          = NULL;
 108 Mutex*   OsrList_lock                 = NULL;
 109 Mutex*   NMethodSweeperStats_lock     = NULL;
 110 #ifndef PRODUCT
 111 Mutex*   FullGCALot_lock              = NULL;
 112 #endif


 137 Mutex*   JfrStacktrace_lock           = NULL;
 138 Monitor* JfrMsg_lock                  = NULL;
 139 Mutex*   JfrBuffer_lock               = NULL;
 140 Mutex*   JfrStream_lock               = NULL;
 141 Monitor* JfrThreadSampler_lock        = NULL;
 142 #endif
 143 
 144 #ifndef SUPPORTS_NATIVE_CX8
 145 Mutex*   UnsafeJlong_lock             = NULL;
 146 #endif
 147 Monitor* CodeHeapStateAnalytics_lock  = NULL;
 148 
 149 Mutex*   MetaspaceExpand_lock         = NULL;
 150 Mutex*   ClassLoaderDataGraph_lock    = NULL;
 151 Monitor* ThreadsSMRDelete_lock        = NULL;
 152 Mutex*   SharedDecoder_lock           = NULL;
 153 Mutex*   DCmdFactory_lock             = NULL;
 154 #if INCLUDE_NMT
 155 Mutex*   NMTQuery_lock                = NULL;
 156 #endif
 157 #if INCLUDE_CDS
 158 #if INCLUDE_JVMTI
 159 Mutex*   CDSClassFileStream_lock      = NULL;
 160 #endif
 161 Mutex*   DumpTimeTable_lock           = NULL;
 162 #endif // INCLUDE_CDS
 163 
 164 #if INCLUDE_JVMCI
 165 Monitor* JVMCI_lock                   = NULL;
 166 Mutex*   JVMCIGlobalAlloc_lock        = NULL;
 167 Mutex*   JVMCIGlobalActive_lock       = NULL;
 168 #endif
 169 
 170 
 171 #define MAX_NUM_MUTEX 128
 172 static Monitor * _mutex_array[MAX_NUM_MUTEX];
 173 static int _num_mutex;
 174 
 175 #ifdef ASSERT
 176 void assert_locked_or_safepoint(const Monitor * lock) {
 177   // check if this thread owns the lock (common case)
 178   if (IgnoreLockingAssertions) return;
 179   assert(lock != NULL, "Need non-NULL lock");
 180   if (lock->owned_by_self()) return;
 181   if (SafepointSynchronize::is_at_safepoint()) return;
 182   if (!Universe::is_fully_initialized()) return;
 183   // see if invoker of VM operation owns it
 184   VM_Operation* op = VMThread::vm_operation();
 185   if (op != NULL && op->calling_thread() == lock->owner()) return;
 186   fatal("must own lock %s", lock->name());
 187 }
 188 
 189 // a weaker assertion than the above


 207 
 208 #define def(var, type, pri, vm_block, safepoint_check_allowed ) {      \
 209   var = new type(Mutex::pri, #var, vm_block, safepoint_check_allowed); \
 210   assert(_num_mutex < MAX_NUM_MUTEX, "increase MAX_NUM_MUTEX");        \
 211   _mutex_array[_num_mutex++] = var;                                      \
 212 }
 213 
 214 // Using Padded subclasses to prevent false sharing of these global monitors and mutexes.
 215 void mutex_init() {
 216   def(tty_lock                     , PaddedMutex  , tty,         true,  Monitor::_safepoint_check_never);      // allow to lock in VM
 217 
 218   def(CGC_lock                     , PaddedMonitor, special,     true,  Monitor::_safepoint_check_never);      // coordinate between fore- and background GC
 219   def(STS_lock                     , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);
 220 
 221   def(VMWeakAlloc_lock             , PaddedMutex  , vmweak,      true,  Monitor::_safepoint_check_never);
 222   def(VMWeakActive_lock            , PaddedMutex  , vmweak-1,    true,  Monitor::_safepoint_check_never);
 223 
 224   def(StringTableWeakAlloc_lock    , PaddedMutex  , vmweak,      true,  Monitor::_safepoint_check_never);
 225   def(StringTableWeakActive_lock   , PaddedMutex  , vmweak-1,    true,  Monitor::_safepoint_check_never);
 226 
 227   def(ResolvedMethodTableWeakAlloc_lock    , PaddedMutex  , vmweak,      true,  Monitor::_safepoint_check_never);
 228   def(ResolvedMethodTableWeakActive_lock   , PaddedMutex  , vmweak-1,    true,  Monitor::_safepoint_check_never);
 229 
 230   def(FullGCCount_lock             , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);      // in support of ExplicitGCInvokesConcurrent
 231   if (UseG1GC) {
 232     def(SATB_Q_CBL_mon             , PaddedMonitor, access,      true,  Monitor::_safepoint_check_never);
 233 
 234     def(DirtyCardQ_CBL_mon         , PaddedMonitor, access,      true,  Monitor::_safepoint_check_never);
 235     def(Shared_DirtyCardQ_lock     , PaddedMutex  , access + 1,  true,  Monitor::_safepoint_check_never);
 236 
 237     def(FreeList_lock              , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_never);
 238     def(OldSets_lock               , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_never);
 239     def(RootRegionScan_lock        , PaddedMonitor, leaf     ,   true,  Monitor::_safepoint_check_never);
 240 
 241     def(StringDedupQueue_lock      , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);
 242     def(StringDedupTable_lock      , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 243 
 244     def(MarkStackFreeList_lock     , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_never);
 245     def(MarkStackChunkList_lock    , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_never);
 246 
 247     def(MonitoringSupport_lock     , PaddedMutex  , native   ,   true,  Monitor::_safepoint_check_never);      // used for serviceability monitoring support
 248   }
 249   if (UseShenandoahGC) {
 250     def(SATB_Q_CBL_mon             , PaddedMonitor, access,      true,  Monitor::_safepoint_check_never);
 251 
 252     def(StringDedupQueue_lock      , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);
 253     def(StringDedupTable_lock      , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 254   }
 255   def(ParGCRareEvent_lock          , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_always);
 256   def(CGCPhaseManager_lock         , PaddedMonitor, leaf,        false, Monitor::_safepoint_check_always);

 257   def(CodeCache_lock               , PaddedMutex  , special,     true,  Monitor::_safepoint_check_never);
 258   def(RawMonitor_lock              , PaddedMutex  , special,     true,  Monitor::_safepoint_check_never);
 259   def(OopMapCacheAlloc_lock        , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always); // used for oop_map_cache allocation.
 260 
 261   def(MetaspaceExpand_lock         , PaddedMutex  , leaf-1,      true,  Monitor::_safepoint_check_never);
 262   def(ClassLoaderDataGraph_lock    , PaddedMutex  , nonleaf,     true,  Monitor::_safepoint_check_always);
 263 
 264   def(Patching_lock                , PaddedMutex  , special,     true,  Monitor::_safepoint_check_never);      // used for safepointing and code patching.
 265   def(OsrList_lock                 , PaddedMutex  , special-1,   true,  Monitor::_safepoint_check_never);
 266   def(CompiledMethod_lock          , PaddedMutex  , special-1,   true,  Monitor::_safepoint_check_never);
 267   def(Service_lock                 , PaddedMonitor, special,     true,  Monitor::_safepoint_check_never);      // used for service thread operations
 268   def(JmethodIdCreation_lock       , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always); // used for creating jmethodIDs.
 269 
 270   def(SystemDictionary_lock        , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_always);
 271   def(ProtectionDomainSet_lock     , PaddedMutex  , leaf-1,      true,  Monitor::_safepoint_check_never);
 272   def(SharedDictionary_lock        , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always);
 273   def(Module_lock                  , PaddedMutex  , leaf+2,      true,  Monitor::_safepoint_check_always);
 274   def(InlineCacheBuffer_lock       , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 275   def(VMStatistic_lock             , PaddedMutex  , leaf,        false, Monitor::_safepoint_check_always);
 276   def(ExpandHeap_lock              , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always); // Used during compilation by VM thread
 277   def(JNIHandleBlockFreeList_lock  , PaddedMutex  , leaf-1,      true,  Monitor::_safepoint_check_never);      // handles are used by VM thread
 278   def(SignatureHandlerLibrary_lock , PaddedMutex  , leaf,        false, Monitor::_safepoint_check_always);
 279   def(SymbolArena_lock             , PaddedMutex  , leaf+2,      true,  Monitor::_safepoint_check_never);
 280   def(ProfilePrint_lock            , PaddedMutex  , leaf,        false, Monitor::_safepoint_check_always); // serial profile printing
 281   def(ExceptionCache_lock          , PaddedMutex  , leaf,        false, Monitor::_safepoint_check_always); // serial profile printing

 282   def(Debug1_lock                  , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 283 #ifndef PRODUCT
 284   def(FullGCALot_lock              , PaddedMutex  , leaf,        false, Monitor::_safepoint_check_always); // a lock to make FullGCALot MT safe
 285 #endif
 286   def(BeforeExit_lock              , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_always);
 287   def(PerfDataMemAlloc_lock        , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always); // used for allocating PerfData memory for performance data
 288   def(PerfDataManager_lock         , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always); // used for synchronized access to PerfDataManager resources
 289 
 290   // CMS_modUnionTable_lock                   leaf
 291   // CMS_bitMap_lock                          leaf 1
 292   // CMS_freeList_lock                        leaf 2
 293 
 294   def(Threads_lock                 , PaddedMonitor, barrier,     true,  Monitor::_safepoint_check_sometimes);  // Used for safepoint protocol.
 295   def(NonJavaThreadsList_lock      , PaddedMutex,   leaf,        true,  Monitor::_safepoint_check_never);
 296   def(NonJavaThreadsListSync_lock  , PaddedMutex,   leaf,        true,  Monitor::_safepoint_check_never);
 297 
 298   def(VMOperationQueue_lock        , PaddedMonitor, nonleaf,     true,  Monitor::_safepoint_check_never);  // VM_thread allowed to block on these
 299   def(VMOperationRequest_lock      , PaddedMonitor, nonleaf,     true,  Monitor::_safepoint_check_always);
 300   def(RetData_lock                 , PaddedMutex  , nonleaf,     false, Monitor::_safepoint_check_always);
 301   def(Terminator_lock              , PaddedMonitor, nonleaf,     true,  Monitor::_safepoint_check_always);
 302   def(InitCompleted_lock           , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);
 303   def(VtableStubs_lock             , PaddedMutex  , nonleaf,     true,  Monitor::_safepoint_check_never);
 304   def(Notify_lock                  , PaddedMonitor, nonleaf,     true,  Monitor::_safepoint_check_always);
 305   def(JNIGlobalAlloc_lock          , PaddedMutex  , nonleaf,     true,  Monitor::_safepoint_check_never);
 306   def(JNIGlobalActive_lock         , PaddedMutex  , nonleaf-1,   true,  Monitor::_safepoint_check_never);
 307   def(JNIWeakAlloc_lock            , PaddedMutex  , nonleaf,     true,  Monitor::_safepoint_check_never);
 308   def(JNIWeakActive_lock           , PaddedMutex  , nonleaf-1,   true,  Monitor::_safepoint_check_never);
 309   def(JNICritical_lock             , PaddedMonitor, nonleaf,     true,  Monitor::_safepoint_check_always); // used for JNI critical regions
 310   def(AdapterHandlerLibrary_lock   , PaddedMutex  , nonleaf,     true,  Monitor::_safepoint_check_always);
 311 
 312   def(Heap_lock                    , PaddedMonitor, nonleaf+1,   false, Monitor::_safepoint_check_sometimes);  // Doesn't safepoint check during termination.
 313   def(JfieldIdCreation_lock        , PaddedMutex  , nonleaf+1,   true,  Monitor::_safepoint_check_always); // jfieldID, Used in VM_Operation

 314 
 315   def(CompiledIC_lock              , PaddedMutex  , nonleaf+2,   false, Monitor::_safepoint_check_never);      // locks VtableStubs_lock, InlineCacheBuffer_lock
 316   def(CompileTaskAlloc_lock        , PaddedMutex  , nonleaf+2,   true,  Monitor::_safepoint_check_always);
 317   def(CompileStatistics_lock       , PaddedMutex  , nonleaf+2,   false, Monitor::_safepoint_check_always);
 318   def(DirectivesStack_lock         , PaddedMutex  , special,     true,  Monitor::_safepoint_check_never);
 319   def(MultiArray_lock              , PaddedMutex  , nonleaf+2,   false, Monitor::_safepoint_check_always);
 320 
 321   def(JvmtiThreadState_lock        , PaddedMutex  , nonleaf+2,   false, Monitor::_safepoint_check_always); // Used by JvmtiThreadState/JvmtiEventController
 322   def(Management_lock              , PaddedMutex  , nonleaf+2,   false, Monitor::_safepoint_check_always); // used for JVM management
 323 
 324   def(Compile_lock                 , PaddedMutex  , nonleaf+3,   true,  Monitor::_safepoint_check_always);
 325   def(MethodData_lock              , PaddedMutex  , nonleaf+3,   false, Monitor::_safepoint_check_always);
 326   def(TouchedMethodLog_lock        , PaddedMutex  , nonleaf+3,   false, Monitor::_safepoint_check_always);
 327 
 328   def(MethodCompileQueue_lock      , PaddedMonitor, nonleaf+4,   true,  Monitor::_safepoint_check_always);
 329   def(Debug2_lock                  , PaddedMutex  , nonleaf+4,   true,  Monitor::_safepoint_check_never);
 330   def(Debug3_lock                  , PaddedMutex  , nonleaf+4,   true,  Monitor::_safepoint_check_never);
 331   def(CompileThread_lock           , PaddedMonitor, nonleaf+5,   false, Monitor::_safepoint_check_always);
 332   def(PeriodicTask_lock            , PaddedMonitor, nonleaf+5,   true,  Monitor::_safepoint_check_always);
 333   def(RedefineClasses_lock         , PaddedMonitor, nonleaf+5,   true,  Monitor::_safepoint_check_always);
 334 
 335   if (WhiteBoxAPI) {
 336     def(Compilation_lock           , PaddedMonitor, leaf,        false, Monitor::_safepoint_check_never);
 337   }
 338 
 339 #if INCLUDE_JFR
 340   def(JfrMsg_lock                  , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_always);
 341   def(JfrBuffer_lock               , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 342   def(JfrStream_lock               , PaddedMutex  , leaf+1,      true,  Monitor::_safepoint_check_never);      // ensure to rank lower than 'safepoint'
 343   def(JfrStacktrace_lock           , PaddedMutex  , special,     true,  Monitor::_safepoint_check_never);
 344   def(JfrThreadSampler_lock        , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);
 345 #endif
 346 
 347 #ifndef SUPPORTS_NATIVE_CX8
 348   def(UnsafeJlong_lock             , PaddedMutex  , special,     false, Monitor::_safepoint_check_never);
 349 #endif
 350 
 351   def(CodeHeapStateAnalytics_lock  , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 352   def(NMethodSweeperStats_lock     , PaddedMutex  , special,     true,  Monitor::_safepoint_check_never);

 353   def(ThreadsSMRDelete_lock        , PaddedMonitor, special,     false, Monitor::_safepoint_check_never);
 354   def(SharedDecoder_lock           , PaddedMutex  , native,      false, Monitor::_safepoint_check_never);
 355   def(DCmdFactory_lock             , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 356 #if INCLUDE_NMT
 357   def(NMTQuery_lock                , PaddedMutex  , max_nonleaf, false, Monitor::_safepoint_check_always);
 358 #endif
 359 #if INCLUDE_CDS
 360 #if INCLUDE_JVMTI
 361   def(CDSClassFileStream_lock      , PaddedMutex  , max_nonleaf, false, Monitor::_safepoint_check_always);
 362 #endif
 363 
 364 #if INCLUDE_JVMCI
 365   def(JVMCI_lock                   , PaddedMonitor, nonleaf+2,   true,  Monitor::_safepoint_check_always);
 366   def(JVMCIGlobalAlloc_lock        , PaddedMutex  , nonleaf,     true,  Monitor::_safepoint_check_never);
 367   def(JVMCIGlobalActive_lock       , PaddedMutex  , nonleaf-1,   true,  Monitor::_safepoint_check_never);
 368 #endif
 369   def(DumpTimeTable_lock           , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 370 #endif // INCLUDE_CDS
 371 }
 372 
 373 GCMutexLocker::GCMutexLocker(Monitor * mutex) {
 374   if (SafepointSynchronize::is_at_safepoint()) {
 375     _locked = false;
 376   } else {
 377     _mutex = mutex;
 378     _locked = true;
 379     _mutex->lock();
 380   }
 381 }
 382 
 383 // Print all mutexes/monitors that are currently owned by a thread; called
 384 // by fatal error handler.
 385 void print_owned_locks_on_error(outputStream* st) {
 386   st->print("VM Mutex/Monitor currently owned by a thread: ");
 387   bool none = true;
 388   for (int i = 0; i < _num_mutex; i++) {
 389      // see if it has an owner
 390      if (_mutex_array[i]->owner() != NULL) {


   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 "runtime/mutexLocker.hpp"
  27 #include "runtime/os.inline.hpp"
  28 #include "runtime/safepoint.hpp"
  29 #include "runtime/thread.inline.hpp"
  30 #include "runtime/vmThread.hpp"
  31 
  32 // Mutexes used in the VM (see comment in mutexLocker.hpp):
  33 //
  34 // Note that the following pointers are effectively final -- after having been
  35 // set at JVM startup-time, they should never be subsequently mutated.
  36 // Instead of using pointers to malloc()ed monitors and mutexes we should consider
  37 // eliminating the indirection and using instances instead.
  38 // Consider using GCC's __read_mostly.
  39 
  40 Mutex*   Patching_lock                = NULL;

  41 Monitor* SystemDictionary_lock        = NULL;
  42 Mutex*   ProtectionDomainSet_lock     = NULL;
  43 Mutex*   SharedDictionary_lock        = NULL;
  44 Mutex*   Module_lock                  = NULL;
  45 Mutex*   CompiledIC_lock              = NULL;
  46 Mutex*   InlineCacheBuffer_lock       = NULL;
  47 Mutex*   VMStatistic_lock             = NULL;
  48 Mutex*   JNIGlobalAlloc_lock          = NULL;
  49 Mutex*   JNIGlobalActive_lock         = NULL;
  50 Mutex*   JNIWeakAlloc_lock            = NULL;
  51 Mutex*   JNIWeakActive_lock           = NULL;
  52 Mutex*   StringTableWeakAlloc_lock    = NULL;
  53 Mutex*   StringTableWeakActive_lock   = NULL;
  54 Mutex*   JNIHandleBlockFreeList_lock  = NULL;
  55 Mutex*   VMWeakAlloc_lock             = NULL;
  56 Mutex*   VMWeakActive_lock            = NULL;
  57 Mutex*   ResolvedMethodTable_lock     = NULL;

  58 Mutex*   JmethodIdCreation_lock       = NULL;
  59 Mutex*   JfieldIdCreation_lock        = NULL;
  60 Monitor* JNICritical_lock             = NULL;
  61 Mutex*   JvmtiThreadState_lock        = NULL;
  62 Monitor* Heap_lock                    = NULL;
  63 Mutex*   ExpandHeap_lock              = NULL;
  64 Mutex*   AdapterHandlerLibrary_lock   = NULL;
  65 Mutex*   SignatureHandlerLibrary_lock = NULL;
  66 Mutex*   VtableStubs_lock             = NULL;
  67 Mutex*   SymbolArena_lock             = NULL;
  68 Monitor* StringDedupQueue_lock        = NULL;
  69 Mutex*   StringDedupTable_lock        = NULL;
  70 Monitor* CodeCache_lock               = NULL;
  71 Mutex*   MethodData_lock              = NULL;
  72 Mutex*   TouchedMethodLog_lock        = NULL;
  73 Mutex*   RetData_lock                 = NULL;
  74 Monitor* VMOperationQueue_lock        = NULL;
  75 Monitor* VMOperationRequest_lock      = NULL;
  76 Monitor* SerializePage_lock           = NULL;
  77 Monitor* Threads_lock                 = NULL;
  78 Mutex*   NonJavaThreadsList_lock      = NULL;
  79 Mutex*   NonJavaThreadsListSync_lock  = NULL;
  80 Monitor* CGC_lock                     = NULL;
  81 Monitor* STS_lock                     = NULL;
  82 Monitor* FullGCCount_lock             = NULL;
  83 Monitor* SATB_Q_CBL_mon               = NULL;
  84 Monitor* DirtyCardQ_CBL_mon           = NULL;
  85 Mutex*   Shared_DirtyCardQ_lock       = NULL;
  86 Mutex*   MarkStackFreeList_lock       = NULL;
  87 Mutex*   MarkStackChunkList_lock      = NULL;
  88 Mutex*   MonitoringSupport_lock       = NULL;
  89 Mutex*   ParGCRareEvent_lock          = NULL;
  90 Mutex*   DerivedPointerTableGC_lock   = NULL;
  91 Monitor* CGCPhaseManager_lock         = NULL;
  92 Mutex*   Compile_lock                 = NULL;
  93 Monitor* MethodCompileQueue_lock      = NULL;
  94 Monitor* CompileThread_lock           = NULL;
  95 Monitor* Compilation_lock             = NULL;
  96 Mutex*   CompileTaskAlloc_lock        = NULL;
  97 Mutex*   CompileStatistics_lock       = NULL;
  98 Mutex*   DirectivesStack_lock         = NULL;
  99 Mutex*   MultiArray_lock              = NULL;
 100 Monitor* Terminator_lock              = NULL;
 101 Monitor* InitCompleted_lock           = NULL;
 102 Monitor* BeforeExit_lock              = NULL;
 103 Monitor* Notify_lock                  = NULL;
 104 Mutex*   ProfilePrint_lock            = NULL;
 105 Mutex*   ExceptionCache_lock          = NULL;
 106 Mutex*   OsrList_lock                 = NULL;
 107 Mutex*   NMethodSweeperStats_lock     = NULL;
 108 #ifndef PRODUCT
 109 Mutex*   FullGCALot_lock              = NULL;
 110 #endif


 135 Mutex*   JfrStacktrace_lock           = NULL;
 136 Monitor* JfrMsg_lock                  = NULL;
 137 Mutex*   JfrBuffer_lock               = NULL;
 138 Mutex*   JfrStream_lock               = NULL;
 139 Monitor* JfrThreadSampler_lock        = NULL;
 140 #endif
 141 
 142 #ifndef SUPPORTS_NATIVE_CX8
 143 Mutex*   UnsafeJlong_lock             = NULL;
 144 #endif
 145 Monitor* CodeHeapStateAnalytics_lock  = NULL;
 146 
 147 Mutex*   MetaspaceExpand_lock         = NULL;
 148 Mutex*   ClassLoaderDataGraph_lock    = NULL;
 149 Monitor* ThreadsSMRDelete_lock        = NULL;
 150 Mutex*   SharedDecoder_lock           = NULL;
 151 Mutex*   DCmdFactory_lock             = NULL;
 152 #if INCLUDE_NMT
 153 Mutex*   NMTQuery_lock                = NULL;
 154 #endif
 155 #if INCLUDE_CDS && INCLUDE_JVMTI

 156 Mutex*   CDSClassFileStream_lock      = NULL;
 157 #endif









 158 
 159 #define MAX_NUM_MUTEX 128
 160 static Monitor * _mutex_array[MAX_NUM_MUTEX];
 161 static int _num_mutex;
 162 
 163 #ifdef ASSERT
 164 void assert_locked_or_safepoint(const Monitor * lock) {
 165   // check if this thread owns the lock (common case)
 166   if (IgnoreLockingAssertions) return;
 167   assert(lock != NULL, "Need non-NULL lock");
 168   if (lock->owned_by_self()) return;
 169   if (SafepointSynchronize::is_at_safepoint()) return;
 170   if (!Universe::is_fully_initialized()) return;
 171   // see if invoker of VM operation owns it
 172   VM_Operation* op = VMThread::vm_operation();
 173   if (op != NULL && op->calling_thread() == lock->owner()) return;
 174   fatal("must own lock %s", lock->name());
 175 }
 176 
 177 // a weaker assertion than the above


 195 
 196 #define def(var, type, pri, vm_block, safepoint_check_allowed ) {      \
 197   var = new type(Mutex::pri, #var, vm_block, safepoint_check_allowed); \
 198   assert(_num_mutex < MAX_NUM_MUTEX, "increase MAX_NUM_MUTEX");        \
 199   _mutex_array[_num_mutex++] = var;                                      \
 200 }
 201 
 202 // Using Padded subclasses to prevent false sharing of these global monitors and mutexes.
 203 void mutex_init() {
 204   def(tty_lock                     , PaddedMutex  , tty,         true,  Monitor::_safepoint_check_never);      // allow to lock in VM
 205 
 206   def(CGC_lock                     , PaddedMonitor, special,     true,  Monitor::_safepoint_check_never);      // coordinate between fore- and background GC
 207   def(STS_lock                     , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);
 208 
 209   def(VMWeakAlloc_lock             , PaddedMutex  , vmweak,      true,  Monitor::_safepoint_check_never);
 210   def(VMWeakActive_lock            , PaddedMutex  , vmweak-1,    true,  Monitor::_safepoint_check_never);
 211 
 212   def(StringTableWeakAlloc_lock    , PaddedMutex  , vmweak,      true,  Monitor::_safepoint_check_never);
 213   def(StringTableWeakActive_lock   , PaddedMutex  , vmweak-1,    true,  Monitor::_safepoint_check_never);
 214 
 215   if (UseConcMarkSweepGC || UseG1GC) {
 216     def(FullGCCount_lock           , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);      // in support of ExplicitGCInvokesConcurrent
 217   }

 218   if (UseG1GC) {
 219     def(SATB_Q_CBL_mon             , PaddedMonitor, access,      true,  Monitor::_safepoint_check_never);
 220 
 221     def(DirtyCardQ_CBL_mon         , PaddedMonitor, access,      true,  Monitor::_safepoint_check_never);
 222     def(Shared_DirtyCardQ_lock     , PaddedMutex  , access + 1,  true,  Monitor::_safepoint_check_never);
 223 
 224     def(FreeList_lock              , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_never);
 225     def(OldSets_lock               , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_never);
 226     def(RootRegionScan_lock        , PaddedMonitor, leaf     ,   true,  Monitor::_safepoint_check_never);
 227 
 228     def(StringDedupQueue_lock      , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);
 229     def(StringDedupTable_lock      , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 230 
 231     def(MarkStackFreeList_lock     , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_never);
 232     def(MarkStackChunkList_lock    , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_never);
 233 
 234     def(MonitoringSupport_lock     , PaddedMutex  , native   ,   true,  Monitor::_safepoint_check_never);      // used for serviceability monitoring support
 235   }
 236   if (UseShenandoahGC) {
 237     def(SATB_Q_CBL_mon             , PaddedMonitor, access,      true,  Monitor::_safepoint_check_never);
 238 
 239     def(StringDedupQueue_lock      , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);
 240     def(StringDedupTable_lock      , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 241   }
 242   def(ParGCRareEvent_lock          , PaddedMutex  , leaf     ,   true,  Monitor::_safepoint_check_sometimes);
 243   def(DerivedPointerTableGC_lock   , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 244   def(CGCPhaseManager_lock         , PaddedMonitor, leaf,        false, Monitor::_safepoint_check_sometimes);
 245   def(CodeCache_lock               , PaddedMutex  , special,     true,  Monitor::_safepoint_check_never);
 246   def(RawMonitor_lock              , PaddedMutex  , special,     true,  Monitor::_safepoint_check_never);
 247   def(OopMapCacheAlloc_lock        , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always);     // used for oop_map_cache allocation.
 248 
 249   def(MetaspaceExpand_lock         , PaddedMutex  , leaf-1,      true,  Monitor::_safepoint_check_never);
 250   def(ClassLoaderDataGraph_lock    , PaddedMutex  , nonleaf,     true,  Monitor::_safepoint_check_always);
 251 
 252   def(Patching_lock                , PaddedMutex  , special,     true,  Monitor::_safepoint_check_never);      // used for safepointing and code patching.


 253   def(Service_lock                 , PaddedMonitor, special,     true,  Monitor::_safepoint_check_never);      // used for service thread operations
 254   def(JmethodIdCreation_lock       , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always);     // used for creating jmethodIDs.
 255 
 256   def(SystemDictionary_lock        , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_always);     // lookups done by VM thread
 257   def(ProtectionDomainSet_lock     , PaddedMutex  , leaf-1,      true,  Monitor::_safepoint_check_never);
 258   def(SharedDictionary_lock        , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always);     // lookups done by VM thread
 259   def(Module_lock                  , PaddedMutex  , leaf+2,      true,  Monitor::_safepoint_check_always);
 260   def(InlineCacheBuffer_lock       , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 261   def(VMStatistic_lock             , PaddedMutex  , leaf,        false, Monitor::_safepoint_check_always);
 262   def(ExpandHeap_lock              , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always);     // Used during compilation by VM thread
 263   def(JNIHandleBlockFreeList_lock  , PaddedMutex  , leaf-1,      true,  Monitor::_safepoint_check_never);      // handles are used by VM thread
 264   def(SignatureHandlerLibrary_lock , PaddedMutex  , leaf,        false, Monitor::_safepoint_check_always);
 265   def(SymbolArena_lock             , PaddedMutex  , leaf+2,      true,  Monitor::_safepoint_check_never);
 266   def(ProfilePrint_lock            , PaddedMutex  , leaf,        false, Monitor::_safepoint_check_always);     // serial profile printing
 267   def(ExceptionCache_lock          , PaddedMutex  , leaf,        false, Monitor::_safepoint_check_always);     // serial profile printing
 268   def(OsrList_lock                 , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 269   def(Debug1_lock                  , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 270 #ifndef PRODUCT
 271   def(FullGCALot_lock              , PaddedMutex  , leaf,        false, Monitor::_safepoint_check_always);     // a lock to make FullGCALot MT safe
 272 #endif
 273   def(BeforeExit_lock              , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_always);
 274   def(PerfDataMemAlloc_lock        , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always);     // used for allocating PerfData memory for performance data
 275   def(PerfDataManager_lock         , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_always);     // used for synchronized access to PerfDataManager resources
 276 
 277   // CMS_modUnionTable_lock                   leaf
 278   // CMS_bitMap_lock                          leaf 1
 279   // CMS_freeList_lock                        leaf 2
 280 
 281   def(Threads_lock                 , PaddedMonitor, barrier,     true,  Monitor::_safepoint_check_sometimes);
 282   def(NonJavaThreadsList_lock      , PaddedMutex,   leaf,        true,  Monitor::_safepoint_check_never);
 283   def(NonJavaThreadsListSync_lock  , PaddedMutex,   leaf,        true,  Monitor::_safepoint_check_never);
 284 
 285   def(VMOperationQueue_lock        , PaddedMonitor, nonleaf,     true,  Monitor::_safepoint_check_sometimes);  // VM_thread allowed to block on these
 286   def(VMOperationRequest_lock      , PaddedMonitor, nonleaf,     true,  Monitor::_safepoint_check_sometimes);
 287   def(RetData_lock                 , PaddedMutex  , nonleaf,     false, Monitor::_safepoint_check_always);
 288   def(Terminator_lock              , PaddedMonitor, nonleaf,     true,  Monitor::_safepoint_check_sometimes);
 289   def(InitCompleted_lock           , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);
 290   def(VtableStubs_lock             , PaddedMutex  , nonleaf,     true,  Monitor::_safepoint_check_never);
 291   def(Notify_lock                  , PaddedMonitor, nonleaf,     true,  Monitor::_safepoint_check_always);
 292   def(JNIGlobalAlloc_lock          , PaddedMutex  , nonleaf,     true,  Monitor::_safepoint_check_never);
 293   def(JNIGlobalActive_lock         , PaddedMutex  , nonleaf-1,   true,  Monitor::_safepoint_check_never);
 294   def(JNIWeakAlloc_lock            , PaddedMutex  , nonleaf,     true,  Monitor::_safepoint_check_never);
 295   def(JNIWeakActive_lock           , PaddedMutex  , nonleaf-1,   true,  Monitor::_safepoint_check_never);
 296   def(JNICritical_lock             , PaddedMonitor, nonleaf,     true,  Monitor::_safepoint_check_always);     // used for JNI critical regions
 297   def(AdapterHandlerLibrary_lock   , PaddedMutex  , nonleaf,     true,  Monitor::_safepoint_check_always);
 298 
 299   def(Heap_lock                    , PaddedMonitor, nonleaf+1,   false, Monitor::_safepoint_check_sometimes);
 300   def(JfieldIdCreation_lock        , PaddedMutex  , nonleaf+1,   true,  Monitor::_safepoint_check_always);     // jfieldID, Used in VM_Operation
 301   def(ResolvedMethodTable_lock     , PaddedMutex  , nonleaf+1,   false, Monitor::_safepoint_check_always);     // Used to protect ResolvedMethodTable
 302 
 303   def(CompiledIC_lock              , PaddedMutex  , nonleaf+2,   false, Monitor::_safepoint_check_never);      // locks VtableStubs_lock, InlineCacheBuffer_lock
 304   def(CompileTaskAlloc_lock        , PaddedMutex  , nonleaf+2,   true,  Monitor::_safepoint_check_always);
 305   def(CompileStatistics_lock       , PaddedMutex  , nonleaf+2,   false, Monitor::_safepoint_check_always);
 306   def(DirectivesStack_lock         , PaddedMutex  , special,     true,  Monitor::_safepoint_check_never);
 307   def(MultiArray_lock              , PaddedMutex  , nonleaf+2,   false, Monitor::_safepoint_check_always);
 308 
 309   def(JvmtiThreadState_lock        , PaddedMutex  , nonleaf+2,   false, Monitor::_safepoint_check_always);     // Used by JvmtiThreadState/JvmtiEventController
 310   def(Management_lock              , PaddedMutex  , nonleaf+2,   false, Monitor::_safepoint_check_always);     // used for JVM management
 311 
 312   def(Compile_lock                 , PaddedMutex  , nonleaf+3,   true,  Monitor::_safepoint_check_always);
 313   def(MethodData_lock              , PaddedMutex  , nonleaf+3,   false, Monitor::_safepoint_check_always);
 314   def(TouchedMethodLog_lock        , PaddedMutex  , nonleaf+3,   false, Monitor::_safepoint_check_always);
 315 
 316   def(MethodCompileQueue_lock      , PaddedMonitor, nonleaf+4,   true,  Monitor::_safepoint_check_always);
 317   def(Debug2_lock                  , PaddedMutex  , nonleaf+4,   true,  Monitor::_safepoint_check_never);
 318   def(Debug3_lock                  , PaddedMutex  , nonleaf+4,   true,  Monitor::_safepoint_check_never);
 319   def(CompileThread_lock           , PaddedMonitor, nonleaf+5,   false, Monitor::_safepoint_check_always);
 320   def(PeriodicTask_lock            , PaddedMonitor, nonleaf+5,   true,  Monitor::_safepoint_check_sometimes);
 321   def(RedefineClasses_lock         , PaddedMonitor, nonleaf+5,   true,  Monitor::_safepoint_check_always);
 322 
 323   if (WhiteBoxAPI) {
 324     def(Compilation_lock           , PaddedMonitor, leaf,        false, Monitor::_safepoint_check_never);
 325   }
 326 
 327 #if INCLUDE_JFR
 328   def(JfrMsg_lock                  , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_always);
 329   def(JfrBuffer_lock               , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 330   def(JfrStream_lock               , PaddedMutex  , leaf+1,      true,  Monitor::_safepoint_check_never);      // ensure to rank lower than 'safepoint'
 331   def(JfrStacktrace_lock           , PaddedMutex  , special,     true,  Monitor::_safepoint_check_sometimes);
 332   def(JfrThreadSampler_lock        , PaddedMonitor, leaf,        true,  Monitor::_safepoint_check_never);
 333 #endif
 334 
 335 #ifndef SUPPORTS_NATIVE_CX8
 336   def(UnsafeJlong_lock             , PaddedMutex  , special,     false, Monitor::_safepoint_check_never);
 337 #endif
 338 
 339   def(CodeHeapStateAnalytics_lock  , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 340 
 341   def(NMethodSweeperStats_lock     , PaddedMutex  , special,     true,  Monitor::_safepoint_check_sometimes);
 342   def(ThreadsSMRDelete_lock        , PaddedMonitor, special,     false, Monitor::_safepoint_check_never);
 343   def(SharedDecoder_lock           , PaddedMutex  , native,      false, Monitor::_safepoint_check_never);
 344   def(DCmdFactory_lock             , PaddedMutex  , leaf,        true,  Monitor::_safepoint_check_never);
 345 #if INCLUDE_NMT
 346   def(NMTQuery_lock                , PaddedMutex  , max_nonleaf, false, Monitor::_safepoint_check_always);
 347 #endif
 348 #if INCLUDE_CDS && INCLUDE_JVMTI

 349   def(CDSClassFileStream_lock      , PaddedMutex  , max_nonleaf, false, Monitor::_safepoint_check_always);
 350 #endif








 351 }
 352 
 353 GCMutexLocker::GCMutexLocker(Monitor * mutex) {
 354   if (SafepointSynchronize::is_at_safepoint()) {
 355     _locked = false;
 356   } else {
 357     _mutex = mutex;
 358     _locked = true;
 359     _mutex->lock();
 360   }
 361 }
 362 
 363 // Print all mutexes/monitors that are currently owned by a thread; called
 364 // by fatal error handler.
 365 void print_owned_locks_on_error(outputStream* st) {
 366   st->print("VM Mutex/Monitor currently owned by a thread: ");
 367   bool none = true;
 368   for (int i = 0; i < _num_mutex; i++) {
 369      // see if it has an owner
 370      if (_mutex_array[i]->owner() != NULL) {
< prev index next >