1 /*
   2  * Copyright (c) 1997, 2015, 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 "runtime/mutexLocker.hpp"
  27 #include "runtime/safepoint.hpp"
  28 #include "runtime/thread.inline.hpp"
  29 #include "runtime/threadLocalStorage.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*   PackageTable_lock            = NULL;
  43 Mutex*   CompiledIC_lock              = NULL;
  44 Mutex*   InlineCacheBuffer_lock       = NULL;
  45 Mutex*   VMStatistic_lock             = NULL;
  46 Mutex*   JNIGlobalHandle_lock         = NULL;
  47 Mutex*   JNIHandleBlockFreeList_lock  = NULL;
  48 Mutex*   MemberNameTable_lock         = NULL;
  49 Mutex*   JmethodIdCreation_lock       = NULL;
  50 Mutex*   JfieldIdCreation_lock        = NULL;
  51 Monitor* JNICritical_lock             = NULL;
  52 Mutex*   JvmtiThreadState_lock        = NULL;
  53 Monitor* JvmtiPendingEvent_lock       = NULL;
  54 Monitor* Heap_lock                    = NULL;
  55 Mutex*   ExpandHeap_lock              = NULL;
  56 Mutex*   AdapterHandlerLibrary_lock   = NULL;
  57 Mutex*   SignatureHandlerLibrary_lock = NULL;
  58 Mutex*   VtableStubs_lock             = NULL;
  59 Mutex*   SymbolTable_lock             = NULL;
  60 Mutex*   StringTable_lock             = NULL;
  61 Monitor* StringDedupQueue_lock        = NULL;
  62 Mutex*   StringDedupTable_lock        = NULL;
  63 Mutex*   CodeCache_lock               = NULL;
  64 Mutex*   MethodData_lock              = NULL;
  65 Mutex*   RetData_lock                 = NULL;
  66 Monitor* VMOperationQueue_lock        = NULL;
  67 Monitor* VMOperationRequest_lock      = NULL;
  68 Monitor* Safepoint_lock               = NULL;
  69 Monitor* SerializePage_lock           = NULL;
  70 Monitor* Threads_lock                 = NULL;
  71 Monitor* CGC_lock                     = NULL;
  72 Monitor* STS_lock                     = NULL;
  73 Monitor* SLT_lock                     = NULL;
  74 Monitor* iCMS_lock                    = NULL;
  75 Monitor* FullGCCount_lock             = NULL;
  76 Monitor* CMark_lock                   = NULL;
  77 Mutex*   CMRegionStack_lock           = NULL;
  78 Mutex*   SATB_Q_FL_lock               = NULL;
  79 Monitor* SATB_Q_CBL_mon               = NULL;
  80 Mutex*   Shared_SATB_Q_lock           = NULL;
  81 Mutex*   DirtyCardQ_FL_lock           = NULL;
  82 Monitor* DirtyCardQ_CBL_mon           = NULL;
  83 Mutex*   Shared_DirtyCardQ_lock       = NULL;
  84 Mutex*   ParGCRareEvent_lock          = NULL;
  85 Mutex*   EvacFailureStack_lock        = NULL;
  86 Mutex*   DerivedPointerTableGC_lock   = NULL;
  87 Mutex*   Compile_lock                 = NULL;
  88 Monitor* MethodCompileQueue_lock      = NULL;
  89 Monitor* CompileThread_lock           = NULL;
  90 Mutex*   CompileTaskAlloc_lock        = NULL;
  91 Mutex*   CompileStatistics_lock       = NULL;
  92 Mutex*   MultiArray_lock              = NULL;
  93 Monitor* Terminator_lock              = NULL;
  94 Monitor* BeforeExit_lock              = NULL;
  95 Monitor* Notify_lock                  = NULL;
  96 Monitor* Interrupt_lock               = NULL;
  97 Monitor* ProfileVM_lock               = NULL;
  98 Mutex*   ProfilePrint_lock            = NULL;
  99 Mutex*   ExceptionCache_lock          = NULL;
 100 Monitor* ObjAllocPost_lock            = NULL;
 101 Mutex*   OsrList_lock                 = NULL;
 102 #ifndef PRODUCT
 103 Mutex*   FullGCALot_lock              = NULL;
 104 #endif
 105 
 106 Mutex*   Debug1_lock                  = NULL;
 107 Mutex*   Debug2_lock                  = NULL;
 108 Mutex*   Debug3_lock                  = NULL;
 109 
 110 Mutex*   tty_lock                     = NULL;
 111 
 112 Mutex*   RawMonitor_lock              = NULL;
 113 Mutex*   PerfDataMemAlloc_lock        = NULL;
 114 Mutex*   PerfDataManager_lock         = NULL;
 115 Mutex*   OopMapCacheAlloc_lock        = NULL;
 116 
 117 Mutex*   FreeList_lock                = NULL;
 118 Monitor* SecondaryFreeList_lock       = NULL;
 119 Mutex*   OldSets_lock                 = NULL;
 120 Monitor* RootRegionScan_lock          = NULL;
 121 Mutex*   MMUTracker_lock              = NULL;
 122 
 123 Monitor* GCTaskManager_lock           = NULL;
 124 
 125 Mutex*   Management_lock              = NULL;
 126 Monitor* Service_lock                 = NULL;
 127 Monitor* PeriodicTask_lock            = NULL;
 128 Monitor* RedefineClasses_lock         = NULL;
 129 
 130 #ifdef INCLUDE_TRACE
 131 Mutex*   JfrStacktrace_lock           = NULL;
 132 Monitor* JfrMsg_lock                  = NULL;
 133 Mutex*   JfrBuffer_lock               = NULL;
 134 Mutex*   JfrStream_lock               = NULL;
 135 Mutex*   JfrThreadGroups_lock         = NULL;
 136 #endif
 137 
 138 #ifndef SUPPORTS_NATIVE_CX8
 139 Mutex*   UnsafeJlong_lock             = NULL;
 140 #endif
 141 
 142 #define MAX_NUM_MUTEX 128
 143 static Monitor * _mutex_array[MAX_NUM_MUTEX];
 144 static int _num_mutex;
 145 
 146 #ifdef ASSERT
 147 void assert_locked_or_safepoint(const Monitor * lock) {
 148   // check if this thread owns the lock (common case)
 149   if (IgnoreLockingAssertions) return;
 150   assert(lock != NULL, "Need non-NULL lock");
 151   if (lock->owned_by_self()) return;
 152   if (SafepointSynchronize::is_at_safepoint()) return;
 153   if (!Universe::is_fully_initialized()) return;
 154   // see if invoker of VM operation owns it
 155   VM_Operation* op = VMThread::vm_operation();
 156   if (op != NULL && op->calling_thread() == lock->owner()) return;
 157   fatal(err_msg("must own lock %s", lock->name()));
 158 }
 159 
 160 // a stronger assertion than the above
 161 void assert_lock_strong(const Monitor * lock) {
 162   if (IgnoreLockingAssertions) return;
 163   assert(lock != NULL, "Need non-NULL lock");
 164   if (lock->owned_by_self()) return;
 165   fatal(err_msg("must own lock %s", lock->name()));
 166 }
 167 #endif
 168 
 169 #define def(var, type, pri, vm_block) {                           \
 170   var = new type(Mutex::pri, #var, vm_block);                     \
 171   assert(_num_mutex < MAX_NUM_MUTEX,                              \
 172                     "increase MAX_NUM_MUTEX");                    \
 173   _mutex_array[_num_mutex++] = var;                               \
 174 }
 175 
 176 void mutex_init() {
 177   def(tty_lock                     , Mutex  , event,       true ); // allow to lock in VM
 178 
 179   def(CGC_lock                   , Monitor, special,     true ); // coordinate between fore- and background GC
 180   def(STS_lock                   , Monitor, leaf,        true );
 181   if (UseConcMarkSweepGC) {
 182     def(iCMS_lock                  , Monitor, special,     true ); // CMS incremental mode start/stop notification
 183   }
 184   if (UseConcMarkSweepGC || UseG1GC) {
 185     def(FullGCCount_lock           , Monitor, leaf,        true ); // in support of ExplicitGCInvokesConcurrent
 186   }
 187   if (UseG1GC) {
 188     def(CMark_lock                 , Monitor, nonleaf,     true ); // coordinate concurrent mark thread
 189     def(CMRegionStack_lock         , Mutex,   leaf,        true );
 190     def(SATB_Q_FL_lock             , Mutex  , special,     true );
 191     def(SATB_Q_CBL_mon             , Monitor, nonleaf,     true );
 192     def(Shared_SATB_Q_lock         , Mutex,   nonleaf,     true );
 193 
 194     def(DirtyCardQ_FL_lock         , Mutex  , special,     true );
 195     def(DirtyCardQ_CBL_mon         , Monitor, nonleaf,     true );
 196     def(Shared_DirtyCardQ_lock     , Mutex,   nonleaf,     true );
 197 
 198     def(FreeList_lock              , Mutex,   leaf     ,   true );
 199     def(SecondaryFreeList_lock     , Monitor, leaf     ,   true );
 200     def(OldSets_lock               , Mutex  , leaf     ,   true );
 201     def(RootRegionScan_lock        , Monitor, leaf     ,   true );
 202     def(MMUTracker_lock            , Mutex  , leaf     ,   true );
 203     def(EvacFailureStack_lock      , Mutex  , nonleaf  ,   true );
 204 
 205     def(StringDedupQueue_lock      , Monitor, leaf,        true );
 206     def(StringDedupTable_lock      , Mutex  , leaf,        true );
 207   }





 208   def(ParGCRareEvent_lock          , Mutex  , leaf     ,   true );
 209   def(DerivedPointerTableGC_lock   , Mutex,   leaf,        true );
 210   def(CodeCache_lock               , Mutex  , special,     true );
 211   def(Interrupt_lock               , Monitor, special,     true ); // used for interrupt processing
 212   def(RawMonitor_lock              , Mutex,   special,     true );
 213   def(OopMapCacheAlloc_lock        , Mutex,   leaf,        true ); // used for oop_map_cache allocation.
 214 
 215   def(Patching_lock                , Mutex  , special,     true ); // used for safepointing and code patching.
 216   def(ObjAllocPost_lock            , Monitor, special,     false);
 217   def(Service_lock                 , Monitor, special,     true ); // used for service thread operations
 218   def(JmethodIdCreation_lock       , Mutex  , leaf,        true ); // used for creating jmethodIDs.
 219 
 220   def(SystemDictionary_lock        , Monitor, leaf,        true ); // lookups done by VM thread
 221   def(PackageTable_lock            , Mutex  , leaf,        false);
 222   def(InlineCacheBuffer_lock       , Mutex  , leaf,        true );
 223   def(VMStatistic_lock             , Mutex  , leaf,        false);
 224   def(ExpandHeap_lock              , Mutex  , leaf,        true ); // Used during compilation by VM thread
 225   def(JNIHandleBlockFreeList_lock  , Mutex  , leaf,        true ); // handles are used by VM thread
 226   def(SignatureHandlerLibrary_lock , Mutex  , leaf,        false);
 227   def(SymbolTable_lock             , Mutex  , leaf+2,      true );
 228   def(StringTable_lock             , Mutex  , leaf,        true );
 229   def(ProfilePrint_lock            , Mutex  , leaf,        false); // serial profile printing
 230   def(ExceptionCache_lock          , Mutex  , leaf,        false); // serial profile printing
 231   def(OsrList_lock                 , Mutex  , leaf,        true );
 232   def(Debug1_lock                  , Mutex  , leaf,        true );
 233 #ifndef PRODUCT
 234   def(FullGCALot_lock              , Mutex  , leaf,        false); // a lock to make FullGCALot MT safe
 235 #endif
 236   def(BeforeExit_lock              , Monitor, leaf,        true );
 237   def(PerfDataMemAlloc_lock        , Mutex  , leaf,        true ); // used for allocating PerfData memory for performance data
 238   def(PerfDataManager_lock         , Mutex  , leaf,        true ); // used for synchronized access to PerfDataManager resources
 239 
 240   // CMS_modUnionTable_lock                   leaf
 241   // CMS_bitMap_lock                          leaf + 1
 242   // CMS_freeList_lock                        leaf + 2
 243 
 244   def(Safepoint_lock               , Monitor, safepoint,   true ); // locks SnippetCache_lock/Threads_lock
 245 
 246   def(Threads_lock                 , Monitor, barrier,     true );
 247 
 248   def(VMOperationQueue_lock        , Monitor, nonleaf,     true ); // VM_thread allowed to block on these
 249   def(VMOperationRequest_lock      , Monitor, nonleaf,     true );
 250   def(RetData_lock                 , Mutex  , nonleaf,     false);
 251   def(Terminator_lock              , Monitor, nonleaf,     true );
 252   def(VtableStubs_lock             , Mutex  , nonleaf,     true );
 253   def(Notify_lock                  , Monitor, nonleaf,     true );
 254   def(JNIGlobalHandle_lock         , Mutex  , nonleaf,     true ); // locks JNIHandleBlockFreeList_lock
 255   def(JNICritical_lock             , Monitor, nonleaf,     true ); // used for JNI critical regions
 256   def(AdapterHandlerLibrary_lock   , Mutex  , nonleaf,     true);
 257   if (UseConcMarkSweepGC) {
 258     def(SLT_lock                   , Monitor, nonleaf,     false );
 259                     // used in CMS GC for locking PLL lock
 260   }
 261   def(Heap_lock                    , Monitor, nonleaf+1,   false);
 262   def(JfieldIdCreation_lock        , Mutex  , nonleaf+1,   true ); // jfieldID, Used in VM_Operation
 263   def(MemberNameTable_lock         , Mutex  , nonleaf+1,   false); // Used to protect MemberNameTable
 264 
 265   def(CompiledIC_lock              , Mutex  , nonleaf+2,   false); // locks VtableStubs_lock, InlineCacheBuffer_lock
 266   def(CompileTaskAlloc_lock        , Mutex  , nonleaf+2,   true );
 267   def(CompileStatistics_lock       , Mutex  , nonleaf+2,   false);
 268   def(MultiArray_lock              , Mutex  , nonleaf+2,   false); // locks SymbolTable_lock
 269 
 270   def(JvmtiThreadState_lock        , Mutex  , nonleaf+2,   false); // Used by JvmtiThreadState/JvmtiEventController
 271   def(JvmtiPendingEvent_lock       , Monitor, nonleaf,     false); // Used by JvmtiCodeBlobEvents
 272   def(Management_lock              , Mutex  , nonleaf+2,   false); // used for JVM management
 273 
 274   def(Compile_lock                 , Mutex  , nonleaf+3,   true );
 275   def(MethodData_lock              , Mutex  , nonleaf+3,   false);
 276 
 277   def(MethodCompileQueue_lock      , Monitor, nonleaf+4,   true );
 278   def(Debug2_lock                  , Mutex  , nonleaf+4,   true );
 279   def(Debug3_lock                  , Mutex  , nonleaf+4,   true );
 280   def(ProfileVM_lock               , Monitor, special,   false); // used for profiling of the VMThread
 281   def(CompileThread_lock           , Monitor, nonleaf+5,   false );
 282   def(PeriodicTask_lock            , Monitor, nonleaf+5,   true);
 283   def(RedefineClasses_lock         , Monitor, nonleaf+5,   true);
 284 
 285 #ifdef INCLUDE_TRACE
 286   def(JfrMsg_lock                  , Monitor, leaf,        true);
 287   def(JfrBuffer_lock               , Mutex,   leaf,        true);
 288   def(JfrThreadGroups_lock         , Mutex,   leaf,        true);
 289   def(JfrStream_lock               , Mutex,   nonleaf,     true);
 290   def(JfrStacktrace_lock           , Mutex,   special,     true);
 291 #endif
 292 
 293 #ifndef SUPPORTS_NATIVE_CX8
 294   def(UnsafeJlong_lock             , Mutex,   special,     false);
 295 #endif
 296 }
 297 
 298 GCMutexLocker::GCMutexLocker(Monitor * mutex) {
 299   if (SafepointSynchronize::is_at_safepoint()) {
 300     _locked = false;
 301   } else {
 302     _mutex = mutex;
 303     _locked = true;
 304     _mutex->lock();
 305   }
 306 }
 307 
 308 // Print all mutexes/monitors that are currently owned by a thread; called
 309 // by fatal error handler.
 310 void print_owned_locks_on_error(outputStream* st) {
 311   st->print("VM Mutex/Monitor currently owned by a thread: ");
 312   bool none = true;
 313   for (int i = 0; i < _num_mutex; i++) {
 314      // see if it has an owner
 315      if (_mutex_array[i]->owner() != NULL) {
 316        if (none) {
 317           // print format used by Mutex::print_on_error()
 318           st->print_cr(" ([mutex/lock_event])");
 319           none = false;
 320        }
 321        _mutex_array[i]->print_on_error(st);
 322        st->cr();
 323      }
 324   }
 325   if (none) st->print_cr("None");
 326 }
--- EOF ---