1 /*
2  * Copyright (C) 2011 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "mutex.h"
18 
19 #include <errno.h>
20 #include <sys/time.h>
21 
22 #define ATRACE_TAG ATRACE_TAG_DALVIK
23 #include "cutils/trace.h"
24 
25 #include "atomic.h"
26 #include "base/logging.h"
27 #include "base/time_utils.h"
28 #include "base/value_object.h"
29 #include "mutex-inl.h"
30 #include "runtime.h"
31 #include "scoped_thread_state_change.h"
32 #include "thread-inl.h"
33 
34 namespace art {
35 
36 Mutex* Locks::abort_lock_ = nullptr;
37 Mutex* Locks::alloc_tracker_lock_ = nullptr;
38 Mutex* Locks::allocated_monitor_ids_lock_ = nullptr;
39 Mutex* Locks::allocated_thread_ids_lock_ = nullptr;
40 ReaderWriterMutex* Locks::breakpoint_lock_ = nullptr;
41 ReaderWriterMutex* Locks::classlinker_classes_lock_ = nullptr;
42 Mutex* Locks::deoptimization_lock_ = nullptr;
43 ReaderWriterMutex* Locks::heap_bitmap_lock_ = nullptr;
44 Mutex* Locks::instrument_entrypoints_lock_ = nullptr;
45 Mutex* Locks::intern_table_lock_ = nullptr;
46 Mutex* Locks::jni_libraries_lock_ = nullptr;
47 Mutex* Locks::logging_lock_ = nullptr;
48 Mutex* Locks::mem_maps_lock_ = nullptr;
49 Mutex* Locks::modify_ldt_lock_ = nullptr;
50 ReaderWriterMutex* Locks::mutator_lock_ = nullptr;
51 Mutex* Locks::profiler_lock_ = nullptr;
52 Mutex* Locks::reference_processor_lock_ = nullptr;
53 Mutex* Locks::reference_queue_cleared_references_lock_ = nullptr;
54 Mutex* Locks::reference_queue_finalizer_references_lock_ = nullptr;
55 Mutex* Locks::reference_queue_phantom_references_lock_ = nullptr;
56 Mutex* Locks::reference_queue_soft_references_lock_ = nullptr;
57 Mutex* Locks::reference_queue_weak_references_lock_ = nullptr;
58 Mutex* Locks::runtime_shutdown_lock_ = nullptr;
59 Mutex* Locks::thread_list_lock_ = nullptr;
60 ConditionVariable* Locks::thread_exit_cond_ = nullptr;
61 Mutex* Locks::thread_suspend_count_lock_ = nullptr;
62 Mutex* Locks::trace_lock_ = nullptr;
63 Mutex* Locks::unexpected_signal_lock_ = nullptr;
64 
65 struct AllMutexData {
66   // A guard for all_mutexes_ that's not a mutex (Mutexes must CAS to acquire and busy wait).
67   Atomic<const BaseMutex*> all_mutexes_guard;
68   // All created mutexes guarded by all_mutexes_guard_.
69   std::set<BaseMutex*>* all_mutexes;
AllMutexDataart::AllMutexData70   AllMutexData() : all_mutexes(nullptr) {}
71 };
72 static struct AllMutexData gAllMutexData[kAllMutexDataSize];
73 
74 #if ART_USE_FUTEXES
ComputeRelativeTimeSpec(timespec * result_ts,const timespec & lhs,const timespec & rhs)75 static bool ComputeRelativeTimeSpec(timespec* result_ts, const timespec& lhs, const timespec& rhs) {
76   const int32_t one_sec = 1000 * 1000 * 1000;  // one second in nanoseconds.
77   result_ts->tv_sec = lhs.tv_sec - rhs.tv_sec;
78   result_ts->tv_nsec = lhs.tv_nsec - rhs.tv_nsec;
79   if (result_ts->tv_nsec < 0) {
80     result_ts->tv_sec--;
81     result_ts->tv_nsec += one_sec;
82   } else if (result_ts->tv_nsec > one_sec) {
83     result_ts->tv_sec++;
84     result_ts->tv_nsec -= one_sec;
85   }
86   return result_ts->tv_sec < 0;
87 }
88 #endif
89 
90 class ScopedAllMutexesLock FINAL {
91  public:
ScopedAllMutexesLock(const BaseMutex * mutex)92   explicit ScopedAllMutexesLock(const BaseMutex* mutex) : mutex_(mutex) {
93     while (!gAllMutexData->all_mutexes_guard.CompareExchangeWeakAcquire(0, mutex)) {
94       NanoSleep(100);
95     }
96   }
97 
~ScopedAllMutexesLock()98   ~ScopedAllMutexesLock() {
99 #if !defined(__clang__)
100     // TODO: remove this workaround target GCC/libc++/bionic bug "invalid failure memory model".
101     while (!gAllMutexData->all_mutexes_guard.CompareExchangeWeakSequentiallyConsistent(mutex_, 0)) {
102 #else
103     while (!gAllMutexData->all_mutexes_guard.CompareExchangeWeakRelease(mutex_, 0)) {
104 #endif
105       NanoSleep(100);
106     }
107   }
108 
109  private:
110   const BaseMutex* const mutex_;
111 };
112 
113 // Scoped class that generates events at the beginning and end of lock contention.
114 class ScopedContentionRecorder FINAL : public ValueObject {
115  public:
ScopedContentionRecorder(BaseMutex * mutex,uint64_t blocked_tid,uint64_t owner_tid)116   ScopedContentionRecorder(BaseMutex* mutex, uint64_t blocked_tid, uint64_t owner_tid)
117       : mutex_(kLogLockContentions ? mutex : nullptr),
118         blocked_tid_(kLogLockContentions ? blocked_tid : 0),
119         owner_tid_(kLogLockContentions ? owner_tid : 0),
120         start_nano_time_(kLogLockContentions ? NanoTime() : 0) {
121     if (ATRACE_ENABLED()) {
122       std::string msg = StringPrintf("Lock contention on %s (owner tid: %" PRIu64 ")",
123                                      mutex->GetName(), owner_tid);
124       ATRACE_BEGIN(msg.c_str());
125     }
126   }
127 
~ScopedContentionRecorder()128   ~ScopedContentionRecorder() {
129     ATRACE_END();
130     if (kLogLockContentions) {
131       uint64_t end_nano_time = NanoTime();
132       mutex_->RecordContention(blocked_tid_, owner_tid_, end_nano_time - start_nano_time_);
133     }
134   }
135 
136  private:
137   BaseMutex* const mutex_;
138   const uint64_t blocked_tid_;
139   const uint64_t owner_tid_;
140   const uint64_t start_nano_time_;
141 };
142 
BaseMutex(const char * name,LockLevel level)143 BaseMutex::BaseMutex(const char* name, LockLevel level) : level_(level), name_(name) {
144   if (kLogLockContentions) {
145     ScopedAllMutexesLock mu(this);
146     std::set<BaseMutex*>** all_mutexes_ptr = &gAllMutexData->all_mutexes;
147     if (*all_mutexes_ptr == nullptr) {
148       // We leak the global set of all mutexes to avoid ordering issues in global variable
149       // construction/destruction.
150       *all_mutexes_ptr = new std::set<BaseMutex*>();
151     }
152     (*all_mutexes_ptr)->insert(this);
153   }
154 }
155 
~BaseMutex()156 BaseMutex::~BaseMutex() {
157   if (kLogLockContentions) {
158     ScopedAllMutexesLock mu(this);
159     gAllMutexData->all_mutexes->erase(this);
160   }
161 }
162 
DumpAll(std::ostream & os)163 void BaseMutex::DumpAll(std::ostream& os) {
164   if (kLogLockContentions) {
165     os << "Mutex logging:\n";
166     ScopedAllMutexesLock mu(reinterpret_cast<const BaseMutex*>(-1));
167     std::set<BaseMutex*>* all_mutexes = gAllMutexData->all_mutexes;
168     if (all_mutexes == nullptr) {
169       // No mutexes have been created yet during at startup.
170       return;
171     }
172     typedef std::set<BaseMutex*>::const_iterator It;
173     os << "(Contended)\n";
174     for (It it = all_mutexes->begin(); it != all_mutexes->end(); ++it) {
175       BaseMutex* mutex = *it;
176       if (mutex->HasEverContended()) {
177         mutex->Dump(os);
178         os << "\n";
179       }
180     }
181     os << "(Never contented)\n";
182     for (It it = all_mutexes->begin(); it != all_mutexes->end(); ++it) {
183       BaseMutex* mutex = *it;
184       if (!mutex->HasEverContended()) {
185         mutex->Dump(os);
186         os << "\n";
187       }
188     }
189   }
190 }
191 
CheckSafeToWait(Thread * self)192 void BaseMutex::CheckSafeToWait(Thread* self) {
193   if (self == nullptr) {
194     CheckUnattachedThread(level_);
195     return;
196   }
197   if (kDebugLocking) {
198     CHECK(self->GetHeldMutex(level_) == this || level_ == kMonitorLock)
199         << "Waiting on unacquired mutex: " << name_;
200     bool bad_mutexes_held = false;
201     for (int i = kLockLevelCount - 1; i >= 0; --i) {
202       if (i != level_) {
203         BaseMutex* held_mutex = self->GetHeldMutex(static_cast<LockLevel>(i));
204         // We expect waits to happen while holding the thread list suspend thread lock.
205         if (held_mutex != nullptr) {
206           LOG(ERROR) << "Holding \"" << held_mutex->name_ << "\" "
207                      << "(level " << LockLevel(i) << ") while performing wait on "
208                      << "\"" << name_ << "\" (level " << level_ << ")";
209           bad_mutexes_held = true;
210         }
211       }
212     }
213     if (gAborting == 0) {  // Avoid recursive aborts.
214       CHECK(!bad_mutexes_held);
215     }
216   }
217 }
218 
AddToWaitTime(uint64_t value)219 void BaseMutex::ContentionLogData::AddToWaitTime(uint64_t value) {
220   if (kLogLockContentions) {
221     // Atomically add value to wait_time.
222     wait_time.FetchAndAddSequentiallyConsistent(value);
223   }
224 }
225 
RecordContention(uint64_t blocked_tid,uint64_t owner_tid,uint64_t nano_time_blocked)226 void BaseMutex::RecordContention(uint64_t blocked_tid,
227                                  uint64_t owner_tid,
228                                  uint64_t nano_time_blocked) {
229   if (kLogLockContentions) {
230     ContentionLogData* data = contention_log_data_;
231     ++(data->contention_count);
232     data->AddToWaitTime(nano_time_blocked);
233     ContentionLogEntry* log = data->contention_log;
234     // This code is intentionally racy as it is only used for diagnostics.
235     uint32_t slot = data->cur_content_log_entry.LoadRelaxed();
236     if (log[slot].blocked_tid == blocked_tid &&
237         log[slot].owner_tid == blocked_tid) {
238       ++log[slot].count;
239     } else {
240       uint32_t new_slot;
241       do {
242         slot = data->cur_content_log_entry.LoadRelaxed();
243         new_slot = (slot + 1) % kContentionLogSize;
244       } while (!data->cur_content_log_entry.CompareExchangeWeakRelaxed(slot, new_slot));
245       log[new_slot].blocked_tid = blocked_tid;
246       log[new_slot].owner_tid = owner_tid;
247       log[new_slot].count.StoreRelaxed(1);
248     }
249   }
250 }
251 
DumpContention(std::ostream & os) const252 void BaseMutex::DumpContention(std::ostream& os) const {
253   if (kLogLockContentions) {
254     const ContentionLogData* data = contention_log_data_;
255     const ContentionLogEntry* log = data->contention_log;
256     uint64_t wait_time = data->wait_time.LoadRelaxed();
257     uint32_t contention_count = data->contention_count.LoadRelaxed();
258     if (contention_count == 0) {
259       os << "never contended";
260     } else {
261       os << "contended " << contention_count
262          << " total wait of contender " << PrettyDuration(wait_time)
263          << " average " << PrettyDuration(wait_time / contention_count);
264       SafeMap<uint64_t, size_t> most_common_blocker;
265       SafeMap<uint64_t, size_t> most_common_blocked;
266       for (size_t i = 0; i < kContentionLogSize; ++i) {
267         uint64_t blocked_tid = log[i].blocked_tid;
268         uint64_t owner_tid = log[i].owner_tid;
269         uint32_t count = log[i].count.LoadRelaxed();
270         if (count > 0) {
271           auto it = most_common_blocked.find(blocked_tid);
272           if (it != most_common_blocked.end()) {
273             most_common_blocked.Overwrite(blocked_tid, it->second + count);
274           } else {
275             most_common_blocked.Put(blocked_tid, count);
276           }
277           it = most_common_blocker.find(owner_tid);
278           if (it != most_common_blocker.end()) {
279             most_common_blocker.Overwrite(owner_tid, it->second + count);
280           } else {
281             most_common_blocker.Put(owner_tid, count);
282           }
283         }
284       }
285       uint64_t max_tid = 0;
286       size_t max_tid_count = 0;
287       for (const auto& pair : most_common_blocked) {
288         if (pair.second > max_tid_count) {
289           max_tid = pair.first;
290           max_tid_count = pair.second;
291         }
292       }
293       if (max_tid != 0) {
294         os << " sample shows most blocked tid=" << max_tid;
295       }
296       max_tid = 0;
297       max_tid_count = 0;
298       for (const auto& pair : most_common_blocker) {
299         if (pair.second > max_tid_count) {
300           max_tid = pair.first;
301           max_tid_count = pair.second;
302         }
303       }
304       if (max_tid != 0) {
305         os << " sample shows tid=" << max_tid << " owning during this time";
306       }
307     }
308   }
309 }
310 
311 
Mutex(const char * name,LockLevel level,bool recursive)312 Mutex::Mutex(const char* name, LockLevel level, bool recursive)
313     : BaseMutex(name, level), recursive_(recursive), recursion_count_(0) {
314 #if ART_USE_FUTEXES
315   DCHECK_EQ(0, state_.LoadRelaxed());
316   DCHECK_EQ(0, num_contenders_.LoadRelaxed());
317 #else
318   CHECK_MUTEX_CALL(pthread_mutex_init, (&mutex_, nullptr));
319 #endif
320   exclusive_owner_ = 0;
321 }
322 
323 // Helper to ignore the lock requirement.
IsShuttingDown()324 static bool IsShuttingDown() NO_THREAD_SAFETY_ANALYSIS {
325   Runtime* runtime = Runtime::Current();
326   return runtime == nullptr || runtime->IsShuttingDownLocked();
327 }
328 
~Mutex()329 Mutex::~Mutex() {
330   bool shutting_down = IsShuttingDown();
331 #if ART_USE_FUTEXES
332   if (state_.LoadRelaxed() != 0) {
333     LOG(shutting_down ? WARNING : FATAL) << "destroying mutex with owner: " << exclusive_owner_;
334   } else {
335     if (exclusive_owner_ != 0) {
336       LOG(shutting_down ? WARNING : FATAL) << "unexpectedly found an owner on unlocked mutex "
337                                            << name_;
338     }
339     if (num_contenders_.LoadSequentiallyConsistent() != 0) {
340       LOG(shutting_down ? WARNING : FATAL) << "unexpectedly found a contender on mutex " << name_;
341     }
342   }
343 #else
344   // We can't use CHECK_MUTEX_CALL here because on shutdown a suspended daemon thread
345   // may still be using locks.
346   int rc = pthread_mutex_destroy(&mutex_);
347   if (rc != 0) {
348     errno = rc;
349     // TODO: should we just not log at all if shutting down? this could be the logging mutex!
350     MutexLock mu(Thread::Current(), *Locks::runtime_shutdown_lock_);
351     PLOG(shutting_down ? WARNING : FATAL) << "pthread_mutex_destroy failed for " << name_;
352   }
353 #endif
354 }
355 
ExclusiveLock(Thread * self)356 void Mutex::ExclusiveLock(Thread* self) {
357   DCHECK(self == nullptr || self == Thread::Current());
358   if (kDebugLocking && !recursive_) {
359     AssertNotHeld(self);
360   }
361   if (!recursive_ || !IsExclusiveHeld(self)) {
362 #if ART_USE_FUTEXES
363     bool done = false;
364     do {
365       int32_t cur_state = state_.LoadRelaxed();
366       if (LIKELY(cur_state == 0)) {
367         // Change state from 0 to 1 and impose load/store ordering appropriate for lock acquisition.
368         done = state_.CompareExchangeWeakAcquire(0 /* cur_state */, 1 /* new state */);
369       } else {
370         // Failed to acquire, hang up.
371         ScopedContentionRecorder scr(this, SafeGetTid(self), GetExclusiveOwnerTid());
372         num_contenders_++;
373         if (futex(state_.Address(), FUTEX_WAIT, 1, nullptr, nullptr, 0) != 0) {
374           // EAGAIN and EINTR both indicate a spurious failure, try again from the beginning.
375           // We don't use TEMP_FAILURE_RETRY so we can intentionally retry to acquire the lock.
376           if ((errno != EAGAIN) && (errno != EINTR)) {
377             PLOG(FATAL) << "futex wait failed for " << name_;
378           }
379         }
380         num_contenders_--;
381       }
382     } while (!done);
383     DCHECK_EQ(state_.LoadRelaxed(), 1);
384 #else
385     CHECK_MUTEX_CALL(pthread_mutex_lock, (&mutex_));
386 #endif
387     DCHECK_EQ(exclusive_owner_, 0U);
388     exclusive_owner_ = SafeGetTid(self);
389     RegisterAsLocked(self);
390   }
391   recursion_count_++;
392   if (kDebugLocking) {
393     CHECK(recursion_count_ == 1 || recursive_) << "Unexpected recursion count on mutex: "
394         << name_ << " " << recursion_count_;
395     AssertHeld(self);
396   }
397 }
398 
ExclusiveTryLock(Thread * self)399 bool Mutex::ExclusiveTryLock(Thread* self) {
400   DCHECK(self == nullptr || self == Thread::Current());
401   if (kDebugLocking && !recursive_) {
402     AssertNotHeld(self);
403   }
404   if (!recursive_ || !IsExclusiveHeld(self)) {
405 #if ART_USE_FUTEXES
406     bool done = false;
407     do {
408       int32_t cur_state = state_.LoadRelaxed();
409       if (cur_state == 0) {
410         // Change state from 0 to 1 and impose load/store ordering appropriate for lock acquisition.
411         done = state_.CompareExchangeWeakAcquire(0 /* cur_state */, 1 /* new state */);
412       } else {
413         return false;
414       }
415     } while (!done);
416     DCHECK_EQ(state_.LoadRelaxed(), 1);
417 #else
418     int result = pthread_mutex_trylock(&mutex_);
419     if (result == EBUSY) {
420       return false;
421     }
422     if (result != 0) {
423       errno = result;
424       PLOG(FATAL) << "pthread_mutex_trylock failed for " << name_;
425     }
426 #endif
427     DCHECK_EQ(exclusive_owner_, 0U);
428     exclusive_owner_ = SafeGetTid(self);
429     RegisterAsLocked(self);
430   }
431   recursion_count_++;
432   if (kDebugLocking) {
433     CHECK(recursion_count_ == 1 || recursive_) << "Unexpected recursion count on mutex: "
434         << name_ << " " << recursion_count_;
435     AssertHeld(self);
436   }
437   return true;
438 }
439 
ExclusiveUnlock(Thread * self)440 void Mutex::ExclusiveUnlock(Thread* self) {
441   if (kIsDebugBuild && self != nullptr && self != Thread::Current()) {
442     std::string name1 = "<null>";
443     std::string name2 = "<null>";
444     if (self != nullptr) {
445       self->GetThreadName(name1);
446     }
447     if (Thread::Current() != nullptr) {
448       Thread::Current()->GetThreadName(name2);
449     }
450     LOG(FATAL) << GetName() << " level=" << level_ << " self=" << name1
451                << " Thread::Current()=" << name2;
452   }
453   AssertHeld(self);
454   DCHECK_NE(exclusive_owner_, 0U);
455   recursion_count_--;
456   if (!recursive_ || recursion_count_ == 0) {
457     if (kDebugLocking) {
458       CHECK(recursion_count_ == 0 || recursive_) << "Unexpected recursion count on mutex: "
459           << name_ << " " << recursion_count_;
460     }
461     RegisterAsUnlocked(self);
462 #if ART_USE_FUTEXES
463     bool done = false;
464     do {
465       int32_t cur_state = state_.LoadRelaxed();
466       if (LIKELY(cur_state == 1)) {
467         // We're no longer the owner.
468         exclusive_owner_ = 0;
469         // Change state to 0 and impose load/store ordering appropriate for lock release.
470         // Note, the relaxed loads below musn't reorder before the CompareExchange.
471         // TODO: the ordering here is non-trivial as state is split across 3 fields, fix by placing
472         // a status bit into the state on contention.
473         done =  state_.CompareExchangeWeakSequentiallyConsistent(cur_state, 0 /* new state */);
474         if (LIKELY(done)) {  // Spurious fail?
475           // Wake a contender.
476           if (UNLIKELY(num_contenders_.LoadRelaxed() > 0)) {
477             futex(state_.Address(), FUTEX_WAKE, 1, nullptr, nullptr, 0);
478           }
479         }
480       } else {
481         // Logging acquires the logging lock, avoid infinite recursion in that case.
482         if (this != Locks::logging_lock_) {
483           LOG(FATAL) << "Unexpected state_ in unlock " << cur_state << " for " << name_;
484         } else {
485           LogMessage::LogLine(__FILE__, __LINE__, INTERNAL_FATAL,
486                               StringPrintf("Unexpected state_ %d in unlock for %s",
487                                            cur_state, name_).c_str());
488           _exit(1);
489         }
490       }
491     } while (!done);
492 #else
493     exclusive_owner_ = 0;
494     CHECK_MUTEX_CALL(pthread_mutex_unlock, (&mutex_));
495 #endif
496   }
497 }
498 
Dump(std::ostream & os) const499 void Mutex::Dump(std::ostream& os) const {
500   os << (recursive_ ? "recursive " : "non-recursive ")
501       << name_
502       << " level=" << static_cast<int>(level_)
503       << " rec=" << recursion_count_
504       << " owner=" << GetExclusiveOwnerTid() << " ";
505   DumpContention(os);
506 }
507 
operator <<(std::ostream & os,const Mutex & mu)508 std::ostream& operator<<(std::ostream& os, const Mutex& mu) {
509   mu.Dump(os);
510   return os;
511 }
512 
ReaderWriterMutex(const char * name,LockLevel level)513 ReaderWriterMutex::ReaderWriterMutex(const char* name, LockLevel level)
514     : BaseMutex(name, level)
515 #if ART_USE_FUTEXES
516     , state_(0), num_pending_readers_(0), num_pending_writers_(0)
517 #endif
518 {  // NOLINT(whitespace/braces)
519 #if !ART_USE_FUTEXES
520   CHECK_MUTEX_CALL(pthread_rwlock_init, (&rwlock_, nullptr));
521 #endif
522   exclusive_owner_ = 0;
523 }
524 
~ReaderWriterMutex()525 ReaderWriterMutex::~ReaderWriterMutex() {
526 #if ART_USE_FUTEXES
527   CHECK_EQ(state_.LoadRelaxed(), 0);
528   CHECK_EQ(exclusive_owner_, 0U);
529   CHECK_EQ(num_pending_readers_.LoadRelaxed(), 0);
530   CHECK_EQ(num_pending_writers_.LoadRelaxed(), 0);
531 #else
532   // We can't use CHECK_MUTEX_CALL here because on shutdown a suspended daemon thread
533   // may still be using locks.
534   int rc = pthread_rwlock_destroy(&rwlock_);
535   if (rc != 0) {
536     errno = rc;
537     // TODO: should we just not log at all if shutting down? this could be the logging mutex!
538     MutexLock mu(Thread::Current(), *Locks::runtime_shutdown_lock_);
539     Runtime* runtime = Runtime::Current();
540     bool shutting_down = runtime == nullptr || runtime->IsShuttingDownLocked();
541     PLOG(shutting_down ? WARNING : FATAL) << "pthread_rwlock_destroy failed for " << name_;
542   }
543 #endif
544 }
545 
ExclusiveLock(Thread * self)546 void ReaderWriterMutex::ExclusiveLock(Thread* self) {
547   DCHECK(self == nullptr || self == Thread::Current());
548   AssertNotExclusiveHeld(self);
549 #if ART_USE_FUTEXES
550   bool done = false;
551   do {
552     int32_t cur_state = state_.LoadRelaxed();
553     if (LIKELY(cur_state == 0)) {
554       // Change state from 0 to -1 and impose load/store ordering appropriate for lock acquisition.
555       done =  state_.CompareExchangeWeakAcquire(0 /* cur_state*/, -1 /* new state */);
556     } else {
557       // Failed to acquire, hang up.
558       ScopedContentionRecorder scr(this, SafeGetTid(self), GetExclusiveOwnerTid());
559       ++num_pending_writers_;
560       if (futex(state_.Address(), FUTEX_WAIT, cur_state, nullptr, nullptr, 0) != 0) {
561         // EAGAIN and EINTR both indicate a spurious failure, try again from the beginning.
562         // We don't use TEMP_FAILURE_RETRY so we can intentionally retry to acquire the lock.
563         if ((errno != EAGAIN) && (errno != EINTR)) {
564           PLOG(FATAL) << "futex wait failed for " << name_;
565         }
566       }
567       --num_pending_writers_;
568     }
569   } while (!done);
570   DCHECK_EQ(state_.LoadRelaxed(), -1);
571 #else
572   CHECK_MUTEX_CALL(pthread_rwlock_wrlock, (&rwlock_));
573 #endif
574   DCHECK_EQ(exclusive_owner_, 0U);
575   exclusive_owner_ = SafeGetTid(self);
576   RegisterAsLocked(self);
577   AssertExclusiveHeld(self);
578 }
579 
ExclusiveUnlock(Thread * self)580 void ReaderWriterMutex::ExclusiveUnlock(Thread* self) {
581   DCHECK(self == nullptr || self == Thread::Current());
582   AssertExclusiveHeld(self);
583   RegisterAsUnlocked(self);
584   DCHECK_NE(exclusive_owner_, 0U);
585 #if ART_USE_FUTEXES
586   bool done = false;
587   do {
588     int32_t cur_state = state_.LoadRelaxed();
589     if (LIKELY(cur_state == -1)) {
590       // We're no longer the owner.
591       exclusive_owner_ = 0;
592       // Change state from -1 to 0 and impose load/store ordering appropriate for lock release.
593       // Note, the relaxed loads below musn't reorder before the CompareExchange.
594       // TODO: the ordering here is non-trivial as state is split across 3 fields, fix by placing
595       // a status bit into the state on contention.
596       done =  state_.CompareExchangeWeakSequentiallyConsistent(-1 /* cur_state*/, 0 /* new state */);
597       if (LIKELY(done)) {  // Weak CAS may fail spuriously.
598         // Wake any waiters.
599         if (UNLIKELY(num_pending_readers_.LoadRelaxed() > 0 ||
600                      num_pending_writers_.LoadRelaxed() > 0)) {
601           futex(state_.Address(), FUTEX_WAKE, -1, nullptr, nullptr, 0);
602         }
603       }
604     } else {
605       LOG(FATAL) << "Unexpected state_:" << cur_state << " for " << name_;
606     }
607   } while (!done);
608 #else
609   exclusive_owner_ = 0;
610   CHECK_MUTEX_CALL(pthread_rwlock_unlock, (&rwlock_));
611 #endif
612 }
613 
614 #if HAVE_TIMED_RWLOCK
ExclusiveLockWithTimeout(Thread * self,int64_t ms,int32_t ns)615 bool ReaderWriterMutex::ExclusiveLockWithTimeout(Thread* self, int64_t ms, int32_t ns) {
616   DCHECK(self == nullptr || self == Thread::Current());
617 #if ART_USE_FUTEXES
618   bool done = false;
619   timespec end_abs_ts;
620   InitTimeSpec(true, CLOCK_MONOTONIC, ms, ns, &end_abs_ts);
621   do {
622     int32_t cur_state = state_.LoadRelaxed();
623     if (cur_state == 0) {
624       // Change state from 0 to -1 and impose load/store ordering appropriate for lock acquisition.
625       done =  state_.CompareExchangeWeakAcquire(0 /* cur_state */, -1 /* new state */);
626     } else {
627       // Failed to acquire, hang up.
628       timespec now_abs_ts;
629       InitTimeSpec(true, CLOCK_MONOTONIC, 0, 0, &now_abs_ts);
630       timespec rel_ts;
631       if (ComputeRelativeTimeSpec(&rel_ts, end_abs_ts, now_abs_ts)) {
632         return false;  // Timed out.
633       }
634       ScopedContentionRecorder scr(this, SafeGetTid(self), GetExclusiveOwnerTid());
635       ++num_pending_writers_;
636       if (futex(state_.Address(), FUTEX_WAIT, cur_state, &rel_ts, nullptr, 0) != 0) {
637         if (errno == ETIMEDOUT) {
638           --num_pending_writers_;
639           return false;  // Timed out.
640         } else if ((errno != EAGAIN) && (errno != EINTR)) {
641           // EAGAIN and EINTR both indicate a spurious failure,
642           // recompute the relative time out from now and try again.
643           // We don't use TEMP_FAILURE_RETRY so we can recompute rel_ts;
644           PLOG(FATAL) << "timed futex wait failed for " << name_;
645         }
646       }
647       --num_pending_writers_;
648     }
649   } while (!done);
650 #else
651   timespec ts;
652   InitTimeSpec(true, CLOCK_REALTIME, ms, ns, &ts);
653   int result = pthread_rwlock_timedwrlock(&rwlock_, &ts);
654   if (result == ETIMEDOUT) {
655     return false;
656   }
657   if (result != 0) {
658     errno = result;
659     PLOG(FATAL) << "pthread_rwlock_timedwrlock failed for " << name_;
660   }
661 #endif
662   exclusive_owner_ = SafeGetTid(self);
663   RegisterAsLocked(self);
664   AssertSharedHeld(self);
665   return true;
666 }
667 #endif
668 
669 #if ART_USE_FUTEXES
HandleSharedLockContention(Thread * self,int32_t cur_state)670 void ReaderWriterMutex::HandleSharedLockContention(Thread* self, int32_t cur_state) {
671   // Owner holds it exclusively, hang up.
672   ScopedContentionRecorder scr(this, GetExclusiveOwnerTid(), SafeGetTid(self));
673   ++num_pending_readers_;
674   if (futex(state_.Address(), FUTEX_WAIT, cur_state, nullptr, nullptr, 0) != 0) {
675     if (errno != EAGAIN) {
676       PLOG(FATAL) << "futex wait failed for " << name_;
677     }
678   }
679   --num_pending_readers_;
680 }
681 #endif
682 
SharedTryLock(Thread * self)683 bool ReaderWriterMutex::SharedTryLock(Thread* self) {
684   DCHECK(self == nullptr || self == Thread::Current());
685 #if ART_USE_FUTEXES
686   bool done = false;
687   do {
688     int32_t cur_state = state_.LoadRelaxed();
689     if (cur_state >= 0) {
690       // Add as an extra reader and impose load/store ordering appropriate for lock acquisition.
691       done =  state_.CompareExchangeWeakAcquire(cur_state, cur_state + 1);
692     } else {
693       // Owner holds it exclusively.
694       return false;
695     }
696   } while (!done);
697 #else
698   int result = pthread_rwlock_tryrdlock(&rwlock_);
699   if (result == EBUSY) {
700     return false;
701   }
702   if (result != 0) {
703     errno = result;
704     PLOG(FATAL) << "pthread_mutex_trylock failed for " << name_;
705   }
706 #endif
707   RegisterAsLocked(self);
708   AssertSharedHeld(self);
709   return true;
710 }
711 
IsSharedHeld(const Thread * self) const712 bool ReaderWriterMutex::IsSharedHeld(const Thread* self) const {
713   DCHECK(self == nullptr || self == Thread::Current());
714   bool result;
715   if (UNLIKELY(self == nullptr)) {  // Handle unattached threads.
716     result = IsExclusiveHeld(self);  // TODO: a better best effort here.
717   } else {
718     result = (self->GetHeldMutex(level_) == this);
719   }
720   return result;
721 }
722 
Dump(std::ostream & os) const723 void ReaderWriterMutex::Dump(std::ostream& os) const {
724   os << name_
725       << " level=" << static_cast<int>(level_)
726       << " owner=" << GetExclusiveOwnerTid()
727 #if ART_USE_FUTEXES
728       << " state=" << state_.LoadSequentiallyConsistent()
729       << " num_pending_writers=" << num_pending_writers_.LoadSequentiallyConsistent()
730       << " num_pending_readers=" << num_pending_readers_.LoadSequentiallyConsistent()
731 #endif
732       << " ";
733   DumpContention(os);
734 }
735 
operator <<(std::ostream & os,const ReaderWriterMutex & mu)736 std::ostream& operator<<(std::ostream& os, const ReaderWriterMutex& mu) {
737   mu.Dump(os);
738   return os;
739 }
740 
ConditionVariable(const char * name,Mutex & guard)741 ConditionVariable::ConditionVariable(const char* name, Mutex& guard)
742     : name_(name), guard_(guard) {
743 #if ART_USE_FUTEXES
744   DCHECK_EQ(0, sequence_.LoadRelaxed());
745   num_waiters_ = 0;
746 #else
747   pthread_condattr_t cond_attrs;
748   CHECK_MUTEX_CALL(pthread_condattr_init, (&cond_attrs));
749 #if !defined(__APPLE__)
750   // Apple doesn't have CLOCK_MONOTONIC or pthread_condattr_setclock.
751   CHECK_MUTEX_CALL(pthread_condattr_setclock, (&cond_attrs, CLOCK_MONOTONIC));
752 #endif
753   CHECK_MUTEX_CALL(pthread_cond_init, (&cond_, &cond_attrs));
754 #endif
755 }
756 
~ConditionVariable()757 ConditionVariable::~ConditionVariable() {
758 #if ART_USE_FUTEXES
759   if (num_waiters_!= 0) {
760     Runtime* runtime = Runtime::Current();
761     bool shutting_down = runtime == nullptr || runtime->IsShuttingDown(Thread::Current());
762     LOG(shutting_down ? WARNING : FATAL) << "ConditionVariable::~ConditionVariable for " << name_
763         << " called with " << num_waiters_ << " waiters.";
764   }
765 #else
766   // We can't use CHECK_MUTEX_CALL here because on shutdown a suspended daemon thread
767   // may still be using condition variables.
768   int rc = pthread_cond_destroy(&cond_);
769   if (rc != 0) {
770     errno = rc;
771     MutexLock mu(Thread::Current(), *Locks::runtime_shutdown_lock_);
772     Runtime* runtime = Runtime::Current();
773     bool shutting_down = (runtime == nullptr) || runtime->IsShuttingDownLocked();
774     PLOG(shutting_down ? WARNING : FATAL) << "pthread_cond_destroy failed for " << name_;
775   }
776 #endif
777 }
778 
Broadcast(Thread * self)779 void ConditionVariable::Broadcast(Thread* self) {
780   DCHECK(self == nullptr || self == Thread::Current());
781   // TODO: enable below, there's a race in thread creation that causes false failures currently.
782   // guard_.AssertExclusiveHeld(self);
783   DCHECK_EQ(guard_.GetExclusiveOwnerTid(), SafeGetTid(self));
784 #if ART_USE_FUTEXES
785   if (num_waiters_ > 0) {
786     sequence_++;  // Indicate the broadcast occurred.
787     bool done = false;
788     do {
789       int32_t cur_sequence = sequence_.LoadRelaxed();
790       // Requeue waiters onto mutex. The waiter holds the contender count on the mutex high ensuring
791       // mutex unlocks will awaken the requeued waiter thread.
792       done = futex(sequence_.Address(), FUTEX_CMP_REQUEUE, 0,
793                    reinterpret_cast<const timespec*>(std::numeric_limits<int32_t>::max()),
794                    guard_.state_.Address(), cur_sequence) != -1;
795       if (!done) {
796         if (errno != EAGAIN) {
797           PLOG(FATAL) << "futex cmp requeue failed for " << name_;
798         }
799       }
800     } while (!done);
801   }
802 #else
803   CHECK_MUTEX_CALL(pthread_cond_broadcast, (&cond_));
804 #endif
805 }
806 
Signal(Thread * self)807 void ConditionVariable::Signal(Thread* self) {
808   DCHECK(self == nullptr || self == Thread::Current());
809   guard_.AssertExclusiveHeld(self);
810 #if ART_USE_FUTEXES
811   if (num_waiters_ > 0) {
812     sequence_++;  // Indicate a signal occurred.
813     // Futex wake 1 waiter who will then come and in contend on mutex. It'd be nice to requeue them
814     // to avoid this, however, requeueing can only move all waiters.
815     int num_woken = futex(sequence_.Address(), FUTEX_WAKE, 1, nullptr, nullptr, 0);
816     // Check something was woken or else we changed sequence_ before they had chance to wait.
817     CHECK((num_woken == 0) || (num_woken == 1));
818   }
819 #else
820   CHECK_MUTEX_CALL(pthread_cond_signal, (&cond_));
821 #endif
822 }
823 
Wait(Thread * self)824 void ConditionVariable::Wait(Thread* self) {
825   guard_.CheckSafeToWait(self);
826   WaitHoldingLocks(self);
827 }
828 
WaitHoldingLocks(Thread * self)829 void ConditionVariable::WaitHoldingLocks(Thread* self) {
830   DCHECK(self == nullptr || self == Thread::Current());
831   guard_.AssertExclusiveHeld(self);
832   unsigned int old_recursion_count = guard_.recursion_count_;
833 #if ART_USE_FUTEXES
834   num_waiters_++;
835   // Ensure the Mutex is contended so that requeued threads are awoken.
836   guard_.num_contenders_++;
837   guard_.recursion_count_ = 1;
838   int32_t cur_sequence = sequence_.LoadRelaxed();
839   guard_.ExclusiveUnlock(self);
840   if (futex(sequence_.Address(), FUTEX_WAIT, cur_sequence, nullptr, nullptr, 0) != 0) {
841     // Futex failed, check it is an expected error.
842     // EAGAIN == EWOULDBLK, so we let the caller try again.
843     // EINTR implies a signal was sent to this thread.
844     if ((errno != EINTR) && (errno != EAGAIN)) {
845       PLOG(FATAL) << "futex wait failed for " << name_;
846     }
847   }
848   guard_.ExclusiveLock(self);
849   CHECK_GE(num_waiters_, 0);
850   num_waiters_--;
851   // We awoke and so no longer require awakes from the guard_'s unlock.
852   CHECK_GE(guard_.num_contenders_.LoadRelaxed(), 0);
853   guard_.num_contenders_--;
854 #else
855   uint64_t old_owner = guard_.exclusive_owner_;
856   guard_.exclusive_owner_ = 0;
857   guard_.recursion_count_ = 0;
858   CHECK_MUTEX_CALL(pthread_cond_wait, (&cond_, &guard_.mutex_));
859   guard_.exclusive_owner_ = old_owner;
860 #endif
861   guard_.recursion_count_ = old_recursion_count;
862 }
863 
TimedWait(Thread * self,int64_t ms,int32_t ns)864 bool ConditionVariable::TimedWait(Thread* self, int64_t ms, int32_t ns) {
865   DCHECK(self == nullptr || self == Thread::Current());
866   bool timed_out = false;
867   guard_.AssertExclusiveHeld(self);
868   guard_.CheckSafeToWait(self);
869   unsigned int old_recursion_count = guard_.recursion_count_;
870 #if ART_USE_FUTEXES
871   timespec rel_ts;
872   InitTimeSpec(false, CLOCK_REALTIME, ms, ns, &rel_ts);
873   num_waiters_++;
874   // Ensure the Mutex is contended so that requeued threads are awoken.
875   guard_.num_contenders_++;
876   guard_.recursion_count_ = 1;
877   int32_t cur_sequence = sequence_.LoadRelaxed();
878   guard_.ExclusiveUnlock(self);
879   if (futex(sequence_.Address(), FUTEX_WAIT, cur_sequence, &rel_ts, nullptr, 0) != 0) {
880     if (errno == ETIMEDOUT) {
881       // Timed out we're done.
882       timed_out = true;
883     } else if ((errno == EAGAIN) || (errno == EINTR)) {
884       // A signal or ConditionVariable::Signal/Broadcast has come in.
885     } else {
886       PLOG(FATAL) << "timed futex wait failed for " << name_;
887     }
888   }
889   guard_.ExclusiveLock(self);
890   CHECK_GE(num_waiters_, 0);
891   num_waiters_--;
892   // We awoke and so no longer require awakes from the guard_'s unlock.
893   CHECK_GE(guard_.num_contenders_.LoadRelaxed(), 0);
894   guard_.num_contenders_--;
895 #else
896 #if !defined(__APPLE__)
897   int clock = CLOCK_MONOTONIC;
898 #else
899   int clock = CLOCK_REALTIME;
900 #endif
901   uint64_t old_owner = guard_.exclusive_owner_;
902   guard_.exclusive_owner_ = 0;
903   guard_.recursion_count_ = 0;
904   timespec ts;
905   InitTimeSpec(true, clock, ms, ns, &ts);
906   int rc = TEMP_FAILURE_RETRY(pthread_cond_timedwait(&cond_, &guard_.mutex_, &ts));
907   if (rc == ETIMEDOUT) {
908     timed_out = true;
909   } else if (rc != 0) {
910     errno = rc;
911     PLOG(FATAL) << "TimedWait failed for " << name_;
912   }
913   guard_.exclusive_owner_ = old_owner;
914 #endif
915   guard_.recursion_count_ = old_recursion_count;
916   return timed_out;
917 }
918 
Init()919 void Locks::Init() {
920   if (logging_lock_ != nullptr) {
921     // Already initialized.
922     if (kRuntimeISA == kX86 || kRuntimeISA == kX86_64) {
923       DCHECK(modify_ldt_lock_ != nullptr);
924     } else {
925       DCHECK(modify_ldt_lock_ == nullptr);
926     }
927     DCHECK(abort_lock_ != nullptr);
928     DCHECK(alloc_tracker_lock_ != nullptr);
929     DCHECK(allocated_monitor_ids_lock_ != nullptr);
930     DCHECK(allocated_thread_ids_lock_ != nullptr);
931     DCHECK(breakpoint_lock_ != nullptr);
932     DCHECK(classlinker_classes_lock_ != nullptr);
933     DCHECK(deoptimization_lock_ != nullptr);
934     DCHECK(heap_bitmap_lock_ != nullptr);
935     DCHECK(intern_table_lock_ != nullptr);
936     DCHECK(jni_libraries_lock_ != nullptr);
937     DCHECK(logging_lock_ != nullptr);
938     DCHECK(mutator_lock_ != nullptr);
939     DCHECK(profiler_lock_ != nullptr);
940     DCHECK(thread_list_lock_ != nullptr);
941     DCHECK(thread_suspend_count_lock_ != nullptr);
942     DCHECK(trace_lock_ != nullptr);
943     DCHECK(unexpected_signal_lock_ != nullptr);
944   } else {
945     // Create global locks in level order from highest lock level to lowest.
946     LockLevel current_lock_level = kInstrumentEntrypointsLock;
947     DCHECK(instrument_entrypoints_lock_ == nullptr);
948     instrument_entrypoints_lock_ = new Mutex("instrument entrypoint lock", current_lock_level);
949 
950     #define UPDATE_CURRENT_LOCK_LEVEL(new_level) \
951       if (new_level >= current_lock_level) { \
952         /* Do not use CHECKs or FATAL here, abort_lock_ is not setup yet. */ \
953         fprintf(stderr, "New local level %d is not less than current level %d\n", \
954                 new_level, current_lock_level); \
955         exit(1); \
956       } \
957       current_lock_level = new_level;
958 
959     UPDATE_CURRENT_LOCK_LEVEL(kMutatorLock);
960     DCHECK(mutator_lock_ == nullptr);
961     mutator_lock_ = new ReaderWriterMutex("mutator lock", current_lock_level);
962 
963     UPDATE_CURRENT_LOCK_LEVEL(kHeapBitmapLock);
964     DCHECK(heap_bitmap_lock_ == nullptr);
965     heap_bitmap_lock_ = new ReaderWriterMutex("heap bitmap lock", current_lock_level);
966 
967     UPDATE_CURRENT_LOCK_LEVEL(kTraceLock);
968     DCHECK(trace_lock_ == nullptr);
969     trace_lock_ = new Mutex("trace lock", current_lock_level);
970 
971     UPDATE_CURRENT_LOCK_LEVEL(kRuntimeShutdownLock);
972     DCHECK(runtime_shutdown_lock_ == nullptr);
973     runtime_shutdown_lock_ = new Mutex("runtime shutdown lock", current_lock_level);
974 
975     UPDATE_CURRENT_LOCK_LEVEL(kProfilerLock);
976     DCHECK(profiler_lock_ == nullptr);
977     profiler_lock_ = new Mutex("profiler lock", current_lock_level);
978 
979     UPDATE_CURRENT_LOCK_LEVEL(kDeoptimizationLock);
980     DCHECK(deoptimization_lock_ == nullptr);
981     deoptimization_lock_ = new Mutex("Deoptimization lock", current_lock_level);
982 
983     UPDATE_CURRENT_LOCK_LEVEL(kAllocTrackerLock);
984     DCHECK(alloc_tracker_lock_ == nullptr);
985     alloc_tracker_lock_ = new Mutex("AllocTracker lock", current_lock_level);
986 
987     UPDATE_CURRENT_LOCK_LEVEL(kThreadListLock);
988     DCHECK(thread_list_lock_ == nullptr);
989     thread_list_lock_ = new Mutex("thread list lock", current_lock_level);
990 
991     UPDATE_CURRENT_LOCK_LEVEL(kJniLoadLibraryLock);
992     DCHECK(jni_libraries_lock_ == nullptr);
993     jni_libraries_lock_ = new Mutex("JNI shared libraries map lock", current_lock_level);
994 
995     UPDATE_CURRENT_LOCK_LEVEL(kBreakpointLock);
996     DCHECK(breakpoint_lock_ == nullptr);
997     breakpoint_lock_ = new ReaderWriterMutex("breakpoint lock", current_lock_level);
998 
999     UPDATE_CURRENT_LOCK_LEVEL(kClassLinkerClassesLock);
1000     DCHECK(classlinker_classes_lock_ == nullptr);
1001     classlinker_classes_lock_ = new ReaderWriterMutex("ClassLinker classes lock",
1002                                                       current_lock_level);
1003 
1004     UPDATE_CURRENT_LOCK_LEVEL(kMonitorPoolLock);
1005     DCHECK(allocated_monitor_ids_lock_ == nullptr);
1006     allocated_monitor_ids_lock_ =  new Mutex("allocated monitor ids lock", current_lock_level);
1007 
1008     UPDATE_CURRENT_LOCK_LEVEL(kAllocatedThreadIdsLock);
1009     DCHECK(allocated_thread_ids_lock_ == nullptr);
1010     allocated_thread_ids_lock_ =  new Mutex("allocated thread ids lock", current_lock_level);
1011 
1012     if (kRuntimeISA == kX86 || kRuntimeISA == kX86_64) {
1013       UPDATE_CURRENT_LOCK_LEVEL(kModifyLdtLock);
1014       DCHECK(modify_ldt_lock_ == nullptr);
1015       modify_ldt_lock_ = new Mutex("modify_ldt lock", current_lock_level);
1016     }
1017 
1018     UPDATE_CURRENT_LOCK_LEVEL(kInternTableLock);
1019     DCHECK(intern_table_lock_ == nullptr);
1020     intern_table_lock_ = new Mutex("InternTable lock", current_lock_level);
1021 
1022     UPDATE_CURRENT_LOCK_LEVEL(kReferenceProcessorLock);
1023     DCHECK(reference_processor_lock_ == nullptr);
1024     reference_processor_lock_ = new Mutex("ReferenceProcessor lock", current_lock_level);
1025 
1026     UPDATE_CURRENT_LOCK_LEVEL(kReferenceQueueClearedReferencesLock);
1027     DCHECK(reference_queue_cleared_references_lock_ == nullptr);
1028     reference_queue_cleared_references_lock_ = new Mutex("ReferenceQueue cleared references lock", current_lock_level);
1029 
1030     UPDATE_CURRENT_LOCK_LEVEL(kReferenceQueueWeakReferencesLock);
1031     DCHECK(reference_queue_weak_references_lock_ == nullptr);
1032     reference_queue_weak_references_lock_ = new Mutex("ReferenceQueue cleared references lock", current_lock_level);
1033 
1034     UPDATE_CURRENT_LOCK_LEVEL(kReferenceQueueFinalizerReferencesLock);
1035     DCHECK(reference_queue_finalizer_references_lock_ == nullptr);
1036     reference_queue_finalizer_references_lock_ = new Mutex("ReferenceQueue finalizer references lock", current_lock_level);
1037 
1038     UPDATE_CURRENT_LOCK_LEVEL(kReferenceQueuePhantomReferencesLock);
1039     DCHECK(reference_queue_phantom_references_lock_ == nullptr);
1040     reference_queue_phantom_references_lock_ = new Mutex("ReferenceQueue phantom references lock", current_lock_level);
1041 
1042     UPDATE_CURRENT_LOCK_LEVEL(kReferenceQueueSoftReferencesLock);
1043     DCHECK(reference_queue_soft_references_lock_ == nullptr);
1044     reference_queue_soft_references_lock_ = new Mutex("ReferenceQueue soft references lock", current_lock_level);
1045 
1046     UPDATE_CURRENT_LOCK_LEVEL(kAbortLock);
1047     DCHECK(abort_lock_ == nullptr);
1048     abort_lock_ = new Mutex("abort lock", current_lock_level, true);
1049 
1050     UPDATE_CURRENT_LOCK_LEVEL(kThreadSuspendCountLock);
1051     DCHECK(thread_suspend_count_lock_ == nullptr);
1052     thread_suspend_count_lock_ = new Mutex("thread suspend count lock", current_lock_level);
1053 
1054     UPDATE_CURRENT_LOCK_LEVEL(kUnexpectedSignalLock);
1055     DCHECK(unexpected_signal_lock_ == nullptr);
1056     unexpected_signal_lock_ = new Mutex("unexpected signal lock", current_lock_level, true);
1057 
1058     UPDATE_CURRENT_LOCK_LEVEL(kMemMapsLock);
1059     DCHECK(mem_maps_lock_ == nullptr);
1060     mem_maps_lock_ = new Mutex("mem maps lock", current_lock_level);
1061 
1062     UPDATE_CURRENT_LOCK_LEVEL(kLoggingLock);
1063     DCHECK(logging_lock_ == nullptr);
1064     logging_lock_ = new Mutex("logging lock", current_lock_level, true);
1065 
1066     #undef UPDATE_CURRENT_LOCK_LEVEL
1067 
1068     InitConditions();
1069   }
1070 }
1071 
InitConditions()1072 void Locks::InitConditions() {
1073   thread_exit_cond_ = new ConditionVariable("thread exit condition variable", *thread_list_lock_);
1074 }
1075 
1076 }  // namespace art
1077